@openlup/platform 0.26.0 → 0.27.0

package/dist/commerce/model/omsReadModelList.js

@@ -0,0 +1,50 @@
+import { adminCommerceOrdersListResponseSchema } from "../oms/omsContracts.js";
+import { summarizeOmsListTotals } from "./omsListTotals.js";
+import { findCustomer } from "./omsReadModelHelpers.js";
+import { summarizeOmsListOrders } from "./omsReadModelListSummary.js";
+import { buildOmsOrderRowCore } from "./omsReadModelRowCore.js";
+import { COMMERCE_CONTRACT_VERSION } from "../../pricing/contracts/index.js";
+export function buildOmsOrderListResponse(input) {
+    const orders = input.orders.map((order) => {
+        // The list's only job on top of the shared core is to narrow each collection
+        // to this order; the detail hands the core the singletons it already loaded.
+        const { row: listItem } = buildOmsOrderRowCore({
+            projections: input.projections,
+            order,
+            activeHoldCount: input.activeHoldCounts[order.id] ?? 0,
+            paymentIntents: input.paymentIntents,
+            paymentAttempts: input.paymentAttempts ?? [],
+            identity: { customer: findCustomer(order, input.customers ?? []), ...input.identityExtras?.[order.id] },
+            orderItems: input.orderItems?.filter((item) => item.order_id === order.id),
+            inventoryReservations: (input.inventoryReservations ?? []).filter((reservation) => reservation.order_id === order.id),
+            fulfillmentOrders: (input.fulfillmentOrders ?? []).filter((candidate) => candidate.order_id === order.id),
+            fulfillmentOperations: input.fulfillmentOperations ?? [],
+            shipmentExternalRefs: (input.shipmentExternalRefs ?? []).filter((candidate) => candidate.order_id === order.id),
+            dispatchRefs: input.providerDispatchRefs ?? [],
+            statusEvidence: input.providerStatusEvidence ?? [],
+            releasedProviderExceptionHolds: (input.releasedProviderExceptionHolds ?? []).filter((hold) => hold.order_id === order.id),
+            accountingInvoice: (input.accountingInvoices ?? []).find((invoice) => invoice.order_id === order.id) ?? null,
+            accountingOutbox: input.accountingOutbox ?? [],
+            subscriptionCycleStatus: order.subscription_cycle_id ? input.subscriptionCycleStatuses?.[order.subscription_cycle_id] ?? null : null,
+        });
+        // Both diagnostics arrive as per-order maps built by the read that owns the
+        // rows they are derived from - the hold `reason` column for one, the health
+        // builder for the other - exactly as `activeHoldCounts` already does. A caller
+        // that supplies neither gets the quiet row it would have got before this wave.
+        const diagnostics = {
+            activeHoldReasons: input.activeHoldReasons?.[order.id] ?? [],
+            fulfillmentHealthDigest: input.fulfillmentHealthDigests?.[order.id] ?? { healthStatus: "ok", attentionReasons: [] },
+        };
+        const match = input.searchMatches?.[order.id];
+        return match ? { ...listItem, ...diagnostics, match } : { ...listItem, ...diagnostics };
+    });
+    return (input.projections?.parseList ?? (value => adminCommerceOrdersListResponseSchema.parse(value)))({
+        contractVersion: COMMERCE_CONTRACT_VERSION,
+        orders,
+        summaryCounts: input.summaryCounts ?? summarizeOmsListOrders(orders, input.projections),
+        summaryTotals: input.summaryTotals ?? summarizeOmsListTotals(orders, input.projections?.currency),
+        totalCount: input.totalCount,
+        page: input.page,
+        pageSize: input.pageSize,
+    });
+}

package/dist/commerce/model/omsReadModelListSummary.d.ts

@@ -0,0 +1,3 @@
+import type { AdminCommerceOrdersListResponse } from "../oms/omsContracts.js";
+import type { OmsReadModelProjections } from "./omsReadModelProjections.js";
+export declare function summarizeOmsListOrders(orders: AdminCommerceOrdersListResponse["orders"], projections?: OmsReadModelProjections): AdminCommerceOrdersListResponse["summaryCounts"];

