@porulle/plugin-channel-connector 0.10.8 → 0.11.0

package/dist/catalog-field-mapping.d.ts

@@ -0,0 +1,32 @@
+import type { FieldPath } from "@porulle/core";
+export declare const catalogFieldTargets: readonly ["native", "attribute", "meta"];
+export type CatalogFieldTarget = (typeof catalogFieldTargets)[number];
+export interface CatalogFieldMappingRow {
+    fieldPath: FieldPath;
+    provider: string;
+    target: CatalogFieldTarget;
+    remoteKey: string;
+}
+export type CatalogFieldMapping = CatalogFieldMappingRow[];
+export type CatalogFieldMappingInput = Array<{
+    fieldPath: string;
+    provider?: string;
+    target: CatalogFieldTarget;
+    remoteKey: string;
+}> | Record<string, {
+    provider?: string;
+    target: CatalogFieldTarget;
+    remoteKey: string;
+}>;
+export declare const providerCatalogFieldMappingDefaults: Record<string, CatalogFieldMapping>;
+export declare function matchFieldPath(pattern: string, path: string): boolean;
+export declare function isValidCatalogMappingFieldPath(value: string): boolean;
+export declare function validateCatalogMappingRow(input: Partial<CatalogFieldMappingRow> & {
+    fieldPath: string;
+    target: CatalogFieldTarget;
+    remoteKey: string;
+}, provider: string): CatalogFieldMappingRow;
+export declare function normalizeCatalogFieldMapping(input: unknown, provider: string): CatalogFieldMapping;
+export declare function mergeCatalogFieldMapping(provider: string, overrides: unknown, filterableCustomFields?: ReadonlySet<string> | Readonly<Record<string, boolean>>, warnings?: string[]): CatalogFieldMapping;
+export declare function compareCatalogFieldMappingSpecificity(left: CatalogFieldMappingRow, right: CatalogFieldMappingRow): number;
+export declare function selectCatalogFieldMapping(mapping: CatalogFieldMapping, path: string): CatalogFieldMappingRow | undefined;

package/dist/catalog-field-mapping.js

