# 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`. > **Fixed (FC-01/SEC-01), route removed:** the merged staff `admin.const.*` route is > gone. It had no production caller (the admin apps use `admin.region.*`, the > superadmin UI uses `superadmin.const.*`) and was the last place that could rebuild > every region's cache files on a region-key change, hand a staff token a merged read > of global constants, and accept bound-scope keys while silently dropping them. > Writes now go to the scope-specific routes, all of which are `staffProcedure` / > `superadminProcedure` and scope-checked (`assertConstantKeysInScope`). > `apps/backend/tests/helpers/consts.ts` reads/writes bound + region constants through > those routes; legacy constants have no staff-readable endpoint by design, so the api > tests no longer cover them. 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". > **Fixed (coupon stacking):** coupon discounts are now rounded to the nearest > rupee in the shared `computeCartPricing` / `computeCouponStack` > (`packages/shared/cart-pricing.ts`) and multiple coupons stack **sequentially in > the order the customer applied them**. `orders.totalAmount` no longer carries > float noise. --- ## 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) OTP (`sendOtp`/`verifyOtp`) and `deleteAccount` are deliberately untested and not listed here. Online payments were removed from the product (COD-only).