package/dist/commerce/model/omsReadModelListSummary.js

@@ -0,0 +1,13 @@
+export function summarizeOmsListOrders(orders, projections) {
+    return {
+        needsAttention: orders.filter((order) => order.attentionReason !== "none").length,
+        activeHold: orders.filter((order) => order.activeHoldCount > 0).length,
+        readyForFulfillment: orders.filter((order) => order.nextAction === "create_fulfillment").length,
+        paymentIssues: orders.filter((order) => order.attentionReason === "payment_required").length,
+        inventoryRisk: orders.filter((order) => order.attentionReason === "inventory_missing").length,
+        fulfillmentBlocked: orders.filter((order) => order.attentionReason === "fulfillment_blocked").length,
+        fulfillmentExceptions: orders.filter((order) => order.attentionReason === "fulfillment_exception").length,
+        invoiceIssues: orders.filter((order) => order.nextAction === "review_invoice").length,
+        providerDispatchedNotPicked: orders.filter((order) => Boolean(projections?.dispatchedNotPickedStatus) && order.providerOpsStatus === projections?.dispatchedNotPickedStatus).length,
+    };
+}

package/dist/commerce/model/omsReadModelPricing.d.ts

@@ -0,0 +1,5 @@
+import type { OmsOrderDetail } from "../oms/omsContracts.js";
+import type { OmsOrderItemRow, OmsOrderRow } from "./omsReadModelRows.js";
+import { type CanonicalOrderMoney } from "../orderMoney.js";
+export declare function deriveOmsOrderMoney(order: OmsOrderRow, items?: readonly OmsOrderItemRow[]): CanonicalOrderMoney;
+export declare function pricingSummaryForOrder(order: OmsOrderRow, items?: readonly OmsOrderItemRow[], orderMoney?: CanonicalOrderMoney): OmsOrderDetail["pricingSummary"];

package/dist/commerce/model/omsReadModelPricing.js

@@ -0,0 +1,36 @@
+import { deriveOrderMoney, } from "../orderMoney.js";
+export function deriveOmsOrderMoney(order, items) {
+    return deriveOrderMoney({
+        id: order.id,
+        currency: order.currency,
+        subtotal_cents: order.subtotal_cents ?? order.total_cents,
+        discount_cents: order.discount_cents ?? 0,
+        shipping_cents: order.shipping_cents ?? 0,
+        shipping_discount_cents: order.shipping_discount_cents ?? 0,
+        tax_cents: order.tax_cents ?? 0,
+        total_cents: order.total_cents,
+    }, items?.map((item) => ({
+        id: item.id,
+        quantity: item.quantity,
+        unit_price_cents: item.unit_price_cents ?? 0,
+        total_cents: item.total_cents ?? 0,
+        discount_allocated_cents: item.discount_allocated_cents,
+        effective_total_cents: item.effective_total_cents,
+        effective_net_cents: item.effective_net_cents,
+        vat_rate_bps: item.vat_rate_bps ?? 0,
+    })));
+}
+export function pricingSummaryForOrder(order, items, orderMoney = deriveOmsOrderMoney(order, items)) {
+    return {
+        subtotal: money(orderMoney.subtotal, order.currency),
+        productDiscount: money(orderMoney.productDiscount, order.currency),
+        shipping: money(orderMoney.shippingEffective, order.currency),
+        shippingDiscount: money(orderMoney.shippingDiscount, order.currency),
+        discountTotal: money(orderMoney.productDiscount + orderMoney.shippingDiscount, order.currency),
+        finalTotal: money(orderMoney.total, order.currency),
+        source: "order_columns",
+    };
+}
+function money(amountMinor, currency) {
+    return { amountMinor, currency };
+}

package/dist/commerce/model/omsReadModelProjections.d.ts

@@ -0,0 +1 @@
+export type { OmsReadModelProjections } from "../contracts/omsTypes.js";

package/dist/commerce/model/omsReadModelProjections.js