@@ -0,0 +1,178 @@
+export const catalogFieldTargets = ["native", "attribute", "meta"];
+const fieldSegment = /^[A-Za-z0-9_-]+$/;
+const forbiddenFieldPaths = ["variants.sku", "variants.barcode", "options", "prices", "entity.status"];
+export const providerCatalogFieldMappingDefaults = {
+    shopify: [
+        { fieldPath: "attributes.*.title", provider: "shopify", target: "native", remoteKey: "title" },
+        { fieldPath: "attributes.*.description", provider: "shopify", target: "native", remoteKey: "body_html" },
+        { fieldPath: "attributes.*.seoTitle", provider: "shopify", target: "meta", remoteKey: "seo_title" },
+        { fieldPath: "attributes.*.seoDescription", provider: "shopify", target: "meta", remoteKey: "seo_description" },
+        { fieldPath: "customFields.*.*", provider: "shopify", target: "meta", remoteKey: "metafields" },
+        { fieldPath: "media.*", provider: "shopify", target: "native", remoteKey: "images" },
+        { fieldPath: "entity.metadata.*", provider: "shopify", target: "meta", remoteKey: "metafields" },
+    ],
+    woocommerce: [
+        { fieldPath: "attributes.*.title", provider: "woocommerce", target: "native", remoteKey: "name" },
+        { fieldPath: "attributes.*.description", provider: "woocommerce", target: "native", remoteKey: "description" },
+        { fieldPath: "attributes.*.seoTitle", provider: "woocommerce", target: "meta", remoteKey: "yoast_wpseo_title" },
+        { fieldPath: "attributes.*.seoDescription", provider: "woocommerce", target: "meta", remoteKey: "yoast_wpseo_metadesc" },
+        { fieldPath: "customFields.*.*", provider: "woocommerce", target: "meta", remoteKey: "porulle_meta_data" },
+        { fieldPath: "media.*", provider: "woocommerce", target: "native", remoteKey: "images" },
+        { fieldPath: "entity.metadata.*", provider: "woocommerce", target: "meta", remoteKey: "porulle_meta_data" },
+    ],
+};
+export function matchFieldPath(pattern, path) {
+    const patternSegments = pattern.split(".");
+    const pathSegments = path.split(".");
+    return patternSegments.length === pathSegments.length
+        && patternSegments.every((segment, index) => pathSegments[index] !== "" && (segment === "*" || segment === pathSegments[index]));
+}
+export function isValidCatalogMappingFieldPath(value) {
+    const segments = value.split(".");
+    return segments.length > 0 && segments.every((segment) => segment === "*" || fieldSegment.test(segment));
+}
+function couldCoverForbiddenSubtree(fieldPath, root) {
+    const fieldSegments = fieldPath.split(".");
+    const rootSegments = root.split(".");
+    return fieldSegments.length >= rootSegments.length
+        && rootSegments.every((segment, index) => fieldSegments[index] === "*" || fieldSegments[index] === segment);
+}
+function isForbiddenMappingFieldPath(fieldPath) {
+    return forbiddenFieldPaths.some((root) => couldCoverForbiddenSubtree(fieldPath, root));
+}
+export function validateCatalogMappingRow(input, provider) {
+    if (!isValidCatalogMappingFieldPath(input.fieldPath)) {
+        throw new Error("Catalog mapping field paths must contain dot-separated alphanumeric, underscore, hyphen, or wildcard segments.");
+    }
+    if (isForbiddenMappingFieldPath(input.fieldPath)) {
+        throw new Error(`Catalog mapping cannot write the forbidden field path "${input.fieldPath}".`);
+    }
+    if (!catalogFieldTargets.includes(input.target)) {
+        throw new Error(`Catalog mapping target "${input.target}" is invalid.`);
+    }
+    const remoteKey = input.remoteKey.trim();
+    if (remoteKey.length === 0) {
+        throw new Error("Catalog mapping remoteKey must not be empty.");
+    }
+    const rowProvider = input.provider ?? provider;
+    if (rowProvider !== provider) {
+        throw new Error(`Catalog mapping provider must be "${provider}" for this store.`);
+    }
+    if (rowProvider === "woocommerce" && input.target === "meta" && remoteKey.startsWith("_")) {
+        throw new Error("WooCommerce meta keys must not start with an underscore.");
+    }
+    return {
+        fieldPath: input.fieldPath,
+        provider: rowProvider,
+        target: input.target,
+        remoteKey,
+    };
+}
+function mappingEntries(input) {
+    if (Array.isArray(input))
+        return input;
+    if (!input || typeof input !== "object")
+        throw new Error("Catalog mapping must be an array or an object.");
+    return Object.entries(input).map(([fieldPath, value]) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("Catalog mapping values must be objects.");
+        return { ...value, fieldPath };
+    });
+}
+function normalizeCatalogMappingRow(row, provider) {
+    if (!row || typeof row !== "object" || Array.isArray(row))
+        throw new Error("Catalog mapping rows must be objects.");
+    const value = row;
+    if (typeof value.fieldPath !== "string" || typeof value.target !== "string" || typeof value.remoteKey !== "string") {
+        throw new Error("Catalog mapping rows require fieldPath, target, and remoteKey.");
+    }
+    return validateCatalogMappingRow({
+        fieldPath: value.fieldPath,
+        ...(typeof value.provider === "string" ? { provider: value.provider } : {}),
+        target: value.target,
+        remoteKey: value.remoteKey,
+    }, provider);
+}
+export function normalizeCatalogFieldMapping(input, provider) {
+    return mappingEntries(input).map((row) => normalizeCatalogMappingRow(row, provider));
+}
+function normalizeStoredCatalogFieldMapping(input, provider, warnings) {
+    let entries;
+    try {
+        entries = mappingEntries(input ?? []);
+    }
+    catch (error) {
+        warnings.push(error instanceof Error ? error.message : "Stored catalog mapping is invalid.");
+        return [];
+    }
+    return entries.flatMap((row, index) => {
+        try {
+            return [normalizeCatalogMappingRow(row, provider)];
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "Stored catalog mapping row is invalid.";
+            warnings.push(`Skipped catalog mapping row ${index}: ${message}`);
+            return [];
+        }
+    });
+}
+function filterableEntries(hint) {
+    if (hint instanceof Set)
+        return [...hint].map((path) => [path, true]);
+    return Object.entries(hint);
+}
+export function mergeCatalogFieldMapping(provider, overrides, filterableCustomFields, warnings = []) {
+    const defaults = (providerCatalogFieldMappingDefaults[provider] ?? []).map((row) => ({ ...row }));
+    const rows = normalizeStoredCatalogFieldMapping(overrides, provider, warnings);
+    const merged = [...defaults];
+    for (const row of rows) {
+        const index = merged.findIndex((defaultRow) => defaultRow.fieldPath === row.fieldPath && defaultRow.provider === row.provider);
+        if (index === -1)
+            merged.push(row);
+        else
+            merged[index] = row;
+    }
+    if (!filterableCustomFields)
+        return merged;
+    const hints = filterableEntries(filterableCustomFields).filter(([path]) => isValidCatalogMappingFieldPath(path));
+    if (hints.length === 0)
+        return merged;
+    const customFieldPattern = "customFields.*.*";
+    const customFieldDefault = merged.find((row) => row.fieldPath === customFieldPattern);
+    if (!customFieldDefault)
+        return merged;
+    const expanded = hints
+        .filter(([path]) => matchFieldPath(customFieldPattern, path))
+        .map(([fieldPath, filterable]) => ({
+        ...customFieldDefault,
+        fieldPath,
+        target: filterable ? "attribute" : "meta",
+        remoteKey: fieldPath.split(".")[1] ?? customFieldDefault.remoteKey,
+    }));
+    return [...merged.filter((row) => row.fieldPath !== customFieldPattern), ...expanded];
+}
+function wildcardCount(fieldPath) {
+    return fieldPath.split(".").filter((segment) => segment === "*").length;
+}
+function compareStrings(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}
+export function compareCatalogFieldMappingSpecificity(left, right) {
+    const wildcardDifference = wildcardCount(left.fieldPath) - wildcardCount(right.fieldPath);
+    if (wildcardDifference !== 0)
+        return wildcardDifference;
+    const fieldPathDifference = compareStrings(left.fieldPath, right.fieldPath);
+    if (fieldPathDifference !== 0)
+        return fieldPathDifference;
+    const providerDifference = compareStrings(left.provider, right.provider);
+    if (providerDifference !== 0)
+        return providerDifference;
+    return compareStrings(left.remoteKey, right.remoteKey);
+}
+export function selectCatalogFieldMapping(mapping, path) {
+    return mapping.filter((row) => matchFieldPath(row.fieldPath, path)).sort(compareCatalogFieldMappingSpecificity)[0];
+}

