@mohasinac/appkit 4.14.0 → 4.15.0

package/dist/features/events/schemas/event-form.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+/**
+ * ## `.passthrough()` STAYS here, deliberately
+ *
+ * `EventDraft` carries ~40 fields; this schema names seven. The blog form's
+ * equivalent was safe to tighten because its draft had fourteen fields and all
+ * fourteen could be named in one sitting. This one cannot: most of its fields
+ * are per-event-type (poll options, survey fields, spin prizes, raffle config)
+ * and only apply under a `type` discriminator, so naming them correctly means
+ * modelling the discriminated union rather than listing keys.
+ *
+ * Tightening it blind is the single most dangerous edit available in this
+ * codebase — `z.object()` strips unknown keys, so every field this schema
+ * failed to name would vanish from the draft the moment passthrough came off.
+ * That is exactly how `productBaseSchema` came to eat every `classified*` /
+ * `digitalCode*` / `liveItem*` / `prize*` field.
+ *
+ * The wire payload is NOT at risk either way: it is built explicitly below
+ * (`type`, `title`, `slug`, … plus `buildEventTypeConfig` /
+ * `buildEventRaffleFields`), never by spreading the draft.
+ *
+ * Prerequisite for removing it: a FULL-collection `roundtrip-diff --entity
+ * event --full`, not a sample — per the data-integrity protocol.
+ *
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export declare const eventDraftSchema: z.ZodEffects<z.ZodObject<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    type: z.ZodString;
+    title: z.ZodString;
+    startsAt: z.ZodString;
+    endsAt: z.ZodString;
+    couponId: z.ZodString;
+    displayCode: z.ZodString;
+    pollOptions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>;

package/dist/features/events/schemas/event-form.js

@@ -0,0 +1,82 @@
+/*
+ * WHY: Same reason as the blog form schema — keeping it in the `.tsx` view
+ *      would have dragged a React component tree into every API route through
+ *      `SCHEMAS` -> `routeHandler`.
+ * WHAT: The event editor's form schema, with its UI metadata.
+ *
+ * EXPORTS:
+ *   eventDraftSchema
+ *
+ * @tag domain:events
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:AdminEventEditorView,SCHEMAS.forms
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+/**
+ * ## `.passthrough()` STAYS here, deliberately
+ *
+ * `EventDraft` carries ~40 fields; this schema names seven. The blog form's
+ * equivalent was safe to tighten because its draft had fourteen fields and all
+ * fourteen could be named in one sitting. This one cannot: most of its fields
+ * are per-event-type (poll options, survey fields, spin prizes, raffle config)
+ * and only apply under a `type` discriminator, so naming them correctly means
+ * modelling the discriminated union rather than listing keys.
+ *
+ * Tightening it blind is the single most dangerous edit available in this
+ * codebase — `z.object()` strips unknown keys, so every field this schema
+ * failed to name would vanish from the draft the moment passthrough came off.
+ * That is exactly how `productBaseSchema` came to eat every `classified*` /
+ * `digitalCode*` / `liveItem*` / `prize*` field.
+ *
+ * The wire payload is NOT at risk either way: it is built explicitly below
+ * (`type`, `title`, `slug`, … plus `buildEventTypeConfig` /
+ * `buildEventRaffleFields`), never by spreading the draft.
+ *
+ * Prerequisite for removing it: a FULL-collection `roundtrip-diff --entity
+ * event --full`, not a sample — per the data-integrity protocol.
+ *
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export const eventDraftSchema = z.object({
+    type: annotate(z.string(), {
+        section: "details", sectionLabel: "Details", sectionRequired: true,
+        quick: true, order: 1, row: "pair", kind: "select",
+    }),
+    title: annotate(z.string().min(1, "Title is required"), {
+        section: "details", quick: true, order: 2, row: "full",
+    }),
+    startsAt: annotate(z.string().min(1, "Start date is required"), {
+        section: "details", quick: true, order: 3, row: "pair", kind: "date",
+    }),
+    endsAt: annotate(z.string().min(1, "End date is required"), {
+        section: "details", quick: true, order: 4, row: "pair", kind: "date",
+    }),
+    couponId: annotate(z.string(), {
+        section: "settings", sectionLabel: "Settings", order: 1, row: "pair",
+        help: "Required for offer events.",
+    }),
+    displayCode: annotate(z.string(), {
+        section: "settings", order: 2, row: "pair",
+        help: "Required for offer events.",
+    }),
+    pollOptions: annotate(z.array(z.object({ id: z.string(), label: z.string() })), {
+        section: "settings", order: 3, row: "full", kind: "list",
+    }),
+}).passthrough().superRefine((v, ctx) => {
+    if (v.type === "offer") {
+        if (!v.couponId.trim()) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["couponId"], message: "Coupon is required for offer events" });
+        }
+        if (!v.displayCode.trim()) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["displayCode"], message: "Display code is required for offer events" });
+        }
+    }
+    if (v.type === "poll" && v.pollOptions.filter((o) => o.label.trim()).length < 2) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["pollOptions"], message: "Poll events require at least 2 options" });
+    }
+});

package/dist/features/grouped/schemas/grouped-listing-form.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export declare const groupedListingFormSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    groupTheme: z.ZodEnum<["related", "character", "lineage", "set", "generic"]>;
+    productIds: z.ZodArray<z.ZodString, "many">;
+    minActiveMembers: z.ZodNumber;
+    coverImage: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodBoolean;
+    isFeatured: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    isActive: boolean;
+    isFeatured: boolean;
+    productIds: string[];
+    groupTheme: "set" | "related" | "character" | "lineage" | "generic";
+    minActiveMembers: number;
+    description?: string | undefined;
+    coverImage?: string | undefined;
+}, {
+    title: string;
+    isActive: boolean;
+    isFeatured: boolean;
+    productIds: string[];
+    groupTheme: "set" | "related" | "character" | "lineage" | "generic";
+    minActiveMembers: number;
+    description?: string | undefined;
+    coverImage?: string | undefined;
+}>;
+export type GroupedListingFormValues = z.infer<typeof groupedListingFormSchema>;
+/**
+ * Create contract. `storeId` is absent — the store route sets it from the
+ * session, so a seller cannot file a group under another store.
+ */
+export declare const groupedListingCreateSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    isActive: z.ZodBoolean;
+    isFeatured: z.ZodOptional<z.ZodBoolean>;
+    coverImage: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    productIds: z.ZodArray<z.ZodString, "many">;
+    groupTheme: z.ZodEnum<["related", "character", "lineage", "set", "generic"]>;
+    minActiveMembers: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    isActive: boolean;
+    productIds: string[];
+    groupTheme: "set" | "related" | "character" | "lineage" | "generic";
+    description?: string | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    minActiveMembers?: number | undefined;
+}, {
+    title: string;
+    isActive: boolean;
+    productIds: string[];
+    groupTheme: "set" | "related" | "character" | "lineage" | "generic";
+    description?: string | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    minActiveMembers?: number | undefined;
+}>;
+/** Update contract — partial, `.strict()` so an unknown key is a 400. */
+export declare const groupedListingUpdateSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    groupTheme: z.ZodOptional<z.ZodEnum<["related", "character", "lineage", "set", "generic"]>>;
+    productIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    minActiveMembers: z.ZodOptional<z.ZodNumber>;
+    coverImage: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodOptional<z.ZodBoolean>;
+    isFeatured: z.ZodOptional<z.ZodBoolean>;
+    brandSlug: z.ZodOptional<z.ZodString>;
+    categorySlug: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    title?: string | undefined;
+    description?: string | undefined;
+    categorySlug?: string | undefined;
+    brandSlug?: string | undefined;
+    isActive?: boolean | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    productIds?: string[] | undefined;
+    groupTheme?: "set" | "related" | "character" | "lineage" | "generic" | undefined;
+    minActiveMembers?: number | undefined;
+}, {
+    title?: string | undefined;
+    description?: string | undefined;
+    categorySlug?: string | undefined;
+    brandSlug?: string | undefined;
+    isActive?: boolean | undefined;
+    isFeatured?: boolean | undefined;
+    coverImage?: string | undefined;
+    productIds?: string[] | undefined;
+    groupTheme?: "set" | "related" | "character" | "lineage" | "generic" | undefined;
+    minActiveMembers?: number | undefined;
+}>;

