@porulle/plugin-channel-connector 0.26.0 → 0.28.0

package/dist/schema.js

@@ -1,4 +1,5 @@
 import { boolean, index, integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid, sql, } from "@porulle/core/drizzle";
+import { sellableEntities } from "@porulle/core/schema";
 export const connectedStores = pgTable("connected_stores", {
     id: uuid("id").defaultRandom().primaryKey(),
     organizationId: text("organization_id").notNull(),
@@ -29,7 +30,7 @@ export const channelEntityMap = pgTable("channel_entity_map", {
     storeId: uuid("store_id").references(() => connectedStores.id, { onDelete: "cascade" }).notNull(),
     kind: text("kind", { enum: ["entity", "variant"] }).notNull(),
     externalId: text("external_id").notNull(),
-    entityId: uuid("entity_id").notNull(),
+    entityId: uuid("entity_id").references(() => sellableEntities.id, { onDelete: "cascade" }).notNull(),
     variantId: uuid("variant_id"),
     lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }).defaultNow().notNull(),
     syncHash: text("sync_hash").notNull(),

package/dist/service.js

@@ -72,6 +72,8 @@ export function canCatalogPushTransition(from, to) {
 function hash(value) {
     return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
+/** Mid-import map rows carry this until convergence finishes; must not equal any real remote hash. */
+const PENDING_ENTITY_MAP_SYNC_HASH = "";
 export const CATALOG_OUTBOUND_SUPPRESSION_WINDOW_MS = 15 * 60 * 1000;
 function normalizeCanonicalValue(value) {
     if (typeof value === "string")
@@ -1864,35 +1866,64 @@ export class ChannelConnectorService {
                 .select()
                 .from(channelEntityMap)
                 .where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.kind, "entity"), eq(channelEntityMap.externalId, item.externalId)));
-            const entityMapping = existing.find((entry) => entry.kind === "entity");
+            let entityMapping = existing.find((entry) => entry.kind === "entity");
             let entityId;
             let isNew = false;
+            let adoptedOrphan = false;
             let entityTouched = false;
             let existingEntity;
             if (entityMapping) {
                 const [entity] = await this.db.select().from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), eq(sellableEntities.id, entityMapping.entityId)));
                 if (!entity) {
-                    warnings.push(`Skipped "${item.externalId}": mapped entity ${entityMapping.entityId} no longer exists.`);
-                    continue;
+                    await this.db.delete(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.entityId, entityMapping.entityId)));
+                    entityMapping = undefined;
+                }
+                else {
+                    entityId = entityMapping.entityId;
+                    existingEntity = entity;
                 }
-                entityId = entityMapping.entityId;
-                existingEntity = entity;
             }
-            else {
-                const status = item.status;
-                const entity = await this.catalog.create({
-                    type: "product",
-                    slug: item.slug,
-                    sourceStoreId: storeId,
-                    metadata: mergeMetadata(undefined, item.metadata ?? {}),
-                    ...(status !== undefined ? { status, isVisible: status === "active" } : {}),
-                }, actor);
-                if (!entity.ok)
-                    return PluginErr(entity.error.message);
-                entityId = entity.value.id;
-                isNew = true;
-                imported += 1;
-                entityTouched = true;
+            if (entityId === undefined) {
+                const [orphan] = await this.db.select().from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), eq(sellableEntities.sourceStoreId, storeId), eq(sellableEntities.slug, item.slug)));
+                if (orphan) {
+                    entityId = orphan.id;
+                    existingEntity = orphan;
+                    adoptedOrphan = true;
+                }
+                else {
+                    const status = item.status;
+                    try {
+                        entityId = await this.transact(async (tx) => {
+                            const txContext = createTxContext(tx, { actor });
+                            const created = await this.catalog.create({
+                                type: "product",
+                                slug: item.slug,
+                                sourceStoreId: storeId,
+                                metadata: mergeMetadata(undefined, item.metadata ?? {}),
+                                ...(status !== undefined ? { status, isVisible: status === "active" } : {}),
+                            }, actor, txContext);
+                            if (!created.ok)
+                                throw new Error(created.error.message);
+                            await tx.insert(channelEntityMap).values({
+                                organizationId: orgId,
+                                storeId,
+                                kind: "entity",
+                                externalId: item.externalId,
+                                entityId: created.value.id,
+                                syncHash: PENDING_ENTITY_MAP_SYNC_HASH,
+                                heldFieldPaths: [],
+                                forcedPushFieldPaths: [],
+                            });
+                            return created.value.id;
+                        });
+                    }
+                    catch (error) {
+                        return PluginErr(error instanceof Error ? error.message : "Failed to create catalog entity.");
+                    }
+                    isNew = true;
+                    imported += 1;
+                    entityTouched = true;
+                }
             }
             const ownershipBeforeSeed = await this.catalog.resolveFieldOwners(entityId, storeId);
             const seedPaths = importedFieldPaths(item).filter((path) => !ownershipBeforeSeed.has(path));