package/dist/index.d.ts

@@ -2,8 +2,10 @@ import { type ChannelConnectorPluginOptions } from "./service.js";
 export { mockChannelConnector } from "./mock-connector.js";
 export type { MockChannelConnectorOptions } from "./mock-connector.js";
 export { ChannelConnectorService, canExportTransition, } from "./service.js";
+export { isValidCatalogMappingFieldPath, matchFieldPath, mergeCatalogFieldMapping, normalizeCatalogFieldMapping, compareCatalogFieldMappingSpecificity, providerCatalogFieldMappingDefaults, selectCatalogFieldMapping, validateCatalogMappingRow, } from "./catalog-field-mapping.js";
+export type { CatalogFieldMapping, CatalogFieldMappingInput, CatalogFieldMappingRow, CatalogFieldTarget, } from "./catalog-field-mapping.js";
 export { signState, verifyState } from "./oauth-state.js";
-export type { ChannelComplianceData, ChannelConnectorPluginOptions, ChannelStockLine, ExportState, PublicConnectedStore, ReconcileReport, } from "./service.js";
+export type { BackfillCatalogOptions, BackfillCatalogReport, BuildCatalogPushItemsOptions, BuildCatalogPushItemsResult, CatalogFieldConflict, CatalogFieldSkip, CatalogPushFieldSkip, CatalogPushSkipReason, CatalogWriteSettings, ChannelComplianceData, ChannelConnectorPluginOptions, ChannelStockLine, ExportState, PublicConnectedStore, ReconcileReport, } from "./service.js";
 export type { OAuthStatePayload, OAuthStateResult } from "./oauth-state.js";
 export type { ChannelEntityMapEntry, ChannelExportEvent, ChannelOrderExport, ChannelRefundEvent, ChannelRefundRequest, ConnectedStore, } from "./schema.js";
 export declare function channelConnectorPlugin(options?: ChannelConnectorPluginOptions): import("@porulle/core").CommercePlugin;

