@openlup/platform 0.16.0 → 0.18.0

package/dist/catalog/draftSchemas.js

@@ -0,0 +1,89 @@
+import { z } from "./validation.js";
+import { CATALOG_DRAFT_MAX_PAGE, canonicalCatalogDraftJson } from "./contracts/draft.js";
+export { CATALOG_DRAFT_MAX_BYTES, CATALOG_DRAFT_MAX_PAGE, canonicalCatalogDraftJson } from "./contracts/draft.js";
+import { catalogDocumentRevisionRefSchema } from "./foundationSchemas.js";
+import { catalogDimensionKeySchema, catalogNamespacedKeySchema, catalogOptionValueSchema, catalogProductTypeRefSchema, catalogQuantitySchema, } from "./productTypeSchemas.js";
+const id = z.guid().refine((value) => value === value.toLowerCase(), "UUID must be lowercase");
+const reference = z.string().min(1).max(240).refine((value) => value.trim() === value);
+const code = z.string().min(1).max(160).regex(/^[A-Za-z0-9._:-]+$/u);
+const revision = z.number().int().min(0).max(2_147_483_646);
+const persistedRevision = z.number().int().positive().max(2_147_483_647);
+const commandKey = reference;
+const jsonContent = z.unknown().refine((value) => value !== undefined, "content must be JSON");
+export const catalogDraftPayloadSchema = z.object({
+    schemaVersion: z.literal(1),
+    product: z.object({
+        id, type: catalogProductTypeRefSchema, slug: code.optional(), primarySkuId: id.optional(),
+        dimensions: z.array(catalogDimensionKeySchema).max(16),
+        sharedContent: jsonContent.optional(), documentRevision: catalogDocumentRevisionRefSchema.optional(),
+    }).strict(),
+    skus: z.array(z.object({
+        id, productId: id, code: code.optional(),
+        options: z.record(catalogDimensionKeySchema, catalogOptionValueSchema),
+        netContent: catalogQuantitySchema.optional(),
+        identifiers: z.array(z.object({
+            scheme: catalogNamespacedKeySchema, issuer: reference, value: z.string().min(1).max(128),
+            packagingLevel: z.enum(["unit", "case"]), quantity: z.number().int().min(1).max(2_147_483_647).optional(),
+        }).strict()).max(32).optional(),
+        assetRefs: z.array(reference).max(32).optional(), grossMass: catalogQuantitySchema.optional(),
+        priceRef: reference.optional(), logisticsRef: reference.optional(),
+    }).strict()).max(10_000),
+}).strict().superRefine((payload, context) => {
+    try {
+        canonicalCatalogDraftJson(payload);
+    }
+    catch {
+        context.addIssue({ code: "custom", message: "payload must be bounded safe JSON" });
+    }
+    if (payload.product.documentRevision && payload.product.documentRevision.productId !== payload.product.id) {
+        context.addIssue({ code: "custom", path: ["product", "documentRevision", "productId"], message: "document must belong to product" });
+    }
+    if (payload.product.primarySkuId && !payload.skus.some((sku) => sku.id === payload.product.primarySkuId)) {
+        context.addIssue({ code: "custom", path: ["product", "primarySkuId"], message: "primary must belong to product" });
+    }
+    payload.skus.forEach((sku, index) => {
+        if (sku.productId !== payload.product.id)
+            context.addIssue({ code: "custom", path: ["skus", index, "productId"], message: "SKU must belong to product" });
+    });
+});
+export const catalogDraftCommandSchema = z.object({
+    schemaVersion: z.literal(1), action: z.enum(["create", "revise", "abandon"]),
+    draftId: id, commandKey, expectedRevision: revision, payload: catalogDraftPayloadSchema.optional(),
+}).strict().superRefine((command, context) => {
+    if ((command.action === "abandon") === (command.payload !== undefined)) {
+        context.addIssue({ code: "custom", path: ["payload"], message: "payload is required only for create and revise" });
+    }
+    if ((command.action === "create") !== (command.expectedRevision === 0)) {
+        context.addIssue({ code: "custom", path: ["expectedRevision"], message: "create starts at revision zero; other commands require a persisted revision" });
+    }
+});
+export const catalogDraftGetQuerySchema = z.object({
+    draftId: id, revision: persistedRevision.optional(), commandKey: commandKey.optional(),
+}).strict().refine((query) => query.revision === undefined || query.commandKey === undefined, "selectors are mutually exclusive");
+export const catalogDraftListQuerySchema = z.object({
+    afterDraftId: id.optional(), limit: z.number().int().min(1).max(CATALOG_DRAFT_MAX_PAGE),
+}).strict();
+export const catalogDraftSummarySchema = z.object({
+    draftId: id, productId: id, revision: persistedRevision, status: z.enum(["open", "abandoned"]),
+    commandKey, fingerprint: z.string().regex(/^[a-f0-9]{64}$/u), actorId: reference,
+    createdAt: z.string().datetime({ offset: true }),
+}).strict();
+export const catalogDraftRecordSchema = catalogDraftSummarySchema.extend({ payload: catalogDraftPayloadSchema }).strict()
+    .refine((record) => record.productId === record.payload.product.id, "record product must own payload");
+export const catalogDraftPageSchema = z.object({
+    items: z.array(catalogDraftSummarySchema).max(CATALOG_DRAFT_MAX_PAGE), nextCursor: id.nullable(),
+}).strict().superRefine((page, context) => {
+    const ids = page.items.map((item) => item.draftId);
+    if (ids.some((value, index) => index > 0 && value <= ids[index - 1])
+        || (page.nextCursor !== null && page.nextCursor !== ids[ids.length - 1])) {
+        context.addIssue({ code: "custom", message: "page must have ordered unique heads and a matching cursor" });
+    }
+});
+export const catalogDraftRefusalSchema = z.object({
+    outcome: z.enum(["conflict", "validation_issue", "unauthorized", "dependency_unavailable"]),
+    reason: z.string().min(1).max(160).regex(/^[a-z][a-z0-9_]*$/u), currentRevision: z.number().int().min(0).max(2_147_483_647).optional(),
+}).strict();
+export const catalogDraftApplyResultSchema = z.union([
+    z.object({ outcome: z.enum(["committed", "replayed"]), record: catalogDraftRecordSchema }).strict(),
+    catalogDraftRefusalSchema,
+]);