package/dist/features/grouped/schemas/grouped-listing-form.js

@@ -0,0 +1,89 @@
+/*
+ * WHY: `POST /api/store/grouped-listings` spread the raw request body into
+ *      `.create()` and its PATCH built `{...body}` — no Zod on either. The two
+ *      pages behind them validated one field between them (`new` checked
+ *      `title` was non-empty and toasted; `[id]/edit` checked nothing at all).
+ * WHAT: One schema for the pages AND the store routes.
+ *
+ * ## `activeMemberCount` is NOT in this schema
+ *
+ * It is derived — both routes already recompute it from `productIds.length`,
+ * which is correct and was verified rather than assumed. Accepting it from the
+ * body would let a caller set a count that disagrees with the array, and the
+ * count is what the public visibility check reads.
+ *
+ * `slug`, `visibilityStatus` and `createdBy` are absent for the same reason:
+ * derived or session-owned, never typed.
+ *
+ * EXPORTS:
+ *   groupedListingFormSchema, groupedListingCreateSchema,
+ *   groupedListingUpdateSchema, type GroupedListingFormValues
+ *
+ * @tag domain:grouped
+ * @tag layer:schema
+ * @tag pattern:none
+ * @tag access:isomorphic
+ * @tag consumers:store/grouped-listings pages,/api/store/grouped-listings
+ * @tag sideEffects:none
+ */
+import { z } from "zod";
+import { annotate } from "../../shell/field-ui-meta";
+/** Mirrors `GroupTheme` in ./firestore. */
+const groupThemeSchema = z.enum(["related", "character", "lineage", "set", "generic"]);
+/**
+ * 🛑 `annotate()` must be the OUTERMOST call on each field — it keys a WeakMap
+ * by schema instance and every zod wrapper returns a new one.
+ */
+export const groupedListingFormSchema = z.object({
+    title: annotate(z.string().min(1, "Title is required").max(120, "Keep the title under 120 characters."), {
+        section: "basics", sectionLabel: "Group", sectionRequired: true,
+        quick: true, order: 1, row: "full",
+    }),
+    description: annotate(z.string().max(500, "Keep the description under 500 characters.").optional(), {
+        section: "basics", order: 2, row: "full",
+    }),
+    groupTheme: annotate(groupThemeSchema, {
+        section: "basics", quick: true, order: 3, row: "pair",
+    }),
+    productIds: annotate(z.array(z.string()), {
+        section: "members", sectionLabel: "Members", order: 1, row: "full", kind: "list",
+    }),
+    minActiveMembers: annotate(z.coerce.number().int("Must be a whole number.").min(1, "A group needs at least one member to show."), {
+        section: "members", order: 2, row: "pair",
+        help: "Below this many in-stock members, the group hides itself.",
+    }),
+    coverImage: annotate(z.string().optional(), {
+        section: "media", sectionLabel: "Media", order: 1, row: "full", kind: "media",
+    }),
+    isActive: annotate(z.boolean(), {
+        section: "visibility", sectionLabel: "Visibility", order: 1, row: "quarter",
+    }),
+    isFeatured: annotate(z.boolean(), {
+        section: "visibility", order: 2, row: "quarter",
+    }),
+});
+/**
+ * Create contract. `storeId` is absent — the store route sets it from the
+ * session, so a seller cannot file a group under another store.
+ */
+export const groupedListingCreateSchema = groupedListingFormSchema.partial({
+    description: true,
+    coverImage: true,
+    isFeatured: true,
+    minActiveMembers: true,
+});
+/** Update contract — partial, `.strict()` so an unknown key is a 400. */
+export const groupedListingUpdateSchema = z
+    .object({
+    title: z.string().min(1).max(120).optional(),
+    description: z.string().max(500).optional(),
+    groupTheme: groupThemeSchema.optional(),
+    productIds: z.array(z.string()).optional(),
+    minActiveMembers: z.coerce.number().int().min(1).optional(),
+    coverImage: z.string().optional(),
+    isActive: z.boolean().optional(),
+    isFeatured: z.boolean().optional(),
+    brandSlug: z.string().optional(),
+    categorySlug: z.string().optional(),
+})
+    .strict();

