freshyo/backend-test-change-log.txt
2026-09-26 22:29:54 +05:30

628 lines
38 KiB
Text

Test / change log
Entries are appended newest-last with a [YYYY-MM-DD HH:MM:SS] timestamp.
This file supersedes change-log.txt (see the entry below).
[2026-09-26 13:42:15] Log destination switched to backend-test-change-log.txt.
Per instruction, all change-log entries from now on are written here instead of
change-log.txt. The earlier history remains in change-log.txt; nothing was moved.
[2026-09-26 14:16:46] backend: API test harness (jest) — tRPC flows + static JSON cache.
Adds apps/backend/tests/ (jest + ts-jest, node environment, runInBand) driving the
local backend over HTTP (:8787, API_BASE_URL-overridable) using credentials from
tests/.env:
- tests/jest.config.js, tests/tsconfig.json, tests/setup.ts (loads tests/.env)
- helpers/env.ts API_BASE_URL + creds with clear failure messages
- helpers/api.ts tRPC client (httpBatchLink) + optional bearer token
- helpers/sessions.ts staff/user login (token cached) + server preflight
- helpers/fixtures.ts store + product/SKU + future slot via admin APIs; user address
- helpers/cache.ts essentialConsts, versioned cache URLs, fetchJson, pollUntil
- api/health.test.ts (3), auth.test.ts (3), admin.test.ts (2),
order-flow.test.ts (5), order-edge-cases.test.ts (4),
cache-slots.test.ts (3), cache-availability.test.ts (2),
cache-products.test.ts (2, eventual/polling)
- package.json: scripts test:api / test:api:typecheck; devDeps jest, ts-jest,
@types/jest, @trpc/client
- tests/.env added to .gitignore; tests/.env.example committed
Not yet run: the local backend (cd apps/backend && bun run dev) must be up and
tests/.env filled with the staff + user credentials.
Verification done:
- bun install added ts-jest (bun.lock updated).
- bun run test:api:typecheck -> clean (fixed a nullable createAddress data access).
- jest --listTests -> all 8 suites discovered.
- A backend IS reachable on :8787 -> tests/api/health.test.ts PASSES (3/3).
- The other 7 suites load and fail only on the missing credential, with
"[api-tests] ADMIN_NAME is not set. Copy apps/backend/tests/.env.example ...".
- Full run: 1 passed / 7 failed suites, 3 passed / 21 failed tests — all failures
are the credential gate, so nothing was created yet.
- apps/backend/test-case-info.md documents all 24 cases.
Blocked on: filling apps/backend/tests/.env (ADMIN_NAME/PASSWORD,
USER_IDENTIFIER/PASSWORD) — then `cd apps/backend && bun run test:api`.
[2026-09-26 14:52:00] backend: API suite green (8 suites / 24 tests) + 3 fixes.
Ran with the populated tests/.env against the local backend:
Test Suites: 8 passed, Tests: 24 passed, ~49s. test:api:typecheck clean.
First run exposed 3 issues, all in the tests/premises (fixed):
- cache-availability: availability.json is keyed by SKU id, not product id;
lookup by skuId (toggleProductOutOfStock flips product_market_stats for every
SKU, so the change is app-visible).
- cache-products: the rebuild PUTs all files in parallel (non-atomic), so the
version bump does not mean every file is up yet — the store file 404'd then
appeared. Both cache-products cases now poll for the individual file.
- order-edge-cases: placeOrder accepts a non-existent slotId (no FK/validity
check; only capacity). The case now documents that behaviour and asserts the
bogus slotId is stored verbatim, instead of expecting a rejection.
Docs updated: apps/backend/test-case-info.md (findings section + corrected rows).
Note: the run creates real rows (stores/products/SKUs/slots/orders/addresses) and
writes cache objects to the dev R2 bucket — per the approved "leave data" decision.
[2026-09-26 15:40:00] backend: second wave — authz, order rules, lifecycle, user
surface, cache consistency. 13 suites / 52 tests green (~98s).
New suites (28 tests):
- api/authorization.test.ts (5): anonymous/staff/user boundary checks, staff-guarded
admin writes rejected for user tokens, one user cannot see another's addresses.
- api/order-rules.test.ts (6): delivery charge vs minRegularOrderValue, per-slot
grouping (2 slots -> 2 orders, charged once), full-slot rejection (403),
flash-disabled rejection (const flipped then restored), invalid quantity.
- api/order-lifecycle.test.ts (5): notes persistence, cancel + reason in the list,
empty-reason rejection, "ORD<id>" rejection, pagination + pageSize 51 rejection.
- api/user-surface.test.ts (7): product detail, createReview -> getProductReviews,
generateUploadUrls, getEligible/getMyCoupons, unknown coupon rejection,
getSelfData, complaint raise -> staff resolve.
- api/cache-consistency.test.ts (5): availability/slots ids present in products.json
(polling), availability count, essential-consts self-consistency, stores productCount
vs store detail length.
New helpers: helpers/consts.ts (getConstants/setConst/asNumber); fixtures gain an
optional price and registerThrowawayUser(); api.ts gains captureError(); cache.ts gains
stores/essential-consts URLs.
Findings (documented in test-case-info.md):
- Admin reads are NOT staff-guarded: a user token can call admin.product.getProducts
(bare protectedProcedure). Staff-guarded writes do check ctx.staffUser.
- availability.json and slots.json are bumped synchronously and can reference product
ids that products.json (rebuilt ~30s later) does not have yet; consistency checks poll.
- essential-consts.json embeds a version snapshot, so its slots/availability versions
can lag the live ones (consumers read versions via tRPC anyway).
- Cache rebuild writes files in parallel (non-atomic) — poll per file.
Config-mutating cases (flash gate, slot capacity) restore the previous state.
[2026-09-26 16:20:00] backend: third wave — admin catalog + admin orders. 15 suites /
71 tests green (~75s). Payments and OTP intentionally excluded (user's call).
New suites (19 tests):
- api/admin-catalog.test.ts (9): getStoreById/updateStore, getProductById/updateProduct,
getGroups/createGroup, coupon.getAll, vendorSnippets.getAll, complaint.getAll.
- api/admin-orders.test.ts (10): getAll, getOrderDetails, getSlotOrders, updateNotes,
updatePackaged, updateDelivered (user then sees deliveryStatus success),
removeDeliveryCharge, updateAddressCoords, cancelOrder (fresh order), rebalanceSlots.
Started the local backend: the running wrangler dev instance was listening on :8787 but
not responding (health timed out), so it was killed and restarted via `bun run dev`
(background task). Tests then ran green.
Findings (documented in test-case-info.md):
- updateProduct requires a SKU feature literally named "quantity" (same as create).
- admin.order.updateAddressCoords succeeds but the coords are NOT exposed by
user.address.getUserAddresses (latitude null/0) — admin write vs user read disagree.
- admin.order.cancelOrder refuses an already-delivered order.
- admin.order id types are inconsistent: number for getOrderDetails/updateNotes/
removeDeliveryCharge/cancelOrder; string for updatePackaged/updateDelivered/getSlotOrders.
- admin.product.updateProduct and createGroup are reachable with the staff token as expected.
Still not covered: admin user management (getAllUsers/getUserDetails/getUserIncidents/
addUserIncident/getUsersForNotification/sendNotification), banner + vendorSnippet CRUD,
coupon create/update/delete, product-tag CRUD, product delete, const write round-trip,
order concurrency, queue no-op assertions. Payments/OTP excluded per instruction.
[2026-09-26 17:05:00] backend: coupon CRUD + user-side application. 16 suites /
78 tests green (~117s).
tests/api/coupons.test.ts (7): create (flat discount, apply-for-all) -> getById ->
update({id, updates}) -> visible in user.coupon.getEligible -> placeOrder({couponId})
reduces the order (couponCode + discountAmount === 2) -> delete invalidates -> the
invalidated coupon is rejected by placeOrder and drops out of getEligible -> a coupon
with both discountPercent and flatDiscount is rejected.
Findings (documented in test-case-info.md):
- admin.coupon.create returns Coupon[] (take [0].id), not a single object.
- admin.coupon.update takes { id, updates } and merges partially.
- admin.coupon.delete soft-invalidates: getById still returns the row, but the coupon
leaves getEligible and placeOrder refuses it.
- create validates that exactly one of discountPercent/flatDiscount is provided.
Earlier gap list trimmed: coupon create/update/delete now covered.
[2026-09-26 19:20:00] backend: remaining admin surface automated (everything except
payments/OTP). 21 suites / 103 tests green (~166s), test:api:typecheck clean.
New files (apps/backend/tests/api/):
+ admin-users.test.ts (8) getEssentials, getAllUsers, getUserDetails, getStaff,
addUserIncident -> getUserIncidents, getUsersForNotification,
updateUserSuspension(true/false), sendNotification(no-token recipient)
+ admin-banners.test.ts (4) getBanners, createBanner -> getBanner, updateBanner, deleteBanner
+ admin-tags.test.ts (4) createProductTag -> getProductTags, getProductTagById,
updateProductTag, deleteProductTag
+ admin-vendor-snippets.test.ts (4) create -> getAll, update, getOrdersBySnippet, delete
+ admin-ops.test.ts (5) updateConstants round-trip, createGroup/updateGroup/deleteGroup,
deleteProduct(rejection), store.createStore/deleteStore,
two concurrent placeOrder calls
Modified:
M tests/api/admin.test.ts slots.getAll membership moved to the unbounded public
user.slots.getSlots + assert the 20-slot cap
M tests/api/cache-products.test.ts store-detail poll resolves the *current* cacheVersion each
attempt (was pinned to the version captured after the write)
Findings (documented in test-case-info.md):
- admin.user.getUserDetails fails once a user has ~110 orders: unchunked
"select ... from order_status where order_id in (...)" over the whole history. The suite now
uses a fresh user. Same pattern in getAllUsers' order stats.
- admin.product.deleteProduct fails for a product with SKUs (hard delete vs FK); returns a raw
"Failed query" instead of 404/409. No soft-delete path through this procedure.
- admin.store.deleteStore takes { storeId }, not { id } like its siblings.
- admin.slots.getAll is capped at 20 slots, so a new slot isn't guaranteed inside the window.
- vendorSnippets.getOrdersBySnippet requires a slot-linked snippet; snippetCode is required.
- createBanner requires a URL-shaped imageUrl (a plain assets URL is fine, no upload).
- Suspension is a live precondition: placeOrder rejects a suspended user, so admin-ops
unsuspends in beforeAll and the suspension test restores in a finally.
- stores/<id>.json can land in a later cacheVersion than the one captured right after a write.
Remaining (per instruction): payments (success path) and OTP login only.
[2026-09-26 20:05:00] user-ui: coupon application + discount-calculation tests.
Not functional app changes: adds UI test coverage only. Coupon selection and the
discount maths already exist in components/checkout-page.tsx (lines 189-223) and
components/cart-page.tsx (lines 200-281) but had no tests — the existing suites only
used discountAmount: 0 / selectedCoupons: [] fixtures.
New:
+ apps/user-ui/tests/screens/checkout-coupons.test.tsx discount calculation end to end
(percentage, percentage capped by maxValue, flat, flat capped by maxValue, flat
capped at the item total, discount pushing the total under the free-delivery
threshold, min-order-ineligible coupon via ?coupons=, usage-limit coupon dropped,
couponId -> placeOrder)
+ apps/user-ui/tests/screens/cart-coupons.test.tsx cart picker selection, the
disabled/ineligible option labels, Coupon Applied + removal, and the &coupons= param
handed to checkout
Docs: user-ui/test-case-info.md gains the new cases.
[2026-09-26 20:40:00] user-ui: coupon tests — final shape + findings.
Correction to the entry above: the checkout-page suite was written, then deleted. Mounting
components/checkout-page.tsx with a NON-empty cart never settles in this environment (it spins
even with CheckoutAddressSelector and AddressForm stubbed), which is why its two existing cases
only ever exercise the empty-cart short-circuit. The discount maths moved to the cart page,
which shares the same formulas and mounts cleanly.
Landed:
apps/user-ui/tests/screens/cart-coupons.test.tsx 11 tests (new file)
apps/user-ui/tests/components/payment-and-order.test.tsx +2 tests (4 -> 6)
Result: 53 suites / 266 tests, 52 suites / 264 pass. The one red suite,
tests/contexts/auth-lifecycle.test.tsx, is untracked and pre-existing (it references an
undefined setLoginError and fails on its own) — not touched here, and excluded from the
passing totals. test:typecheck clean.
Findings recorded in user-ui/test-case-info.md:
- The cart's coupon picker only enforces isEligible in the dropdown (disabled option); the
discount sum itself does not re-check it. A minOrder coupon selected via ?coupons= is
therefore still discounted on checkout (checkout-side, unverified — page can't be mounted).
- The cart's flat-discount cap is min(discountValue, maxValue || totalPrice), so a flat
discount larger than the cart is clamped to the item total, never below zero.
- deliveryCharge is computed from finalTotal (post-discount), so a coupon can push an order
back under the free-delivery threshold and re-add the fee.
- PaymentAndOrderComponent's savings banner counts the waived delivery fee as savings.
- BottomDropdown options render in a Modal and are addressed via testID
`undefined-option-<id>` when the call site sets no testID (the cart's coupon dropdown).
[2026-09-26 21:30:00] user-ui: CORRECTION — why the checkout page could not be mounted.
My earlier note said the checkout page "spins" with a non-empty cart. That was wrong. It
throws, and the real cause is a Rules-of-Hooks violation in components/checkout-page.tsx:
trpc.user.coupon.getEligible.useQuery and four useMemos sit AFTER the
`if (selectedItems.length === 0) return ...` guard, so the hook count changes from 4 to 9 as
soon as useGetCart resolves from [] to slotted lines, and React throws "Rendered more hooks
than during the previous render." Every real checkout goes through that transition, so the
screen cannot render at all with slotted items.
With no error boundary the throw escapes the act environment and wedges the runner: no
output, ~0% CPU, no jest timeout — which is what looked like a hang. Note the parallel work
in the tree already tracked this (tests/KNOWN-GAPS.md #1, pinned by
tests/screens/checkout-crash.test.tsx, green); I reproduced it independently before reading
that file. Course-correcting my own conclusion: it is not a test-environment artefact and not
a spin, it is a real render crash.
Evidence gathered on the way (all consistent with the crash):
- the page rendered the empty-cart tree while its own ['local-cart-regular'] query sat at
status=success with items=1 — the tree was the first (pre-resolution) render; the next
render threw, so nothing ever updated;
- hooks/cart-query-hooks.tsx:233 gates the cart query on `enabled:
Object.keys(productsById).length > 0`, and its queryFn drops any line whose skuId is
missing from productsById/productSlotsMap (`return null`) — so there is always a
legitimately-empty window before the CDN stores land (also KNOWN-GAPS.md #6);
- tests/setup.ts:158 installs `jest.useFakeTimers({ now: Date.now() })` globally, so
react-query's timer-batched notifications only flush when timers advance.
Docs updated (apps/user-ui/test-case-info.md):
- header totals refreshed for the grown tree: 61 suites / 316 tests, all green;
- the "Not covered" checkout note replaced with the hooks-order crash above;
- group counts refreshed (screens 119, components 63, hooks/stores/lib/contexts 81) and a
note added that the suites which appeared alongside the parallel work are documented in
tests/KNOWN-GAPS.md rather than in this file's per-suite tables.
Note: tests/KNOWN-GAPS.md item 4 cites apps/user-ui/tests/screens/cart-coupons.test.tsx as the
pinning test for the post-discount delivery-threshold behaviour, so that file and its test
names should be kept as-is.
[2026-09-26 22:00:00] user-ui FIX: checkout-page.tsx Rules-of-Hooks violation.
File: apps/user-ui/components/checkout-page.tsx (app code — first functional change in this
log's user-ui section; everything above was test-only).
Diff (pure reordering, no logic touched):
- remove the `// Handle empty cart case` / `if (selectedItems.length === 0) { return (...)
}` block from between the `params.coupons` effect and `const totalPrice = ...`
+ re-insert the same block after `const finalTotalWithDelivery = finalTotal + deliveryCharge;`
Why: `trpc.user.coupon.getEligible.useQuery` and the four useMemos (eligibleCoupons,
selectedCoupons, discountAmount, deliveryCharge) sat below the early return, so the hook count
was 4 on the pre-resolution render and 9 once useGetCart resolved to slotted lines. React threw
"Rendered more hooks than during the previous render." — the checkout screen could not render at
all with slotted items (tests/KNOWN-GAPS.md #1).
Behaviour notes:
- the guard now runs after the coupon query and the memos, so an empty/unsupported cart also
fetches user.coupon.getEligible when authenticated (same as cart-page.tsx does). No visible
change; totalPrice is 0 there, so the discount maths is inert.
- no other semantics change: same JSX, same conditions, same derived values.
Tests follow in the same pass: tests/screens/checkout-crash.test.tsx (the last case pinned the
crash and is rewritten as a totals assertion) plus a new tests/screens/checkout-coupons.test.tsx.
[2026-09-26 22:30:00] user-ui: tests for the hooks fix.
tests/screens/checkout-crash.test.tsx (4 tests, unchanged count) — the last case was the
crash pin: "throws a hooks-order error once the cart resolves to slotted items". It is now
"renders the bill once the cart resolves to slotted items" and asserts the header, Item Total
₹215 and To Pay ₹230 with no discount. The ErrorBoundary helper and the `Text` import existed
only for that pin and are gone. File header updated.
tests/screens/checkout-coupons.test.tsx (NEW, 10 tests) — the checkout side of the coupon work,
which the hooks crash had made unreachable. Cart 2 x product 2 @ 215 = 430, threshold 249,
delivery 15:
percentage -> -₹43 / ₹387 / "Free" / "You saved ₹68 on this order" (43 discount + 10 market
saving + 15 waived delivery); percentage capped by maxValue (-₹50 / ₹380); flat (-₹100 /
₹330); flat capped by maxValue (-₹150 / ₹280); flat larger than the cart capped at the item
total (-₹430); discount pushing the total under the threshold (-₹200 / ₹245 + the
"Add products worth ₹19 for free delivery" nudge); a minOrder coupon passed via ?coupons=
still applied (-₹50 / ₹380); a usage-limit coupon dropped outright; no ?coupons= -> no
discount; and couponId: 77 + totalAmount=387 on placeOrder.
tests/KNOWN-GAPS.md — item 1 (the checkout crash) removed and the remaining items renumbered
1-10; new item 11 pins the coupon-eligibility gap that checkout-coupons.test.tsx case 7
exposes (isEligible is computed but never consulted when the discount is summed; only the
cart's picker enforces it). Item 3 now also cites the checkout-side threshold test.
Cross-references updated for the renumbering: checkout-crash.test.tsx and
test-case-info.md no longer point at "#1".
Result: 62 suites / 326 tests green, test:typecheck clean.
Note for whoever picks up KNOWN-GAPS #3 next: the checkout-side delivery-threshold behaviour is
now pinned twice (cart-coupons case 7 and checkout-coupons case 6) — both must be updated
together if the threshold moves to the pre-discount total.
[2026-09-26 23:00:00] user-ui FIX + test flip: coupon eligibility (KNOWN-GAPS #11).
File: apps/user-ui/components/checkout-page.tsx (app code).
Diff:
- selectedCouponId ? eligibleCoupons?.filter((coupon) => coupon.id === selectedCouponId) : [],
+ selectedCouponId
+ ? eligibleCoupons?.filter((coupon) => coupon.id === selectedCouponId && coupon.isEligible)
+ : [],
Why: `isEligible` (minOrder, per-user usage limit) is computed per coupon but was never
consulted when the coupon id arrived from the checkout URL, so a coupon the cart could not use
still reduced the bill. The `selectedCoupons` memo is the single funnel: `discountAmount` sums
it and `PaymentAndOrderComponent` forwards its id as `couponId`, so filtering here fixes both
the displayed discount and what is sent to placeOrder.
Test flip: tests/screens/checkout-coupons.test.tsx case 7 went from "applies a coupon whose
minOrder is not met when it arrives via the URL" (-₹50 / ₹380) to "does not apply a coupon
whose minOrder is not met, even from the URL" (no Product Discount row).
[2026-09-26 23:20:00] user-ui: KNOWN-GAPS #11 narrowed; cart half deliberately not touched.
tests/KNOWN-GAPS.md item 11 is rewritten. It no longer describes the checkout page (fixed in
the entry above) and now covers only the cart: cart-page.tsx:201 has the same
id-only `selectedCoupons` memo, so a coupon selected while eligible keeps its discount if the
cart later moves against it (a quantity drop taking the total back under minOrder). The picker
disables ineligible options, which covers the "cannot select it" case but not the drift.
The same one-line guard was NOT applied to cart-page.tsx on purpose: the cart's quantity
stepper has no testID and there is no established way to drive a quantity change from a test
(cart-money.test.tsx seeds quantities instead), so the transition could not be covered. Item 11
records the fix plus the coverage work it needs (add a testID to the stepper, or seed a line
whose product price changes) so the two land together.
Verification: 62 suites / 326 tests green, test:typecheck clean.
[2026-09-26 23:45:00] user-ui FIX: addressable quantity stepper + the cart's coupon eligibility.
App-code changes, three files:
1. packages/shared/types/ui-common.types.ts — QuantifierProps gains `testID?: string`
(optional, so every existing call site keeps the current behaviour).
2. packages/ui/src/components/quantifier.tsx — the three testIDs are now derived from a prefix
that defaults to the old literal:
- testID="quantifier-decrement" + testID={`${testID}-decrement`} (default 'quantifier')
- testID="quantifier-value" -> same treatment
- testID="quantifier-increment" -> same treatment
Why: the static ids are ambiguous as soon as two steppers are on screen, which is exactly the
cart page (one per line). The home-page suites that drive the floating cart bar's stepper
(home.test.tsx, home-floating-cart-bar.test.tsx, home-add-to-cart-dialog.test.tsx) pass no
testID, so they keep quantifier-* and are unaffected.
3. apps/user-ui/components/cart-page.tsx
a) the line's stepper now passes testID={`cart-item-${item.id}`}, giving per-line ids
(cart-item-<id>-increment / -decrement / -value) so a quantity change can be driven from a
test at all.
b) same guard as the checkout page: `selectedCoupons` now filters on `isEligible` as well as
the id, so a coupon that was picked while it qualified stops discounting when the cart
moves against it (a quantity drop taking the total back under minOrder). This closes
tests/KNOWN-GAPS.md #11.
Test added with it: tests/screens/cart-coupons.test.tsx — "drops the discount when a quantity
change takes the cart below the coupon's minOrder" (selects a minOrder-300 coupon at ₹430, then
decrements to ₹215).
[2026-09-26 00:10:00] user-ui: verification for the stepper + cart-eligibility pass.
tests/screens/cart-coupons.test.tsx — 12 tests green. The new case drives the stepper for real:
seeds 2 x 215 = 430, selects a minOrder-300 coupon (-₹50 applied), presses
cart-item-1-decrement, and asserts the discount and the "Coupon Applied" row are gone at
cart-item-1-value = 1. It fails against the pre-fix code (the id-only memo kept the discount),
so it genuinely pins the guard rather than describing it.
Full user-ui run: 62 suites / 327 tests green. `NODE_ENV=test bun run test:typecheck` clean.
Repo-wide `bun run typecheck` (bash typecheck) run because the Quantifier change is in a shared
package. Per-package:
apps/backend, apps/user-ui, apps/admin-ui, apps/web-ui, packages/db_helper_sqlite,
packages/migrator, packages/web-components ..... clean
packages/db_helper_postgres ................... 41 errors
apps/fallback-ui .............................. 1 error
Both failures are pre-existing and unrelated: db_helper_postgres drifts from the shared types
(Coupon is missing skuIds/isFirstOrderOnly, AdminProduct lacks unitId, Complaint.images is
unknown) and fallback-ui fails on vite.config.ts(8,13) TS2769. The only change made here in
packages/shared is the additive optional `testID?: string` on QuantifierProps (git diff above),
which cannot produce either. Every package that actually renders Quantifier typechecks clean.
[2026-09-26 00:15:00] scope: packages/db_helper_postgres is out of scope for now.
Its 41 typecheck errors are pre-existing and untouched by this work, and nothing in the user-ui
tests or the coupon/checkout changes depends on that package. Left alone on request; it is not
counted as a regression and should not block the user-ui work. The only other red package is
apps/fallback-ui (1 error, vite.config.ts TS2769), also pre-existing.
Still green for everything this work touches: apps/backend, apps/user-ui, apps/admin-ui,
apps/web-ui, packages/db_helper_sqlite, packages/migrator, packages/web-components — plus
62 suites / 327 tests in user-ui.
[2026-09-26 00:35:00] backend: jest globals not resolving in tests/api/*.test.ts.
Symptom: "Cannot find name 'describe'. Do you need to install type definitions for a test
runner? ... add 'jest' to the types field in your tsconfig" reported for
@apps/backend/tests/api/cache-products.test.ts.
Diagnosis: apps/backend/tests/tsconfig.json only extends ../tsconfig.json, so its typeRoots come
from the app config:
"typeRoots": ["../../node_modules/@types", "./node_modules/@types", "../shared-types"]
Those paths are written relative to apps/backend. @types/jest is installed at the repo root
(hoisted), so a run that resolves them relative to apps/backend finds it and passes
(`bun run test:api:typecheck` is clean), which is why the CLI never complained and the repo
`typecheck` script stays green — that script runs `tsc --noEmit` from each app root, and
apps/backend's own include does not cover tests/ at all. A checker that resolves the inherited
relative paths against the inheriting config (apps/backend/tests/) looks at apps/node_modules and
apps/backend/tests/node_modules instead, finds no @types/jest, and drops the jest globals.
Fix: declare the type roots in tests/tsconfig.json itself, with paths correct for its own
directory, and name the globals explicitly:
+ "typeRoots": ["../../../node_modules/@types", "../node_modules/@types"],
+ "types": ["jest", "node"]
Both are idempotent with the inherited values under correct resolution and independent of it
under the other.
Verified after the change: test:api:typecheck clean and one API suite still green (ts-jest reads
this tsconfig, so a restricted `types` array had to be proven not to break the runner).
[2026-09-26 00:40:00] backend: tsconfig fix verified.
- from apps/backend/tests, ../../../node_modules/@types/jest and ../node_modules/@types/node
both resolve (the earlier ls that said otherwise was run from apps/backend, one level up);
- `bun run test:api:typecheck` (tsc --noEmit -p tests/tsconfig.json) clean — all 21 test files
including tests/api/cache-products.test.ts;
- ts-jest still works with the restricted types array: health + auth suites run green (6 tests);
- the app project (`npx tsc --noEmit` in apps/backend) stays clean, so the repo `typecheck`
script's verdict for apps/backend is unchanged.
The same nested-tests-tsconfig hazard does not apply to apps/user-ui — it has a single root
tsconfig that the tests are checked through, so there are no inherited relative paths to
misresolve.
[2026-09-26 01:00:00] backend: image upload integrity suite.
New: apps/backend/tests/api/uploads.test.ts. Purpose: prove that what the app asks for and what
it later reads back are the same bytes — the presign -> PUT -> GET round trip, not just the shape
of the response the existing user-surface case asserts.
Mechanics: the presigned PUT carries its own signature, so the test process needs no R2
credentials: it PUTs a real PNG to the URL common.generateUploadUrls returns, then GETs
<assetsDomain>/<key> (assetsDomain comes from common.essentialConsts via helpers/cache.ts, the
same source the app uses) and compares bytes and sha256. The key is derived from the presigned
URL the way extractKeyFromPresignedUrl does (last two path segments after the bucket).
Cases: (1) a single PNG round-trips byte-identically with a matching content-length; (2) two
uploads in different folders stay distinct and each serves its own bytes; (3) one call with two
mime types returns two usable URLs whose objects hold their own bytes.
Per instruction the same-millisecond key collision in generateUploadUrls is NOT covered here.
Writes real objects into the dev bucket and leaves them, consistent with the existing data
policy.
[2026-09-26 01:10:00] backend: uploads suite verified + documented.
Verified: apps/backend/tests/api/uploads.test.ts 4/4 green on the first run — the presigned PUT
to R2 worked from the test process and every object read back byte-identically from the public
assets domain, with the 404 case proving the read-back is real. Full run 22 suites / 107 tests
green (was 21/103); test:api:typecheck clean.
Documented in apps/backend/test-case-info.md: header total 22/107, a new `api/uploads.test.ts`
section (cases 104-107), and four findings — a presigned URL is usable with no credentials and
unsigned Content-Type; the `${folder}/${Date.now()}${ext}` key (same-ms collision left uncovered
by request); every presign writing a pending status row that claimUploadUrl flips; and the
untested remainder (claim/re-claim, deleteImageUtil on replacement).
[2026-09-26 02:00:00] stale-data fixes across user-ui + admin-ui (from the mutation-refetch audit).
Planned changes (all app code):
A. Dead invalidations — the raw queryClient.invalidateQueries keys are dotted strings, which can
never match a tRPC v11 key ([pathArray, {type}]):
apps/user-ui/components/CheckoutAddressSelector.tsx:37 ['user.address.getUserAddresses']
apps/admin-ui/.../customize-app/popular-items.tsx:214 ['const.getConstants']
apps/admin-ui/.../customize-app/all-items-order.tsx:180 ['const.getConstants']
apps/admin-ui/.../product-tags/order.tsx:169 ['const.getConstants']
-> switch to trpc.useUtils().<router path>.invalidate(). Note the admin const procedures are
admin.const.*, so the old string was wrong twice (missing 'admin' and a string not an array).
B. packages/ui/hooks/useMarkDataFetchers.ts — refresh-on-focus fired only from the 3rd focus
(`focusCountRef.current > 1` from a ref starting at 0) and the callback was frozen by
useCallback(..., []). Fix keeps a callback ref (so the focus effect does not re-run on every
render, which would loop) and fires from the 2nd focus.
C. admin-ui mutations that leave the same screen stale (no refetch at all):
products/detail/[id].tsx respondToReview -> refetch getProductReviews
manage-orders/order-details/[id].tsx generateCancellationCoupon -> refetch getOrderDetails
manage-orders/order-details/[id].tsx initiateRefund -> refetch getOrderDetails
manage-orders/delivery-sequences/… handleSaveSequence -> refetchSequence/Orders
dashboard-banners/index.tsx handleEmptySlot -> refetch getBanners
manage-orders/delivery-sequences/… onAttachLocation={() => {}} -> refetch both
D. admin-ui edit screens that never refresh their own detail query — invalidate the router:
product-tags/edit/index.tsx, dashboard-banners/edit/[id].tsx, components/SlotForm.tsx
(update path), components/ProductGroupForm.tsx
Not touched: the identical dotted-key bug in apps/admin-web (3 sites) and apps/web-ui (3 sites),
outside the two apps in scope; apps/user-ui/utils/queryClient.ts staleTime: 1200000 is a policy
call and is left as-is.
[2026-09-26 02:30:00] stale-data fixes applied — A, B, C, D.
A. Dead invalidations replaced (dotted string -> tRPC utils, key built by the library):
apps/user-ui/components/CheckoutAddressSelector.tsx utils.user.address.getUserAddresses.invalidate()
admin-ui customize-app/popular-items.tsx utils.admin.const.getConstants.invalidate()
admin-ui customize-app/all-items-order.tsx utils.admin.const.getConstants.invalidate()
admin-ui product-tags/order.tsx utils.admin.const.getConstants.invalidate()
Each of the three admin files then had an unused queryClient + useQueryClient import; both
removed.
B. packages/ui/hooks/useMarkDataFetchers.ts rewritten: the callback is held in a ref (so the
focus effect does not re-subscribe on every render, which would refetch in a loop) and the
guard is now `focusCountRef.current > 0`, so the second focus refreshes. Previously `> 1`
skipped the first return-to-screen entirely and the callback was frozen at first render.
C. Same-screen refetches added (admin-ui):
products/detail/[id].tsx respondToReview -> utils.admin.product.getProductReviews.invalidate()
order-details/[id].tsx generateCancellationCoupon -> refetch()
order-details/[id].tsx initiateRefund -> refetch()
delivery-sequences/index.tsx handleSaveSequence -> refetchSequence() + refetchOrders()
dashboard-banners/index.tsx handleEmptySlot -> refetch()
delivery-sequences/index.tsx onAttachLocation={() => {}} -> refetchOrders() + refetchSequence()
D. Edit screens now invalidate what they were seeded from (admin-ui):
product-tags/edit/index.tsx utils.admin.product.getProductTagById.invalidate()
dashboard-banners/edit/[id].tsx utils.admin.banner.getBanner.invalidate()
components/SlotForm.tsx (update) utils.admin.slots.invalidate()
components/ProductGroupForm.tsx utils.admin.product.getGroups.invalidate()
Tests: apps/user-ui/tests/lib/query-invalidation-keys.test.tsx (new, 1 test) pins the root cause
without touching the network — it reads the key tRPC actually produced
([['user','address','getUserAddresses'], {type}]) and asserts getQueryCache().findAll() matches
the array form and returns nothing for the dotted form. findAll runs the same matcher
invalidateQueries uses, so it is the invalidation semantics minus the round trip.
Verified: apps/user-ui 63 suites / 328 tests green; test:typecheck clean; apps/admin-ui
`tsc --noEmit` clean (it has no test harness, so C/D are compile-verified only).
Still open, unchanged and out of the requested scope: the same dotted-key bug in apps/admin-web
(3 sites) and apps/web-ui (3 sites), and the user-ui client's staleTime: 1200000 policy —
fixing the invalidations removes the steady-state staleness but a 20-minute staleTime still
means any future missed invalidation is durable.
[2026-09-26 03:00:00] tests for the stale-data fixes.
New: apps/user-ui/tests/hooks/useMarkDataFetchers.test.tsx — pins fix B by driving the focus
lifecycle explicitly (the global setup mocks useFocusEffect to run once on mount, so this file
overrides it with a version that records the callback and lets the test fire further focuses).
Cases: the first focus does not refresh, the second does (the old `> 1` guard skipped it), and
after a re-render the newer callback runs rather than the one captured on mount (the frozen
useCallback).
Extended: apps/user-ui/tests/components/address-selectors.test.tsx — pins fix A end to end.
Asserts that '+ Attach Current Location' sends the mocked coords via user.address.updateAddress
AND that user.address.getUserAddresses is fetched a second time afterwards; with the old dotted
key that refetch never happened, so this fails against the previous code.
Not testable today: the admin-ui half (C + D). apps/admin-ui has no jest config, no mocks and no
provider harness — nothing in that app has ever been rendered under test. Recorded rather than
faked; scaffolding a harness for it is a separate, larger job.
[2026-09-26 03:30:00] tests outcome — one landed, one abandoned with the reason.
Landed:
apps/user-ui/tests/components/address-selectors.test.tsx +1 test (3 -> 6 total, was 5 with
two QuickDelivery cases): "refreshes the addresses after attaching the current location".
It presses the Attach button (the expo-location stub grants permission and returns
17.385/78.4867), asserts updateAddress receives those coords, then asserts
user.address.getUserAddresses is fetched a SECOND time. Against the old dotted-string key that
second read never happened, so the test pins fix A.
apps/user-ui/tests/lib/query-invalidation-keys.test.tsx (already in place) pins the same class
at the key level via getQueryCache().findAll(), which uses the matcher invalidateQueries uses.
Abandoned: a useMarkDataFetchers test (fix B). Three attempts failed for the same reason: the
hook's `useFocusEffect` never reaches the mock. Instrumentation settled it — a console.log inside
the useFocusEffect override in tests/setup.ts never fires while the hook renders successfully, so
packages/ui's import of '@react-navigation/native' resolves to a DIFFERENT module instance than
the app's (bun's symlinked install; jest keys the mock by resolved path). A per-file
jest.mock(...) does not intercept it either. I tried a shared seam (tests/mocks/focus.ts recording
callbacks + re-exporting fireFocus from the setup mock) and that failed the same way, so both the
seam and the test were reverted rather than left dead. tests/setup.ts is byte-identical to before.
Consequence worth knowing: the setup comment claims its useFocusEffect override "runs the callback
once on mount ... so focus-driven side effects are testable", but for the shared hook in
packages/ui that override is not in play at all. Making fix B testable needs either a
NavigationContainer in the test (so the real hook works) or a mock registered for the instance
packages/ui actually resolves. Not attempted here.
Result: apps/user-ui 63 suites / 329 tests green; test:typecheck clean. The admin-ui half (fixes C
and D) still has no harness — that app has no jest config at all, so nothing in it is testable
today.