package/dist/catalog/draftValidation.d.ts

@@ -0,0 +1,21 @@
+import type { CatalogDraftPayload } from "./draftSchemas.js";
+import { type CatalogDraftIssue, type CatalogProductTypeRegistry } from "./productTypeSchemas.js";
+export interface CatalogDraftReadiness {
+    publication: {
+        status: "incomplete" | "not_assessed";
+        issues: CatalogDraftIssue[];
+    };
+    commercial: {
+        status: "inactive";
+        issues: CatalogDraftIssue[];
+    };
+}
+export type CatalogDraftValidation = {
+    valid: false;
+    issues: CatalogDraftIssue[];
+} | {
+    valid: true;
+    readiness: CatalogDraftReadiness;
+};
+/** Supplied facts must be true; absent publish-time facts remain draft readiness issues. */
+export declare function validateCatalogDraft(payload: CatalogDraftPayload, registry: CatalogProductTypeRegistry): CatalogDraftValidation;

package/dist/catalog/draftValidation.js

@@ -0,0 +1,125 @@
+import { isValidGtin } from "./foundationSchemas.js";
+import { canonicalCatalogOption, validateCatalogQuantity, } from "./productTypeSchemas.js";
+/** Supplied facts must be true; absent publish-time facts remain draft readiness issues. */
+export function validateCatalogDraft(payload, registry) {
+    const issues = [];
+    const publication = [];
+    const commercial = [];
+    const add = (path, code) => issues.push({ path, code });
+    const missing = (path, code) => publication.push({ path, code });
+    const { product, skus } = payload;
+    const definition = registry.resolve(product.type);
+    if (!definition)
+        return { valid: false, issues: [{ path: "product.type", code: "type_not_installed" }] };
+    const dimensions = new Map(definition.dimensions.map((dimension) => [dimension.key, dimension]));
+    const netContentKey = definition.dimensions.find((dimension) => dimension.kind === "quantity" && dimension.role === "net_content")?.key;
+    if (new Set(product.dimensions).size !== product.dimensions.length)
+        add("product.dimensions", "duplicate_dimension");
+    product.dimensions.forEach((key) => { if (!dimensions.has(key))
+        add(`product.dimensions.${key}`, "dimension_not_installed"); });
+    if (product.sharedContent !== undefined) {
+        issues.push(...definition.validateContent(product.sharedContent).map((issue) => ({ ...issue, path: `product.sharedContent${issue.path ? `.${issue.path}` : ""}` })));
+    }
+    else if (!product.documentRevision)
+        missing("product.sharedContent", "content_missing");
+    if (product.documentRevision && product.documentRevision.productId !== product.id)
+        add("product.documentRevision.productId", "foreign_product_reference");
+    if (product.primarySkuId && !skus.some((sku) => sku.id === product.primarySkuId))
+        add("product.primarySkuId", "primary_sku_not_in_product");
+    if (!product.primarySkuId)
+        missing("product.primarySkuId", "primary_sku_missing");
+    if (!product.slug)
+        missing("product.slug", "slug_missing");
+    if (!skus.length)
+        missing("skus", "sku_missing");
+    const skuIds = new Set();
+    const skuCodes = new Set();
+    const combinations = new Set();
+    const identifiers = new Set();
+    skus.forEach((sku, index) => {
+        const path = `skus.${index}`;
+        if (sku.productId !== product.id)
+            add(`${path}.productId`, "foreign_product_reference");
+        if (skuIds.has(sku.id))
+            add(`${path}.id`, "duplicate_sku_id");
+        skuIds.add(sku.id);
+        if (sku.code) {
+            if (skuCodes.has(sku.code))
+                add(`${path}.code`, "duplicate_sku_code");
+            skuCodes.add(sku.code);
+        }
+        else
+            missing(`${path}.code`, "sku_code_missing");
+        const optionKeys = Object.keys(sku.options);
+        for (const key of optionKeys) {
+            const option = sku.options[key];
+            const dimension = dimensions.get(key);
+            if (!product.dimensions.includes(key) || !dimension) {
+                add(`${path}.options.${key}`, "dimension_not_declared");
+                continue;
+            }
+            if (dimension.kind !== option.kind) {
+                add(`${path}.options.${key}`, "option_type_invalid");
+                continue;
+            }
+            if (dimension.kind === "choice" && option.kind === "choice" && !dimension.values.includes(option.value))
+                add(`${path}.options.${key}`, "option_value_invalid");
+            if (dimension.kind === "quantity" && option.kind === "quantity"
+                && (option.value.dimension !== dimension.dimension || !dimension.units.includes(option.value.unit)
+                    || !validateCatalogQuantity(option.value, definition)))
+                add(`${path}.options.${key}`, "option_quantity_invalid");
+        }
+        const absent = product.dimensions.filter((key) => !Object.prototype.hasOwnProperty.call(sku.options, key));
+        absent.forEach((key) => missing(`${path}.options.${key}`, "option_missing"));
+        if (!absent.length && optionKeys.length === product.dimensions.length) {
+            const combination = JSON.stringify([...product.dimensions].sort().map((key) => [key, canonicalCatalogOption(sku.options[key])]));
+            if (combinations.has(combination))
+                add(`${path}.options`, "duplicate_option_combination");
+            combinations.add(combination);
+        }
+        if (sku.netContent) {
+            if (!validateCatalogQuantity(sku.netContent, definition) || !definition.netContentUnits.includes(sku.netContent.unit))
+                add(`${path}.netContent`, "net_content_invalid");
+        }
+        else
+            missing(`${path}.netContent`, "net_content_missing");
+        const netContentOption = netContentKey === undefined ? undefined : sku.options[netContentKey];
+        if (netContentOption?.kind === "quantity" && sku.netContent
+            && canonicalCatalogOption(netContentOption) !== canonicalCatalogOption({ kind: "quantity", value: sku.netContent }))
+            add(`${path}.options.${netContentKey}`, "net_content_option_mismatch");
+        if (sku.grossMass && (sku.grossMass.dimension !== "mass" || !validateCatalogQuantity(sku.grossMass, definition)))
+            add(`${path}.grossMass`, "gross_mass_invalid");
+        (sku.identifiers ?? []).forEach((identifier, identifierIndex) => {
+            const at = `${path}.identifiers.${identifierIndex}`;
+            // One GTIN is one identity in any 8-, 12-, 13- or 14-digit spelling, whatever its issuer text.
+            const gtin = identifier.scheme === "gs1:gtin" && isValidGtin(identifier.value) ? identifier.value.padStart(14, "0") : null;
+            const identity = JSON.stringify(gtin === null ? [identifier.scheme, identifier.issuer, identifier.value] : [identifier.scheme, gtin]);
+            if (identifiers.has(identity))
+                add(at, "duplicate_trade_identifier");
+            identifiers.add(identity);
+            if (identifier.scheme === "gs1:gtin" && gtin === null)
+                add(at, "trade_identifier_invalid");
+            if (identifier.scheme !== "gs1:gtin" && identifier.scheme.startsWith("gs1:"))
+                add(at, "trade_identifier_scheme_unsupported");
+            // Checked here, not in the wire schema, so a stored revision without a quantity stays readable.
+            if (identifier.packagingLevel === "case" ? (identifier.quantity ?? 0) < 2 : (identifier.quantity ?? 1) !== 1)
+                add(`${at}.quantity`, "trade_identifier_quantity_invalid");
+        });
+        if (!sku.identifiers?.length)
+            commercial.push({ path: `${path}.identifiers`, code: "channel_identity_not_assessed" });
+        if (!sku.identifiers?.some((identifier) => identifier.scheme === "gs1:gtin" && identifier.packagingLevel === "unit"))
+            commercial.push({ path: `${path}.identifiers`, code: "unit_trade_identifier_missing" });
+        if (!sku.priceRef)
+            commercial.push({ path: `${path}.priceRef`, code: "price_reference_missing" });
+        if (!sku.logisticsRef)
+            commercial.push({ path: `${path}.logisticsRef`, code: "logistics_reference_missing" });
+    });
+    if (issues.length)
+        return { valid: false, issues };
+    // Opaque references are not current pricing, stock, logistics or publication proof.
+    commercial.push({ path: "skus", code: "commercial_activation_not_assessed" });
+    return { valid: true, readiness: {
+            publication: { status: publication.length ? "incomplete" : "not_assessed", issues: publication },
+            commercial: { status: "inactive", issues: commercial },
+        } };
+}