package/dist/features/homepage/actions/homepage-section-actions.d.ts

@@ -2,21 +2,29 @@ import { z } from "zod";
 import type { HomepageSectionDocument } from "../schemas";
 import type { FirebaseSieveResult } from "../../../providers/db-firebase";
 export declare const createSectionSchema: z.ZodObject<{
-    type: z.ZodString;
+    type: z.ZodEnum<["welcome", "carousel", "stats", "trust-indicators", "categories", "brands", "products", "pre-orders", "auctions", "banner", "features", "reviews", "whatsapp-community", "faq", "blog-articles", "newsletter", "stores", "events", "social-feed", "custom-cards", "google-reviews", "featured-bundles", "prize-draws", "event-raffles", "collection-cards"]>;
     enabled: z.ZodDefault<z.ZodBoolean>;
     order: z.ZodDefault<z.ZodNumber>;
     config: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
 }, "strip", z.ZodTypeAny, {
-    type: string;
+    type: "banner" | "stores" | "products" | "pre-orders" | "prize-draws" | "auctions" | "reviews" | "events" | "categories" | "brands" | "carousel" | "newsletter" | "features" | "stats" | "welcome" | "trust-indicators" | "whatsapp-community" | "faq" | "blog-articles" | "social-feed" | "custom-cards" | "google-reviews" | "featured-bundles" | "event-raffles" | "collection-cards";
     enabled: boolean;
     order: number;
     config?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
 }, {
-    type: string;
+    type: "banner" | "stores" | "products" | "pre-orders" | "prize-draws" | "auctions" | "reviews" | "events" | "categories" | "brands" | "carousel" | "newsletter" | "features" | "stats" | "welcome" | "trust-indicators" | "whatsapp-community" | "faq" | "blog-articles" | "social-feed" | "custom-cards" | "google-reviews" | "featured-bundles" | "event-raffles" | "collection-cards";
     enabled?: boolean | undefined;
     order?: number | undefined;
     config?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
 }>;
