@porulle/plugin-channel-connector 0.10.8 → 0.13.0

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.`));