@openlup/platform 0.26.0 → 0.28.0

package/dist/commerce/orderReviewPorts.d.ts

@@ -0,0 +1,140 @@
+import type { OrderReview, OrderReviewAdminDetail, OrderReviewMedia, OrderReviewMediaConfirm, OrderReviewMediaIntent, OrderReviewMediaIntentResult, OrderReviewModeration, OrderReviewReadResult, OrderReviewSubmit } from "./orderReviewContracts.js";
+export type Replay<T> = {
+    value: T;
+    replayed: boolean;
+};
+/** Server-only storage locator. It is not a public schema or BFF DTO. */
+export type OrderReviewMediaObject = {
+    media: OrderReviewMedia;
+    objectKey: string;
+};
+/** A live raw-upload lease; the clear capability itself is deliberately absent. */
+export type OrderReviewUploadReservation = OrderReviewMediaObject & {
+    leaseVersion: number;
+    leaseExpiresAt: string;
+    declaredContentType: "image/jpeg" | "image/png" | "image/webp";
+    declaredByteLength: number;
+};
+/** Physical deletion is fenced by a durable, non-public cleanup receipt. */
+export type OrderReviewMediaCleanup = OrderReviewMediaObject & {
+    tempKey?: string;
+    cleanupReceipt: string;
+    replayed: boolean;
+};
+export type OrderReviewUploadAdmission = {
+    kind: "unavailable";
+} | {
+    kind: "conflict";
+} | {
+    kind: "lease";
+    reservation: OrderReviewUploadReservation;
+} | {
+    kind: "complete";
+    media: OrderReviewMedia;
+};
+/** Claimed by one worker; no worker may scan a volume or infer an object key. */
+export type OrderReviewMediaReconcileTask = {
+    receipt: string;
+    kind: "finalize" | "delete";
+    objectKey: string;
+    tempKey?: string;
+    expectedDeclaredContentType: "image/jpeg" | "image/png" | "image/webp";
+    expectedDeclaredByteLength: number;
+};
+export type OrderReviewMediaReconcileOutcome = {
+    kind: "stored";
+    observedContentType: "image/jpeg" | "image/png" | "image/webp";
+    observedByteLength: number;
+    observedDigest: string;
+} | {
+    kind: "deleted";
+} | {
+    kind: "retry";
+    reason: string;
+};
+export interface OrderReviewLifecyclePort {
+    /** null means an invalid/revoked grant; { review: null } is an eligible first submission. */
+    read(grant: string): Promise<OrderReviewReadResult | null>;
+    submit(input: OrderReviewSubmit): Promise<Replay<OrderReview>>;
+    createMediaIntent(input: OrderReviewMediaIntent): Promise<OrderReviewMediaIntentResult>;
+    confirmMedia(input: OrderReviewMediaConfirm): Promise<Replay<OrderReviewMedia>>;
+    moderate(input: OrderReviewModeration & {
+        actorRef: string;
+    }): Promise<Replay<OrderReview>>;
+    revoke(input: {
+        reviewRef: string;
+        actorRef: string;
+        idempotencyKey: string;
+    }): Promise<{
+        replayed: boolean;
+    }>;
+}
+/** Metadata-only seam. Lane B owns bytes and can never resolve a grant directly. */
+export interface OrderReviewMediaPort {
+    /** The route may expose only .media; .objectKey is for the object-store adapter. */
+    readAuthorized(grant: string, mediaRef: string): Promise<OrderReviewMediaObject | null>;
+    /**
+     * Raw ingress supplies only SHA-256(clear capability), never grant/order/media
+     * identifiers. The implementation must lock and re-check grant -> review ->
+     * media while admitting this live lease.
+     */
+    admitUpload(input: {
+        capabilityDigest: string;
+        declaredContentType: "image/jpeg" | "image/png" | "image/webp";
+        declaredByteLength: number;
+        writerRef: string;
+    }): Promise<OrderReviewUploadAdmission>;
+    /** The transaction remains open across promote; a stale grant/lease cannot rename. */
+    finalizeUpload(input: {
+        capabilityDigest: string;
+        writerRef: string;
+        leaseVersion: number;
+        digest: string;
+        byteLength: number;
+        promote: () => Promise<void>;
+    }): Promise<OrderReviewMedia | null>;
+    abortUpload(input: {
+        capabilityDigest: string;
+        writerRef: string;
+        leaseVersion: number;
+        reason: string;
+    }): Promise<void>;
+    readAdmin(input: {
+        actorRef: string;
+        mediaRef: string;
+    }): Promise<OrderReviewMediaObject | null>;
+    /** Marks cleanup_pending and returns the exact object key plus durable receipt. */
+    prepareAdminDelete(input: {
+        actorRef: string;
+        mediaRef: string;
+        idempotencyKey: string;
+    }): Promise<OrderReviewMediaCleanup | null>;
+    /** May mark deleted only after object storage confirms physical removal. */
+    completeAdminDelete(input: {
+        actorRef: string;
+        cleanupReceipt: string;
+    }): Promise<{
+        replayed: boolean;
+    }>;
+    /** Claims bounded exact keys under SKIP LOCKED; B owns physical inspection/deletion. */
+    claimReconcile(limit: number): Promise<OrderReviewMediaReconcileTask[]>;
+    /** Fenced completion cannot overwrite a later lease or a different object outcome. */
+    completeReconcile(input: {
+        receipt: string;
+        outcome: OrderReviewMediaReconcileOutcome;
+    }): Promise<void>;
+}
+export interface OrderReviewAdminReadPort {
+    list(input: {
+        actorRef: string;
+        cursor?: string;
+        limit: number;
+    }): Promise<{
+        items: OrderReview[];
+        nextCursor?: string;
+    }>;
+    read(input: {
+        actorRef: string;
+        reviewRef: string;
+    }): Promise<OrderReviewAdminDetail | null>;
+}

