@porulle/plugin-channel-connector 0.50.0 → 0.50.2

package/package.json

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

package/src/index.ts

@@ -308,7 +308,11 @@ export function channelConnectorPlugin(options: ChannelConnectorPluginOptions =
       handler: async ({ input, ctx }: { input: Record<string, unknown>; ctx: import("@porulle/core").TaskContext }) => {
         const orgId = String(input.orgId);
         const jobs = ctx.services.jobs as JobsAdapter;
-        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/src/service.ts

@@ -40,6 +40,8 @@ import {
   customerAddresses,
   customers,
   entityMedia,
+  entityBrands,
+  entityCategories,
   entityTags,
   inventoryLevels,
   mediaAssets,
@@ -165,6 +167,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 {
@@ -1633,6 +1638,22 @@ 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);
@@ -1738,6 +1759,9 @@ 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,
@@ -1746,6 +1770,7 @@ export class ChannelConnectorService {
           compareAtAmount: price.compareAtAmount ?? null,
         }, 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
@@ -1806,14 +1831,48 @@ export class ChannelConnectorService {
     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.
+   */
+  private async createTaxonomyOrAdopt<Row>(
+    create: () => Promise<{ ok: true; value: { id: string } } | { ok: false; error: { message: string } }>,
+    byId: (id: string) => Promise<Row | undefined>,
+    bySlug: () => Promise<Row | undefined>,
+    label: string,
+  ): Promise<PluginResult<Row>> {
+    let failure: unknown = `${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)}`);
+  }
+
   private async applyTaxonomy(
     orgId: string,
     entityId: string,
     item: ChannelCatalogItem,
     actor: Actor,
     warnings: string[],
-  ): Promise<PluginResult<void>> {
+  ): Promise<PluginResult<{ changed: boolean }>> {
     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);
@@ -1822,30 +1881,42 @@ export class ChannelConnectorService {
         continue;
       }
       if (!category) {
-        const created = await this.catalog.createCategory({ slug }, actor);
-        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;
+        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 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);
-        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;
+        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 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;
@@ -1860,9 +1931,10 @@ export class ChannelConnectorService {
         if (!tag) 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 });
   }
 
   private async applyMedia(
@@ -3815,14 +3887,14 @@ export class ChannelConnectorService {
       // that item's failure, reported with its error — not a page error the caller would retry.
       if (!variantIds.ok) { failures.push({ externalId: item.externalId, error: variantIds.error }); 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;
       attributesCreated += attributes.value.created;
       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
       // product did not (a blanked map row, a change in how an item serialises) is not drift.
@@ -3990,6 +4062,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(),