@porulle/plugin-channel-connector 0.11.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/plugin-channel-connector",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -19,15 +19,15 @@
   "dependencies": {
     "@hono/zod-openapi": "^1.2.2",
     "hono": "^4.12.5",
-    "@porulle/core": "0.11.0"
+    "@porulle/core": "0.13.0"
   },
   "devDependencies": {
     "@types/node": "^24.5.2",
     "eslint": "^9.39.1",
     "typescript": "5.9.2",
     "vitest": "^3.2.4",
-    "@porulle/eslint-config": "0.1.0",
-    "@porulle/typescript-config": "0.1.0"
+    "@porulle/typescript-config": "0.1.0",
+    "@porulle/eslint-config": "0.1.0"
   },
   "publishConfig": {
     "access": "public"

package/src/catalog-push-trigger.ts

@@ -0,0 +1,99 @@
+import { resolveOrgIdForCommerce, isValidFieldPath, type FieldOwner } from "@porulle/core";
+import type { HookContext } from "@porulle/core";
+import { and, eq } from "@porulle/core/drizzle";
+import { catalogPushConcurrencyKey } from "./service.js";
+import { channelEntityMap } from "./schema.js";
+
+type CatalogUpdateInput = {
+  slug?: string;
+  status?: string;
+  metadata?: Record<string, unknown>;
+  customFields?: Record<string, unknown | null>;
+};
+
+export const CHANNEL_CONVERGENCE_ORIGIN = "channel-convergence";
+
+export const CHANNEL_CONVERGENCE_CTX = {
+  hookContext: { origin: CHANNEL_CONVERGENCE_ORIGIN },
+};
+
+interface CatalogOwnershipService {
+  resolveFieldOwners(entityId: string, storeId: string): Promise<Map<string, FieldOwner>>;
+}
+
+function updateInputFieldPaths(input: CatalogUpdateInput): string[] {
+  const paths: string[] = [];
+  if (input.slug !== undefined) paths.push("entity.slug");
+  if (input.status !== undefined) paths.push("entity.status");
+  if (input.metadata) {
+    for (const key of Object.keys(input.metadata)) paths.push(`entity.metadata.${key}`);
+  }
+  if (input.customFields) {
+    for (const name of Object.keys(input.customFields)) paths.push(`customFields.${name}.en`);
+  }
+  return paths.filter(isValidFieldPath);
+}
+
+export async function maybeEnqueueCatalogPush(args: {
+  entityId: string;
+  changedFieldPaths: string[];
+  context: HookContext;
+}): Promise<void> {
+  if (args.context.context.origin === CHANNEL_CONVERGENCE_ORIGIN) return;
+  if (args.changedFieldPaths.length === 0) return;
+
+  const orgId = resolveOrgIdForCommerce(args.context.actor, args.context.commerceConfig);
+  const catalog = args.context.services.catalog as CatalogOwnershipService;
+  const mappings = await args.context.db
+    .select({ storeId: channelEntityMap.storeId })
+    .from(channelEntityMap)
+    .where(and(
+      eq(channelEntityMap.organizationId, orgId),
+      eq(channelEntityMap.entityId, args.entityId),
+      eq(channelEntityMap.kind, "entity"),
+    ));
+
+  const forceFieldPathsByStore = new Map<string, string[]>();
+  for (const mapping of mappings) {
+    const owners = await catalog.resolveFieldOwners(args.entityId, mapping.storeId);
+    const changedPaths = args.changedFieldPaths.filter((path) => {
+      const owner = owners.get(path);
+      return owner === "platform" || owner === "shared";
+    });
+    if (changedPaths.length > 0) forceFieldPathsByStore.set(mapping.storeId, changedPaths);
+  }
+
+  await Promise.all([...forceFieldPathsByStore].map(([storeId, forceFieldPaths]) => args.context.jobs.enqueue(
+    "channel/push-catalog",
+    {
+      organizationId: orgId,
+      storeId,
+      entityIds: [args.entityId],
+      forceFieldPaths: { [args.entityId]: forceFieldPaths },
+    },
+    {
+      organizationId: orgId,
+      concurrencyKey: catalogPushConcurrencyKey({ storeId, entityIds: [args.entityId] }),
+      supersedes: true,
+    },
+  )));
+}
+
+export function recordUpdateFieldPaths(input: CatalogUpdateInput, context: HookContext): CatalogUpdateInput {
+  context.context.changedFieldPaths = updateInputFieldPaths(input);
+  return input;
+}
+
+export async function handleCatalogAfterUpdate(args: {
+  result: { id: string };
+  context: HookContext;
+}): Promise<void> {
+  const changedFieldPaths = Array.isArray(args.context.context.changedFieldPaths)
+    ? args.context.context.changedFieldPaths.map(String)
+    : [];
+  await maybeEnqueueCatalogPush({
+    entityId: args.result.id,
+    changedFieldPaths,
+    context: args.context,
+  });
+}

package/src/hooks.ts

@@ -1,5 +1,5 @@
-import { resolveOrgId } from "@porulle/core";
-import type { PluginHookRegistration } from "@porulle/core";
+import { resolveOrgIdForCommerce } from "@porulle/core";
+import type { Actor, CommerceConfig, PluginHookRegistration } from "@porulle/core";
 import { and, eq, inArray } from "@porulle/core/drizzle";
 import { sellableEntities } from "@porulle/core/schema";
 import {
@@ -7,6 +7,10 @@ import {
   type ChannelConnectorPluginOptions,
   type ChannelStockLine,
 } from "./service.js";
+import {
+  handleCatalogAfterUpdate,
+  recordUpdateFieldPaths,
+} from "./catalog-push-trigger.js";
 
 export function buildHooks(options: ChannelConnectorPluginOptions): PluginHookRegistration[] {
   return [{
@@ -15,14 +19,16 @@ export function buildHooks(options: ChannelConnectorPluginOptions): PluginHookRe
       const { data, context } = args as {
         data: { lineItems: ChannelStockLine[] };
         context: {
-          actor: Parameters<typeof resolveOrgId>[0];
+          actor: Actor | null;
+          commerceConfig?: CommerceConfig | null;
           db: ConstructorParameters<typeof ChannelConnectorService>[0];
           services: Record<string, unknown>;
         };
       };
+      if (data.lineItems.length === 0) return data;
       const service = new ChannelConnectorService(context.db, context.services, options);
       await service.validateLineStock(
-        resolveOrgId(context.actor),
+        resolveOrgIdForCommerce(context.actor, context.commerceConfig),
         data.lineItems,
         options.inventoryTimeoutMs,
       );
@@ -33,12 +39,30 @@ export function buildHooks(options: ChannelConnectorPluginOptions): PluginHookRe
     async handler(args: unknown) {
       const { result, context } = args as {
         result: { id: string; lineItems?: Array<{ entityId: string }> };
-        context: { actor: Parameters<typeof resolveOrgId>[0]; db: ConstructorParameters<typeof ChannelConnectorService>[0]; services: Record<string, unknown>; jobs: { enqueue(task: string, input: Record<string, unknown>, options: { organizationId: string; concurrencyKey: string; supersedes: boolean }): Promise<string> } };
+        context: { actor: Actor | null; commerceConfig?: CommerceConfig | null; db: ConstructorParameters<typeof ChannelConnectorService>[0]; services: Record<string, unknown>; jobs: { enqueue(task: string, input: Record<string, unknown>, options: { organizationId: string; concurrencyKey: string; supersedes: boolean }): Promise<string> } };
       };
-      const orgId = resolveOrgId(context.actor);
+      const orgId = resolveOrgIdForCommerce(context.actor, context.commerceConfig);
       const entities = await context.db.select({ id: sellableEntities.id, sourceStoreId: sellableEntities.sourceStoreId }).from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), inArray(sellableEntities.id, (result.lineItems ?? []).map((line) => line.entityId))));
       const stores = new Set(entities.map((entity) => entity.sourceStoreId).filter((storeId): storeId is string => storeId !== null));
       await Promise.all([...stores].map((storeId) => context.jobs.enqueue("channel/push-order", { orgId, storeId, orderId: result.id }, { organizationId: orgId, concurrencyKey: `push:${result.id}:${storeId}`, supersedes: true })));
     },
+  }, {
+    key: "catalog.beforeUpdate",
+    handler(args: unknown) {
+      const { data, context } = args as {
+        data: Parameters<typeof recordUpdateFieldPaths>[0];
+        context: Parameters<typeof recordUpdateFieldPaths>[1];
+      };
+      return recordUpdateFieldPaths(data, context);
+    },
+  }, {
+    key: "catalog.afterUpdate",
+    async handler(args: unknown) {
+      const { result, context } = args as {
+        result: { id: string };
+        context: Parameters<typeof handleCatalogAfterUpdate>[0]["context"];
+      };
+      await handleCatalogAfterUpdate({ result, context });
+    },
   }];
 }

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,16 +38,24 @@ 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,
@@ -63,10 +79,22 @@ export type {
   BackfillCatalogReport,
   BuildCatalogPushItemsOptions,
   BuildCatalogPushItemsResult,
+  CatalogPushAssemblyField,
+  CatalogPushAssemblyImage,
+  CatalogPushAssemblyItem,
+  CatalogPushPreviewBefore,
+  CatalogPushPreviewBeforeStatus,
+  CatalogPushPreviewDiff,
+  CatalogPushPreviewItem,
+  CatalogPushPreviewResult,
+  CatalogPushPreviewUnavailable,
+  PushCatalogToStoreResult,
+  CatalogPushJobResult,
   CatalogFieldConflict,
   CatalogFieldSkip,
   CatalogPushFieldSkip,
   CatalogPushSkipReason,
+  CatalogConflictState,
   CatalogWriteSettings,
   ChannelComplianceData,
   ChannelConnectorPluginOptions,
@@ -77,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,
@@ -228,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 }) => {
@@ -250,6 +313,10 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
     schema: () => ({
       connectedStores,
       channelEntityMap,
+      channelCatalogPushes,
+      channelCatalogPushEvents,
+      channelCatalogConflicts,
+      channelCatalogConflictEvents,
       channelOrderExports,
       channelExportEvents,
       channelRefundRequests,
@@ -458,6 +525,25 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
         .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")
@@ -480,6 +566,39 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
           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")
@@ -498,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")
@@ -511,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/schema.ts

@@ -8,8 +8,9 @@ import {
   timestamp,
   uniqueIndex,
   uuid,
+  sql,
 } from "@porulle/core/drizzle";
-import type { FieldPath } from "@porulle/core";
+import type { ChannelPushCatalogItem, FieldPath } from "@porulle/core";
 import type { CatalogFieldMapping } from "./catalog-field-mapping.js";
 
 export const connectedStores = pgTable(
@@ -53,7 +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),
@@ -66,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",
   {
@@ -97,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",
   {
@@ -158,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;