package/dist/commerce/orderReviewPorts.js

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

package/dist/commerce/outboxDispatchContracts.d.ts

@@ -0,0 +1,30 @@
+import type { OutboxHandler as KernelHandler } from "@openlup/core/outbox";
+export type { OutboxEventRow, OutboxHandlerOutcome, OutboxHandlerExecutionContext, OutboxHandlerDescriptor } from "@openlup/core/outbox";
+export type OutboxHandler = KernelHandler<AbortSignal>;
+export type OutboxHandlerRegistry = ReadonlyMap<string, OutboxHandler>;
+export interface CheckoutEmailOutboxReconcileResult {
+    checked: {
+        paid: number;
+        failed: number;
+        expired: number;
+    };
+    inserted: {
+        commerceOrderPaid: number;
+        commerceOrderPaidEmail: number;
+        commercePaymentFailed: number;
+        commerceCheckoutExpired: number;
+    };
+}
+export interface CheckoutEmailOutboxReconcilePort {
+    reconcile(limit: number): Promise<CheckoutEmailOutboxReconcileResult>;
+}
+export interface ReorderReminderEnqueueResult {
+    enqueued: number;
+}
+export interface ReorderReminderEnqueuePort {
+    enqueue(limit: number): Promise<ReorderReminderEnqueueResult>;
+}
+export interface ReviewRequestEnqueuePort {
+    enqueueRequests(limit: number): Promise<number>;
+    enqueueEffects(limit: number): Promise<number>;
+}

package/dist/commerce/outboxDispatchContracts.js

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

package/dist/commerce/outboxEventSchemas.d.ts