@@ -0,0 +1 @@
+export {};

package/dist/commerce/model/omsReadModelRowCore.d.ts

@@ -0,0 +1,79 @@
+import type { OmsDeliveryContactResolution, OmsOrderDetail } from "../oms/omsContracts.js";
+import { type OmsProviderDispatchRefRow as OmsDispatchRefRow, type OmsFulfillmentOrderRow } from "./omsFulfillmentSummary.js";
+import type { OmsOrderRowCore, OmsOrderRowCoreInput } from "./omsReadModelRows.js";
+export declare function buildOmsOrderRowCore(input: OmsOrderRowCoreInput): OmsOrderRowCore;
+type DeliveryContact = NonNullable<NonNullable<OmsOrderDetail["deliveryContact"]>["effective"]>;
+export declare function buildOmsDeliveryContactProjection(input: {
+    resolution: OmsDeliveryContactResolution;
+    currentParcel: OmsFulfillmentOrderRow | null;
+    dispatchRefs: OmsDispatchRefRow[];
+}): NonNullable<OmsOrderDetail["deliveryContact"]>;
+export declare function deliveryContactAddress(contact: DeliveryContact | null, addressId: string | null | undefined): OmsOrderDetail["shippingAddress"];
+export declare function buildCurrentDeliveryContact(input: {
+    resolution: OmsDeliveryContactResolution;
+    shippingAddressId: string | null | undefined;
+    fulfillmentOrders: OmsFulfillmentOrderRow[];
+    dispatchRefs: OmsDispatchRefRow[];
+}): {
+    deliveryContact: {
+        baseline: null | {
+            schemaVersion: 1;
+            source: string;
+            revision: number;
+            recipientName: null | string;
+            contactEmail: null | string;
+            contactPhone: null | string;
+            line1: null | string;
+            line2: null | string;
+            city: null | string;
+            postalCode: null | string;
+            country: null | string;
+            selectedDelivery: null | {
+                [key: string]: unknown;
+            };
+            deliveryInstructions: null | string;
+            courierInstructions: null | string;
+        };
+        effective: null | {
+            schemaVersion: 1;
+            source: string;
+            revision: number;
+            recipientName: null | string;
+            contactEmail: null | string;
+            contactPhone: null | string;
+            line1: null | string;
+            line2: null | string;
+            city: null | string;
+            postalCode: null | string;
+            country: null | string;
+            selectedDelivery: null | {
+                [key: string]: unknown;
+            };
+            deliveryInstructions: null | string;
+            courierInstructions: null | string;
+        };
+        scope: "missing" | "baseline" | "order_override" | "parcel" | "legacy_inferred";
+        source: null | string;
+        revision: null | number;
+        digest: null | string;
+        frozen: false | true;
+        providerSubmissionState: "draft" | "failed" | "cancelled" | "not_started" | "created" | "unknown" | "not_materialized" | "submitting" | "uncertain" | "cancel_requested";
+        correctionAllowed: false | true;
+    };
+    effectiveShippingAddress: {
+        id: string;
+        label: null | string;
+        line1: null | string;
+        line2: null | string;
+        city: null | string;
+        postalCode: null | string;
+        country: null | string;
+        recipientName: null | string;
+        contactPhone: null | string;
+        companyName: null | string;
+        taxId: null | string;
+        deliveryNotes: null | string;
+        courierInstructions: null | string;
+    } | null;
+};
+export {};

package/dist/commerce/model/omsReadModelRowCore.js