package/dist/catalog/foundationSchemas.d.ts

@@ -0,0 +1,98 @@
+import { z } from "./validation.js";
+export { CATALOG_FOUNDATION_CONTRACT_VERSION, CatalogSkuAuthorityError, isValidGtin, assertPrimaryUnitGtinAuthority, requireCurrentCatalogDocumentAuthority } from "./contracts/foundation.js";
+export type { CatalogDocumentRevisionRef, CatalogSkuIdentifier, CatalogSkuEnvelopeSelector, NeutralSkuEnvelopeV1, CatalogPriceContext, CatalogSkuAuthorityRefusal } from "./contracts/foundation.js";
+export declare const catalogFixedPointSchema: z.ZodObject<{
+    unscaled: z.ZodNumber;
+    scale: z.ZodNumber;
+    unit: z.ZodString;
+}, z.core.$strict>;
+export declare const catalogDocumentRevisionRefSchema: z.ZodObject<{
+    id: z.ZodGUID;
+    productId: z.ZodGUID;
+    revisionNo: z.ZodNumber;
+    schemaId: z.ZodString;
+    documentRef: z.ZodString;
+    sourceRef: z.ZodString;
+    digest: z.ZodString;
+}, z.core.$strict>;
+export declare const catalogSkuIdentifierSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    normalizedValue: z.ZodString;
+    kind: z.ZodEnum<{
+        gtin: "gtin";
+        other: "other";
+    }>;
+    packKind: z.ZodEnum<{
+        unit: "unit";
+        collective: "collective";
+    }>;
+    packQuantity: z.ZodNumber;
+    isPrimary: z.ZodBoolean;
+}, z.core.$strict>;
+/** Stable, payload-free detail selectors shared by both catalog adapters. */
+export declare const catalogSkuEnvelopeSelectorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"sku_code">;
+    skuCode: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"primary_product_slug">;
+    productSlug: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const neutralSkuEnvelopeV1Schema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<"catalog.foundation.v1">;
+    product: z.ZodObject<{
+        id: z.ZodGUID;
+        slug: z.ZodString;
+        primarySkuId: z.ZodGUID;
+    }, z.core.$strict>;
+    sku: z.ZodObject<{
+        id: z.ZodGUID;
+        productId: z.ZodGUID;
+        code: z.ZodString;
+        netContent: z.ZodObject<{
+            unscaled: z.ZodNumber;
+            scale: z.ZodNumber;
+            unit: z.ZodString;
+        }, z.core.$strict>;
+        sellability: z.ZodObject<{
+            status: z.ZodEnum<{
+                draft: "draft";
+                active: "active";
+                archived: "archived";
+            }>;
+            oneTime: z.ZodBoolean;
+            subscription: z.ZodBoolean;
+        }, z.core.$strict>;
+        isAddon: z.ZodBoolean;
+        assetRef: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    documentRevision: z.ZodObject<{
+        id: z.ZodGUID;
+        productId: z.ZodGUID;
+        revisionNo: z.ZodNumber;
+        schemaId: z.ZodString;
+        documentRef: z.ZodString;
+        sourceRef: z.ZodString;
+        digest: z.ZodString;
+    }, z.core.$strict>;
+    identifiers: z.ZodArray<z.ZodObject<{
+        issuer: z.ZodString;
+        normalizedValue: z.ZodString;
+        kind: z.ZodEnum<{
+            gtin: "gtin";
+            other: "other";
+        }>;
+        packKind: z.ZodEnum<{
+            unit: "unit";
+            collective: "collective";
+        }>;
+        packQuantity: z.ZodNumber;
+        isPrimary: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const catalogPriceContextSchema: z.ZodObject<{
+    priceListId: z.ZodGUID;
+    regionCode: z.ZodString;
+    currency: z.ZodString;
+    channel: z.ZodString;
+    atTime: z.ZodString;
+}, z.core.$strict>;

package/dist/catalog/foundationSchemas.js

@@ -0,0 +1,110 @@
+import { z } from "./validation.js";
+import { CATALOG_FOUNDATION_CONTRACT_VERSION, isValidGtin } from "./contracts/foundation.js";
+export { CATALOG_FOUNDATION_CONTRACT_VERSION, CatalogSkuAuthorityError, isValidGtin, assertPrimaryUnitGtinAuthority, requireCurrentCatalogDocumentAuthority } from "./contracts/foundation.js";
+/**
+ * Portable, payload-free catalog shape. Document interpretation remains an
+ * adopter concern; this module can only carry immutable document references.
+ */
+const entityIdSchema = z.guid();
+const opaqueReferenceSchema = z.string().trim().min(1).max(240);
+const codeSchema = z.string().trim().min(1).max(160).regex(/^[A-Za-z0-9._:-]+$/);
+const sha256DigestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const currencyCodeSchema = z.string().regex(/^[A-Z]{3}$/u);
+export const catalogFixedPointSchema = z.object({
+    /** SKU net content is a physical, positive quantity; signed values need a distinct contract. */
+    unscaled: z.number().int().positive().safe(),
+    scale: z.number().int().min(0).max(12).safe(),
+    unit: z.string().trim().min(1).max(64).regex(/^[A-Z][A-Z0-9_]*$/),
+}).strict();
+export const catalogDocumentRevisionRefSchema = z.object({
+    id: entityIdSchema,
+    productId: entityIdSchema,
+    revisionNo: z.number().int().positive(),
+    schemaId: opaqueReferenceSchema,
+    documentRef: opaqueReferenceSchema,
+    sourceRef: opaqueReferenceSchema,
+    digest: sha256DigestSchema,
+}).strict();
+export const catalogSkuIdentifierSchema = z.object({
+    issuer: opaqueReferenceSchema,
+    normalizedValue: z.string().trim().min(1).max(128),
+    kind: z.enum(["gtin", "other"]),
+    packKind: z.enum(["unit", "collective"]),
+    packQuantity: z.number().int().positive(),
+    isPrimary: z.boolean(),
+}).strict();
+/** Stable, payload-free detail selectors shared by both catalog adapters. */
+export const catalogSkuEnvelopeSelectorSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("sku_code"),
+        skuCode: codeSchema,
+    }).strict(),
+    z.object({
+        kind: z.literal("primary_product_slug"),
+        productSlug: codeSchema,
+    }).strict(),
+]);
+export const neutralSkuEnvelopeV1Schema = z.object({
+    contractVersion: z.literal(CATALOG_FOUNDATION_CONTRACT_VERSION),
+    product: z.object({
+        id: entityIdSchema,
+        slug: codeSchema,
+        primarySkuId: entityIdSchema,
+    }).strict(),
+    sku: z.object({
+        id: entityIdSchema,
+        productId: entityIdSchema,
+        code: codeSchema,
+        netContent: catalogFixedPointSchema,
+        sellability: z.object({
+            status: z.enum(["draft", "active", "archived"]),
+            oneTime: z.boolean(),
+            subscription: z.boolean(),
+        }).strict(),
+        /** Structural SKU classification shared by both bundle schemas. */
+        isAddon: z.boolean(),
+        assetRef: opaqueReferenceSchema.nullable(),
+    }).strict(),
+    documentRevision: catalogDocumentRevisionRefSchema,
+    identifiers: z.array(catalogSkuIdentifierSchema).max(32),
+}).strict().superRefine((envelope, context) => {
+    if (envelope.product.id !== envelope.sku.productId) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["sku", "productId"], message: "sku must belong to envelope product" });
+    }
+    if (envelope.product.id !== envelope.documentRevision.productId) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["documentRevision", "productId"], message: "document revision must belong to envelope product" });
+    }
+    const seen = new Set();
+    let primaryGtinCount = 0;
+    envelope.identifiers.forEach((identifier, index) => {
+        const identity = `${identifier.issuer}\u0000${identifier.normalizedValue}`;
+        if (seen.has(identity)) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["identifiers", index], message: "identifier issuer/value pairs must be unique" });
+        }
+        seen.add(identity);
+        if (identifier.packKind === "unit" && identifier.packQuantity !== 1) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["identifiers", index, "packQuantity"], message: "unit identifiers require pack quantity 1" });
+        }
+        if (identifier.packKind === "collective" && identifier.packQuantity <= 1) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: ["identifiers", index, "packQuantity"], message: "collective identifiers require pack quantity above 1" });
+        }
+        if (identifier.isPrimary) {
+            primaryGtinCount += 1;
+            if (identifier.kind !== "gtin"
+                || identifier.packKind !== "unit"
+                || !isValidGtin(identifier.normalizedValue)) {
+                context.addIssue({ code: z.ZodIssueCode.custom, path: ["identifiers", index], message: "a primary identifier must be a unit GTIN" });
+            }
+        }
+    });
+    if (primaryGtinCount > 1) {
+        context.addIssue({ code: z.ZodIssueCode.custom, path: ["identifiers"], message: "a SKU may have at most one primary GTIN" });
+    }
+});
+export const catalogPriceContextSchema = z.object({
+    priceListId: entityIdSchema,
+    regionCode: z.string().regex(/^[A-Z]{2,3}$/u),
+    currency: currencyCodeSchema,
+    channel: z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9._:-]+$/),
+    atTime: z.string().datetime({ offset: true }),
+}).strict();