@@ -0,0 +1,162 @@
+import { z } from "zod";
+export declare const COMMERCE_ORDER_DRAFT_CREATED_EVENT_TYPE = "commerce.order_draft.created";
+export declare const COMMERCE_ORDER_DRAFT_CREATED_EVENT_CONTRACT_VERSION = "commerce.order_draft.created.v1";
+export declare const COMMERCE_ORDER_PAID_EVENT_TYPE = "commerce.order.paid";
+export declare const COMMERCE_ORDER_PAID_EVENT_CONTRACT_VERSION = "commerce.order.paid.v1";
+export declare const COMMERCE_ORDER_PAID_EMAIL_EVENT_TYPE = "commerce.order.paid.email";
+export declare const COMMERCE_PAYMENT_FAILED_EVENT_TYPE = "commerce.payment.failed";
+export declare const COMMERCE_CHECKOUT_EXPIRED_EVENT_TYPE = "commerce.checkout.expired";
+export declare const COMMERCE_ORDER_CANCELED_EVENT_TYPE = "commerce.order.canceled";
+export declare const COMMERCE_ORDER_REFUNDED_EVENT_TYPE = "commerce.order.refunded";
+export declare const COMMERCE_SHIPMENT_DISPATCHED_EVENT_TYPE = "commerce.shipment.dispatched";
+export declare const COMMERCE_SHIPMENT_DELIVERED_EVENT_TYPE = "commerce.shipment.delivered";
+export declare const COMMERCE_SHIPMENT_EXCEPTION_EVENT_TYPE = "commerce.shipment.exception";
+export declare const COMMERCE_RETURN_APPROVED_EVENT_TYPE = "commerce.return.approved";
+export declare const COMMERCE_RETURN_REJECTED_EVENT_TYPE = "commerce.return.rejected";
+export declare const COMMERCE_ORDER_REVIEW_REQUEST_EVENT_TYPE = "commerce.order.review_request";
+export declare const COMMERCE_ORDER_REVIEW_EFFECTS_EVENT_TYPE = "commerce.order.review_effects";
+export declare const COMMERCE_PRODUCT_BACK_IN_STOCK_EVENT_TYPE = "commerce.product.back_in_stock";
+export declare const commerceProductBackInStockPayloadSchema: z.ZodObject<{
+    sku: z.ZodString;
+    email: z.ZodString;
+}, z.core.$strict>;
+export type CommerceProductBackInStockPayload = z.infer<typeof commerceProductBackInStockPayloadSchema>;
+export declare const COMMERCE_ORDER_DRAFT_ABANDONED_1H_EVENT_TYPE = "commerce.order_draft.abandoned.1h";
+export declare const COMMERCE_ORDER_DRAFT_ABANDONED_24H_EVENT_TYPE = "commerce.order_draft.abandoned.24h";
+export declare const COMMERCE_ORDER_DRAFT_ABANDONED_72H_EVENT_TYPE = "commerce.order_draft.abandoned.72h";
+export declare const COMMERCE_ORDER_REORDER_REMINDER_EVENT_TYPE = "commerce.order.reorder_reminder";
+export declare const COMMERCE_CHECKOUT_RECOVERY_EVENT_TYPE = "commerce.checkout_recovery";
+export declare const commerceOutboxEventStatuses: readonly ["pending", "processing", "processed", "failed", "discarded"];
+/** Bind host quote and draft snapshots without importing their policy. */
+export declare function createCommerceOutboxEventSchemas<Quote extends z.ZodType, Snapshot extends z.ZodType, Pair extends z.ZodType>(input: {
+    quoteSnapshotSchema: Quote;
+    orderDraftSnapshotSchema: Snapshot;
+    snapshotPairSchema: Pair;
+}): {
+    commerceOrderDraftCreatedPayloadSchema: z.ZodObject<{
+        orderId: z.ZodString;
+        orderUuid: z.ZodGUID;
+        quoteSnapshot: Quote;
+        orderDraftSnapshot: Snapshot;
+    }, z.core.$strict>;
+    commerceOrderDraftCreatedOutboxRecordSchema: z.ZodObject<{
+        id: z.ZodGUID;
+        created_at: z.ZodString;
+        available_at: z.ZodString;
+        processed_at: z.ZodNullable<z.ZodString>;
+        aggregate_type: z.ZodLiteral<"commerce_order">;
+        aggregate_id: z.ZodGUID;
+        event_type: z.ZodLiteral<"commerce.order_draft.created">;
+        idempotency_key: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            processing: "processing";
+            processed: "processed";
+            discarded: "discarded";
+        }>;
+        attempts: z.ZodNumber;
+        payload: z.ZodObject<{
+            orderId: z.ZodString;
+            orderUuid: z.ZodGUID;
+            quoteSnapshot: Quote;
+            orderDraftSnapshot: Snapshot;
+        }, z.core.$strict>;
+        error: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    commerceOrderDraftCreatedEventSchema: z.ZodObject<{
+        contractVersion: z.ZodLiteral<"commerce.order_draft.created.v1">;
+        id: z.ZodGUID;
+        createdAt: z.ZodString;
+        availableAt: z.ZodString;
+        processedAt: z.ZodNullable<z.ZodString>;
+        aggregateType: z.ZodLiteral<"commerce_order">;
+        aggregateId: z.ZodGUID;
+        eventType: z.ZodLiteral<"commerce.order_draft.created">;
+        idempotencyKey: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            processing: "processing";
+            processed: "processed";
+            discarded: "discarded";
+        }>;
+        attempts: z.ZodNumber;
+        payload: z.ZodObject<{
+            orderId: z.ZodString;
+            orderUuid: z.ZodGUID;
+            quoteSnapshot: Quote;
+            orderDraftSnapshot: Snapshot;
+        }, z.core.$strict>;
+        error: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>;
+    parseCommerceOrderDraftCreatedOutboxEvent: (record: unknown) => z.output<z.ZodObject<{
+        contractVersion: z.ZodLiteral<"commerce.order_draft.created.v1">;
+        id: z.ZodGUID;
+        createdAt: z.ZodString;
+        availableAt: z.ZodString;
+        processedAt: z.ZodNullable<z.ZodString>;
+        aggregateType: z.ZodLiteral<"commerce_order">;
+        aggregateId: z.ZodGUID;
+        eventType: z.ZodLiteral<"commerce.order_draft.created">;
+        idempotencyKey: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            processing: "processing";
+            processed: "processed";
+            discarded: "discarded";
+        }>;
+        attempts: z.ZodNumber;
+        payload: z.ZodObject<{
+            orderId: z.ZodString;
+            orderUuid: z.ZodGUID;
+            quoteSnapshot: Quote;
+            orderDraftSnapshot: Snapshot;
+        }, z.core.$strict>;
+        error: z.ZodNullable<z.ZodString>;
+        metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>;
+};
+export declare const commerceOrderPaidPayloadSchema: z.ZodObject<{
+    orderId: z.ZodString;
+    orderUuid: z.ZodGUID;
+    mode: z.ZodString;
+    occurredAt: z.ZodString;
+}, z.core.$strict>;
+export declare const commerceOrderPaidOutboxRecordSchema: z.ZodObject<{
+    id: z.ZodGUID;
+    created_at: z.ZodString;
+    available_at: z.ZodString;
+    processed_at: z.ZodNullable<z.ZodString>;
+    aggregate_type: z.ZodLiteral<"commerce_order">;
+    aggregate_id: z.ZodGUID;
+    event_type: z.ZodLiteral<"commerce.order.paid">;
+    idempotency_key: z.ZodString;
+    status: z.ZodEnum<{
+        pending: "pending";
+        failed: "failed";
+        processing: "processing";
+        processed: "processed";
+        discarded: "discarded";
+    }>;
+    attempts: z.ZodNumber;
+    payload: z.ZodObject<{
+        orderId: z.ZodString;
+        orderUuid: z.ZodGUID;
+        mode: z.ZodString;
+        occurredAt: z.ZodString;
+    }, z.core.$strict>;
+    error: z.ZodNullable<z.ZodString>;
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;
+export type CommerceOrderPaidPayload = z.infer<typeof commerceOrderPaidPayloadSchema>;
+export type CommerceOrderPaidOutboxRecord = z.infer<typeof commerceOrderPaidOutboxRecordSchema>;
+export declare const commerceOrderReviewRequestPayloadSchema: z.ZodObject<{
+    orderId: z.ZodString;
+    orderUuid: z.ZodGUID;
+    token: z.ZodString;
+}, z.core.$loose>;
+export type CommerceOrderReviewRequestPayload = z.infer<typeof commerceOrderReviewRequestPayloadSchema>;

package/dist/commerce/outboxEventSchemas.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import { commerceIdempotencyKeySchema } from "./contractPrimitives.js";
+export const COMMERCE_ORDER_DRAFT_CREATED_EVENT_TYPE = "commerce.order_draft.created";
+export const COMMERCE_ORDER_DRAFT_CREATED_EVENT_CONTRACT_VERSION = "commerce.order_draft.created.v1";
+export const COMMERCE_ORDER_PAID_EVENT_TYPE = "commerce.order.paid";
+export const COMMERCE_ORDER_PAID_EVENT_CONTRACT_VERSION = "commerce.order.paid.v1";
+export const COMMERCE_ORDER_PAID_EMAIL_EVENT_TYPE = "commerce.order.paid.email";
+export const COMMERCE_PAYMENT_FAILED_EVENT_TYPE = "commerce.payment.failed";
+export const COMMERCE_CHECKOUT_EXPIRED_EVENT_TYPE = "commerce.checkout.expired";
+export const COMMERCE_ORDER_CANCELED_EVENT_TYPE = "commerce.order.canceled";
+export const COMMERCE_ORDER_REFUNDED_EVENT_TYPE = "commerce.order.refunded";
+export const COMMERCE_SHIPMENT_DISPATCHED_EVENT_TYPE = "commerce.shipment.dispatched";
+export const COMMERCE_SHIPMENT_DELIVERED_EVENT_TYPE = "commerce.shipment.delivered";
+export const COMMERCE_SHIPMENT_EXCEPTION_EVENT_TYPE = "commerce.shipment.exception";
+export const COMMERCE_RETURN_APPROVED_EVENT_TYPE = "commerce.return.approved";
+export const COMMERCE_RETURN_REJECTED_EVENT_TYPE = "commerce.return.rejected";
+export const COMMERCE_ORDER_REVIEW_REQUEST_EVENT_TYPE = "commerce.order.review_request";
+export const COMMERCE_ORDER_REVIEW_EFFECTS_EVENT_TYPE = "commerce.order.review_effects";
+export const COMMERCE_PRODUCT_BACK_IN_STOCK_EVENT_TYPE = "commerce.product.back_in_stock";
+export const commerceProductBackInStockPayloadSchema = z
+    .object({
+    sku: z.string().trim().min(1),
+    email: z.string().trim().email(),
+})
+    .strict();
+export const COMMERCE_ORDER_DRAFT_ABANDONED_1H_EVENT_TYPE = "commerce.order_draft.abandoned.1h";
+export const COMMERCE_ORDER_DRAFT_ABANDONED_24H_EVENT_TYPE = "commerce.order_draft.abandoned.24h";
+export const COMMERCE_ORDER_DRAFT_ABANDONED_72H_EVENT_TYPE = "commerce.order_draft.abandoned.72h";
+export const COMMERCE_ORDER_REORDER_REMINDER_EVENT_TYPE = "commerce.order.reorder_reminder";
+export const COMMERCE_CHECKOUT_RECOVERY_EVENT_TYPE = "commerce.checkout_recovery";
+export const commerceOutboxEventStatuses = [
+    "pending",
+    "processing",
+    "processed",
+    "failed",
+    "discarded",
+];
+const uuidSchema = z.guid();
+const timestampSchema = z.string().datetime({ offset: true });
+/** Bind host quote and draft snapshots without importing their policy. */
+export function createCommerceOutboxEventSchemas(input) {
+    const commerceOrderDraftCreatedPayloadSchema = z
+        .object({
+        orderId: z.string().regex(/^order_[a-f0-9-]{36}$/),
+        orderUuid: uuidSchema,
+        quoteSnapshot: input.quoteSnapshotSchema,
+        orderDraftSnapshot: input.orderDraftSnapshotSchema,
+    })
+        .strict()
+        .refine((payload) => payload.orderId === `order_${payload.orderUuid}`, {
+        message: "orderId must contain the order UUID",
+        path: ["orderId"],
+    })
+        .refine((payload) => input.snapshotPairSchema.safeParse({
+        quoteSnapshot: payload.quoteSnapshot,
+        orderDraftSnapshot: payload.orderDraftSnapshot,
+    }).success, {
+        message: "order draft snapshot must match the quote snapshot",
+        path: ["orderDraftSnapshot"],
+    });
+    const commerceOrderDraftCreatedOutboxRecordSchema = z
+        .object({
+        id: uuidSchema,
+        created_at: timestampSchema,
+        available_at: timestampSchema,
+        processed_at: timestampSchema.nullable(),
+        aggregate_type: z.literal("commerce_order"),
+        aggregate_id: uuidSchema,
+        event_type: z.literal(COMMERCE_ORDER_DRAFT_CREATED_EVENT_TYPE),
+        idempotency_key: commerceIdempotencyKeySchema,
+        status: z.enum(commerceOutboxEventStatuses),
+        attempts: z.number().int().nonnegative(),
+        payload: commerceOrderDraftCreatedPayloadSchema,
+        error: z.string().nullable(),
+        metadata: z.record(z.string(), z.unknown()),
+    })
+        .strict()
+        .refine((record) => record.aggregate_id === record.payload.orderUuid, {
+        message: "aggregate_id must match payload.orderUuid",
+        path: ["aggregate_id"],
+    });
+    const commerceOrderDraftCreatedEventSchema = z
+        .object({
+        contractVersion: z.literal(COMMERCE_ORDER_DRAFT_CREATED_EVENT_CONTRACT_VERSION),
+        id: uuidSchema,
+        createdAt: timestampSchema,
+        availableAt: timestampSchema,
+        processedAt: timestampSchema.nullable(),
+        aggregateType: z.literal("commerce_order"),
+        aggregateId: uuidSchema,
+        eventType: z.literal(COMMERCE_ORDER_DRAFT_CREATED_EVENT_TYPE),
+        idempotencyKey: commerceIdempotencyKeySchema,
+        status: z.enum(commerceOutboxEventStatuses),
+        attempts: z.number().int().nonnegative(),
+        payload: commerceOrderDraftCreatedPayloadSchema,
+        error: z.string().nullable(),
+        metadata: z.record(z.string(), z.unknown()),
+    })
+        .strict()
+        .refine((event) => event.aggregateId === event.payload.orderUuid, {
+        message: "aggregateId must match payload.orderUuid",
+        path: ["aggregateId"],
+    });
+    function parseCommerceOrderDraftCreatedOutboxEvent(record) {
+        const parsed = commerceOrderDraftCreatedOutboxRecordSchema.parse(record);
+        return commerceOrderDraftCreatedEventSchema.parse({
+            contractVersion: COMMERCE_ORDER_DRAFT_CREATED_EVENT_CONTRACT_VERSION,
+            id: parsed.id,
+            createdAt: parsed.created_at,
+            availableAt: parsed.available_at,
+            processedAt: parsed.processed_at,
+            aggregateType: parsed.aggregate_type,
+            aggregateId: parsed.aggregate_id,
+            eventType: parsed.event_type,
+            idempotencyKey: parsed.idempotency_key,
+            status: parsed.status,
+            attempts: parsed.attempts,
+            payload: parsed.payload,
+            error: parsed.error,
+            metadata: parsed.metadata,
+        });
+    }
+    return { commerceOrderDraftCreatedPayloadSchema, commerceOrderDraftCreatedOutboxRecordSchema, commerceOrderDraftCreatedEventSchema, parseCommerceOrderDraftCreatedOutboxEvent };
+}
+export const commerceOrderPaidPayloadSchema = z
+    .object({
+    orderId: z.string().regex(/^order_[a-f0-9-]{36}$/),
+    orderUuid: uuidSchema,
+    mode: z.string().min(1),
+    occurredAt: timestampSchema,
+})
+    .strict()
+    .refine((payload) => payload.orderId === `order_${payload.orderUuid}`, {
+    message: "orderId must contain the order UUID",
+    path: ["orderId"],
+});
+export const commerceOrderPaidOutboxRecordSchema = z
+    .object({
+    id: uuidSchema,
+    created_at: timestampSchema,
+    available_at: timestampSchema,
+    processed_at: timestampSchema.nullable(),
+    aggregate_type: z.literal("commerce_order"),
+    aggregate_id: uuidSchema,
+    event_type: z.literal(COMMERCE_ORDER_PAID_EVENT_TYPE),
+    idempotency_key: commerceIdempotencyKeySchema,
+    status: z.enum(commerceOutboxEventStatuses),
+    attempts: z.number().int().nonnegative(),
+    payload: commerceOrderPaidPayloadSchema,
+    error: z.string().nullable(),
+    metadata: z.record(z.string(), z.unknown()),
+})
+    .strict()
+    .refine((record) => record.aggregate_id === record.payload.orderUuid, {
+    message: "aggregate_id must match payload.orderUuid",
+    path: ["aggregate_id"],
+});
+export const commerceOrderReviewRequestPayloadSchema = z
+    .object({
+    orderId: z.string().min(1),
+    orderUuid: uuidSchema,
+    token: z.string().min(1),
+})
+    .passthrough();