@porulle/plugin-channel-connector 0.50.1 → 0.50.2

package/dist/index.js

@@ -151,7 +151,11 @@ export function channelConnectorPlugin(options = {}) {
             handler: async ({ input, ctx }) => {
                 const orgId = String(input.orgId);
                 const jobs = ctx.services.jobs;
-                const stores = await ctx.db.select().from(connectedStores).where(and(eq(connectedStores.organizationId, orgId), eq(connectedStores.status, "connected")));
+                // Only stores a registered connector can reach: a reconcile for any other provider (the
+                // seed's `manual` point-of-sale store) can only fail with "No connector registered".
+                const providers = new Set((options.connectors ?? []).map((connector) => connector.providerId));
+                const stores = (await ctx.db.select().from(connectedStores).where(and(eq(connectedStores.organizationId, orgId), eq(connectedStores.status, "connected"))))
+                    .filter((store) => providers.has(store.provider));
                 const window = options.reconcileJitterWindowMs ?? 60 * 60 * 1000;
                 for (const store of stores) {
                     const offset = createHash("sha256").update(store.id).digest().readUInt32BE(0) % window;

package/dist/service.d.ts

@@ -42,6 +42,9 @@ export interface ReconcileReport extends Record<string, unknown> {
     skipped?: CatalogFieldSkip[];
     conflicts?: CatalogFieldConflict[];
     warnings?: string[];
+    /** Items this reconcile could not converge, each with its error. A reconcile that dropped an
+     *  item is never reported as a clean one. */
+    failures?: CatalogConvergenceFailure[];
 }
 export interface CatalogFieldConflict {
     entityId: string;
@@ -333,6 +336,12 @@ export declare class ChannelConnectorService {
      */
     private taxonomyCache;
     private taxonomyFor;
+    /**
+     * Create a category or brand, or adopt the one another writer created first. The taxonomy
+     * snapshot is per converge, so two stores converging at once can both see a slug missing and both
+     * create it; the loser's conflict — returned or thrown — means the row it wanted now exists.
+     */
+    private createTaxonomyOrAdopt;
     private applyTaxonomy;
     private applyMedia;
     private getStoreRecord;

package/dist/service.js

@@ -1152,6 +1152,30 @@ export class ChannelConnectorService {
         this.taxonomyCache = { orgId, categories: categoryRows, brands: brandRows, tags: tagRows };
         return this.taxonomyCache;
     }
+    /**
+     * Create a category or brand, or adopt the one another writer created first. The taxonomy
+     * snapshot is per converge, so two stores converging at once can both see a slug missing and both
+     * create it; the loser's conflict — returned or thrown — means the row it wanted now exists.
+     */
+    async createTaxonomyOrAdopt(create, byId, bySlug, label) {
+        let failure = `${label} was not persisted.`;
+        try {
+            const created = await create();
+            if (created.ok) {
+                const row = await byId(created.value.id);
+                if (row !== undefined)
+                    return Ok(row);
+            }
+            else {
+                failure = created.error;
+            }
+        }
+        catch (error) {
+            failure = error;
+        }
+        const existing = await bySlug();
+        return existing !== undefined ? Ok(existing) : PluginErr(`${label}: ${errorMessage(failure)}`);
+    }
     async applyTaxonomy(orgId, entityId, item, actor, warnings) {
         const taxonomy = await this.taxonomyFor(orgId);
         // The links this entity already has, read only for the classes the item names. A link already
@@ -1169,13 +1193,10 @@ export class ChannelConnectorService {
                 continue;
             }
             if (!category) {
-                const created = await this.catalog.createCategory({ slug }, actor);
+                const created = await this.createTaxonomyOrAdopt(() => this.catalog.createCategory({ slug }, actor), async (id) => (await this.db.select().from(categories).where(eq(categories.id, id)))[0], async () => (await this.db.select().from(categories).where(and(eq(categories.organizationId, orgId), eq(categories.slug, slug))))[0], `Category "${slug}"`);
                 if (!created.ok)
-                    return PluginErr(created.error.message);
-                const [createdCategory] = await this.db.select().from(categories).where(eq(categories.id, created.value.id));
-                if (!createdCategory)
-                    return PluginErr(`Category "${slug}" was not persisted.`);
-                category = createdCategory;
+                    return created;
+                category = created.value;
                 categoryRows.push(category);
             }
             if (linkedCategories.has(category.id))
@@ -1189,13 +1210,11 @@ export class ChannelConnectorService {
         if (item.brand) {
             let brand = brandRows.find((row) => row.slug === item.brand);
             if (!brand) {
-                const created = await this.catalog.createBrand({ slug: item.brand, displayName: item.brand }, actor);
+                const brandSlug = item.brand;
+                const created = await this.createTaxonomyOrAdopt(() => this.catalog.createBrand({ slug: brandSlug, displayName: brandSlug }, actor), async (id) => (await this.db.select().from(brands).where(eq(brands.id, id)))[0], async () => (await this.db.select().from(brands).where(and(eq(brands.organizationId, orgId), eq(brands.slug, brandSlug))))[0], `Brand "${brandSlug}"`);
                 if (!created.ok)
-                    return PluginErr(created.error.message);
-                const [createdBrand] = await this.db.select().from(brands).where(eq(brands.id, created.value.id));
-                if (!createdBrand)
-                    return PluginErr(`Brand "${item.brand}" was not persisted.`);
-                brand = createdBrand;
+                    return created;
+                brand = created.value;
                 brandRows.push(brand);
             }
             if (!linkedBrands.has(brand.id)) {
@@ -2905,8 +2924,10 @@ export class ChannelConnectorService {
                     continue;
                 }
                 const taxonomy = await this.applyTaxonomy(orgId, entityId, writable, actor, warnings);
-                if (!taxonomy.ok)
-                    return taxonomy;
+                if (!taxonomy.ok) {
+                    failures.push({ externalId: item.externalId, error: taxonomy.error });
+                    continue;
+                }
                 const media = await this.applyMedia(orgId, entityId, writable, variantIds.value.value, actor, warnings, owners);
                 if (!media.ok)
                     return media;
@@ -3069,6 +3090,7 @@ export class ChannelConnectorService {
             ...(skipped.length > 0 ? { skipped: uniqueSkipped(skipped) } : {}),
             ...(converged.value.conflicts.length > 0 ? { conflicts: converged.value.conflicts } : {}),
             ...(converged.value.warnings.length > 0 ? { warnings: converged.value.warnings } : {}),
+            ...(converged.value.failures.length > 0 ? { failures: converged.value.failures } : {}),
         };
         await this.db.update(connectedStores).set({
             lastReconcileAt: new Date(),