package/dist/catalog/index.d.ts

@@ -0,0 +1,43 @@
+export * from "./contracts/index.js";
+export { parseCatalogActiveSkuSelection } from "./activeSkuSelection.js";
+export { createCatalogDraftHandler } from "./draftHandler.js";
+export type { CatalogDraftHandlerDeps, CatalogDraftCommandResult } from "./draftHandler.js";
+export { CatalogDraftStoreError } from "./draftPorts.js";
+export type { CatalogDraftOperator, CatalogDraftStorePort } from "./draftPorts.js";
+export { catalogDraftPayloadSchema, catalogDraftCommandSchema, catalogDraftGetQuerySchema, catalogDraftListQuerySchema, catalogDraftSummarySchema, catalogDraftRecordSchema, catalogDraftPageSchema, catalogDraftRefusalSchema, catalogDraftApplyResultSchema } from "./draftSchemas.js";
+export { validateCatalogDraft } from "./draftValidation.js";
+export type { CatalogDraftReadiness, CatalogDraftValidation } from "./draftValidation.js";
+export { catalogFixedPointSchema, catalogDocumentRevisionRefSchema, catalogSkuIdentifierSchema, catalogSkuEnvelopeSelectorSchema, neutralSkuEnvelopeV1Schema, catalogPriceContextSchema } from "./foundationSchemas.js";
+export { catalogNamespacedKeySchema, catalogDimensionKeySchema, catalogQuantityDimensionSchema, catalogQuantitySchema, catalogOptionValueSchema, catalogProductTypeRefSchema, createCatalogProductTypeRegistry } from "./productTypeSchemas.js";
+export type { SellableCatalogPort, CatalogSkuEnvelopeReadPort, PublicCatalogSkuEnvelopeReadPort, CatalogSkuEnvelopeListQuery, CatalogActiveSkuEnvelopeListQuery, CatalogSkuEnvelopePage } from "./readPorts.js";
+export { createReferenceCatalogItemsHandler } from "./referenceCatalogHandler.js";
+export { RESOLVED_SKU_PROJECTION_VERSION, resolvedSkuProjectionSchema, buildResolvedSkuProjection } from "./resolvedSkuProjection.js";
+export type { ResolvedSkuProjection, ResolvedSkuProjectionInput } from "./resolvedSkuProjection.js";
+export { sellableCatalogItemSchema, sellableCatalogProfileSchema, sellableCatalogListResponseSchema } from "./sellableSchemas.js";
+export { SOURCE_PACK_LIMITS, CatalogMediaSourcePackError, readCatalogMediaSourceManifest, validateCatalogMediaSourcePack, exportCatalogMediaSourcePack, restoreCatalogMediaSourcePack, importCatalogMediaSourcePack } from "./mediaSourcePack.js";
+export type { CatalogMediaSourcePack, CatalogMediaImportOutcome } from "./mediaSourcePack.js";
+export type { CatalogValidationPort, CatalogPublicationReadPort, CatalogPublicationPort, VerifiedCatalogPublisher, CatalogCapabilityDescriptor } from "./publicationPorts.js";
+export { SUPPORTED_BUNDLE_FULFILLMENT_MODES, createBundleWriteRules, evaluateBundleComposition, evaluateBundleFulfillmentMode, evaluateBundleTargetPrice, isEmptyCompositionConstraint, evaluateBundleCompositionConstraint } from "./bundleRules.js";
+export type { BundleCompositionEntry, SupportedBundleFulfillmentMode } from "./bundleRules.js";
+export { BUNDLE_RULE_CODES, BUNDLE_ALLOCATION_RULE_CODE, BUNDLE_RULE_ENFORCEMENT } from "./bundleRuleCodes.js";
+export type { BundleRuleCode, BundleActorKind, BundleWriteOperation, BundleRuleResult } from "./bundleRuleCodes.js";
+export { DEFAULT_BUNDLE_LOW_STOCK_THRESHOLD, BUNDLE_COMPONENT_STOCK_UNKNOWN, BUNDLE_COMPOSITION_EMPTY, createBundleAvailability } from "./bundleAvailability.js";
+export type { BundleAvailabilityComponent, BundleAvailability, DeriveBundleAvailabilityInput } from "./bundleAvailability.js";
+export { BundleCatalogReadError } from "./bundleCatalogReadPort.js";
+export type { BundleListStatusFilter, ListBundlesInput, BundleSummary, ListBundlesResult, BundleComponentRow, BundleTargetPriceRow, BundleDetail, GetBundleInput, ActiveBundleComposition, BundleHistoryEvent, BundleHistoryInput, BundleHistoryResult, BundleCatalogReadPort } from "./bundleCatalogReadPort.js";
+export { createBundleAvailabilityServices, createUnknownOfferAvailabilityPort } from "./bundleAvailabilityService.js";
+export type { BundleAvailabilityServiceDeps, BundleAvailabilityRow, BundleAvailabilityService } from "./bundleAvailabilityService.js";
+export type { BundleWriteResult, BundleCompositionConstraintEnvelope, AdminBundleWritePort } from "./adminBundleWritePort.js";
+export { createAdminBundleHandlers } from "./adminBundleHandler.js";
+export type { AdminBundleHandlerDeps } from "./adminBundleHandler.js";
+export { createAdminBundleReadHandlers } from "./adminBundleReadHandler.js";
+export type { AdminBundleReadHandlerDeps } from "./adminBundleReadHandler.js";
+export { createSellableBundleHandlers, toSellableBundle } from "./sellableBundleHandler.js";
+export type { SellableBundleHandlerDeps } from "./sellableBundleHandler.js";
+export type { BundleStockStatus, BundleStockRequestItem, BundleStockAvailability, BundleStockPort, BundleRuleBindings } from "./bundleBindings.js";
+export type { AuthorizeAdmin, AgentDomainQuerySpec, AgentDomainMutationSpec, BundleMutationKey, BundleQueryKey, BundleResponseSchema, BundleAdminBindings } from "./adminBindings.js";
+export { createPostgresBundleCatalogStore } from "./bundleCatalogStore.js";
+export { BUNDLE_MIGRATIONS, CATALOG_MIGRATIONS } from "./sql.js";
+export { SUMMARY_COLUMNS, LIST_FILTER, LIST_SQL, COUNT_SQL, DETAIL_SQL, REFERENCE_PRICE, COMPONENT_SQL, FEED_COMPONENT_SQL, PRICE_SQL, OWN_LIST_SQL, CURRENCY_LIST_SQL, FEED_SQL, HISTORY_SQL, HISTORY_COUNT_SQL } from "./bundleCatalogQueries.js";
+export { createPostgresCatalogSkuEnvelopeReadPort } from "./catalogSkuEnvelope.js";
+export { createPostgresCatalogDraftStore } from "./catalogDraftStore.js";

