@porulle/plugin-channel-connector 0.10.8 → 0.13.0

package/src/index.ts

@@ -7,12 +7,18 @@ import {
   defineCommercePlugin,
   router,
   createSystemActor,
+  isValidFieldPath,
+  requireUserId,
 } from "@porulle/core";
-import type { JobsAdapter, PluginResult, PluginRouteRegistration, TaskDefinition } from "@porulle/core";
+import type { FieldPath, JobsAdapter, PluginResult, PluginRouteRegistration, TaskDefinition } from "@porulle/core";
 import { z } from "@hono/zod-openapi";
 import { and, eq } from "@porulle/core/drizzle";
 import { processedWebhookEvents } from "@porulle/core/schema";
 import {
+  channelCatalogPushEvents,
+  channelCatalogPushes,
+  channelCatalogConflicts,
+  channelCatalogConflictEvents,
   channelEntityMap,
   channelExportEvents,
   channelOrderExports,
@@ -22,6 +28,8 @@ import {
 } from "./schema.js";
 import {
   ChannelConnectorService,
+  catalogPushConcurrencyKey,
+  type CatalogConflictState,
   type ChannelComplianceData,
   type ChannelConnectorPluginOptions,
 } from "./service.js";
@@ -30,19 +38,64 @@ import { oauthStateEventId, signState, verifyState } from "./oauth-state.js";
 
 type ChannelRouteContext = {
   input: unknown;
+  query?: unknown;
   params: Record<string, string>;
   orgId: string;
-  actor: { userId: string } | null;
+  actor: { userId: string | null } | null;
 };
 
 export { mockChannelConnector } from "./mock-connector.js";
 export type { MockChannelConnectorOptions } from "./mock-connector.js";
 export {
   ChannelConnectorService,
+  CATALOG_OUTBOUND_SUPPRESSION_WINDOW_MS,
+  CATALOG_PUSH_BATCH_SIZES,
+  CATALOG_PUSH_MAX_ATTEMPTS,
+  canCatalogPushTransition,
   canExportTransition,
+  catalogPushConcurrencyKey,
+  catalogPushRetryDelayMs,
+  isCatalogPushBreakerOpen,
 } 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 {
+  BackfillCatalogOptions,
+  BackfillCatalogReport,
+  BuildCatalogPushItemsOptions,
+  BuildCatalogPushItemsResult,
+  CatalogPushAssemblyField,
+  CatalogPushAssemblyImage,
+  CatalogPushAssemblyItem,
+  CatalogPushPreviewBefore,
+  CatalogPushPreviewBeforeStatus,
+  CatalogPushPreviewDiff,
+  CatalogPushPreviewItem,
+  CatalogPushPreviewResult,
+  CatalogPushPreviewUnavailable,
+  PushCatalogToStoreResult,
+  CatalogPushJobResult,
+  CatalogFieldConflict,
+  CatalogFieldSkip,
+  CatalogPushFieldSkip,
+  CatalogPushSkipReason,
+  CatalogConflictState,
+  CatalogWriteSettings,
   ChannelComplianceData,
   ChannelConnectorPluginOptions,
   ChannelStockLine,
@@ -52,6 +105,10 @@ export type {
 } from "./service.js";
 export type { OAuthStatePayload, OAuthStateResult } from "./oauth-state.js";
 export type {
+  ChannelCatalogPush,
+  ChannelCatalogPushEvent,
+  ChannelCatalogConflict,
+  ChannelCatalogConflictEvent,
   ChannelEntityMapEntry,
   ChannelExportEvent,
   ChannelOrderExport,
@@ -138,7 +195,38 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
         const service = new ChannelConnectorService(ctx.db, ctx.services, 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: Record<string, unknown>) => String(input.storeId) },
+      handler: async ({ input, ctx }: { input: Record<string, unknown>; ctx: import("@porulle/core").TaskContext }) => {
+        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 as JobsAdapter;
+          await jobs.enqueue("channel/backfill-catalog", { orgId, storeId, dryRun }, {
+            organizationId: orgId,
+            concurrencyKey: storeId,
+            supersedes: false,
+          });
+        }
+        return { output: result.value };
       },
     },
     {
@@ -172,6 +260,37 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
         return { output: { exportId: result.value.id, state: result.value.state } };
       },
     },