+/**
+ * The next free `order` value.
+ *
+ * `HomepageSectionCreateInput.order` is REQUIRED, and both API create routes
+ * need the same answer for "the caller did not choose one". Two copies of this
+ * query is how they would come to disagree about where a new section lands.
+ */
+export declare function resolveNextSectionOrder(): Promise<number>;
 export declare const updateSectionSchema: z.ZodObject<{
     order: z.ZodOptional<z.ZodNumber>;
     enabled: z.ZodOptional<z.ZodBoolean>;

package/dist/features/homepage/actions/homepage-section-actions.js

@@ -1,13 +1,45 @@
 import { z } from "zod";
 import { serverLogger } from "../../../monitoring";
+import { sortBy } from "../../../constants/sort";
+import { HOMEPAGE_SECTION_FIELDS } from "../../../constants/field-names";
 import { homepageSectionsRepository } from "../repository/homepage-sections.repository";
+import { homepageSectionTypeSchema } from "../schemas";
 // --- Schemas --------------------------------------------------------------
+/*
+ * 🛑 `type` was `z.string().min(1)` — ANY non-empty string.
+ *
+ * This is the third of three create paths for `homepageSections`
+ * (`POST /api/admin/sections`, `POST /api/homepage-sections`, and this server
+ * action via `createHomepageSectionAction`), and it was the loosest: a caller
+ * could store a section whose `type` matches no renderer, which the homepage
+ * then skips in silence — a row that exists, occupies an order slot, and draws
+ * nothing.
+ *
+ * All three now agree on `homepageSectionTypeSchema`, which is derived from
+ * the `SectionType` union.
+ */
 export const createSectionSchema = z.object({
-    type: z.string().min(1),
+    type: homepageSectionTypeSchema,
     enabled: z.boolean().default(true),
     order: z.number().int().default(0),
     config: z.object({}).passthrough().optional(),
 });
+/**
+ * The next free `order` value.
+ *
+ * `HomepageSectionCreateInput.order` is REQUIRED, and both API create routes
+ * need the same answer for "the caller did not choose one". Two copies of this
+ * query is how they would come to disagree about where a new section lands.
+ */
+export async function resolveNextSectionOrder() {
+    const latest = await homepageSectionsRepository.list({
+        sorts: sortBy(HOMEPAGE_SECTION_FIELDS.ORDER),
+        page: "1",
+        pageSize: "1",
+    });
+    const top = latest.items[0]?.order;
+    return typeof top === "number" ? top + 1 : 1;
+}
 export const updateSectionSchema = z.object({
     order: z.number().int().optional(),
     enabled: z.boolean().optional(),

package/dist/features/homepage/schemas/index.d.ts

@@ -47,6 +47,37 @@ export declare const homepageSectionFirestoreSchema: z.ZodObject<{
     order: number;
     config: Record<string, JsonValue>;
 }>;
+/**
+ * The create contract for a homepage section, shared by BOTH routes that can
+ * create one — `POST /api/admin/sections` (what the editor calls) and
+ * `POST /api/homepage-sections` (reachable by URL only).
+ *
+ * It exists because those two had drifted into being one validated path and
+ * one raw `{...body}` spread, and because the validated one's hand-written
+ * type list had fallen four values behind `SectionType` — so an admin could
+ * configure a Featured Bundles / Prize Draws / Event Raffles / Collection
+ * Cards section in full and get a 400 on save.
+ *
+ * `type` comes from `homepageSectionTypeSchema`, which is derived from the
+ * union, so that gap cannot reopen.
+ */
+export declare const homepageSectionCreateSchema: z.ZodObject<{
+    type: z.ZodEnum<["welcome", "carousel", "stats", "trust-indicators", "categories", "brands", "products", "pre-orders", "auctions", "banner", "features", "reviews", "whatsapp-community", "faq", "blog-articles", "newsletter", "stores", "events", "social-feed", "custom-cards", "google-reviews", "featured-bundles", "prize-draws", "event-raffles", "collection-cards"]>;
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    order: z.ZodOptional<z.ZodNumber>;
+    config: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, z.ZodTypeDef, JsonValue>>;
+}, "strip", z.ZodTypeAny, {
+    type: "banner" | "stores" | "products" | "pre-orders" | "prize-draws" | "auctions" | "reviews" | "events" | "categories" | "brands" | "carousel" | "newsletter" | "features" | "stats" | "welcome" | "trust-indicators" | "whatsapp-community" | "faq" | "blog-articles" | "social-feed" | "custom-cards" | "google-reviews" | "featured-bundles" | "event-raffles" | "collection-cards";
+    enabled: boolean;
+    config: Record<string, JsonValue>;
+    order?: number | undefined;
+}, {
+    type: "banner" | "stores" | "products" | "pre-orders" | "prize-draws" | "auctions" | "reviews" | "events" | "categories" | "brands" | "carousel" | "newsletter" | "features" | "stats" | "welcome" | "trust-indicators" | "whatsapp-community" | "faq" | "blog-articles" | "social-feed" | "custom-cards" | "google-reviews" | "featured-bundles" | "event-raffles" | "collection-cards";
+    config: Record<string, JsonValue>;
+    enabled?: boolean | undefined;
+    order?: number | undefined;
+}>;
+export type HomepageSectionCreateValues = z.infer<typeof homepageSectionCreateSchema>;
 export declare const carouselBackgroundSchema: z.ZodObject<{
     type: z.ZodEnum<["image", "video", "color", "gradient"]>;
     url: z.ZodOptional<z.ZodString>;

package/dist/features/homepage/schemas/index.js

@@ -56,6 +56,30 @@ export const homepageSectionFirestoreSchema = z.object({
     config: z.record(z.string(), jsonValueSchema),
     ...auditTimestampsShape,
 });
+/**
+ * The create contract for a homepage section, shared by BOTH routes that can
+ * create one — `POST /api/admin/sections` (what the editor calls) and
+ * `POST /api/homepage-sections` (reachable by URL only).
+ *
+ * It exists because those two had drifted into being one validated path and
+ * one raw `{...body}` spread, and because the validated one's hand-written
+ * type list had fallen four values behind `SectionType` — so an admin could
+ * configure a Featured Bundles / Prize Draws / Event Raffles / Collection
+ * Cards section in full and get a 400 on save.
+ *
+ * `type` comes from `homepageSectionTypeSchema`, which is derived from the
+ * union, so that gap cannot reopen.
+ */
+export const homepageSectionCreateSchema = z.object({
+    type: homepageSectionTypeSchema,
+    enabled: z.boolean().optional().default(true),
+    order: z.number().int().optional(),
+    // Deliberately open. Every section type carries a different config shape,
+    // and a closed schema here would silently STRIP the builder's output for any
+    // type it did not enumerate — the `productBaseSchema` failure, one domain
+    // over.
+    config: z.record(z.string(), jsonValueSchema),
+});
 export const carouselBackgroundSchema = z.object({
     type: z.enum(["image", "video", "color", "gradient"]),
     url: z.string().optional(),

package/dist/features/orders/components/OrderStatusTimeline.d.ts

@@ -1,5 +1,9 @@
+import { type TimelineEntry } from "../../status-history/components/StatusTimeline";
 export interface OrderStatusTimelineProps {
     orderStatus: string;
+    /** Recorded history. When present it wins over the scalar-date fallback. */
+    timeline?: TimelineEntry[];
+    timelineTruncated?: number;
     orderDate?: string;
     shippingDate?: string;
     deliveryDate?: string;
@@ -9,4 +13,4 @@ export interface OrderStatusTimelineProps {
     trackingUrl?: string;
     className?: string;
 }
-export declare function OrderStatusTimeline({ orderStatus, orderDate, shippingDate, deliveryDate, cancellationDate, trackingNumber, shippingCarrier, trackingUrl, className, }: OrderStatusTimelineProps): import("react").JSX.Element;
+export declare function OrderStatusTimeline({ orderStatus, timeline, timelineTruncated, orderDate, shippingDate, deliveryDate, cancellationDate, trackingNumber, shippingCarrier, trackingUrl, className, }: OrderStatusTimelineProps): import("react").JSX.Element;

package/dist/features/orders/components/OrderStatusTimeline.js

@@ -1,16 +1,25 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /**
- * OrderStatusTimeline — a genuine (not fabricated/estimated) status timeline
- * built from the real per-status timestamps already written by the
- * order-status-update path (`orderDate`/`shippingDate`/`deliveryDate`/
- * `cancellationDate`). No live courier-API integration — `trackingUrl` is
- * just the passthrough link a seller/admin entered, rendered as an external
- * link that opens in a new tab. Statuses with no dedicated date field
- * (confirmed/processing/return_requested/returned/refunded) render as a step
- * without a timestamp rather than showing a made-up date.
+ * OrderStatusTimeline — the order-shaped wrapper around `<StatusTimeline>`.
+ *
+ * Two branches, and the fallback matters as much as the primary path:
+ *
+ * **Branch A — real history.** When the order carries `timeline` entries
+ * (written by the repository since W2), each status change becomes a step
+ * dated by when it actually happened, stamped with who did it. This finally
+ * makes transitions with no dedicated date field visible at all — a payment
+ * review, a re-upload request, a partial refund.
+ *
+ * **Branch B — legacy orders.** Every order written before `statusHistory`
+ * existed has none, and back-filling one would mean inventing timestamps. So
+ * the original derivation from the four scalar dates is kept verbatim for
+ * those. Statuses with no dedicated date field render without one.
+ *
+ * No live courier API: `trackingUrl` is the passthrough link a seller entered.
  */
-import { Anchor, Badge, Div, Heading, Row, Stack, Text } from "../../../ui";
+import { Anchor, Badge, Row, Stack, Text } from "../../../ui";
+import { StatusTimeline, stepsFromEntries, } from "../../status-history/components/StatusTimeline";
 const STAGE_SEQUENCE = ["pending", "confirmed", "processing", "shipped", "delivered"];
 const STAGE_LABELS = {
     pending: "Order placed",
@@ -23,10 +32,16 @@ const STAGE_LABELS = {
     returned: "Returned",
     refunded: "Refunded",
 };
-function buildSteps(props) {
+const NEGATIVE_STATUSES = new Set(["cancelled"]);
+const labelFor = (status) => STAGE_LABELS[status] ?? status;
+const isNegative = (status) => NEGATIVE_STATUSES.has(status);
+/** Branch B — derive from the four scalar dates, for orders with no history. */
+function buildLegacySteps(props) {
     const status = (props.orderStatus ?? "").toLowerCase();
     const currentIndex = STAGE_SEQUENCE.indexOf(status);
-    const steps = [{ key: "pending", label: STAGE_LABELS.pending, date: props.orderDate }];
+    const steps = [
+        { key: "pending", label: STAGE_LABELS.pending, date: props.orderDate },
+    ];
     if ((status === "confirmed" || status === "processing") && !props.shippingDate) {
         steps.push({ key: status, label: STAGE_LABELS[status] });
     }
@@ -37,19 +52,23 @@ function buildSteps(props) {
         steps.push({ key: "delivered", label: STAGE_LABELS.delivered, date: props.deliveryDate });
     }
     if (status === "cancelled" || props.cancellationDate) {
-        steps.push({ key: "cancelled", label: STAGE_LABELS.cancelled, date: props.cancellationDate });
+        steps.push({
+            key: "cancelled",
+            label: STAGE_LABELS.cancelled,
+            date: props.cancellationDate,
+            negative: true,
+        });
     }
     else if (status === "return_requested" || status === "returned" || status === "refunded") {
         steps.push({ key: status, label: STAGE_LABELS[status] ?? status });
     }
     return steps;
 }
-export function OrderStatusTimeline({ orderStatus, orderDate, shippingDate, deliveryDate, cancellationDate, trackingNumber, shippingCarrier, trackingUrl, className = "", }) {
-    const steps = buildSteps({ orderStatus, orderDate, shippingDate, deliveryDate, cancellationDate });
-    const isTerminalNegative = steps[steps.length - 1]?.key === "cancelled";
-    return (_jsxs(Div, { className: className, rounded: "xl", padding: "md", surface: "muted", border: "default", children: [_jsx(Heading, { level: 3, size: "sm", weight: "semibold", color: "muted", className: "mb-3", children: "Tracking" }), _jsx(Stack, { gap: "none", children: steps.map((step, i) => {
-                    const isLast = i === steps.length - 1;
-                    const isNegative = step.key === "cancelled";
-                    return (_jsxs(Row, { gap: "sm", padding: isLast ? "none" : "b-md", children: [_jsxs(Stack, { gap: "none", align: "center", className: "shrink-0", children: [_jsx(Div, { className: `h-2.5 w-2.5 ${isNegative ? "" : "bg-[var(--appkit-color-primary)]"}`, rounded: "full", surface: isNegative ? "danger-surface" : "none" }), !isLast && _jsx(Div, { className: "w-px flex-1 min-h-[24px]", surface: "subtle" })] }), _jsxs(Stack, { gap: "none", className: "min-w-0 flex-1", children: [_jsx(Text, { size: "sm", weight: "medium", className: isNegative ? "text-error" : undefined, children: step.label }), _jsx(Text, { size: "xs", color: "muted", children: step.date ? new Date(step.date).toLocaleString() : "—" })] })] }, step.key));
-                }) }), (trackingNumber || shippingCarrier || trackingUrl) && !isTerminalNegative && (_jsx(Div, { className: "mt-3 border-t border-[var(--appkit-color-border)]", padding: "t-sm", children: _jsxs(Stack, { gap: "xs", children: [shippingCarrier && (_jsxs(Row, { justify: "between", children: [_jsx(Text, { size: "sm", color: "muted", children: "Carrier" }), _jsx(Text, { size: "sm", weight: "medium", children: shippingCarrier })] })), trackingNumber && (_jsxs(Row, { justify: "between", children: [_jsx(Text, { size: "sm", color: "muted", children: "Tracking number" }), _jsx(Text, { size: "sm", weight: "medium", children: trackingNumber })] })), trackingUrl && (_jsx(Row, { justify: "end", children: _jsx(Anchor, { href: trackingUrl, tone: "brand", weight: "semibold", size: "sm", children: "Track with carrier \u2192" }) }))] }) })), !trackingNumber && !trackingUrl && !isTerminalNegative && (_jsx(Badge, { variant: "default", className: "mt-3", children: "No tracking details yet" }))] }));
+export function OrderStatusTimeline({ orderStatus, timeline, timelineTruncated, orderDate, shippingDate, deliveryDate, cancellationDate, trackingNumber, shippingCarrier, trackingUrl, className = "", }) {
+    const fromHistory = stepsFromEntries(timeline, labelFor, isNegative);
+    const steps = fromHistory.length
+        ? fromHistory
+        : buildLegacySteps({ orderStatus, orderDate, shippingDate, deliveryDate, cancellationDate });
+    const hasTracking = Boolean(trackingNumber || shippingCarrier || trackingUrl);
+    return (_jsx(StatusTimeline, { title: "Tracking", steps: steps, truncatedCount: timelineTruncated, className: className, footer: hasTracking ? (_jsxs(Stack, { gap: "xs", children: [shippingCarrier && (_jsxs(Row, { justify: "between", children: [_jsx(Text, { size: "sm", color: "muted", children: "Carrier" }), _jsx(Text, { size: "sm", weight: "medium", children: shippingCarrier })] })), trackingNumber && (_jsxs(Row, { justify: "between", children: [_jsx(Text, { size: "sm", color: "muted", children: "Tracking number" }), _jsx(Text, { size: "sm", weight: "medium", children: trackingNumber })] })), trackingUrl && (_jsx(Row, { justify: "end", children: _jsx(Anchor, { href: trackingUrl, tone: "brand", weight: "semibold", size: "sm", children: "Track with carrier \u2192" }) }))] })) : (_jsx(Badge, { variant: "default", children: "No tracking details yet" })) }));
 }