@@ -0,0 +1,149 @@
+import { accountingSummary } from "./omsAccountingVisibility.js";
+import { buildOmsFulfillmentSummary, deriveOmsCustomerFulfillmentStep } from "./omsFulfillmentSummary.js";
+import { paymentMethodForOrder } from "./omsPaymentMethodSummary.js";
+import { baseOrder, evaluateOperationalState, inventorySummary, paymentStatusForOrder, } from "./omsReadModelHelpers.js";
+import { evaluateCommerceFulfillmentEligibility } from "../fulfillmentEligibility.js";
+export function buildOmsOrderRowCore(input) {
+    const paymentStatus = paymentStatusForOrder(input.order.id, input.paymentIntents);
+    const paymentMethod = paymentMethodForOrder(input.order.id, input.paymentIntents, input.paymentAttempts, input.projections);
+    const inventory = inventorySummary(input.inventoryReservations, input.orderItems ?? []);
+    const fulfillment = buildOmsFulfillmentSummary({
+        projections: input.projections,
+        fulfillmentOrders: input.fulfillmentOrders,
+        fulfillmentOperations: input.fulfillmentOperations,
+        shipmentExternalRefs: input.shipmentExternalRefs,
+        providerAttempts: input.providerAttempts,
+        providerDispatchRefs: input.dispatchRefs,
+        providerStatusEvidence: input.statusEvidence,
+    });
+    const providerOps = input.projections?.providerOps?.(input) ?? { status: "none", sla: null, providerOrderId: null };
+    const customerFulfillmentStep = deriveOmsCustomerFulfillmentStep(input.order.status, fulfillment, input.fulfillmentOrders[0]?.delivered_at, input.releasedProviderExceptionHolds, input.statusEvidence, input.activeHoldCount, input.projections);
+    const accounting = accountingSummary(input.accountingInvoice, input.accountingOutbox, input.projections);
+    const fulfillmentEligibility = evaluateCommerceFulfillmentEligibility({
+        orderMode: input.order.mode,
+        orderStatus: input.order.status,
+        paymentStatus,
+        subscriptionCycleStatus: input.subscriptionCycleStatus,
+        activeHoldCount: input.activeHoldCount,
+        hasShippingAddress: Boolean(input.order.shipping_address_id),
+        inventoryStatus: inventory.status,
+    });
+    const operational = evaluateOperationalState({
+        order: input.order,
+        paymentStatus,
+        activeHoldCount: input.activeHoldCount,
+        inventoryStatus: inventory.status,
+        fulfillmentStatus: fulfillment.status,
+        fulfillmentEligibility,
+        accountingStatus: accounting.status,
+    });
+    return {
+        row: baseOrder({
+            order: input.order,
+            paymentStatus,
+            paymentMethod,
+            activeHoldCount: input.activeHoldCount,
+            identity: input.identity,
+            inventoryStatus: inventory.status,
+            fulfillmentStatus: fulfillment.status,
+            customerFulfillmentStep,
+            accountingStatus: accounting.status,
+            providerOpsStatus: providerOps.status,
+            providerOpsSla: providerOps.sla,
+            providerOrderId: providerOps.providerOrderId,
+            attentionReason: operational.attentionReason,
+            nextAction: operational.nextAction,
+            orderItems: input.orderItems,
+            orderMoney: input.orderMoney,
+        }),
+        paymentStatus,
+        inventory,
+        fulfillment,
+        accounting,
+        fulfillmentEligibility,
+    };
+}
+export function buildOmsDeliveryContactProjection(input) {
+    const baseline = parseDeliveryContact(input.resolution.baseline);
+    const effective = parseDeliveryContact(input.resolution.contact);
+    const providerSubmissionState = deliveryContactProviderSubmissionState(input.currentParcel, input.dispatchRefs);
+    const frozen = input.dispatchRefs.some(deliveryContactRefIsEffectful)
+        || Boolean(input.currentParcel && !canUpdateShippingAddress(input.currentParcel.status));
+    return {
+        baseline, effective, scope: input.resolution.scope, source: effective?.source ?? null,
+        revision: effective?.revision ?? null, digest: effective ? input.resolution.contactDigest : null,
+        frozen, providerSubmissionState,
+        correctionAllowed: Boolean(effective && input.resolution.contactDigest) && !frozen,
+    };
+}
+export function deliveryContactAddress(contact, addressId) {
+    if (!contact || !addressId)
+        return null;
+    return {
+        id: addressId, label: null, line1: contact.line1, line2: contact.line2,
+        city: contact.city, postalCode: contact.postalCode, country: contact.country,
+        recipientName: contact.recipientName, contactPhone: contact.contactPhone,
+        companyName: null, taxId: null, deliveryNotes: contact.deliveryInstructions,
+        courierInstructions: contact.courierInstructions,
+    };
+}
+export function buildCurrentDeliveryContact(input) {
+    const currentParcel = input.fulfillmentOrders[0] ?? null;
+    const deliveryContact = buildOmsDeliveryContactProjection({
+        resolution: input.resolution,
+        currentParcel,
+        dispatchRefs: currentParcel
+            ? input.dispatchRefs.filter((row) => row.fulfillment_order_id === currentParcel.id)
+            : [],
+    });
+    return {
+        deliveryContact,
+        effectiveShippingAddress: deliveryContactAddress(deliveryContact.effective, input.shippingAddressId),
+    };
+}
+function parseDeliveryContact(value) {
+    const row = objectRecord(value);
+    if (row.schemaVersion !== 1)
+        return null;
+    const source = nullableText(row.source);
+    const revision = positiveInteger(row.revision);
+    if (!source || revision === null)
+        return null;
+    return {
+        schemaVersion: 1, source, revision,
+        recipientName: nullableText(row.recipientName), contactEmail: nullableText(row.contactEmail),
+        contactPhone: nullableText(row.contactPhone), line1: nullableText(row.line1),
+        line2: nullableText(row.line2), city: nullableText(row.city),
+        postalCode: nullableText(row.postalCode), country: nullableText(row.country),
+        selectedDelivery: recordOrNull(row.selectedDelivery),
+        deliveryInstructions: nullableText(row.deliveryInstructions),
+        courierInstructions: nullableText(row.courierInstructions),
+    };
+}
+function deliveryContactProviderSubmissionState(parcel, dispatchRefs) {
+    if (!parcel)
+        return "not_materialized";
+    if (!dispatchRefs.length)
+        return "not_started";
+    const dispatchRef = dispatchRefs.find(deliveryContactRefIsEffectful) ?? dispatchRefs[0];
+    const known = ["draft", "submitting", "created", "uncertain", "failed", "cancel_requested", "cancelled"];
+    return known.find((status) => status === dispatchRef.status) ?? "unknown";
+}
+function deliveryContactRefIsEffectful(dispatchRef) {
+    return Boolean(dispatchRef && !(dispatchRef.status === "draft" && !dispatchRef.provider_order_id));
+}
+function objectRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function recordOrNull(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function nullableText(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : null;
+}
+function canUpdateShippingAddress(status) {
+    return !status || status === "created" || status === "packed" || status === "label_pending";
+}

package/dist/commerce/model/omsReadModelRows.d.ts

@@ -0,0 +1 @@
+export type { OmsAccountingInvoiceRow, OmsAccountingOutboxRow, OmsAddressRow, OmsCommunicationDeliveryRow, OmsCustomerRow, OmsHoldRow, OmsInventoryReservationRow, OmsOperationRow, OmsOrderItemRow, OmsOrderRow, OmsOrderRowCore, OmsOrderRowCoreInput, OmsPaymentAttemptRow, OmsPaymentIntentRow, OmsPaymentTransitionRow } from "../contracts/omsTypes.js";

package/dist/commerce/model/omsReadModelRows.js

@@ -0,0 +1,6 @@
+export {};
+// Every status union below is read back out of the contract the row feeds, so a
+// vocabulary can only be widened in one place. The rows are DB shapes, not
+// contract shapes, so the derivation is by indexed access rather than by
+// re-importing the zod schemas - this file stays type-only and carries no
+// runtime import.

package/dist/commerce/offerAvailability.d.ts

@@ -0,0 +1,18 @@
+import type { CommerceOfferAvailability, CommerceOfferAvailabilityRequestItem, CommerceOfferAvailabilityStatus } from "./contracts/availability.js";
+export declare const DEFAULT_LOW_STOCK_THRESHOLD = 20;
+export interface DeriveOfferAvailabilityInput extends CommerceOfferAvailabilityRequestItem {
+    sellableNow: number | null;
+    lowStockThreshold?: number;
+    source: string;
+}
+export declare function deriveOfferAvailability(input: DeriveOfferAvailabilityInput): CommerceOfferAvailability;
+export declare function defaultOfferAvailability(item: CommerceOfferAvailabilityRequestItem, source?: string): CommerceOfferAvailability;
+export declare function availabilityBySku(items: readonly CommerceOfferAvailability[]): Map<string, CommerceOfferAvailability>;
+/**
+ * The status ladder itself, exported so a composed offer (a bundle derives one
+ * status from many components) reads the SAME four rungs rather than mirroring
+ * them. A second copy would drift the first time a rung moves.
+ */
+export declare function statusForSellableNow(sellableNow: number | null, lowStockThreshold?: number): CommerceOfferAvailabilityStatus;
+/** The reason-code vocabulary for a stock-derived status; exported for the same reason. */
+export declare function reasonCodeFor(status: CommerceOfferAvailabilityStatus): string;

package/dist/commerce/offerAvailability.js

@@ -0,0 +1,53 @@
+export const DEFAULT_LOW_STOCK_THRESHOLD = 20;
+export function deriveOfferAvailability(input) {
+    const status = statusForSellableNow(input.sellableNow, input.lowStockThreshold);
+    return {
+        sku: input.sku,
+        productSlug: input.productSlug,
+        variantId: input.variantId,
+        status,
+        visibleInConfigurator: status !== "out_of_stock",
+        sellableNow: input.sellableNow,
+        reasonCode: reasonCodeFor(status),
+        source: input.source,
+    };
+}
+export function defaultOfferAvailability(item, source = "static") {
+    return {
+        sku: item.sku,
+        productSlug: item.productSlug,
+        variantId: item.variantId,
+        status: "available",
+        visibleInConfigurator: true,
+        sellableNow: null,
+        reasonCode: "static_available",
+        source,
+    };
+}
+export function availabilityBySku(items) {
+    return new Map(items.map((item) => [item.sku, item]));
+}
+/**
+ * The status ladder itself, exported so a composed offer (a bundle derives one
+ * status from many components) reads the SAME four rungs rather than mirroring
+ * them. A second copy would drift the first time a rung moves.
+ */
+export function statusForSellableNow(sellableNow, lowStockThreshold = DEFAULT_LOW_STOCK_THRESHOLD) {
+    if (sellableNow == null)
+        return "unknown";
+    if (sellableNow <= 0)
+        return "out_of_stock";
+    if (sellableNow <= lowStockThreshold)
+        return "low_stock";
+    return "available";
+}
+/** The reason-code vocabulary for a stock-derived status; exported for the same reason. */
+export function reasonCodeFor(status) {
+    if (status === "available")
+        return "stock_available";
+    if (status === "low_stock")
+        return "low_stock";
+    if (status === "out_of_stock")
+        return "out_of_stock";
+    return "stock_unknown";
+}

package/dist/commerce/offerAvailabilitySchemas.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import type { CommerceOfferAvailabilityRequestItem } from "./contracts/index.js";
+/** Bind the existing product identifier and SKU validators without importing a host. */
+export declare function createOfferAvailabilitySchemas(catalogProductSlugSchema: z.ZodType<string, string>, commerceSkuSchema: z.ZodType<string, string>): {
+    commerceOfferAvailabilityStatusSchema: z.ZodEnum<{
+        unknown: "unknown";
+        available: "available";
+        low_stock: "low_stock";
+        out_of_stock: "out_of_stock";
+    }>;
+    commerceOfferAvailabilitySourceSchema: z.ZodString;
+    commerceOfferAvailabilityRequestItemSchema: z.ZodObject<{
+        sku: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        productSlug: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        variantId: z.ZodString;
+        requestedQuantity: z.ZodDefault<z.ZodNumber>;
+        checkoutMode: z.ZodDefault<z.ZodEnum<{
+            subscription: "subscription";
+            one_time: "one_time";
+        }>>;
+    }, z.core.$strict>;
+    commerceOfferAvailabilitySchema: z.ZodObject<{
+        sku: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        productSlug: z.ZodType<string, string, z.core.$ZodTypeInternals<string, string>>;
+        variantId: z.ZodString;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            available: "available";
+            low_stock: "low_stock";
+            out_of_stock: "out_of_stock";
+        }>;
+        visibleInConfigurator: z.ZodBoolean;
+        sellableNow: z.ZodNullable<z.ZodNumber>;
+        reasonCode: z.ZodString;
+        source: z.ZodString;
+    }, z.core.$strict>;
+};
+/** One request per variant, preserving order and checkout mode. */
+export declare function offerAvailabilityRequestItems(variants: readonly {
+    sku: string;
+    slug: string;
+    variantId: string;
+}[], checkoutMode: CommerceOfferAvailabilityRequestItem["checkoutMode"]): CommerceOfferAvailabilityRequestItem[];