@@ -1989,6 +2020,14 @@ export class ChannelConnectorService {
             const latestRevisionAt = revisionMarkers.at(-1)?.createdAt;
             const lastSyncedAt = latestRevisionAt ?? entityMapping?.lastSyncedAt ?? new Date();
             if (isNew) {
+                await this.db.update(channelEntityMap).set({
+                    syncHash: remoteHash,
+                    lastSyncedAt,
+                    heldFieldPaths: heldSharedPaths,
+                    forcedPushFieldPaths: survivingForcedPaths,
+                }).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.kind, "entity"), eq(channelEntityMap.externalId, item.externalId), eq(channelEntityMap.entityId, entityId)));
+            }
+            else if (adoptedOrphan) {
                 await this.db.insert(channelEntityMap).values({
                     organizationId: orgId,
                     storeId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/plugin-channel-connector",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -19,7 +19,7 @@
   "dependencies": {
     "@hono/zod-openapi": "^1.2.2",
     "hono": "^4.12.5",
-    "@porulle/core": "0.26.0"
+    "@porulle/core": "0.28.0"
   },
   "devDependencies": {
     "@types/node": "^24.5.2",

package/src/schema.ts

@@ -11,6 +11,7 @@ import {
   sql,
 } from "@porulle/core/drizzle";
 import type { ChannelPushCatalogItem, FieldPath } from "@porulle/core";
+import { sellableEntities } from "@porulle/core/schema";
 import type { CatalogFieldMapping } from "./catalog-field-mapping.js";
 
 export const connectedStores = pgTable(
@@ -50,7 +51,7 @@ export const channelEntityMap = pgTable(
     storeId: uuid("store_id").references(() => connectedStores.id, { onDelete: "cascade" }).notNull(),
     kind: text("kind", { enum: ["entity", "variant"] }).notNull(),
     externalId: text("external_id").notNull(),
-    entityId: uuid("entity_id").notNull(),
+    entityId: uuid("entity_id").references(() => sellableEntities.id, { onDelete: "cascade" }).notNull(),
     variantId: uuid("variant_id"),
     lastSyncedAt: timestamp("last_synced_at", { withTimezone: true }).defaultNow().notNull(),
     syncHash: text("sync_hash").notNull(),

package/src/service.ts

@@ -343,6 +343,7 @@ interface CatalogService {
       isVisible?: boolean;
     },
     actor: Actor,
+    ctx?: TxContext,
   ): Promise<{ ok: true; value: { id: string } } | { ok: false; error: { message: string } }>;
   createVariant(
     input: { entityId: string; options: Record<string, string>; sku?: string; barcode?: string },
@@ -481,6 +482,9 @@ function hash(value: unknown): string {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 
+/** Mid-import map rows carry this until convergence finishes; must not equal any real remote hash. */
+const PENDING_ENTITY_MAP_SYNC_HASH = "";
+
 export const CATALOG_OUTBOUND_SUPPRESSION_WINDOW_MS = 15 * 60 * 1000;
 
 function normalizeCanonicalValue(value: unknown): unknown {
@@ -2543,9 +2547,10 @@ export class ChannelConnectorService {
           eq(channelEntityMap.kind, "entity"),
           eq(channelEntityMap.externalId, item.externalId),
         ));
-      const entityMapping = existing.find((entry) => entry.kind === "entity");
-      let entityId: string;
+      let entityMapping = existing.find((entry) => entry.kind === "entity");
+      let entityId: string | undefined;
       let isNew = false;
+      let adoptedOrphan = false;
       let entityTouched = false;
       let existingEntity: typeof sellableEntities.$inferSelect | undefined;
       if (entityMapping) {
@@ -2554,25 +2559,59 @@ export class ChannelConnectorService {
           eq(sellableEntities.id, entityMapping.entityId),
         ));
         if (!entity) {
-          warnings.push(`Skipped "${item.externalId}": mapped entity ${entityMapping.entityId} no longer exists.`);
-          continue;
+          await this.db.delete(channelEntityMap).where(and(
+            eq(channelEntityMap.organizationId, orgId),
+            eq(channelEntityMap.storeId, storeId),
+            eq(channelEntityMap.entityId, entityMapping.entityId),
+          ));
+          entityMapping = undefined;
+        } else {
+          entityId = entityMapping.entityId;
+          existingEntity = entity;
+        }
+      }
+      if (entityId === undefined) {
+        const [orphan] = await this.db.select().from(sellableEntities).where(and(
+          eq(sellableEntities.organizationId, orgId),
+          eq(sellableEntities.sourceStoreId, storeId),
+          eq(sellableEntities.slug, item.slug),
+        ));
+        if (orphan) {
+          entityId = orphan.id;
+          existingEntity = orphan;
+          adoptedOrphan = true;
+        } else {
+          const status = item.status;
+          try {
+            entityId = await this.transact(async (tx) => {
+              const txContext = createTxContext(tx, { actor });
+              const created = await this.catalog.create({
+                type: "product",
+                slug: item.slug,
+                sourceStoreId: storeId,
+                metadata: mergeMetadata(undefined, item.metadata ?? {}),
+                ...(status !== undefined ? { status, isVisible: status === "active" } : {}),
+              }, actor, txContext);
+              if (!created.ok) throw new Error(created.error.message);
+              await tx.insert(channelEntityMap).values({
+                organizationId: orgId,
+                storeId,
+                kind: "entity",
+                externalId: item.externalId,
+                entityId: created.value.id,
+                syncHash: PENDING_ENTITY_MAP_SYNC_HASH,
+                heldFieldPaths: [],
+                forcedPushFieldPaths: [],
+              });
+              return created.value.id;
+            });
+          } catch (error) {
+            return PluginErr(error instanceof Error ? error.message : "Failed to create catalog entity.");
+          }
+          isNew = true;
+          imported += 1;
+          entityTouched = true;
         }
-        entityId = entityMapping.entityId;
-        existingEntity = entity;
-      } else {
-        const status = item.status;
-        const entity = await this.catalog.create({
-          type: "product",
-          slug: item.slug,
-          sourceStoreId: storeId,
-          metadata: mergeMetadata(undefined, item.metadata ?? {}),
-          ...(status !== undefined ? { status, isVisible: status === "active" } : {}),
-        }, actor);
-        if (!entity.ok) return PluginErr(entity.error.message);
-        entityId = entity.value.id;
-        isNew = true;
-        imported += 1;
-        entityTouched = true;
       }
 
       const ownershipBeforeSeed = await this.catalog.resolveFieldOwners(entityId, storeId);
@@ -2684,6 +2723,19 @@ export class ChannelConnectorService {
       const lastSyncedAt = latestRevisionAt ?? entityMapping?.lastSyncedAt ?? new Date();
 
       if (isNew) {
+        await this.db.update(channelEntityMap).set({
+          syncHash: remoteHash,
+          lastSyncedAt,
+          heldFieldPaths: heldSharedPaths,
+          forcedPushFieldPaths: survivingForcedPaths,
+        }).where(and(
+          eq(channelEntityMap.organizationId, orgId),
+          eq(channelEntityMap.storeId, storeId),
+          eq(channelEntityMap.kind, "entity"),
+          eq(channelEntityMap.externalId, item.externalId),
+          eq(channelEntityMap.entityId, entityId),
+        ));
+      } else if (adoptedOrphan) {
         await this.db.insert(channelEntityMap).values({
           organizationId: orgId,
           storeId,