+    {
+      slug: "channel/push-catalog",
+      concurrency: { key: catalogPushConcurrencyKey, supersedes: true },
+      handler: async ({ input, ctx }: { input: Record<string, unknown>; ctx: import("@porulle/core").TaskContext }) => {
+        const service = new ChannelConnectorService(ctx.db, ctx.services, options);
+        const orgId = String(input.organizationId ?? input.orgId);
+        const storeId = String(input.storeId);
+        const entityIds = Array.isArray(input.entityIds)
+          ? input.entityIds.map(String)
+          : undefined;
+        const forceFieldPaths = typeof input.forceFieldPaths === "object" && input.forceFieldPaths !== null
+          ? Object.fromEntries(Object.entries(input.forceFieldPaths).flatMap(([entityId, paths]) => [
+            [entityId, Array.isArray(paths) ? paths.filter((path): path is FieldPath => typeof path === "string" && isValidFieldPath(path)) : []],
+          ]))
+          : undefined;
+        const cursor = typeof input.cursor === "string" ? input.cursor : undefined;
+        const result = await service.executeCatalogPushJob(
+          orgId,
+          storeId,
+          {
+            ...(entityIds ? { entityIds } : {}),
+            ...(forceFieldPaths ? { forceFieldPaths } : {}),
+            ...(cursor ? { cursor } : {}),
+          },
+          createSystemActor(orgId),
+          { jobs: ctx.services.jobs as JobsAdapter },
+        );
+        if (!result.ok) throw new Error(result.error);
+        return { output: result.value };
+      },
+    },
     {
       slug: "channel/reap-exports",
       handler: async ({ input, ctx }: { input: Record<string, unknown>; ctx: import("@porulle/core").TaskContext }) => {
@@ -194,6 +313,10 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
     schema: () => ({
       connectedStores,
       channelEntityMap,
+      channelCatalogPushes,
+      channelCatalogPushEvents,
+      channelCatalogConflicts,
+      channelCatalogConflictEvents,
       channelOrderExports,
       channelExportEvents,
       channelRefundRequests,
@@ -378,11 +501,104 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
         .permission("channels:read")
         .handler(async ({ params, orgId }: ChannelRouteContext) => 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 }: ChannelRouteContext) => 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 }: ChannelRouteContext) => {
+          const values = input as { enabled?: boolean; overrides?: unknown };
+          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 }: ChannelRouteContext) => unwrap(await service.getReconcileStatus(orgId, params.storeId!)));
 