package/dist/catalog/index.js

@@ -0,0 +1,25 @@
+export * from "./contracts/index.js";
+export { parseCatalogActiveSkuSelection } from "./activeSkuSelection.js";
+export { createCatalogDraftHandler } from "./draftHandler.js";
+export { CatalogDraftStoreError } from "./draftPorts.js";
+export { catalogDraftPayloadSchema, catalogDraftCommandSchema, catalogDraftGetQuerySchema, catalogDraftListQuerySchema, catalogDraftSummarySchema, catalogDraftRecordSchema, catalogDraftPageSchema, catalogDraftRefusalSchema, catalogDraftApplyResultSchema } from "./draftSchemas.js";
+export { validateCatalogDraft } from "./draftValidation.js";
+export { catalogFixedPointSchema, catalogDocumentRevisionRefSchema, catalogSkuIdentifierSchema, catalogSkuEnvelopeSelectorSchema, neutralSkuEnvelopeV1Schema, catalogPriceContextSchema } from "./foundationSchemas.js";
+export { catalogNamespacedKeySchema, catalogDimensionKeySchema, catalogQuantityDimensionSchema, catalogQuantitySchema, catalogOptionValueSchema, catalogProductTypeRefSchema, createCatalogProductTypeRegistry } from "./productTypeSchemas.js";
+export { createReferenceCatalogItemsHandler } from "./referenceCatalogHandler.js";
+export { RESOLVED_SKU_PROJECTION_VERSION, resolvedSkuProjectionSchema, buildResolvedSkuProjection } from "./resolvedSkuProjection.js";
+export { sellableCatalogItemSchema, sellableCatalogProfileSchema, sellableCatalogListResponseSchema } from "./sellableSchemas.js";
+export { SOURCE_PACK_LIMITS, CatalogMediaSourcePackError, readCatalogMediaSourceManifest, validateCatalogMediaSourcePack, exportCatalogMediaSourcePack, restoreCatalogMediaSourcePack, importCatalogMediaSourcePack } from "./mediaSourcePack.js";
+export { SUPPORTED_BUNDLE_FULFILLMENT_MODES, createBundleWriteRules, evaluateBundleComposition, evaluateBundleFulfillmentMode, evaluateBundleTargetPrice, isEmptyCompositionConstraint, evaluateBundleCompositionConstraint } from "./bundleRules.js";
+export { BUNDLE_RULE_CODES, BUNDLE_ALLOCATION_RULE_CODE, BUNDLE_RULE_ENFORCEMENT } from "./bundleRuleCodes.js";
+export { DEFAULT_BUNDLE_LOW_STOCK_THRESHOLD, BUNDLE_COMPONENT_STOCK_UNKNOWN, BUNDLE_COMPOSITION_EMPTY, createBundleAvailability } from "./bundleAvailability.js";
+export { BundleCatalogReadError } from "./bundleCatalogReadPort.js";
+export { createBundleAvailabilityServices, createUnknownOfferAvailabilityPort } from "./bundleAvailabilityService.js";
+export { createAdminBundleHandlers } from "./adminBundleHandler.js";
+export { createAdminBundleReadHandlers } from "./adminBundleReadHandler.js";
+export { createSellableBundleHandlers, toSellableBundle } from "./sellableBundleHandler.js";
+export { createPostgresBundleCatalogStore } from "./bundleCatalogStore.js";
+export { BUNDLE_MIGRATIONS, CATALOG_MIGRATIONS } from "./sql.js";
+export { SUMMARY_COLUMNS, LIST_FILTER, LIST_SQL, COUNT_SQL, DETAIL_SQL, REFERENCE_PRICE, COMPONENT_SQL, FEED_COMPONENT_SQL, PRICE_SQL, OWN_LIST_SQL, CURRENCY_LIST_SQL, FEED_SQL, HISTORY_SQL, HISTORY_COUNT_SQL } from "./bundleCatalogQueries.js";
+export { createPostgresCatalogSkuEnvelopeReadPort } from "./catalogSkuEnvelope.js";
+export { createPostgresCatalogDraftStore } from "./catalogDraftStore.js";