package/dist/commerce/offerAvailabilitySchemas.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+/** Bind the existing product identifier and SKU validators without importing a host. */
+export function createOfferAvailabilitySchemas(catalogProductSlugSchema, commerceSkuSchema) {
+    const commerceOfferAvailabilityStatusSchema = z.enum([
+        "available",
+        "low_stock",
+        "out_of_stock",
+        "unknown",
+    ]);
+    const commerceOfferAvailabilitySourceSchema = z
+        .string()
+        .trim()
+        .min(1)
+        .max(80);
+    const commerceOfferAvailabilityRequestItemSchema = z
+        .object({
+        sku: commerceSkuSchema,
+        productSlug: catalogProductSlugSchema,
+        variantId: z.string().trim().min(1).max(120),
+        requestedQuantity: z.number().int().positive().default(1),
+        checkoutMode: z.enum(["one_time", "subscription"]).default("one_time"),
+    })
+        .strict();
+    const commerceOfferAvailabilitySchema = z
+        .object({
+        sku: commerceSkuSchema,
+        productSlug: catalogProductSlugSchema,
+        variantId: z.string().trim().min(1).max(120),
+        status: commerceOfferAvailabilityStatusSchema,
+        visibleInConfigurator: z.boolean(),
+        sellableNow: z.number().int().nonnegative().nullable(),
+        reasonCode: z.string().trim().min(1).max(120),
+        source: commerceOfferAvailabilitySourceSchema,
+    })
+        .strict();
+    return { commerceOfferAvailabilityStatusSchema, commerceOfferAvailabilitySourceSchema, commerceOfferAvailabilityRequestItemSchema, commerceOfferAvailabilitySchema };
+}
+/** One request per variant, preserving order and checkout mode. */
+export function offerAvailabilityRequestItems(variants, checkoutMode) {
+    return variants.map(variant => ({ sku: variant.sku, productSlug: variant.slug,
+        variantId: variant.variantId, requestedQuantity: 1, checkoutMode }));
+}

package/dist/commerce/offerEvidenceSchemas.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/**
+ * The adopter's own record of why a checkout was bound to an offer version.
+ * Server-minted only: core bounds its keys and size and never reads it.
+ */
+export declare const commerceOfferEvidenceSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type CommerceOfferEvidence = z.infer<typeof commerceOfferEvidenceSchema>;

package/dist/commerce/offerEvidenceSchemas.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+const COMMERCE_OFFER_EVIDENCE_MAX_JSON_LENGTH = 4_096;
+/**
+ * The adopter's own record of why a checkout was bound to an offer version.
+ * Server-minted only: core bounds its keys and size and never reads it.
+ */
+export const commerceOfferEvidenceSchema = z
+    .record(z.string().regex(/^[A-Za-z][A-Za-z0-9]{0,39}$/), z.unknown())
+    .superRefine((evidence, ctx) => {
+    if (JSON.stringify(evidence).length > COMMERCE_OFFER_EVIDENCE_MAX_JSON_LENGTH) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "offer evidence exceeds 4096 characters" });
+    }
+});