@mohasinac/appkit 4.32.6 → 4.33.0

package/dist/_internal/server/features/products/actions.js

@@ -6,6 +6,32 @@ import { isAdminUser } from "../../../../features/auth/role-predicates";
 import { productInputSchema, productUpdateSchema, auctionInputSchema, preOrderInputSchema, setFeaturedSchema, setStatusSchema } from "../../../shared/features/products/schema";
 import { assertProductOwnership, assertStatusTransition, assertPrizeDrawNotLocked, assertPrizeDrawWonItemsImmutable, } from "./service";
 import { ValidationError } from "../../../shared/errors/index";
+import { NotFoundError } from "../../../../errors";
+import { storeRepository } from "../../../../features/stores/repository/store.repository";
+/**
+ * The store fields every listing must carry, resolved from the acting seller.
+ *
+ * All three create actions used to write `storeId: user.uid` — an Auth UID,
+ * where every query in the codebase expects the store SLUG (`storeId` IS the
+ * store slug; see the store-identity note in CLAUDE.md). So a listing created
+ * here was filed under an id no store page, cart grouping or payout ever
+ * matches, and carried no `storeName` for a card to render.
+ *
+ * `storeName`/`storeSlug` are denormalized here because the public browse query
+ * never reads `storeRepository` — a card can only show a seller if the product
+ * document already names one.
+ */
+async function sellerStoreFields(ownerId) {
+    const store = await storeRepository.findByOwnerId(ownerId);
+    if (!store) {
+        throw new NotFoundError("No store found for this account. Create your store first.");
+    }
+    return {
+        storeId: store.storeSlug,
+        storeName: store.storeName,
+        storeSlug: store.storeSlug,
+    };
+}
 export async function createProductAction(input) {
     return wrapAction(async () => {
         const user = await requireRoleUser(["seller", "admin"]);
@@ -14,7 +40,7 @@ export async function createProductAction(input) {
             throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
         return productRepository.create({
             ...parsed.data,
-            storeId: user.uid,
+            ...(await sellerStoreFields(user.uid)),
             status: "draft",
             listingType: "standard",
             featured: false,
@@ -29,7 +55,7 @@ export async function createAuctionAction(input) {
             throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
         return productRepository.create({
             ...parsed.data,
-            storeId: user.uid,
+            ...(await sellerStoreFields(user.uid)),
             status: "draft",
             listingType: "auction",
             featured: false,
@@ -44,7 +70,7 @@ export async function createPreOrderAction(input) {
             throw new ValidationError(parsed.error.issues[0]?.message ?? "Invalid input");
         return productRepository.create({
             ...parsed.data,
-            storeId: user.uid,
+            ...(await sellerStoreFields(user.uid)),
             status: "draft",
             listingType: "pre-order",
             featured: false,

package/dist/_internal/server/features/products/list-public.d.ts

@@ -218,5 +218,5 @@ export declare function listPublicProducts(input: PublicProductListInput, opts?:
 export declare function listStoreProducts(storeId: string, listingTypes: readonly string[], searchParams?: URLSearchParams | Record<string, string | string[] | undefined>, defaults?: {
     pageSize?: number;
     sorts?: string;
-}): Promise<PublicProductListResult | null>;
+}, opts?: PublicProductListOptions): Promise<PublicProductListResult | null>;
 export {};

package/dist/_internal/server/features/products/list-public.js

@@ -751,7 +751,15 @@ function finish(draft) {
  * something it never had: the URL's own sort/filter/page params reach the SSR
  * fetch, so the first paint matches what the toolbar says is selected.
  */
-export async function listStoreProducts(storeId, listingTypes, searchParams = {}, defaults) {
+export async function listStoreProducts(storeId, listingTypes, searchParams = {}, defaults, 
+/*
+ * Forwarded, because dropping it made three capabilities unreachable from
+ * every store tab: the viewer (sandbox visibility), `enabledListingTypes` (a
+ * type an admin has switched OFF still rendered its tab's rows), and the
+ * pinned `now`. The wrapper accepted none of them, so no caller could pass
+ * them however much it wanted to.
+ */
+opts) {
     return listPublicProducts({
         ...parsePublicProductParams(searchParams, {
             listingTypes,
@@ -762,7 +770,7 @@ export async function listStoreProducts(storeId, listingTypes, searchParams = {}
         // The route owns the store identity — a `?storeId=` in the URL must not be
         // able to make one store's tab render another store's inventory.
         storeId,
-    });
+    }, opts);
 }
 /**
  * Comparable primitive for one row value.

package/dist/_internal/server/features/stores/denormalize.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The one place a product's denormalized store fields are derived.
+ *
+ * `ProductDocument.storeName` / `.storeSlug` are what every listing card renders
+ * as "by …". They have to be denormalized, because the public browse query
+ * (`listPublicProducts`) never touches `storeRepository` — a card gets the name
+ * only if the document already carries it.
+ *
+ * They were optional and effectively never written: the seller wizard, the three
+ * `create*Action` server actions and the appkit products route all set `storeId`
+ * and stopped there, so only seed data and the admin route ever produced a
+ * product with a store name on it. A seeded environment therefore looked correct
+ * and production did not — every real seller listing rendered a card with no
+ * seller on it.
+ *
+ * `cart-actions.ts` already carries a private copy of this idea (`resolveStoreName`),
+ * written to paper over the same gap one layer downstream. That is deliberately
+ * left alone: it resolves at ADD time from whatever the product happens to hold,
+ * which is still the correct last line of defence for carts built from products
+ * that predate this. This module fixes the source instead.
+ */
+export interface ProductStoreFields {
+    storeName: string;
+    storeSlug: string;
+}
+/**
+ * Resolve the display fields for one store.
+ *
+ * Degrades rather than throws — a listing that saves without its seller's
+ * display name is a cosmetic defect on a card, while a create that 500s because
+ * the store lookup blipped is a seller who cannot list. `storeId` IS the store
+ * slug in this codebase (see the store identity note in CLAUDE.md), so falling
+ * back to it yields a working link and a readable-if-ugly label, never a blank.
+ */
+export declare function resolveStoreFields(storeId: string, route: string): Promise<ProductStoreFields>;
+/**
+ * Batch form, for the backfill job and the rename re-sync.
+ *
+ * Sequential rather than `Promise.all` on purpose: the caller is a background
+ * job over a whole catalogue, distinct stores are few (the grouping is what
+ * makes this cheap), and a burst of parallel reads is exactly the shape Rule #6
+ * asks not to write.
+ */
+export declare function resolveStoreFieldsMany(storeIds: Iterable<string>, route: string): Promise<Map<string, ProductStoreFields>>;

package/dist/_internal/server/features/stores/denormalize.js

@@ -0,0 +1,58 @@
+/**
+ * The one place a product's denormalized store fields are derived.
+ *
+ * `ProductDocument.storeName` / `.storeSlug` are what every listing card renders
+ * as "by …". They have to be denormalized, because the public browse query
+ * (`listPublicProducts`) never touches `storeRepository` — a card gets the name
+ * only if the document already carries it.
+ *
+ * They were optional and effectively never written: the seller wizard, the three
+ * `create*Action` server actions and the appkit products route all set `storeId`
+ * and stopped there, so only seed data and the admin route ever produced a
+ * product with a store name on it. A seeded environment therefore looked correct
+ * and production did not — every real seller listing rendered a card with no
+ * seller on it.
+ *
+ * `cart-actions.ts` already carries a private copy of this idea (`resolveStoreName`),
+ * written to paper over the same gap one layer downstream. That is deliberately
+ * left alone: it resolves at ADD time from whatever the product happens to hold,
+ * which is still the correct last line of defence for carts built from products
+ * that predate this. This module fixes the source instead.
+ */
+import { storeRepository } from "../../../../features/stores/repository/store.repository";
+import { safeRead } from "../../../../errors/safe-read";
+/**
+ * Resolve the display fields for one store.
+ *
+ * Degrades rather than throws — a listing that saves without its seller's
+ * display name is a cosmetic defect on a card, while a create that 500s because
+ * the store lookup blipped is a seller who cannot list. `storeId` IS the store
+ * slug in this codebase (see the store identity note in CLAUDE.md), so falling
+ * back to it yields a working link and a readable-if-ugly label, never a blank.
+ */
+export async function resolveStoreFields(storeId, route) {
+    const store = await safeRead(() => storeRepository.findById(storeId), {
+        route,
+        key: "stores.findById",
+        fallback: null,
+    });
+    return {
+        storeName: store?.storeName ?? storeId,
+        storeSlug: store?.storeSlug ?? storeId,
+    };
+}
+/**
+ * Batch form, for the backfill job and the rename re-sync.
+ *
+ * Sequential rather than `Promise.all` on purpose: the caller is a background
+ * job over a whole catalogue, distinct stores are few (the grouping is what
+ * makes this cheap), and a burst of parallel reads is exactly the shape Rule #6
+ * asks not to write.
+ */
+export async function resolveStoreFieldsMany(storeIds, route) {
+    const out = new Map();
+    for (const storeId of new Set(storeIds)) {
+        out.set(storeId, await resolveStoreFields(storeId, route));
+    }
+    return out;
+}

package/dist/_internal/server/features/stores/index.d.ts

@@ -1,4 +1,5 @@
 export { getStoreForDetail, listStoreProductsInitial, listStoreAuctionsInitial, listStorePreOrdersInitial, listSitemapStores, } from "./data";
 export { STORES_PAGE_SIZE, STORES_PRODUCTS_PAGE_SIZE, STORES_SITEMAP_LIMIT, STORES_FEATURED_LIMIT, } from "../../../shared/features/stores/config";
 export { renderStoreOgImage, renderStoreOg, type StoreOgData } from "./og";
+export { resolveStoreFields, resolveStoreFieldsMany, type ProductStoreFields, } from "./denormalize";
 export { toStoreDetail, toStoreListItem, PUBLIC_STORE_FIELDS, PRIVATE_STORE_FIELDS, type ToStoreDetailOptions, type ToStoreListItemOptions, type StoreProjectionSource, } from "./adapters";

package/dist/_internal/server/features/stores/index.js

@@ -1,4 +1,5 @@
 export { getStoreForDetail, listStoreProductsInitial, listStoreAuctionsInitial, listStorePreOrdersInitial, listSitemapStores, } from "./data";
 export { STORES_PAGE_SIZE, STORES_PRODUCTS_PAGE_SIZE, STORES_SITEMAP_LIMIT, STORES_FEATURED_LIMIT, } from "../../../shared/features/stores/config";
 export { renderStoreOgImage, renderStoreOg } from "./og";
+export { resolveStoreFields, resolveStoreFieldsMany, } from "./denormalize";
 export { toStoreDetail, toStoreListItem, PUBLIC_STORE_FIELDS, PRIVATE_STORE_FIELDS, } from "./adapters";

package/dist/_internal/server/jobs/core/jobRunners.js

@@ -14,6 +14,7 @@ import { runResetOtpVerification } from "./resetOtpVerification";
 import { runWhatsAppNotify } from "./whatsappNotify";
 import { runNewsletterExport } from "./newsletterExport";
 import { runWhatsAppCatalogImport } from "./whatsappCatalogImport";
+import { runStoreNameBackfill } from "./storeNameBackfill";
 async function runPayoutsWeeklyJob(_payload, ctx) {
     const { payoutsCreated, ordersProcessed, payoutIds } = await runWeeklyPayoutEligibility(ctx);
     return {
@@ -49,6 +50,9 @@ async function runNewsletterExportJob(_payload, ctx) {
 async function runWhatsAppCatalogImportJob(payload, ctx) {
     return runWhatsAppCatalogImport({ storeSlug: String(payload.storeSlug ?? "") }, ctx);
 }
+async function runStoreNameBackfillJob(payload, ctx) {
+    return runStoreNameBackfill({ storeId: String(payload.storeId ?? "") }, ctx);
+}
 export const JOB_RUNNERS = {
     payoutsWeekly: runPayoutsWeeklyJob,
     hardBanCascade: runHardBanCascadeJob,
@@ -56,4 +60,5 @@ export const JOB_RUNNERS = {
     whatsappNotify: runWhatsAppNotifyJob,
     newsletterExport: runNewsletterExportJob,
     whatsappCatalogImport: runWhatsAppCatalogImportJob,
+    storeNameBackfill: runStoreNameBackfillJob,
 };

package/dist/_internal/server/jobs/core/storeNameBackfill.d.ts

@@ -0,0 +1,27 @@
+/**
+ * storeNameBackfill — re-sync a store's denormalized display fields onto its
+ * products.
+ *
+ * `ProductDocument.storeName` / `.storeSlug` are denormalized because the public
+ * browse query never touches `storeRepository`: a listing card can only show a
+ * seller if the product document already names one. Denormalizing without a
+ * re-sync is the mirror-drift trap (Root Cause #42) — a renamed store would keep
+ * showing its old name on every card it owns, forever, with nothing reporting a
+ * problem.
+ *
+ * This runs as a JOB rather than inline in the rename request because the write
+ * is unbounded: a store with hundreds of listings would blow the 10s Vercel
+ * ceiling (Rule #6). It reuses the existing Async Job Primitive
+ * (`enqueueJob` → `onJobCreated` → JOB_RUNNERS), so it costs no new Cloud
+ * Scheduler job.
+ *
+ * Idempotent: a product already carrying both correct values is skipped, so a
+ * re-run over a synced catalogue performs zero writes.
+ */
+import type { JobContext } from "../runtime/types";
+import type { JobRunResult } from "./jobRunners";
+export interface StoreNameBackfillPayload {
+    /** The store's slug — which is also its document id, and the products' `storeId`. */
+    storeId: string;
+}
+export declare function runStoreNameBackfill(payload: StoreNameBackfillPayload, ctx: JobContext): Promise<JobRunResult>;

package/dist/_internal/server/jobs/core/storeNameBackfill.js

@@ -0,0 +1,90 @@
+/**
+ * storeNameBackfill — re-sync a store's denormalized display fields onto its
+ * products.
+ *
+ * `ProductDocument.storeName` / `.storeSlug` are denormalized because the public
+ * browse query never touches `storeRepository`: a listing card can only show a
+ * seller if the product document already names one. Denormalizing without a
+ * re-sync is the mirror-drift trap (Root Cause #42) — a renamed store would keep
+ * showing its old name on every card it owns, forever, with nothing reporting a
+ * problem.
+ *
+ * This runs as a JOB rather than inline in the rename request because the write
+ * is unbounded: a store with hundreds of listings would blow the 10s Vercel
+ * ceiling (Rule #6). It reuses the existing Async Job Primitive
+ * (`enqueueJob` → `onJobCreated` → JOB_RUNNERS), so it costs no new Cloud
+ * Scheduler job.
+ *
+ * Idempotent: a product already carrying both correct values is skipped, so a
+ * re-run over a synced catalogue performs zero writes.
+ */
+import { storeRepository } from "../../../../features/stores/repository/store.repository";
+import { productRepository } from "../../../../features/products/repository/products.repository";
+import { normalizeError } from "../../../../errors/normalize";
+/** Firestore caps a batched write at 500 operations. */
+const BATCH_LIMIT = 500;
+export async function runStoreNameBackfill(payload, ctx) {
+    const { storeId } = payload;
+    const empty = {
+        summary: { total: 0, succeeded: 0, skipped: 0, failed: 0 },
+        succeeded: [],
+        skipped: [],
+        failed: [],
+    };
+    if (!storeId) {
+        return { ...empty, failed: [{ id: "-", reason: "storeId is required" }],
+            summary: { total: 0, succeeded: 0, skipped: 0, failed: 1 } };
+    }
+    const store = await storeRepository.findById(storeId);
+    if (!store) {
+        // Not an error worth failing the job over — a store deleted between the
+        // rename and this run is a race, not a fault. Its products are handled by
+        // the store-deletion cascade, not here.
+        ctx.logger.warn("storeNameBackfill: store not found", { storeId });
+        return { ...empty, skipped: [storeId], summary: { total: 0, succeeded: 0, skipped: 1, failed: 0 } };
+    }
+    const products = await productRepository.findByStore(storeId);
+    const stale = products.filter((p) => p.storeName !== store.storeName || p.storeSlug !== store.storeSlug);
+    const succeeded = [];
+    const failed = [];
+    for (let i = 0; i < stale.length; i += BATCH_LIMIT) {
+        const chunk = stale.slice(i, i + BATCH_LIMIT);
+        const batch = ctx.db.batch();
+        for (const product of chunk) {
+            batch.update(ctx.db.collection("products").doc(product.id), {
+                storeName: store.storeName,
+                storeSlug: store.storeSlug,
+                updatedAt: ctx.now,
+            });
+        }
+        try {
+            await batch.commit();
+            succeeded.push(...chunk.map((p) => p.id));
+        }
+        catch (err) {
+            // Per-chunk, not per-job: one failed batch must not discard the chunks
+            // that already committed, and the job is idempotent so a retry is safe.
+            const reason = normalizeError(err).message;
+            failed.push(...chunk.map((p) => ({ id: p.id, reason })));
+        }
+    }
+    const skipped = products.length - stale.length;
+    ctx.logger.info("storeNameBackfill: complete", {
+        storeId,
+        storeName: store.storeName,
+        updated: succeeded.length,
+        skipped,
+        failed: failed.length,
+    });
+    return {
+        summary: {
+            total: products.length,
+            succeeded: succeeded.length,
+            skipped,
+            failed: failed.length,
+        },
+        succeeded,
+        skipped: [],
+        failed,
+    };
+}

package/dist/_internal/shared/features/products/to-product-item.js

@@ -34,6 +34,13 @@ export function toProductItem(doc) {
         status: doc.status ?? "published",
         slug: typeof doc.slug === "string" ? doc.slug : undefined,
         storeName: typeof doc.storeName === "string" ? doc.storeName : undefined,
+        // `storeName` alone was carried here, and `storeId` was dropped — the same
+        // shape as the `listingType` bug two fields down, one field over. A card
+        // needs the id to decide whether it has a seller at all (a name can be
+        // absent on a document written before the create paths denormalized it),
+        // and the slug to name one without a second read.
+        storeId: typeof doc.storeId === "string" ? doc.storeId : undefined,
+        storeSlug: typeof doc.storeSlug === "string" ? doc.storeSlug : undefined,
         rating: typeof doc.rating === "number" ? doc.rating : undefined,
         reviewCount: typeof doc.reviewCount === "number" ? doc.reviewCount : undefined,
         // Without this, every related-item card silently linked to the standard

package/dist/client.d.ts

@@ -260,7 +260,7 @@ export { StoreAddonsPicker, hasAnyStoreAddon } from "./features/cart/index";
 export { clientLineTotal } from "./features/cart/utils/line-total";
 export type { PricedCartLine } from "./features/cart/utils/line-total";
 export type { CartPriceBreakdownData, CartPriceBreakdownStore, StoreAddonsValue, StoreAddonsRates } from "./features/cart/index";
-export { getCartOps, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
+export { getCartOps, clearCartOps, removeCartOpsFor, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
 export type { CartOp } from "./features/cart/utils/pending-ops";
 export type { CartItem, CartItemMeta, CartData, GuestCartItem } from "./features/cart/index";
 export type { CartLineKind, CartGroupSource, CartLineMember, } from "./features/cart/schemas/firestore";

package/dist/client.js

@@ -302,7 +302,10 @@ export { useLogout, useLogin, useGoogleLogin, useLinkGoogleAccount, useRegister,
 export { CartView, CartItemRow, CartGroupLineRow, CartSummary, CartPriceBreakdown, CartDrawer, CheckoutView, CheckoutSuccessView, CheckoutAddressStep, useGuestCart, useCartCount, useAddToCart, useCart, useGuestCartMerge, useCartQuery } from "./features/cart/index";
 export { StoreAddonsPicker, hasAnyStoreAddon } from "./features/cart/index";
 export { clientLineTotal } from "./features/cart/utils/line-total";
-export { getCartOps, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
+// `clearCartOps` / `removeCartOpsFor` are exported because the cart page has to
+// drain the queue after a removal succeeds server-side — without them a cleared
+// row is re-layered onto the next render and re-POSTed by useSyncManager 30s later.
+export { getCartOps, clearCartOps, removeCartOpsFor, CART_OPS_CHANGE_EVENT } from "./features/cart/utils/pending-ops";
 export { useAddresses, useCreateAddress, useUpdateAddress, useDeleteAddress, useSetDefaultAddress, useAddress } from "./features/account/index";
 export { AddressBook, AddressCard, AddressForm } from "./features/account/index";
 export { useProfile, useUpdateProfile } from "./features/account/index";

package/dist/features/admin/actions/admin-actions.js

@@ -17,8 +17,10 @@ import { getProviders } from "../../../contracts";
 import { getAdminAuth } from "../../../providers/db-firebase";
 import { isAdminUser } from "../../auth/role-predicates";
 import { assertPrizeDrawNotLocked, assertPrizeDrawWonItemsImmutable, } from "../../../_internal/server/features/products/service";
+import { resolveStoreFields } from "../../../_internal/server/features/stores/denormalize";
 import { recordAdminAction } from "../../../_internal/server/features/audit-log/actions";
 import { AdminAuditActionValues } from "../../audit-log/schemas/firestore";
+import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
 const ERR_UID_REQUIRED = "uid is required";
 export async function revokeSession(adminId, sessionId) {
     if (!sessionId?.trim()) {
@@ -253,10 +255,18 @@ export async function adminUpdateProduct(adminId, id, input) {
     return updated;
 }
 export async function adminCreateProduct(admin, input) {
+    // Resolve the real store rather than falling back to the literal "Admin",
+    // which is not a seller and renders as one on every listing card. `storeSlug`
+    // is denormalized alongside so a card can link without a second read; both
+    // re-sync through the storeNameBackfill job when the store is renamed.
+    const storeFields = input.storeId
+        ? await resolveStoreFields(input.storeId, ADMIN_ENDPOINTS.PRODUCTS)
+        : null;
     const product = await productRepository.create({
         ...input,
         storeId: input.storeId,
-        storeName: input.storeName || "Admin",
+        storeName: input.storeName || storeFields?.storeName,
+        storeSlug: storeFields?.storeSlug,
     });
     serverLogger.info("adminCreateProduct", {
         adminId: admin.uid,