@openlup/platform 0.26.0 → 0.27.0

package/dist/commerce/oms/omsContractBase.d.ts

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export declare const commerceOrderModeSchema: z.ZodEnum<{
+    one_time: "one_time";
+    subscription_cycle: "subscription_cycle";
+}>;
+export declare const omsPaymentStatusSchema: z.ZodEnum<{
+    expired: "expired";
+    created: "created";
+    failed: "failed";
+    cancelled: "cancelled";
+    refunded: "refunded";
+    not_started: "not_started";
+    requires_action: "requires_action";
+    processing: "processing";
+    partially_refunded: "partially_refunded";
+    disputed: "disputed";
+    succeeded: "succeeded";
+}>;
+export declare const omsPaymentAttemptStatusSchema: z.ZodEnum<{
+    expired: "expired";
+    created: "created";
+    failed: "failed";
+    cancelled: "cancelled";
+    requires_action: "requires_action";
+    processing: "processing";
+    succeeded: "succeeded";
+    blocked_preflight: "blocked_preflight";
+    sent_to_provider: "sent_to_provider";
+}>;
+export declare const omsSubscriptionCycleStatusSchema: z.ZodEnum<{
+    paid: "paid";
+    cancelled: "cancelled";
+    planned: "planned";
+    skipped: "skipped";
+    payment_pending: "payment_pending";
+    payment_failed: "payment_failed";
+    retry_scheduled: "retry_scheduled";
+}>;
+export declare const omsHoldReasonSchema: z.ZodEnum<{
+    payment_not_succeeded: "payment_not_succeeded";
+    inventory_review: "inventory_review";
+    risk_review: "risk_review";
+    fulfillment_exception: "fulfillment_exception";
+    address_review: "address_review";
+    manual_support: "manual_support";
+}>;
+export declare const omsHoldStatusSchema: z.ZodEnum<{
+    active: "active";
+    released: "released";
+}>;
+export declare const omsOperationTypeSchema: z.ZodEnum<{
+    hold_created: "hold_created";
+    hold_released: "hold_released";
+    fulfillment_reviewed: "fulfillment_reviewed";
+    support_note: "support_note";
+    shipping_address_updated: "shipping_address_updated";
+    order_marked_refunded: "order_marked_refunded";
+    order_cancelled_manual: "order_cancelled_manual";
+    replacement_shipment_requested: "replacement_shipment_requested";
+}>;
+export declare const omsFulfillmentBlockReasonSchema: z.ZodEnum<{
+    order_not_paid: "order_not_paid";
+    payment_not_succeeded: "payment_not_succeeded";
+    subscription_cycle_not_paid: "subscription_cycle_not_paid";
+    active_hold: "active_hold";
+    missing_shipping_address: "missing_shipping_address";
+    inventory_review: "inventory_review";
+    risk_review: "risk_review";
+}>;
+export declare const omsInventoryStatusSchema: z.ZodEnum<{
+    expired: "expired";
+    not_checked: "not_checked";
+    reserved: "reserved";
+    missing: "missing";
+    released: "released";
+    consumed: "consumed";
+    review_required: "review_required";
+}>;
+export declare const omsFulfillmentStatusSchema: z.ZodEnum<{
+    created: "created";
+    cancelled: "cancelled";
+    delivered: "delivered";
+    packed: "packed";
+    label_pending: "label_pending";
+    label_created: "label_created";
+    handed_over: "handed_over";
+    in_transit: "in_transit";
+    exception: "exception";
+}>;
+export declare const omsAccountingStatusSchema: z.ZodString;
+export declare const omsAttentionReasonSchema: z.ZodEnum<{
+    fulfillment_pending: "fulfillment_pending";
+    active_hold: "active_hold";
+    missing_shipping_address: "missing_shipping_address";
+    none: "none";
+    fulfillment_exception: "fulfillment_exception";
+    payment_required: "payment_required";
+    inventory_missing: "inventory_missing";
+    fulfillment_blocked: "fulfillment_blocked";
+    invoice_missing: "invoice_missing";
+    invoice_issue_failed: "invoice_issue_failed";
+    invoice_buyer_data_invalid: "invoice_buyer_data_invalid";
+}>;
+export declare const omsNextActionSchema: z.ZodEnum<{
+    none: "none";
+    review_payment: "review_payment";
+    release_hold: "release_hold";
+    review_address: "review_address";
+    review_inventory: "review_inventory";
+    review_fulfillment: "review_fulfillment";
+    create_fulfillment: "create_fulfillment";
+    record_label: "record_label";
+    hand_off: "hand_off";
+    review_tracking: "review_tracking";
+    review_invoice: "review_invoice";
+}>;
+export declare const omsProviderOpsStatusSchema: z.ZodString;
+export declare const omsProviderOpsSlaStatusSchema: z.ZodEnum<{
+    ok: "ok";
+    watch: "watch";
+    breached: "breached";
+    paused_non_shipping_day: "paused_non_shipping_day";
+}>;
+export declare const uuidSchema: z.ZodGUID;
+export declare const datetimeSchema: z.ZodString;
+export declare const nullableTextSchema: z.ZodNullable<z.ZodString>;
+export declare const actionEligibilitySchema: z.ZodObject<{
+    allowed: z.ZodBoolean;
+    reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;

package/dist/commerce/oms/omsContractBase.js

@@ -0,0 +1,86 @@
+import { PAYMENT_ATTEMPT_STATUSES, PAYMENT_INTENT_STATUSES } from "@openlup/core/payment";
+import { SUBSCRIPTION_CYCLE_STATUSES } from "@openlup/core/subscription";
+import { z } from "zod";
+import { OMS_FULFILLMENT_BLOCK_REASONS, OMS_INVENTORY_STATUSES, } from "../contracts/state.js";
+export const commerceOrderModeSchema = z.enum(["one_time", "subscription_cycle"]);
+export const omsPaymentStatusSchema = z.enum(["not_started", ...PAYMENT_INTENT_STATUSES]);
+export const omsPaymentAttemptStatusSchema = z.enum(PAYMENT_ATTEMPT_STATUSES);
+export const omsSubscriptionCycleStatusSchema = z.enum(SUBSCRIPTION_CYCLE_STATUSES);
+export const omsHoldReasonSchema = z.enum([
+    "payment_not_succeeded",
+    "inventory_review",
+    "risk_review",
+    "address_review",
+    "fulfillment_exception",
+    "manual_support",
+]);
+export const omsHoldStatusSchema = z.enum(["active", "released"]);
+export const omsOperationTypeSchema = z.enum([
+    "hold_created",
+    "hold_released",
+    "fulfillment_reviewed",
+    "support_note",
+    "shipping_address_updated",
+    "order_marked_refunded",
+    "order_cancelled_manual",
+    // The replacement command's audit row. The database CHECK was widened for it by
+    // 20260820100000_replacement_shipment_command.sql; without the same widening here
+    // the operation appears in `commerce_order_operations` and then fails this enum on
+    // every read of the order that carries it - the replacement response itself, and
+    // the whole order-detail timeline afterwards.
+    "replacement_shipment_requested",
+]);
+export const omsFulfillmentBlockReasonSchema = z.enum(OMS_FULFILLMENT_BLOCK_REASONS);
+export const omsInventoryStatusSchema = z.enum(OMS_INVENTORY_STATUSES);
+export const omsFulfillmentStatusSchema = z.enum([
+    "created",
+    "packed",
+    "label_pending",
+    "label_created",
+    "handed_over",
+    "in_transit",
+    "delivered",
+    "exception",
+    "cancelled",
+]);
+export const omsAccountingStatusSchema = z.string();
+export const omsAttentionReasonSchema = z.enum([
+    "none",
+    "payment_required",
+    "active_hold",
+    "missing_shipping_address",
+    "inventory_missing",
+    "fulfillment_blocked",
+    "fulfillment_pending",
+    "fulfillment_exception",
+    "invoice_missing",
+    "invoice_issue_failed",
+    "invoice_buyer_data_invalid",
+]);
+export const omsNextActionSchema = z.enum([
+    "none",
+    "review_payment",
+    "release_hold",
+    "review_address",
+    "review_inventory",
+    "review_fulfillment",
+    "create_fulfillment",
+    "record_label",
+    "hand_off",
+    "review_tracking",
+    "review_invoice",
+]);
+export const omsProviderOpsStatusSchema = z.string();
+export const omsProviderOpsSlaStatusSchema = z.enum([
+    "ok",
+    "watch",
+    "breached",
+    "paused_non_shipping_day",
+]);
+export const uuidSchema = z.guid();
+export const datetimeSchema = z.string().datetime({ offset: true });
+export const nullableTextSchema = z.string().nullable();
+export const actionEligibilitySchema = z.object({
+    allowed: z.boolean(),
+    reason: z.string().nullable(),
+}).strict();

package/dist/commerce/oms/omsContractReadAuxSchemas.d.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+export declare const omsPricingSummarySchema: z.ZodObject<{
+    subtotal: z.ZodObject<{
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    productDiscount: z.ZodObject<{
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    shipping: z.ZodObject<{
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    shippingDiscount: z.ZodObject<{
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    discountTotal: z.ZodObject<{
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    finalTotal: z.ZodObject<{
+        amountMinor: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>;
+    source: z.ZodLiteral<"order_columns">;
+}, z.core.$strict>;
+export declare const omsCommunicationDeliveryStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    processing: "processing";
+    delivered: "delivered";
+    planned: "planned";
+    skipped: "skipped";
+    blocked: "blocked";
+    queued: "queued";
+    sent: "sent";
+    delivery_delayed: "delivery_delayed";
+    bounced: "bounced";
+    complained: "complained";
+    missed: "missed";
+    legacy_unlinked: "legacy_unlinked";
+}>;
+export declare const omsCommunicationDeliverySchema: z.ZodObject<{
+    id: z.ZodGUID;
+    purpose: z.ZodString;
+    templateSlug: z.ZodString;
+    triggerSource: z.ZodString;
+    triggerEvent: z.ZodString;
+    aggregateType: z.ZodNullable<z.ZodString>;
+    aggregateId: z.ZodNullable<z.ZodString>;
+    dedupeKey: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        processing: "processing";
+        delivered: "delivered";
+        planned: "planned";
+        skipped: "skipped";
+        blocked: "blocked";
+        queued: "queued";
+        sent: "sent";
+        delivery_delayed: "delivery_delayed";
+        bounced: "bounced";
+        complained: "complained";
+        missed: "missed";
+        legacy_unlinked: "legacy_unlinked";
+    }>;
+    providerKind: z.ZodNullable<z.ZodString>;
+    providerMessageId: z.ZodNullable<z.ZodString>;
+    scheduledDueAt: z.ZodNullable<z.ZodString>;
+    expectedSendAt: z.ZodNullable<z.ZodString>;
+    queuedAt: z.ZodNullable<z.ZodString>;
+    firstAttemptAt: z.ZodNullable<z.ZodString>;
+    sentAt: z.ZodNullable<z.ZodString>;
+    deliveredAt: z.ZodNullable<z.ZodString>;
+    terminalAt: z.ZodNullable<z.ZodString>;
+    lastErrorCode: z.ZodNullable<z.ZodString>;
+    outboxEventId: z.ZodNullable<z.ZodGUID>;
+    platformJobRunId: z.ZodNullable<z.ZodGUID>;
+    emailSendId: z.ZodNullable<z.ZodGUID>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const omsDeliverySelectionSchema: z.ZodObject<{
+    deliveryKind: z.ZodEnum<{
+        "parcel-locker": "parcel-locker";
+        courier: "courier";
+    }>;
+    providerKind: z.ZodNullable<z.ZodString>;
+    carrierKind: z.ZodNullable<z.ZodString>;
+    carrierCode: z.ZodNullable<z.ZodString>;
+    serviceCode: z.ZodNullable<z.ZodString>;
+    pickupPoint: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodNullable<z.ZodObject<{
+            line1: z.ZodString;
+            postalCode: z.ZodString;
+            city: z.ZodString;
+            country: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    source: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const omsDeliveryContactSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    source: z.ZodString;
+    revision: z.ZodNumber;
+    recipientName: z.ZodNullable<z.ZodString>;
+    contactEmail: z.ZodNullable<z.ZodString>;
+    contactPhone: z.ZodNullable<z.ZodString>;
+    line1: z.ZodNullable<z.ZodString>;
+    line2: z.ZodNullable<z.ZodString>;
+    city: z.ZodNullable<z.ZodString>;
+    postalCode: z.ZodNullable<z.ZodString>;
+    country: z.ZodNullable<z.ZodString>;
+    selectedDelivery: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    deliveryInstructions: z.ZodNullable<z.ZodString>;
+    courierInstructions: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const omsDeliveryContactResolutionSchema: z.ZodObject<{
+    resolutionVersion: z.ZodLiteral<1>;
+    scope: z.ZodEnum<{
+        missing: "missing";
+        baseline: "baseline";
+        order_override: "order_override";
+        parcel: "parcel";
+        legacy_inferred: "legacy_inferred";
+    }>;
+    baseline: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        source: z.ZodString;
+        revision: z.ZodNumber;
+        recipientName: z.ZodNullable<z.ZodString>;
+        contactEmail: z.ZodNullable<z.ZodString>;
+        contactPhone: z.ZodNullable<z.ZodString>;
+        line1: z.ZodNullable<z.ZodString>;
+        line2: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        postalCode: z.ZodNullable<z.ZodString>;
+        country: z.ZodNullable<z.ZodString>;
+        selectedDelivery: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        deliveryInstructions: z.ZodNullable<z.ZodString>;
+        courierInstructions: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    contact: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        source: z.ZodString;
+        revision: z.ZodNumber;
+        recipientName: z.ZodNullable<z.ZodString>;
+        contactEmail: z.ZodNullable<z.ZodString>;
+        contactPhone: z.ZodNullable<z.ZodString>;
+        line1: z.ZodNullable<z.ZodString>;
+        line2: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        postalCode: z.ZodNullable<z.ZodString>;
+        country: z.ZodNullable<z.ZodString>;
+        selectedDelivery: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        deliveryInstructions: z.ZodNullable<z.ZodString>;
+        courierInstructions: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    contactDigest: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const omsDeliveryContactProjectionSchema: z.ZodObject<{
+    baseline: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        source: z.ZodString;
+        revision: z.ZodNumber;
+        recipientName: z.ZodNullable<z.ZodString>;
+        contactEmail: z.ZodNullable<z.ZodString>;
+        contactPhone: z.ZodNullable<z.ZodString>;
+        line1: z.ZodNullable<z.ZodString>;
+        line2: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        postalCode: z.ZodNullable<z.ZodString>;
+        country: z.ZodNullable<z.ZodString>;
+        selectedDelivery: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        deliveryInstructions: z.ZodNullable<z.ZodString>;
+        courierInstructions: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    effective: z.ZodNullable<z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        source: z.ZodString;
+        revision: z.ZodNumber;
+        recipientName: z.ZodNullable<z.ZodString>;
+        contactEmail: z.ZodNullable<z.ZodString>;
+        contactPhone: z.ZodNullable<z.ZodString>;
+        line1: z.ZodNullable<z.ZodString>;
+        line2: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        postalCode: z.ZodNullable<z.ZodString>;
+        country: z.ZodNullable<z.ZodString>;
+        selectedDelivery: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        deliveryInstructions: z.ZodNullable<z.ZodString>;
+        courierInstructions: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    scope: z.ZodEnum<{
+        missing: "missing";
+        baseline: "baseline";
+        order_override: "order_override";
+        parcel: "parcel";
+        legacy_inferred: "legacy_inferred";
+    }>;
+    source: z.ZodNullable<z.ZodString>;
+    revision: z.ZodNullable<z.ZodNumber>;
+    digest: z.ZodNullable<z.ZodString>;
+    frozen: z.ZodBoolean;
+    providerSubmissionState: z.ZodEnum<{
+        unknown: "unknown";
+        draft: "draft";
+        created: "created";
+        failed: "failed";
+        cancelled: "cancelled";
+        not_started: "not_started";
+        not_materialized: "not_materialized";
+        submitting: "submitting";
+        uncertain: "uncertain";
+        cancel_requested: "cancel_requested";
+    }>;
+    correctionAllowed: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/commerce/oms/omsContractReadAuxSchemas.js

@@ -0,0 +1,123 @@
+import { z } from "zod";
+import { datetimeSchema, nullableTextSchema, uuidSchema } from "./omsContractBase.js";
+import { commerceMoneySchema } from "./omsPrimitives.js";
+export const omsPricingSummarySchema = z.object({
+    subtotal: commerceMoneySchema,
+    productDiscount: commerceMoneySchema,
+    shipping: commerceMoneySchema,
+    shippingDiscount: commerceMoneySchema,
+    discountTotal: commerceMoneySchema,
+    finalTotal: commerceMoneySchema,
+    source: z.literal("order_columns"),
+}).strict();
+export const omsCommunicationDeliveryStatusSchema = z.enum([
+    "planned",
+    "queued",
+    "blocked",
+    "skipped",
+    "processing",
+    "sent",
+    "delivered",
+    "delivery_delayed",
+    "bounced",
+    "complained",
+    "failed",
+    "missed",
+    "legacy_unlinked",
+]);
+export const omsCommunicationDeliverySchema = z.object({
+    id: uuidSchema,
+    purpose: z.string().min(1),
+    templateSlug: z.string().min(1),
+    triggerSource: z.string().min(1),
+    triggerEvent: z.string().min(1),
+    aggregateType: z.string().nullable(),
+    aggregateId: z.string().nullable(),
+    dedupeKey: z.string().min(1),
+    status: omsCommunicationDeliveryStatusSchema,
+    providerKind: z.string().nullable(),
+    providerMessageId: z.string().nullable(),
+    scheduledDueAt: datetimeSchema.nullable(),
+    expectedSendAt: datetimeSchema.nullable(),
+    queuedAt: datetimeSchema.nullable(),
+    firstAttemptAt: datetimeSchema.nullable(),
+    sentAt: datetimeSchema.nullable(),
+    deliveredAt: datetimeSchema.nullable(),
+    terminalAt: datetimeSchema.nullable(),
+    lastErrorCode: z.string().nullable(),
+    outboxEventId: uuidSchema.nullable(),
+    platformJobRunId: uuidSchema.nullable(),
+    emailSendId: uuidSchema.nullable(),
+    metadata: z.record(z.string(), z.unknown()),
+    createdAt: datetimeSchema,
+    updatedAt: datetimeSchema,
+}).strict();
+export const omsDeliverySelectionSchema = z.object({
+    deliveryKind: z.enum(["courier", "parcel-locker"]),
+    providerKind: nullableTextSchema,
+    carrierKind: nullableTextSchema,
+    carrierCode: nullableTextSchema,
+    serviceCode: nullableTextSchema,
+    pickupPoint: z
+        .object({
+        id: z.string().min(1),
+        name: z.string().min(1),
+        address: z
+            .object({
+            line1: z.string().min(1),
+            postalCode: z.string().min(1),
+            city: z.string().min(1),
+            country: z.string().min(1),
+        })
+            .strict()
+            .nullable(),
+    })
+        .strict()
+        .nullable(),
+    source: nullableTextSchema,
+}).strict();
+export const omsDeliveryContactSchema = z.object({
+    schemaVersion: z.literal(1),
+    source: z.string().trim().min(1).max(80),
+    revision: z.number().int().positive(),
+    recipientName: nullableTextSchema,
+    contactEmail: nullableTextSchema,
+    contactPhone: nullableTextSchema,
+    line1: nullableTextSchema,
+    line2: nullableTextSchema,
+    city: nullableTextSchema,
+    postalCode: nullableTextSchema,
+    country: nullableTextSchema,
+    selectedDelivery: z.record(z.string(), z.unknown()).nullable(),
+    deliveryInstructions: nullableTextSchema,
+    courierInstructions: nullableTextSchema,
+}).strict();
+export const omsDeliveryContactResolutionSchema = z.object({
+    resolutionVersion: z.literal(1),
+    scope: z.enum(["baseline", "order_override", "parcel", "legacy_inferred", "missing"]),
+    baseline: omsDeliveryContactSchema.nullable(),
+    contact: omsDeliveryContactSchema.nullable(),
+    contactDigest: z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+}).strict().superRefine((value, context) => {
+    if (Boolean(value.contact) !== Boolean(value.contactDigest)) {
+        context.addIssue({
+            code: "custom",
+            message: "contact and contactDigest must be present together",
+            path: ["contactDigest"],
+        });
+    }
+});
+export const omsDeliveryContactProjectionSchema = z.object({
+    baseline: omsDeliveryContactSchema.nullable(),
+    effective: omsDeliveryContactSchema.nullable(),
+    scope: z.enum(["baseline", "order_override", "parcel", "legacy_inferred", "missing"]),
+    source: nullableTextSchema,
+    revision: z.number().int().positive().nullable(),
+    digest: z.string().regex(/^[0-9a-f]{32}$/).nullable(),
+    frozen: z.boolean(),
+    providerSubmissionState: z.enum([
+        "not_materialized", "not_started", "draft", "submitting", "created", "uncertain",
+        "failed", "cancel_requested", "cancelled", "unknown",
+    ]),
+    correctionAllowed: z.boolean(),
+}).strict();