@porulle/plugin-channel-connector 0.50.0 → 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

@@ -3,7 +3,7 @@ import { CommerceInvalidTransitionError, CommerceValidationError, Ok, PluginErr,
 import { isValidFieldPath, requireUserId } from "@porulle/core";
 import { CHANNEL_CONVERGENCE_CTX } from "./catalog-push-trigger.js";
 import { and, desc, eq, inArray, isNull, lte, or, sql } from "@porulle/core/drizzle";
-import { brands, categories, customerAddresses, customers, entityMedia, entityTags, inventoryLevels, mediaAssets, optionTypes, optionValues, orderLineItems, orders, prices, sellableAttributes, sellableCustomFields, sellableEntities, sellableEntityRevisions, entityFieldDefinitions, tags, variants, variantOptionValues, } from "@porulle/core/schema";
+import { brands, categories, customerAddresses, customers, entityMedia, entityBrands, entityCategories, entityTags, inventoryLevels, mediaAssets, optionTypes, optionValues, orderLineItems, orders, prices, sellableAttributes, sellableCustomFields, sellableEntities, sellableEntityRevisions, entityFieldDefinitions, tags, variants, variantOptionValues, } from "@porulle/core/schema";
 import { channelCatalogPushEvents, channelCatalogPushes, channelCatalogConflicts, channelCatalogConflictEvents, channelEntityMap, channelExportEvents, channelOrderExports, connectedStores, channelRefundEvents, channelRefundRequests, } from "./schema.js";
 import { mergeCatalogFieldMapping, normalizeCatalogFieldMapping, selectCatalogFieldMapping, } from "./catalog-field-mapping.js";
 export const CATALOG_PUSH_BATCH_SIZES = {
@@ -973,6 +973,14 @@ export class ChannelConnectorService {
                 existingOptionValues.set(row.variantId, list);
             }
         }
+        // The product's plain base prices, read once. `setBasePrice` upserts and fires its hook even at
+        // the same amount, so an unchanged price is skipped here — and a price that IS written is what
+        // makes the variant "changed", which is what `converged` counts.
+        const storedPrices = item.variants.some((variant) => (variant.prices ?? []).length > 0)
+            ? await this.db.select({ variantId: prices.variantId, currency: prices.currency, amount: prices.amount, compareAtAmount: prices.compareAtAmount })
+                .from(prices)
+                .where(and(eq(prices.organizationId, orgId), eq(prices.entityId, entityId), isNull(prices.customerGroupId), isNull(prices.minQuantity), isNull(prices.maxQuantity), isNull(prices.validFrom), isNull(prices.validUntil)))
+            : [];
         for (const sourceVariant of item.variants) {
             const fullSourceVariant = fullItem.variants.find((variant) => variant.externalId === sourceVariant.externalId) ?? sourceVariant;
             let mapping = mappings.find((row) => row.externalId === sourceVariant.externalId);
@@ -1081,6 +1089,10 @@ export class ChannelConnectorService {
                 }
             }
             for (const price of sourceVariant.prices ?? []) {
+                const currency = price.currency.trim().toUpperCase();
+                const stored = storedPrices.find((row) => row.variantId === variantId && row.currency === currency);
+                if (stored && stored.amount === price.amount && stored.compareAtAmount === (price.compareAtAmount ?? null))
+                    continue;
                 const priced = await this.pricing.setBasePrice({
                     entityId,
                     variantId,
@@ -1090,6 +1102,7 @@ export class ChannelConnectorService {
                 }, actor);
                 if (!priced.ok)
                     return PluginErr(priced.error.message);
+                changed = true;
             }
             // Was UNCONDITIONAL: one UPDATE per variant on every import, including a re-sync where the
             // variant is byte-identical. `mapping.syncHash` is already in hand from the select above, so
@@ -1139,8 +1152,39 @@ 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
+        // there is not re-written, and a link that is added is what reports the taxonomy as changed.
+        const linkedCategories = new Set((item.categories ?? []).length === 0 ? [] : (await this.db
+            .select({ id: entityCategories.categoryId }).from(entityCategories).where(eq(entityCategories.entityId, entityId))).map((row) => row.id));
+        const linkedBrands = new Set(!item.brand ? [] : (await this.db
+            .select({ id: entityBrands.brandId }).from(entityBrands).where(eq(entityBrands.entityId, entityId))).map((row) => row.id));
+        let changed = false;
         const categoryRows = taxonomy.categories;
         for (const slug of new Set(item.categories ?? [])) {
             let category = categoryRows.find((row) => row.slug === slug);
@@ -1149,35 +1193,36 @@ 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))
+                continue;
             const linked = await this.catalog.addToCategory(entityId, category.id, actor);
             if (!linked.ok)
                 return PluginErr(linked.error.message);
+            changed = true;
         }
         const brandRows = taxonomy.brands;
         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);
             }
-            const linked = await this.catalog.addToBrand(entityId, brand.id, actor);
-            if (!linked.ok)
-                return PluginErr(linked.error.message);
+            if (!linkedBrands.has(brand.id)) {
+                const linked = await this.catalog.addToBrand(entityId, brand.id, actor);
+                if (!linked.ok)
+                    return PluginErr(linked.error.message);
+                changed = true;
+            }
         }
         const tagRows = taxonomy.tags;
         for (const slug of new Set(item.tags ?? [])) {
@@ -1189,9 +1234,11 @@ export class ChannelConnectorService {
                     return PluginErr(`Tag "${slug}" was not persisted.`);
                 tagRows.push(tag);
             }
-            await this.db.insert(entityTags).values({ entityId, tagId: tag.id }).onConflictDoNothing();
+            const added = await this.db.insert(entityTags).values({ entityId, tagId: tag.id }).onConflictDoNothing().returning({ tagId: entityTags.tagId });
+            if (added.length > 0)
+                changed = true;
         }
-        return Ok(undefined);
+        return Ok({ changed });
     }
     async applyMedia(orgId, entityId, item, variantIds, actor, warnings, owners) {
         const images = item.images ?? [];
@@ -2877,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;
@@ -2886,7 +2935,7 @@ export class ChannelConnectorService {
                 mediaImported += media.value.imported;
                 variantsGivenOptionValues += variantIds.value.repaired;
                 skipped.push(...media.value.skipped.map((fieldPath) => ({ entityId, fieldPath })));
-                entityTouched = entityTouched || optionAxes.value.changed || variantIds.value.changed || media.value.changed || attributes.value.changed;
+                entityTouched = entityTouched || optionAxes.value.changed || variantIds.value.changed || taxonomy.value.changed || media.value.changed || attributes.value.changed;
                 if (entityTouched)
                     entitiesTouched += 1;
                 // Counted from what was written, not from the stored hash: a hash that moved while the
@@ -3041,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(),