package/dist/index.js

@@ -9,6 +9,7 @@ import { buildHooks } from "./hooks.js";
 import { oauthStateEventId, signState, verifyState } from "./oauth-state.js";
 export { mockChannelConnector } from "./mock-connector.js";
 export { ChannelConnectorService, canExportTransition, } from "./service.js";
+export { isValidCatalogMappingFieldPath, matchFieldPath, mergeCatalogFieldMapping, normalizeCatalogFieldMapping, compareCatalogFieldMappingSpecificity, providerCatalogFieldMappingDefaults, selectCatalogFieldMapping, validateCatalogMappingRow, } from "./catalog-field-mapping.js";
 export { signState, verifyState } from "./oauth-state.js";
 function unwrap(result) {
     if (result.ok)
@@ -90,7 +91,39 @@ export function channelConnectorPlugin(options = {}) {
                 const result = await service.importCatalog(String(input.orgId), String(input.storeId), createSystemActor(String(input.orgId)));
                 if (!result.ok)
                     throw new Error(result.error);
-                return { output: { imported: result.value.imported, cursor: result.value.cursor } };
+                return {
+                    output: {
+                        imported: result.value.imported,
+                        cursor: result.value.cursor,
+                        ...(result.value.warnings ? { warnings: result.value.warnings } : {}),
+                    },
+                };
+            },
+        },
+        {
+            slug: "channel/backfill-catalog",
+            concurrency: { key: (input) => String(input.storeId) },
+            handler: async ({ input, ctx }) => {
+                const service = new ChannelConnectorService(ctx.db, ctx.services, options);
+                const orgId = String(input.orgId);
+                const storeId = String(input.storeId);
+                const dryRun = input.dryRun === true;
+                const result = await service.backfillCatalog(orgId, storeId, createSystemActor(orgId), {
+                    dryRun,
+                    ...(input.restart === true ? { resume: false } : {}),
+                    ...(!dryRun ? { maxPages: 1 } : {}),
+                });
+                if (!result.ok)
+                    throw new Error(result.error);
+                if (!result.value.complete && !dryRun) {
+                    const jobs = ctx.services.jobs;
+                    await jobs.enqueue("channel/backfill-catalog", { orgId, storeId, dryRun }, {
+                        organizationId: orgId,
+                        concurrencyKey: storeId,
+                        supersedes: false,
+                    });
+                }
+                return { output: result.value };
             },
         },
         {
@@ -341,10 +374,50 @@ export function channelConnectorPlugin(options = {}) {
                 .summary("Get a connected channel store")
                 .permission("channels:read")
                 .handler(async ({ params, orgId }) => unwrap(await service.getStore(orgId, params.id)));
+            channels.get("/stores/{storeId}/catalog-write")
+                .summary("Get catalog write settings for a channel store")
+                .permission("channels:manage")
+                .handler(async ({ params, orgId }) => unwrap(await service.getCatalogWriteSettings(orgId, params.storeId)));
+            channels.put("/stores/{storeId}/catalog-write")
+                .summary("Update catalog write settings for a channel store")
+                .permission("channels:manage")
+                .input(z.object({
+                enabled: z.boolean().optional(),
+                overrides: z.unknown().optional(),
+            }).refine((value) => value.enabled !== undefined || value.overrides !== undefined))
+                .handler(async ({ params, orgId, input }) => {
+                const values = input;
+                if (values.overrides !== undefined)
+                    unwrap(await service.updateCatalogFieldMapping(orgId, params.storeId, values.overrides));
+                if (values.enabled !== undefined)
+                    unwrap(await service.updateCatalogWriteEnabled(orgId, params.storeId, values.enabled));
+                return unwrap(await service.getCatalogWriteSettings(orgId, params.storeId));
+            });
             channels.get("/stores/{storeId}/reconcile-status")
                 .summary("Get channel reconciliation status")
                 .permission("channels:read")
                 .handler(async ({ params, orgId }) => unwrap(await service.getReconcileStatus(orgId, params.storeId)));
+            channels.post("/stores/{storeId}/backfill")
+                .summary("Backfill a channel catalog into the PIM")
+                .permission("channels:manage")
+                .input(z.object({ dryRun: z.boolean().optional(), restart: z.boolean().optional() }))
+                .handler(async ({ params, orgId, input }) => {
+                const values = input;
+                if (values.dryRun === true) {
+                    return unwrap(await service.backfillCatalog(orgId, params.storeId, createSystemActor(orgId), { dryRun: true }));
+                }
+                const jobs = ctx.services.jobs;
+                await jobs.enqueue("channel/backfill-catalog", {
+                    orgId,
+                    storeId: params.storeId,
+                    ...(values.restart === true ? { restart: true } : {}),
+                }, {
+                    organizationId: orgId,
+                    concurrencyKey: params.storeId,
+                    supersedes: false,
+                });
+                return { enqueued: true, storeId: params.storeId };
+            });
             channels.post("/stores/{id}/disconnect")
                 .summary("Disconnect a channel store")
                 .permission("channels:manage")

package/dist/mock-connector.d.ts

@@ -1,5 +1,5 @@
 import { CommerceValidationError } from "@porulle/core";
-import type { ChannelCatalogItem, ChannelInventoryLevel, ChannelOrderSlice } from "@porulle/core";
+import type { ChannelCatalogItem, ChannelConnectorError, ChannelInventoryLevel, ChannelOrderSlice, ChannelPushCatalogItem, ChannelPushCatalogPreviousField, ChannelStore } from "@porulle/core";
 export interface MockChannelConnectorOptions {
     catalog?: ChannelCatalogItem[];
     inventory?: ChannelInventoryLevel[];
@@ -7,6 +7,9 @@ export interface MockChannelConnectorOptions {
     throwOnInventory?: boolean;
     inventoryDelayMs?: number;
     onFetchInventory?: (ids: string[]) => void;
+    pushCatalogFailures?: Record<string, ChannelConnectorError>;
+    pushCatalogTransportError?: ChannelConnectorError;
+    onPushCatalog?: (items: ChannelPushCatalogItem[]) => void;
 }
 export declare function mockChannelConnector(options?: MockChannelConnectorOptions): {
     providerId: string;
@@ -14,13 +17,14 @@ export declare function mockChannelConnector(options?: MockChannelConnectorOptio
         importCatalog: true;
         importInventory: true;
         pushOrder: true;
+        pushCatalog: true;
         receiveWebhooks: true;
     };
-    importCatalog(): Promise<import("@porulle/core").Result<{
+    importCatalog(_store?: ChannelStore): Promise<import("@porulle/core").Result<{
         items: ChannelCatalogItem[];
         nextCursor: null;
     }, never>>;
-    fetchInventory(_store: import("@porulle/core").ChannelStore, ids: string[] | undefined): Promise<{
+    fetchInventory(_store: ChannelStore, ids: string[] | undefined): Promise<{
         ok: false;
         error: CommerceValidationError;
     } | {
@@ -28,11 +32,32 @@ export declare function mockChannelConnector(options?: MockChannelConnectorOptio
         value: ChannelInventoryLevel[];
         meta?: Record<string, unknown>;
     }>;
-    pushOrder(_store: import("@porulle/core").ChannelStore, slice: ChannelOrderSlice): Promise<import("@porulle/core").Result<{
+    pushOrder(_store: ChannelStore, slice: ChannelOrderSlice): Promise<import("@porulle/core").Result<{
         remoteOrderId: string;
         remoteUrl: string;
     }, never>>;
-    fetchOrderStatus(_store: import("@porulle/core").ChannelStore, remoteId: string): Promise<{
+    pushCatalog(_store: ChannelStore, items: ChannelPushCatalogItem[], opts?: {
+        dryRun?: boolean;
+    }): Promise<{
+        ok: false;
+        error: ChannelConnectorError;
+    } | {
+        ok: true;
+        value: {
+            outcomes: ({
+                externalId: string;
+                ok: boolean;
+                error: ChannelConnectorError;
+            } | {
+                previousFields?: ChannelPushCatalogPreviousField[];
+                externalId: string;
+                ok: boolean;
+                error?: never;
+            })[];
+        };
+        meta?: Record<string, unknown>;
+    }>;
+    fetchOrderStatus(_store: ChannelStore, remoteId: string): Promise<{
         ok: false;
         error: CommerceValidationError;
     } | {
@@ -42,7 +67,7 @@ export declare function mockChannelConnector(options?: MockChannelConnectorOptio
         };
         meta?: Record<string, unknown>;
     }>;
-    verifyWebhook(store: import("@porulle/core").ChannelStore, request: Request): Promise<{
+    verifyWebhook(store: ChannelStore, request: Request): Promise<{
         ok: false;
         error: CommerceValidationError;
     } | {

package/dist/mock-connector.js

@@ -1,16 +1,67 @@
 import { CommerceValidationError, Err, Ok, defineChannelConnector, } from "@porulle/core";
+const defaultCatalog = [{
+        externalId: "mock-product-1",
+        slug: "mock-channel-product",
+        title: "Mock Channel Product",
+        description: "Imported through the mock connector.",
+        attributes: [{
+                locale: "en",
+                title: "Mock Channel Product",
+                subtitle: "A complete mock catalog item",
+                description: "Imported through the mock connector.",
+                richDescription: { blocks: [{ type: "paragraph", text: "Mock product details." }] },
+                seoTitle: "Mock Channel Product | Porulle",
+                seoDescription: "A mock product with the complete channel catalog shape.",
+            }],
+        images: [
+            {
+                externalId: "mock-image-primary",
+                url: "https://mock.channel.test/images/mock-product-1-primary.jpg",
+                alt: "Mock Channel Product",
+                role: "primary",
+                sortOrder: 0,
+            },
+            {
+                externalId: "mock-image-variant",
+                url: "https://mock.channel.test/images/mock-variant-1.jpg",
+                alt: "Mock Channel Product blue variant",
+                role: "gallery",
+                sortOrder: 1,
+                variantExternalIds: ["mock-variant-1"],
+            },
+        ],
+        options: [{
+                name: "color",
+                displayName: "Color",
+                sortOrder: 0,
+                values: [{ value: "blue", displayValue: "Blue", sortOrder: 0 }],
+            }],
+        tags: ["mock", "featured"],
+        brand: "Porulle",
+        categories: ["mock-products"],
+        status: "active",
+        variants: [{
+                externalId: "mock-variant-1",
+                sku: "MOCK-SKU-1",
+                barcode: "0123456789012",
+                optionValues: { color: "blue" },
+                prices: [{ currency: "USD", amount: 2500 }],
+            }],
+    }];
 export function mockChannelConnector(options = {}) {
     const orders = new Map();
+    const catalog = new Map();
     return defineChannelConnector({
         providerId: "mock",
         capabilities: {
             importCatalog: true,
             importInventory: true,
             pushOrder: true,
+            pushCatalog: true,
             receiveWebhooks: true,
         },
-        async importCatalog() {
-            return Ok({ items: options.catalog ?? [], nextCursor: null });
+        async importCatalog(_store) {
+            return Ok({ items: options.catalog ?? defaultCatalog, nextCursor: null });
         },
         async fetchInventory(_store, ids) {
             const requestedIds = ids ?? [];
@@ -33,6 +84,30 @@ export function mockChannelConnector(options = {}) {
                 remoteUrl: `https://mock.channel.test/orders/${remoteOrderId}`,
             });
         },
+        async pushCatalog(_store, items, opts) {
+            if (options.pushCatalogTransportError)
+                return Err(options.pushCatalogTransportError);
+            const outcomes = items.map((item) => {
+                const error = options.pushCatalogFailures?.[item.externalId];
+                if (error)
+                    return { externalId: item.externalId, ok: false, error };
+                const previous = catalog.get(item.externalId);
+                const previousFields = previous
+                    ? [...previous.fields, ...(previous.variants ?? []).flatMap((variant) => variant.fields)]
+                        .map((field) => ({ fieldPath: field.fieldPath, value: structuredClone(field.value) }))
+                    : [];
+                if (opts?.dryRun !== true)
+                    catalog.set(item.externalId, structuredClone(item));
+                return {
+                    externalId: item.externalId,
+                    ok: true,
+                    ...(previousFields.length > 0 ? { previousFields } : {}),
+                };
+            });
+            if (opts?.dryRun !== true)
+                options.onPushCatalog?.(structuredClone(items));
+            return Ok({ outcomes });
+        },
         async fetchOrderStatus(_store, remoteId) {
             if (!orders.has(remoteId)) {
                 return Err(new CommerceValidationError(`Mock order "${remoteId}" was not found.`));

package/dist/schema.d.ts

@@ -1,3 +1,4 @@
+import type { CatalogFieldMapping } from "./catalog-field-mapping.js";
 export declare const connectedStores: import("drizzle-orm/pg-core/table").PgTableWithColumns<{
     name: "connected_stores";
     schema: undefined;
@@ -106,6 +107,42 @@ export declare const connectedStores: import("drizzle-orm/pg-core/table").PgTabl
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        catalogWriteEnabled: import("@porulle/core/drizzle").PgColumn<{
+            name: "catalog_write_enabled";
+            tableName: "connected_stores";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        catalogFieldMapping: import("@porulle/core/drizzle").PgColumn<{
+            name: "catalog_field_mapping";
+            tableName: "connected_stores";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: CatalogFieldMapping;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: CatalogFieldMapping;
+        }>;
         catalogCursor: import("@porulle/core/drizzle").PgColumn<{
             name: "catalog_cursor";
             tableName: "connected_stores";
@@ -423,6 +460,25 @@ export declare const channelEntityMap: import("drizzle-orm/pg-core/table").PgTab
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        heldFieldPaths: import("@porulle/core/drizzle").PgColumn<{
+            name: "held_field_paths";
+            tableName: "channel_entity_map";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: string[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: string[];
+        }>;
     };
     dialect: "pg";
 }>;
@@ -918,7 +974,7 @@ export declare const channelRefundRequests: import("drizzle-orm/pg-core/table").
             tableName: "channel_refund_requests";
             dataType: "string";
             columnType: "PgText";
-            data: "rejected" | "requested" | "approved" | "executed";
+            data: "approved" | "rejected" | "requested" | "executed";
             driverParam: string;
             notNull: true;
             hasDefault: true;

package/dist/schema.js

@@ -1,4 +1,4 @@
-import { index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid, } from "@porulle/core/drizzle";
+import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid, } from "@porulle/core/drizzle";
 export const connectedStores = pgTable("connected_stores", {
     id: uuid("id").defaultRandom().primaryKey(),
     organizationId: text("organization_id").notNull(),
@@ -8,6 +8,8 @@ export const connectedStores = pgTable("connected_stores", {
     status: text("status", { enum: ["connected", "disconnected", "error"] })
         .notNull()
         .default("connected"),
+    catalogWriteEnabled: boolean("catalog_write_enabled").notNull().default(false),
+    catalogFieldMapping: jsonb("catalog_field_mapping").$type().notNull().default([]),
     catalogCursor: text("catalog_cursor"),
     inventoryCursor: text("inventory_cursor"),
     lastSyncAt: timestamp("last_sync_at", { withTimezone: true }),
@@ -31,6 +33,7 @@ export const channelEntityMap = pgTable("channel_entity_map", {
     variantId: uuid("variant_id"),
     lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }).defaultNow().notNull(),
     syncHash: text("sync_hash").notNull(),
+    heldFieldPaths: jsonb("held_field_paths").$type().notNull().default([]),
 }, (table) => ({
     orgIdx: index("idx_channel_entity_map_org").on(table.organizationId),
     storeIdx: index("idx_channel_entity_map_store").on(table.storeId),