@porulle/plugin-channel-connector 0.47.0 → 0.48.1

package/dist/index.js

@@ -184,6 +184,15 @@ export function channelConnectorPlugin(options = {}) {
                         counted: page.value.imported,
                         cursor: page.value.cursor ?? null,
                         ...(page.value.warnings ? { warnings: page.value.warnings } : {}),
+                        // UNCONDITIONAL, unlike `warnings` and `failures` beside it. The step's return value is
+                        // the only per-batch seam a host application has — `walkBatches` keeps just `last` — so
+                        // this is where a page gets its identity. Omitting it when empty would make "this batch
+                        // committed nothing" and "this plugin build does not report entities" the same
+                        // `undefined` at the seam, and a caller that collapses those enqueues nothing and
+                        // reports success. The service's own return declares it unconditional for the same
+                        // reason; dropping it here would have undone that one line later.
+                        entityIds: page.value.entityIds,
+                        ...(page.value.failures ? { failures: page.value.failures } : {}),
                     };
                 });
                 const jobs = ctx.services.jobs;

package/dist/service.d.ts

@@ -291,6 +291,18 @@ export declare class ChannelConnectorService {
         conflicts?: CatalogFieldConflict[];
         warnings?: string[];
         failures?: CatalogConvergenceFailure[];
+        /**
+         * The entities this batch committed — see `CatalogConvergenceStats.entityIds`.
+         *
+         * Declared on the BOUNDED overload only. This is the one a per-batch step wrapper calls, so it
+         * is the one with a page to name. The unbounded overload walks a whole catalogue and would hand
+         * back thousands of ids across a durable step boundary, which is the opposite of the point.
+         *
+         * Required rather than optional here, unlike its siblings, for the reason the implementation
+         * states: a caller must be able to tell "this batch committed nothing" from "this build does
+         * not report entities", and one of those is `[]` while the other is `undefined`.
+         */
+        entityIds: string[];
     }>>;
     importCatalog(orgId: string, storeId: string, actor: Actor, options?: undefined): Promise<PluginResult<{
         imported: number;

package/dist/service.js

@@ -1733,6 +1733,7 @@ export class ChannelConnectorService {
         const conflicts = [];
         const warnings = [];
         const failures = [];
+        const entityIds = [];
         while (remaining > 0) {
             const page = await connector.importCatalog(store, pageCursor ?? undefined);
             if (!page.ok)
@@ -1759,6 +1760,7 @@ export class ChannelConnectorService {
             conflicts.push(...result.value.conflicts);
             warnings.push(...result.value.warnings);
             failures.push(...result.value.failures);
+            entityIds.push(...result.value.entityIds);
             offset += result.value.consumed;
             if (offset >= pageItems.length) {
                 if (page.value.nextCursor) {
@@ -1793,6 +1795,13 @@ export class ChannelConnectorService {
             // Always surfaced when non-empty. A silently dropped product is worse than the halt this
             // replaced: the caller must be able to see which externalIds did not land.
             ...(failures.length > 0 ? { failures } : {}),
+            // UNCONDITIONAL, unlike every optional field above it, and the asymmetry is deliberate.
+            // The caller turns this into one queue message naming the page it just converged. If the key
+            // were omitted when empty, a caller reading `outcome.entityIds` could not tell "this batch
+            // committed nothing" from "this plugin version does not report entities" — both read as
+            // `undefined`, and the second one silently produces an import that enqueues nothing. An
+            // empty array says the first; a missing key says the second. They deserve different answers.
+            entityIds,
         });
     }
     async promoteLegacyAttributes(orgId, storeId, actor, dryRun) {
@@ -1958,6 +1967,7 @@ export class ChannelConnectorService {
             conflicts: [],
             warnings: [],
             failures: [], // a dry run converges nothing, so it can fail nothing
+            entityIds: [], // ...and commits nothing, so it names nothing
         };
         const assets = await this.db.select().from(mediaAssets).where(eq(mediaAssets.organizationId, orgId));
         for (const item of items) {
@@ -2090,6 +2100,8 @@ export class ChannelConnectorService {
         const conflicts = [];
         const warnings = [];
         const failures = [];
+        const entityIds = [];
+        const committed = new Set();
         for (const item of items) {
             consumed += 1;
             try {
@@ -2288,6 +2300,14 @@ export class ChannelConnectorService {
                     }).where(eq(channelEntityMap.id, entityMapping.id));
                 }
                 await this.db.update(channelEntityMap).set({ lastSyncedAt }).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.entityId, entityId), eq(channelEntityMap.kind, "variant")));
+                // LAST statement of the try, and that position is the whole guarantee: every failure path
+                // above reaches `continue` before here, so an id is recorded only once the item's writes are
+                // done. De-duplicated because a connector returning one externalId twice in a page would
+                // otherwise have the consumer pay for the same entity twice.
+                if (!committed.has(entityId)) {
+                    committed.add(entityId);
+                    entityIds.push(entityId);
+                }
             }
             catch (error) {
                 // Anything the stages throw rather than returning. Same disposition: record it against the
@@ -2308,6 +2328,7 @@ export class ChannelConnectorService {
             conflicts,
             warnings,
             failures,
+            entityIds,
         });
     }
     async reconcile(orgId, storeId, actor) {