537 lines
25 KiB
Markdown
537 lines
25 KiB
Markdown
# Known bugs — apps/backend
|
||
|
||
Found while writing the API integration suites under `tests/api/`. Each entry
|
||
gives the source location, the actual behaviour, the expected behaviour and the
|
||
test that pins it. Severity is my judgement of impact.
|
||
|
||
---
|
||
|
||
## High — security / data integrity
|
||
|
||
### 1. A user token can perform admin writes (missing staff guard)
|
||
|
||
`src/trpc/trpc-index.ts` — `protectedProcedure` only requires *some* identity
|
||
(`ctx.user` OR `ctx.staffUser`). Many `admin.*` procedures never re-check
|
||
`ctx.staffUser`, so a plain user token can call them.
|
||
|
||
Confirmed reachable with a user token:
|
||
|
||
- `admin.order.cancelOrder` — cancel any order
|
||
- `admin.user.updateUserSuspension` — suspend any user
|
||
- `admin.user.sendNotification` — broadcast notifications
|
||
- `admin.product.toggleOutOfStock` (and the other `admin.product.*` writes)
|
||
- `admin.staffUser.createStaffUser` — **create a usable staff account (privilege escalation)**; the new account can log in
|
||
|
||
Procedures that *do* guard correctly: `admin.slots.*`, `admin.coupon.create`,
|
||
`admin.coupon.createReservedCoupon` (they check `ctx.staffUser?.id`).
|
||
|
||
**Fix:** add a `staffProcedure` (or a `ctx.staffUser` check) to every `admin.*`
|
||
write.
|
||
|
||
**Pinned by:** `tests/api/authorization-matrix.test.ts`.
|
||
|
||
> **Partially fixed (FC-01/SEC-01):** `admin.const.*` is no longer reachable with
|
||
> a user token. The router now uses `staffProcedure`; `updateConstants` also
|
||
> rejects global-scope keys (globals are superadmin-only), and the redundant
|
||
> `getGlobalConstants`/`updateGlobalConstants`/`getLegacyConstants`/
|
||
> `updateLegacyConstants` procedures were removed (they had no production UI
|
||
> caller — the admin apps use `admin.region.*`, the superadmin UI uses
|
||
> `superadmin.const.*`). The remaining entries above are still open.
|
||
|
||
### 2. Public `admin.vendorSnippets` endpoints
|
||
|
||
`src/trpc/apis/admin-apis/apis/vendor-snippets.ts`
|
||
|
||
- `getUpcomingSlots:176? / 259` — `publicProcedure`
|
||
- `getOrdersBySnippet:176` — `publicProcedure`, returns order/customer data for a snippet code
|
||
- `getOrdersBySnippetAndSlot:275` — `publicProcedure`
|
||
- `updateOrderItemPackaging:362` — `publicProcedure` with the staff check **commented out** (lines 355-360), so anyone can flip packaging state
|
||
|
||
**Fix:** require staff on all four.
|
||
|
||
**Pinned by:** `tests/api/authorization-matrix.test.ts`.
|
||
|
||
### 3. `user.auth.updateProfile` always throws
|
||
|
||
`src/trpc/apis/user-apis/apis/auth.ts:342`
|
||
|
||
```ts
|
||
const authHeader = ctx.req.header('authorization');
|
||
```
|
||
|
||
`ctx.req` is a fetch `Request` (see `src/app.ts` context: `{ req, c, ... }`),
|
||
which has `.headers.get(...)`, not `.header(...)`. The call throws
|
||
`TypeError: ctx.req.header is not a function`.
|
||
|
||
Worse, the profile update (`updateUserProfileInDb`) and the profile image URL
|
||
resolving both run *before* line 342, so the write is committed and the client
|
||
still receives an error — a silent partial success.
|
||
|
||
**Fix:** `ctx.req.headers.get('authorization')` (or use `ctx.c`).
|
||
|
||
**Pinned by:** `tests/api/misc-procedures.test.ts` — "pins: updateProfile
|
||
crashes after writing the change".
|
||
|
||
> **Fixed (FC-15/AU-07):** `Context.req` is now typed as the fetch `Request` the
|
||
> adapter actually passes, and `updateProfile` reads
|
||
> `ctx.req.headers.get('authorization')`. The optional email was also relaxed:
|
||
> an empty email means "no change" (the client only requires it when registering).
|
||
|
||
### 4. `user.auth.updatePassword` silently does nothing
|
||
|
||
`packages/db_helper_sqlite/src/user-apis/auth.ts:177` (`upsertUserPassword`)
|
||
|
||
```ts
|
||
try {
|
||
await db.insert(userCreds).values({ userId, userPassword: hashedPassword })
|
||
return
|
||
} catch (error) {
|
||
if (error.code === '23505') { /* postgres unique violation -> UPDATE */ }
|
||
throw error
|
||
}
|
||
```
|
||
|
||
`user_creds` has **no UNIQUE constraint on `user_id`** (schema: `id, user_id,
|
||
user_password, created_at`), and `23505` is the *Postgres* unique-violation code
|
||
— on D1 the insert simply succeeds. Result: a second credentials row is created,
|
||
`getUserAuthCreds` keeps returning the original row, and the account's password
|
||
never changes.
|
||
|
||
Verified: after "updating" the password, the **old password still logs in** and
|
||
the new one is rejected; the user now has duplicate rows in `user_creds`.
|
||
|
||
**Fix:** add a UNIQUE index on `user_creds.user_id` and handle the SQLite
|
||
constraint code, or do an explicit select-then-insert/update.
|
||
|
||
**Pinned by:** `tests/api/misc-procedures.test.ts` — "pins: updatePassword
|
||
reports success but the old password still works".
|
||
|
||
> **Fixed (FC-16/AU-08):** `upsertUserPassword` now does an explicit
|
||
> select-then-update-or-insert (updating every row for the user, which also
|
||
> repairs existing duplicates), and a `uniqueIndex` on `user_creds.user_id` was
|
||
> added to the schema. Existing duplicate rows must be deduped before the index
|
||
> migration can be applied (the local DB has duplicates for users 379, 908, 1311).
|
||
|
||
---
|
||
|
||
## High — money
|
||
|
||
### 5. A ≥100% coupon produces a negative order total
|
||
|
||
`packages/db_helper_sqlite/src/user-apis/order.ts` (`applyDiscountToOrder`)
|
||
|
||
The percentage branch caps the discount at `maxValue * proportion` or `Infinity`
|
||
and **never at `orderTotal`** (the flat branch does cap at the order total). A
|
||
coupon with `discountPercent >= 100` and no `maxValue` therefore drives
|
||
`orders.totalAmount` to zero or negative. `admin.coupon.create` accepts any
|
||
`discountPercent` (no upper bound).
|
||
|
||
**Pinned by:** `tests/api/coupon-math.test.ts` — "pins: a 150% coupon produces a
|
||
negative total".
|
||
|
||
### 6. The discount is applied to the delivery-inclusive base
|
||
|
||
`src/trpc/apis/user-apis/apis/order.ts:156`
|
||
|
||
```ts
|
||
const orderTotalAmount = isFirstOrder ? subOrderTotalWithDelivery : subOrderTotal;
|
||
```
|
||
|
||
`isFirstOrder` is true for the **first sub-order of every placeOrder call**, so
|
||
that sub-order's discount is computed on `goods + deliveryCharge`. A percentage
|
||
coupon therefore discounts the delivery fee as well.
|
||
|
||
**Pinned by:** `tests/api/coupon-math.test.ts` — "pins: a percentage coupon
|
||
discounts the delivery fee too".
|
||
|
||
> **Fixed (FC-08):** `placeOrderUtil` now computes the coupon discount on the
|
||
> whole cart **subtotal** and decides delivery on the **post-discount** total
|
||
> (`finalTotal < freeDeliveryThreshold`), mirroring the customer app. A
|
||
> percentage coupon no longer touches the delivery fee. (FC-07 is fixed too: the
|
||
> threshold key is now `freeDeliveryThreshold`, not `minRegularOrderValue`.)
|
||
|
||
### 7. Money is never rounded
|
||
|
||
Nothing rounds `totalAmount`; it is written with `.toString()` on a raw float, so
|
||
percentage discounts leave float noise (e.g. `999 - 15%`).
|
||
|
||
**Pinned by:** `tests/api/coupon-math.test.ts` — "pins: amounts are stored
|
||
unrounded".
|
||
|
||
---
|
||
|
||
## Medium — coupon rules
|
||
|
||
### 8. Coupon scoping is not enforced at placeOrder
|
||
|
||
`validateAndGetCoupon` checks invalidated / expiry / per-user limit / minOrder /
|
||
first-order-only, but **not** `isUserBased`, `applicableUsers`, `skuIds` or
|
||
`exclusiveApply`. Only the display endpoints (`getEligible` / `getMyCoupons`)
|
||
filter by applicability, so user B can spend a coupon issued to user A by
|
||
passing its id to `placeOrder`.
|
||
|
||
**Pinned by:** `tests/api/coupon-ux.test.ts` — "rejects user B applying a coupon
|
||
issued to user A".
|
||
|
||
> **FIXED 2026-10-11:** `validateAndGetCoupons` now enforces, per coupon: user-based
|
||
> applicability, `skuIds`/`coupon_applicable_products` product targeting (the coupon must
|
||
> match at least one cart line, and `minOrder` compares against the targeted subtotal),
|
||
> region (`coupons.regionId` null = global, else the order's region), and `exclusiveApply`
|
||
> (an exclusive coupon cannot be combined with any other). The customer coupon list
|
||
> (`getEligible`/`getMyCoupons`) is region-filtered too.
|
||
|
||
### 9. Cancelling an order does not release its coupon usage
|
||
|
||
`recordUserCouponUsage` runs at placement; `cancelOrderTransaction` never touches
|
||
`coupon_usage`. A cancelled order permanently consumes a `maxLimitForUser` slot.
|
||
|
||
**Pinned by:** `tests/api/order-lifecycle-gaps.test.ts` — "pins: cancelling an
|
||
order does not release its coupon usage".
|
||
|
||
> **FIXED 2026-10-11:** both cancel paths now delete the group's `coupon_usage`
|
||
> row(s) once **every** sibling order sharing the `orderGroupId` is cancelled
|
||
> (`releaseCouponUsageIfGroupFullyCancelled`, called from `cancelOrderTransaction`
|
||
> and admin `cancelOrder`). A lone order counts as "all" and releases on cancel.
|
||
> The lifecycle tests now assert the release.
|
||
|
||
### 10. A cancelled first order poisons an `isFirstOrderOnly` coupon
|
||
|
||
`getOrderCount` counts every order including cancelled ones, and
|
||
`isUserBased`/first-order checks run off it — so placing and cancelling a first
|
||
order permanently blocks a first-order-only coupon for that user.
|
||
|
||
**Pinned by:** `tests/api/order-lifecycle-gaps.test.ts` — "pins: a cancelled
|
||
first order poisons an isFirstOrderOnly coupon".
|
||
|
||
> **FIXED 2026-10-11:** first-order eligibility now uses `countEffectiveOrders`
|
||
> — distinct, non-cancelled order groups (a split placement counts once, a
|
||
> cancelled order not at all). `getOrderCount` keeps its row-count meaning for
|
||
> pagination. The lifecycle test now asserts the coupon still applies.
|
||
|
||
### 11. Reserved-coupon expiry is not checked at redemption — **FIXED 2026-10-10**
|
||
|
||
`redeemReservedCoupon` checked "already redeemed" and first-order-only, but not
|
||
`validTill`, so an expired reserved code still redeemed (it only failed later at
|
||
`placeOrder`) and the secret was burned for a dead coupon.
|
||
|
||
**Fix:** the redeem route now rejects `validTill < now` with "This coupon has
|
||
expired" (policy: one deadline for both claiming the secret and spending the
|
||
coupon), and `redeemReservedCoupon` claims the secret with a conditional update
|
||
(`WHERE is_redeemed = 0`) before creating the coupon, so two customers racing the
|
||
same code can no longer both receive one.
|
||
|
||
**Covered by:** `tests/api/coupon-ux.test.ts` — "rejects an expired reserved
|
||
code" and "lets only one of two simultaneous claims win".
|
||
|
||
### 12. `exclusiveApply` is stored but never enforced
|
||
|
||
Coupons carry `exclusiveApply`, and `placeOrder` accepts a single `couponId`, so
|
||
the flag has no effect anywhere. (Observation from reading the code; no runtime
|
||
test.)
|
||
|
||
> **FIXED 2026-10-11:** orders now accept `couponIds: number[]` and
|
||
> `validateAndGetCoupons` rejects any combination where one coupon is exclusive
|
||
> (it must be the only coupon on the order).
|
||
|
||
---
|
||
|
||
## Medium — placeOrder guards
|
||
|
||
### 13. Out-of-stock products are still orderable
|
||
|
||
`placeOrderUtil` checks `isFlashAvailable` for flash orders but never
|
||
`isOutOfStock`.
|
||
|
||
**Pinned by:** `tests/api/place-order-edge-cases.test.ts`.
|
||
|
||
> **Fixed (FC-03/SEC-05):** `placeOrderUtil` now rejects a product that is
|
||
> `isDeleted`, `isOutOfStock` or `isSuspended` (400 "… is unavailable"). The
|
||
> cross-region-SKU case (FC-02/SEC-04) is rejected too: the SKU's product
|
||
> `regionId` must equal the order region (409).
|
||
|
||
### 14. An empty `selectedItems` list fails with a raw DB error
|
||
|
||
There is no `.min(1)` on `selectedItems`, so an empty list reaches Drizzle, which
|
||
throws `values() must be called with at least one value` instead of returning a
|
||
400.
|
||
|
||
**Pinned by:** `tests/api/place-order-edge-cases.test.ts`.
|
||
|
||
### 15. No quantity cap
|
||
|
||
`quantity` is `z.number().int().positive()` with no upper bound; `1_000_000`
|
||
units are accepted.
|
||
|
||
**Pinned by:** `tests/api/place-order-edge-cases.test.ts`.
|
||
|
||
### 16. No slot validity checks
|
||
|
||
`placeOrder` only checks slot *capacity*. An inactive slot, a slot whose delivery
|
||
time has already passed, and a slot that does not carry the ordered SKU are all
|
||
accepted.
|
||
|
||
**Pinned by:** `tests/api/place-order-edge-cases.test.ts`.
|
||
|
||
> **Fixed (FC-03/SEC-05, FC-13/SL-04):** `placeOrderUtil` now requires a
|
||
> non-null `slotId` for scheduled orders and validates the slot: it must exist,
|
||
> belong to the order region (409), be `isActive`, have `freezeTime > now` and
|
||
> `deliveryTime > now`, and carry every ordered `skuId` in `slot.skuIds` (400
|
||
> otherwise).
|
||
|
||
### 17. No idempotency
|
||
|
||
Two identical `placeOrder` calls create two orders (`orderGroupId` is
|
||
`Date.now()-userId`, with no uniqueness check).
|
||
|
||
**Pinned by:** `tests/api/place-order-edge-cases.test.ts`.
|
||
|
||
> **Mitigated client-side (FC-17/OR-12):** the Place Order button is disabled while a
|
||
> submit is in flight and `handlePlaceOrder` early-returns via a synchronous `useRef`
|
||
> guard, so an accidental double-tap cannot submit twice. **Server-side idempotency is
|
||
> still absent** — a direct API replay or network retry can create duplicates. A
|
||
> client-generated idempotency key remains the proper fix if/when wanted.
|
||
|
||
---
|
||
|
||
## Low — error handling / lifecycle
|
||
|
||
### 18. `cancelOrder` swallows every error into one generic message
|
||
|
||
`src/trpc/apis/user-apis/apis/order.ts:554-599` wraps the whole handler in a
|
||
`try/catch` that rethrows `new ApiError("failed to cancel order")`, discarding
|
||
the specific 404/400 messages it constructs ("Order not found", "Order is already
|
||
cancelled", "Cannot cancel delivered order"). `updateUserNotes`, by contrast, has
|
||
no catch and propagates its real messages.
|
||
|
||
**Pinned by:** `tests/api/order-lifecycle-gaps.test.ts` and
|
||
`tests/api/authorization-matrix.test.ts`.
|
||
|
||
### 19. No order status transition guards
|
||
|
||
`admin.order.updateDelivered` / `updatePackaged` accept any state: a cancelled
|
||
order can be marked delivered, and delivered is reversible.
|
||
|
||
**Pinned by:** `tests/api/order-lifecycle-gaps.test.ts`.
|
||
|
||
### 20. `getUserDetails` breaks past ~110 orders
|
||
|
||
`admin.user.getUserDetails` builds an unchunked `IN (...)` over the user's order
|
||
ids and fails once the history is large. Documented in
|
||
`tests/api/admin-users.test.ts` (that suite uses a throwaway user to avoid it).
|
||
|
||
---
|
||
|
||
### 21. Bound pricing followed a client-supplied `boundId` — **FIXED 2026-10-10**
|
||
|
||
`placeOrderUtil` resolved the delivery charge and free-delivery threshold from
|
||
`params.boundId ?? getEffectiveBoundId(regionId)`. `boundId` is a plain optional
|
||
mutation input, and `getRegionSettingsForBound` only checked that the bound
|
||
belongs to the **region** — never to the order's **address**. So an order against
|
||
an address in bound 2 (₹200 / free above ₹800) could be placed with `boundId: 1`
|
||
(₹20 / free above ₹300) and be charged ₹20. The address's own `boundId` was never
|
||
read on this path.
|
||
|
||
**Fix (policy):** the delivery address's bound is authoritative —
|
||
`address.boundId ?? params.boundId ?? getEffectiveBoundId(regionId)`. This mirrors
|
||
the customer app, which already prices the selected address's bound
|
||
(`apps/user-ui/src/hooks/prominent-api-hooks.ts` → `useGetEssentialConsts`), and
|
||
keeps the bound-less-address fallback intact. Verified live: address 879 (bound 2)
|
||
+ `boundId: 1` now charges ₹200 (was ₹20); a bound-less address still honours the
|
||
client bound (₹20 for bound 1, ₹200 for bound 2).
|
||
|
||
**No regression test yet:** the suite has no bound fixtures and no superadmin
|
||
session helper, so it cannot create a second bound to compare against.
|
||
|
||
---
|
||
|
||
### 22. Explicit rebalance dropped the delivery charge — **FIXED 2026-10-10**
|
||
|
||
`rebalanceSlots` repriced an order as `total = items(latest prices) − discount`,
|
||
never adding `deliveryCharge` back — so every rebalanced order lost its fee from
|
||
the payable (while the `delivery_charge` column kept the old value). It also
|
||
re-derived the discount from the coupon's **current** state and looked it up per
|
||
order, so invalidating/expiring a coupon silently raised a historical total, and
|
||
multi-slot sub-orders (which own no `coupon_usage` row) lost their prorated
|
||
discount entirely. Delivered and cancelled orders were repriced too.
|
||
|
||
**Fix (policy): freeze the historic discount and delivery fee; rebalance only
|
||
product prices.** The charged discount is recovered from the stored row itself
|
||
(`items + fee − total`), which is immune to later coupon changes and preserves a
|
||
sub-order's prorated share; the fee is added back; delivered/cancelled orders are
|
||
skipped; a SKU with no price for the region keeps its stored price instead of
|
||
dropping to 0. Verified live: a no-op rebalance now leaves the payable untouched,
|
||
an invalidated coupon no longer changes it, and repricing keeps
|
||
`items − frozen discount + fee`.
|
||
|
||
**Known residue:** the customer/admin order **detail display** still recomputes
|
||
the discount from the coupon, so after a reprice it can show a discount that
|
||
differs from the frozen one (the payable is correct). Same family as the A23
|
||
display decision; `db.transaction` is still the no-op stub, so the write loop is
|
||
not atomic; money is still written unrounded (see #7). Orders rebalanced by the
|
||
old code carry a phantom discount equal to the dropped fee and were not
|
||
auto-repaired.
|
||
|
||
---
|
||
|
||
### 23. `updateProduct` stored unvalidated image keys — **FIXED 2026-10-10**
|
||
|
||
`createProduct` validated every referenced image
|
||
(`skus.flatMap((s) => s.images)` → `assertUploadUrlsClaimable` → `claimUploadUrls`), but
|
||
`updateProduct` validated only the declared `newImageUrls` and then wrote
|
||
`skus[].images` straight through (`extractKeyFromPresignedUrl` → `updateProductInDb`)
|
||
with no check and no claim. A fabricated key therefore produced a permanently
|
||
broken image, and another product's already-claimed key could be silently reused
|
||
(`createProduct` rejects that as "already used").
|
||
|
||
**Fix:** validate the *delta* — the keys the product does not already own (via a
|
||
new `getProductImageKeys(regionId, productId)` helper) plus `newImageUrls` —
|
||
before the write, and claim them after it. The product's own images may be
|
||
re-sent by the edit form untouched. Verified live: fabricated key → rejected with
|
||
nothing written; another product's claimed image → rejected; own image re-sent →
|
||
200; genuine pending upload → 200 and claimed.
|
||
|
||
Banners, stores and global stores also convert URLs to keys without this guard,
|
||
but the upload endpoint only issues the contexts
|
||
`review | product_info | notification | complaint | profile | tags`, so those
|
||
images are never registered in `upload_url_status` — guarding them would reject
|
||
legitimate images.
|
||
|
||
---
|
||
|
||
### 24. Editing an address cleared its default flag — **FIXED 2026-10-10**
|
||
|
||
`user.address.updateAddress` forwarded `isDefault: isDefault || false` while the
|
||
input schema declares `isDefault` **optional**. An edit that omitted the field —
|
||
the natural partial update — therefore unset the address's default and left the
|
||
user with **zero** default addresses. (`createAddress` computes
|
||
`makeDefault = isDefault || no-other-addresses`, so it never had the bug; the
|
||
AddressForm and checkout selector already send the current value, so the UI did
|
||
not expose it.)
|
||
|
||
**Fix:** `isDefault: isDefault ?? existingAddress.isDefault` — omitted keeps the
|
||
current value, explicit `true` sets it and clears the other addresses' defaults,
|
||
explicit `false` still clears it.
|
||
|
||
**Related, still open:** explicitly sending `isDefault: false` (or deleting the
|
||
only default address, see AD-08) can still leave a user with no default.
|
||
|
||
---
|
||
|
||
### 25. Address phone/pincode were unvalidated — **FIXED 2026-10-10**
|
||
|
||
`user.address.createAddress` / `updateAddress` accepted any non-empty string for
|
||
`phone` and `pincode` (only `min(1)`), so `phone: "123"` and `pincode: "12"` were
|
||
persisted. The app's form validated both client-side, so only a non-app client
|
||
could store garbage — which is what the run did.
|
||
|
||
**Fix (rule):** phone = exactly 10 digits starting **6/7/8/9**; pincode = exactly
|
||
6 digits, enforced in both procedures, with the UI's phone regex aligned. Verified
|
||
live: `123` / `1234567890` / `5678901234` / 9-digit / 11-digit phones and 5-digit /
|
||
7-digit / non-numeric pincodes all return **400**; a valid pair is accepted; the
|
||
update path rejects too.
|
||
|
||
**Note:** zod-level input validation already surfaces as HTTP 400 — only
|
||
`ApiError` throws are flattened to 500 (see #… / A19).
|
||
|
||
---
|
||
|
||
### 26. A user could delete their only address — **FIXED 2026-10-10**
|
||
|
||
`user.address.deleteAddress` guarded against an address attached to an ongoing
|
||
order and against the **default** address, but nothing stopped the user deleting
|
||
their **only** address — leaving an account with nowhere to deliver to (the same
|
||
zero-address state that editing could reach, see #24). The refusals were also
|
||
plain `Error`s, so they surfaced as HTTP 500.
|
||
|
||
**Fix (rule):** deleting the user's only address is refused with
|
||
“This is your only address. Add another address before deleting this one.”, and
|
||
the app shows it in a **BottomDialog** (checked before the “are you sure?” step
|
||
and again from the mutation's `onError`). The other refusals now throw `ApiError`
|
||
(409 / 404) so they reach the customer as 4xx.
|
||
|
||
**Still open:** explicitly sending `isDefault: false` for the last default can
|
||
still leave an account with no default address.
|
||
|
||
---
|
||
|
||
### 27. `updateProductPrices` addressed SKUs as `productId` — **FIXED 2026-10-10**
|
||
|
||
`admin.product.updateProductPrices` took `updates[].productId`, but the helper
|
||
validated it against `productSkus.id` and wrote `product_market_stats.skuId`. A
|
||
product id therefore landed on whatever SKU carried the same number (product ids
|
||
and SKU ids are separate, overlapping sequences), and the response still said
|
||
“Updated prices for N **product(s)**”. An entry with no price field wrote nothing
|
||
yet was counted as updated and reported as a success.
|
||
|
||
**Fix:** the input field is **`skuId`** (no alias), the messages say SKU, an entry
|
||
with no price field is rejected up front
|
||
(`No price fields to update for SKU(s): …`), and `updatedCount` counts rows actually written. The admin-ui and admin-web price screens were updated, along with
|
||
three test payloads — `cache-invalidation.test.ts` had been passing a *product* id
|
||
and only passed while the two ids happened to coincide.
|
||
|
||
**Residual (accepted):** id *values* still overlap, so a caller that passes a
|
||
product id for `skuId` still hits the same-numbered SKU. That is now an explicit
|
||
caller error rather than an API trap; mapping a product id to its SKUs is
|
||
deliberately not done because that ambiguity is what caused the bug.
|
||
|
||
---
|
||
|
||
### 28. Business errors left tRPC as HTTP 500 — **FIXED 2026-10-10**
|
||
|
||
`errorLoggerMiddleware` translated our `ApiError` to a `TRPCError` inside a
|
||
`try/catch` around `next()`. In tRPC 11 that catch is **unreachable for resolver
|
||
errors**: `callRecursive` catches them and returns the middleware a
|
||
`{ ok: false, error }` result, and `getTRPCErrorFromUnknown` has already wrapped a
|
||
non-`TRPCError` as `INTERNAL_SERVER_ERROR` (keeping the original on `cause`) —
|
||
which is why every business rejection arrived as HTTP 500 with the correct
|
||
message.
|
||
|
||
**Fix:** the middleware now inspects the result and re-throws
|
||
`translateResultError(result.error)`, which maps `result.error.cause` **only** when
|
||
it is an `ApiError`, so zod `BAD_REQUEST`s, `UNAUTHORIZED`s and genuine 500s keep
|
||
the code tRPC gave them. Verified live: 400 (expired reserved coupon, duplicate
|
||
product name, bogus upload URL on product + tag, wrong-scope const writes on both
|
||
admin and superadmin), 403 (capacity-full slot), 409 (only address, default
|
||
address, address on an open order); controls unchanged (400 zod, 404 unknown
|
||
procedure, 401 no token).
|
||
|
||
**Residual:** business rejections thrown as **plain `Error` inside the db-helper
|
||
packages** still return 500 — `validateAndGetCoupon` (`not applicable`, `Coupon has
|
||
expired`, invalidated, usage-limit, min-order, first-order-only) is the main one.
|
||
Those need a status attached at the throw site (or a package-level ApiError).
|
||
|
||
---
|
||
|
||
### 29. Global products were visible but unusable — **FIXED 2026-10-10**
|
||
|
||
A product with `regionId = null` is **global**: every catalogue read path serves it in
|
||
every region (`or(eq(productInfo.regionId, regionId), isNull(productInfo.regionId))` in
|
||
`user-apis/stores.ts`, `admin-apis/product.ts`), so customers saw global products with a
|
||
regional price. The write guards disagreed:
|
||
|
||
- `placeOrderUtil` (SEC-04) required `product.regionId === regionId` and its comment read
|
||
*“a product with no region is treated as not available anywhere”* → ordering a global SKU
|
||
failed with **409 `Product N is not available in this region`** (verified live with SKU 102).
|
||
- `assertSkuIdsInRegion` in `slots.ts` / `banner.ts` / `coupon.ts` rejected a global SKU as
|
||
*“belongs to a different region”* → a global product could not be attached to a region slot,
|
||
and a scheduled order needs its SKU in the slot.
|
||
|
||
**Fix (rule):** a SKU is acceptable when its product's region is **`null` (global) or the target
|
||
region**. `placeOrderUtil` now allows globals, and the three `assertSkuIdsInRegion` copies accept
|
||
them. `admin-apis/product.ts` already allowed a global SKU inside a regional product.
|
||
|
||
**Verified live:** global SKU 102 attached to region-1 slot 2036 → 200; a scheduled order for it
|
||
→ 200 (Basa Fish Fillets ₹498, free delivery above the threshold); a genuine region-2 SKU is still
|
||
rejected when attached to a region-1 slot and at order time (409). The scheduled slot-SKU
|
||
verification is unchanged.
|
||
|
||
**Not changed:** `admin-apis/vendor-snippets.ts` has the same assert but vendor snippets are
|
||
deprecated/out of scope.
|
||
|
||
---
|
||
|
||
## Out of scope (per request)
|
||
|
||
Online payments (`user.payment.*`, `admin.payments.initiateRefund`), OTP
|
||
(`sendOtp`/`verifyOtp`) and `deleteAccount` are deliberately untested and not
|
||
listed here.
|