+      channels.get("/conflicts")
+        .summary("List channel catalog conflicts")
+        .permission("channels:read")
+        .query(z.object({ storeId: z.string().min(1).optional(), state: z.enum(["open", "resolved"]).optional() }))
+        .handler(async ({ query, orgId }: ChannelRouteContext) => {
+          const values = query as { storeId?: string; state?: CatalogConflictState };
+          return unwrap(await service.listCatalogConflicts(orgId, values.storeId, values.state));
+        });
+
+      channels.post("/conflicts/{id}/resolve")
+        .summary("Resolve a channel catalog conflict")
+        .permission("channels:manage")
+        .params(z.object({ id: z.string().min(1) }))
+        .input(z.object({ choose: z.enum(["platform", "store"]) }))
+        .handler(async ({ params, orgId, input, actor }: ChannelRouteContext) => {
+          const values = input as { choose: "platform" | "store" };
+          return unwrap(await service.resolveCatalogConflict(orgId, params.id!, values.choose, actor!));
+        });
+
+      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 }: ChannelRouteContext) => {
+          const values = input as { dryRun?: boolean; restart?: boolean };
+          if (values.dryRun === true) {
+            return unwrap(await service.backfillCatalog(orgId, params.storeId!, createSystemActor(orgId), { dryRun: true }));
+          }
+          const jobs = ctx.services.jobs as JobsAdapter;
+          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/{storeId}/push-catalog")
+        .summary("Enqueue a catalog push for a connected store")
+        .permission("channels:manage")
+        .input(z.object({ entityIds: z.array(z.string()).optional() }))
+        .handler(async ({ params, orgId, input }: ChannelRouteContext) => {
+          unwrap(await service.getStore(orgId, params.storeId!));
+          const values = input as { entityIds?: string[] };
+          const jobs = ctx.services.jobs as JobsAdapter;
+          await jobs.enqueue("channel/push-catalog", {
+            organizationId: orgId,
+            storeId: params.storeId!,
+            ...(values.entityIds ? { entityIds: values.entityIds } : {}),
+          }, {
+            organizationId: orgId,
+            concurrencyKey: catalogPushConcurrencyKey({
+              storeId: params.storeId!,
+              ...(values.entityIds ? { entityIds: values.entityIds } : {}),
+            }),
+            supersedes: true,
+          });
+          return { enqueued: true, storeId: params.storeId! };
+        });
+
+      channels.post("/stores/{storeId}/push-catalog/preview")
+        .summary("Preview a catalog push for a connected store")
+        .permission("channels:manage")
+        .input(z.object({ entityIds: z.array(z.string()).optional() }))
+        .handler(async ({ params, orgId, input }: ChannelRouteContext) => {
+          unwrap(await service.getStore(orgId, params.storeId!));
+          const values = input as { entityIds?: string[] };
+          return unwrap(await service.previewCatalogPush(orgId, params.storeId!, values.entityIds));
+        });
+
       channels.post("/stores/{id}/disconnect")
         .summary("Disconnect a channel store")
         .permission("channels:manage")
@@ -401,12 +617,12 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
       channels.post("/refund-requests/{id}/approve")
         .summary("Approve a channel refund request")
         .permission("channels:manage")
-        .handler(async ({ params, orgId, actor }: ChannelRouteContext) => unwrap(await service.approveRefund(orgId, params.id!, actor!)));
+        .handler(async ({ params, orgId, actor }: ChannelRouteContext) => unwrap(await service.approveRefund(orgId, params.id!, { userId: requireUserId(actor) })));
 
       channels.post("/refund-requests/{id}/reject")
         .summary("Reject a channel refund request")
         .permission("channels:manage")
-        .handler(async ({ params, orgId, actor }: ChannelRouteContext) => unwrap(await service.rejectRefund(orgId, params.id!, actor!)));
+        .handler(async ({ params, orgId, actor }: ChannelRouteContext) => unwrap(await service.rejectRefund(orgId, params.id!, { userId: requireUserId(actor) })));
 
       channels.post("/exports/{id}/retry")
         .summary("Retry a failed channel order export")
@@ -414,7 +630,7 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
         .handler(async ({ params, orgId, actor }: ChannelRouteContext) => unwrap(await service.retryExport(
           orgId,
           params.id!,
-          actor!.userId,
+          requireUserId(actor),
         )));
 
       return channels.routes() as PluginRouteRegistration[];

package/src/mock-connector.ts

@@ -6,8 +6,12 @@ import {
 } from "@porulle/core";
 import type {
   ChannelCatalogItem,
+  ChannelConnectorError,
   ChannelInventoryLevel,
   ChannelOrderSlice,
+  ChannelPushCatalogItem,
+  ChannelPushCatalogPreviousField,
+  ChannelStore,
 } from "@porulle/core";
 
 export interface MockChannelConnectorOptions {
@@ -17,10 +21,64 @@ export interface MockChannelConnectorOptions {
   throwOnInventory?: boolean;
   inventoryDelayMs?: number;
   onFetchInventory?: (ids: string[]) => void;
+  pushCatalogFailures?: Record<string, ChannelConnectorError>;
+  pushCatalogTransportError?: ChannelConnectorError;
+  onPushCatalog?: (items: ChannelPushCatalogItem[]) => void;
 }
 
+const defaultCatalog: ChannelCatalogItem[] = [{
+  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: MockChannelConnectorOptions = {}) {
   const orders = new Map<string, ChannelOrderSlice>();
+  const catalog = new Map<string, ChannelPushCatalogItem>();
 
   return defineChannelConnector({
     providerId: "mock",
@@ -28,10 +86,11 @@ export function mockChannelConnector(options: MockChannelConnectorOptions = {})
       importCatalog: true,
       importInventory: true,
       pushOrder: true,
+      pushCatalog: true,
       receiveWebhooks: true,
     },
-    async importCatalog() {
-      return Ok({ items: options.catalog ?? [], nextCursor: null });
+    async importCatalog(_store?: ChannelStore) {
+      return Ok({ items: options.catalog ?? defaultCatalog, nextCursor: null });
     },
     async fetchInventory(_store, ids) {
       const requestedIds = ids ?? [];
@@ -52,6 +111,26 @@ export function mockChannelConnector(options: MockChannelConnectorOptions = {})
         remoteUrl: `https://mock.channel.test/orders/${remoteOrderId}`,
       });
     },
+    async pushCatalog(_store, items, opts?: { dryRun?: boolean }) {
+      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: ChannelPushCatalogPreviousField[] = 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/src/schema.ts

@@ -1,4 +1,5 @@
 import {
+  boolean,
   index,
   integer,
   jsonb,
@@ -7,7 +8,10 @@ import {
   timestamp,
   uniqueIndex,
   uuid,
+  sql,
 } from "@porulle/core/drizzle";
+import type { ChannelPushCatalogItem, FieldPath } from "@porulle/core";
+import type { CatalogFieldMapping } from "./catalog-field-mapping.js";
 
 export const connectedStores = pgTable(
   "connected_stores",
@@ -20,6 +24,8 @@ export const connectedStores = pgTable(
     status: text("status", { enum: ["connected", "disconnected", "error"] })
       .notNull()
       .default("connected"),
+    catalogWriteEnabled: boolean("catalog_write_enabled").notNull().default(false),
+    catalogFieldMapping: jsonb("catalog_field_mapping").$type<CatalogFieldMapping>().notNull().default([]),
     catalogCursor: text("catalog_cursor"),
     inventoryCursor: text("inventory_cursor"),
     lastSyncAt: timestamp("last_sync_at", { withTimezone: true }),
@@ -48,6 +54,11 @@ export const channelEntityMap = pgTable(
     variantId: uuid("variant_id"),
     lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }).defaultNow().notNull(),
     syncHash: text("sync_hash").notNull(),
+    outboundHash: text("outbound_hash"),
+    outboundPushedAt: timestamp("outbound_pushed_at", { withTimezone: true }),
+    outboundFieldPaths: jsonb("outbound_field_paths").$type<FieldPath[]>().notNull().default([]),
+    heldFieldPaths: jsonb("held_field_paths").$type<FieldPath[]>().notNull().default([]),
+    forcedPushFieldPaths: jsonb("forced_push_field_paths").$type<FieldPath[]>().notNull().default([]),
   },
   (table) => ({
     orgIdx: index("idx_channel_entity_map_org").on(table.organizationId),
@@ -60,6 +71,48 @@ export const channelEntityMap = pgTable(
   }),
 );
 
+export const channelCatalogConflicts = pgTable(
+  "channel_catalog_conflicts",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    storeId: uuid("store_id").references(() => connectedStores.id, { onDelete: "cascade" }).notNull(),
+    entityId: uuid("entity_id").notNull(),
+    fieldPath: text("field_path").notNull(),
+    platformValue: jsonb("platform_value").$type<unknown>().notNull(),
+    storeValue: jsonb("store_value").$type<unknown>().notNull(),
+    state: text("state", { enum: ["open", "resolved"] }).notNull().default("open"),
+    resolvedBy: text("resolved_by"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_channel_catalog_conflicts_org").on(table.organizationId),
+    stateIdx: index("idx_channel_catalog_conflicts_org_state").on(table.organizationId, table.state),
+    openUnique: uniqueIndex("channel_catalog_conflicts_open_unique")
+      .on(table.storeId, table.entityId, table.fieldPath)
+      .where(sql`${table.state} = 'open'`),
+  }),
+);
+
+export const channelCatalogConflictEvents = pgTable(
+  "channel_catalog_conflict_events",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    conflictId: uuid("conflict_id").references(() => channelCatalogConflicts.id, { onDelete: "cascade" }).notNull(),
+    fromState: text("from_state"),
+    toState: text("to_state").notNull(),
+    reason: text("reason"),
+    changedBy: text("changed_by").notNull(),
+    changedAt: timestamp("changed_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_channel_catalog_conflict_events_org").on(table.organizationId),
+    conflictIdx: index("idx_channel_catalog_conflict_events_conflict").on(table.conflictId),
+  }),
+);
+
 export const channelOrderExports = pgTable(
   "channel_order_exports",
   {
@@ -91,6 +144,55 @@ export const channelOrderExports = pgTable(
   }),
 );
 
+export const channelCatalogPushes = pgTable(
+  "channel_catalog_pushes",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    storeId: uuid("store_id").references(() => connectedStores.id, { onDelete: "cascade" }).notNull(),
+    entityId: uuid("entity_id").notNull(),
+    payloadSnapshot: jsonb("payload_snapshot").$type<ChannelPushCatalogItem | null>(),
+    state: text("state", { enum: ["pending", "exported", "confirmed", "failed", "abandoned"] })
+      .notNull()
+      .default("pending"),
+    failureKind: text("failure_kind", { enum: ["definitive", "transient"] }),
+    attempts: integer("attempts").notNull().default(0),
+    lastError: text("last_error"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_channel_catalog_pushes_org").on(table.organizationId),
+    storeIdx: index("idx_channel_catalog_pushes_store").on(table.storeId),
+    stateIdx: index("idx_channel_catalog_pushes_state").on(table.organizationId, table.state),
+    entityIdx: index("idx_channel_catalog_pushes_entity").on(table.organizationId, table.entityId),
+    storeEntityUnique: uniqueIndex("channel_catalog_pushes_store_entity_unique").on(
+      table.storeId,
+      table.entityId,
+    ),
+  }),
+);
+
+export const channelCatalogPushEvents = pgTable(
+  "channel_catalog_push_events",
+  {
+    id: uuid("id").defaultRandom().primaryKey(),
+    organizationId: text("organization_id").notNull(),
+    pushId: uuid("push_id")
+      .references(() => channelCatalogPushes.id, { onDelete: "cascade" })
+      .notNull(),
+    fromState: text("from_state").notNull(),
+    toState: text("to_state").notNull(),
+    reason: text("reason"),
+    changedBy: text("changed_by").notNull(),
+    changedAt: timestamp("changed_at", { withTimezone: true }).defaultNow().notNull(),
+  },
+  (table) => ({
+    orgIdx: index("idx_channel_catalog_push_events_org").on(table.organizationId),
+    pushIdx: index("idx_channel_catalog_push_events_push").on(table.pushId),
+  }),
+);
+
 export const channelExportEvents = pgTable(
   "channel_export_events",
   {
@@ -152,6 +254,10 @@ export const channelRefundEvents = pgTable(
 
 export type ConnectedStore = typeof connectedStores.$inferSelect;
 export type ChannelEntityMapEntry = typeof channelEntityMap.$inferSelect;
+export type ChannelCatalogConflict = typeof channelCatalogConflicts.$inferSelect;
+export type ChannelCatalogConflictEvent = typeof channelCatalogConflictEvents.$inferSelect;
+export type ChannelCatalogPush = typeof channelCatalogPushes.$inferSelect;
+export type ChannelCatalogPushEvent = typeof channelCatalogPushEvents.$inferSelect;
 export type ChannelOrderExport = typeof channelOrderExports.$inferSelect;
 export type ChannelExportEvent = typeof channelExportEvents.$inferSelect;
 export type ChannelRefundRequest = typeof channelRefundRequests.$inferSelect;