package/dist/catalog/mediaSourcePack.d.ts

@@ -0,0 +1,51 @@
+import type { BlobStoragePort } from "@openlup/core/platform-runtime";
+import { type ProductMediaManifest } from "./contracts/productMediaContracts.js";
+export declare const SOURCE_PACK_LIMITS: Readonly<{
+    assets: 512;
+    products: 256;
+    variants: 1024;
+    associations: 8192;
+    imageBytes: 358400;
+    totalBytes: number;
+    manifestBytes: number;
+    resolvedItems: 32;
+}>;
+export interface CatalogMediaSourcePack {
+    schemaVersion: "catalog.media-source-pack.v1";
+    manifest: ProductMediaManifest;
+}
+export declare class CatalogMediaSourcePackError extends Error {
+    readonly code: string;
+    readonly reference?: string | undefined;
+    constructor(code: string, reference?: string | undefined);
+}
+export declare function readCatalogMediaSourceManifest(path: string): Promise<unknown>;
+export declare function validateCatalogMediaSourcePack(root: string): Promise<{
+    pack: CatalogMediaSourcePack;
+    resources: Map<string, Buffer<ArrayBufferLike>>;
+}>;
+export declare function exportCatalogMediaSourcePack(options: {
+    manifest: unknown;
+    sourceRoot: string;
+    targetRoot: string;
+}): Promise<CatalogMediaSourcePack>;
+export declare function restoreCatalogMediaSourcePack(packRoot: string, targetRoot: string): Promise<CatalogMediaSourcePack>;
+export type CatalogMediaImportOutcome = {
+    status: "complete";
+    successfulKeys: string[];
+    assets: Array<{
+        assetRef: string;
+        key: string;
+        url: string;
+    }>;
+} | {
+    status: "validation_refusal";
+    code: string;
+    reference?: string;
+} | {
+    status: "dependency_unavailable" | "partial_upload";
+    successfulKeys: string[];
+    failedAssetRef: string;
+    failedKey: string;
+};
+export declare function importCatalogMediaSourcePack(root: string, storage: BlobStoragePort): Promise<CatalogMediaImportOutcome>;