@porulle/plugin-channel-connector 0.74.1 → 0.74.2

package/dist/live-credentials.d.ts

@@ -15,11 +15,11 @@ import type { ChannelConnector, ChannelConnectorError, ChannelStore, PluginDb, R
  * token lapsed. The store is then marked `error`, so it reads as "reconnect" instead of failing every
  * later call with a credential error nobody is shown.
  */
+/** Why a store whose key the provider refused is in `error`. */
+export declare const CREDENTIALS_REJECTED_REASON = "The store no longer accepts the key it gave us (it was revoked, or the user who approved it was removed). Reconnect the store.";
 export declare function resolveLiveCredentials(connector: ChannelConnector, db: PluginDb, store: ChannelStore, options?: {
     force?: boolean;
 }): Promise<Result<ChannelStore, ChannelConnectorError>>;
-/** Why a store whose key the provider refused is in `error`. */
-export declare const CREDENTIALS_REJECTED_REASON = "The store no longer accepts the key it gave us (it was revoked, or the user who approved it was removed). Reconnect the store.";
 /**
  * The connector with every store-taking method routed through {@link resolveLiveCredentials}, so no
  * call site can start on a lapsed token by forgetting to ask.

package/dist/live-credentials.js

@@ -17,13 +17,16 @@ import { connectedStores } from "./schema.js";
  * token lapsed. The store is then marked `error`, so it reads as "reconnect" instead of failing every
  * later call with a credential error nobody is shown.
  */
+/** Why a store whose key the provider refused is in `error`. */
+export const CREDENTIALS_REJECTED_REASON = "The store no longer accepts the key it gave us (it was revoked, or the user who approved it was removed). Reconnect the store.";
 export async function resolveLiveCredentials(connector, db, store, options = {}) {
     if (!connector.liveCredentials)
         return Ok(store);
     const answer = await connector.liveCredentials(store, options);
     if (!answer.ok) {
         if (answer.error.retriable !== true) {
-            await db.update(connectedStores).set({ status: "error", updatedAt: new Date() }).where(eq(connectedStores.id, store.id));
+            const statusReason = answer.error.code === CHANNEL_CREDENTIALS_REJECTED ? CREDENTIALS_REJECTED_REASON : answer.error.message;
+            await db.update(connectedStores).set({ status: "error", statusReason, updatedAt: new Date() }).where(eq(connectedStores.id, store.id));
         }
         return answer;
     }
@@ -40,8 +43,6 @@ export async function resolveLiveCredentials(connector, db, store, options = {})
         return Err({ code: "STORE_NOT_FOUND", message: `Connected store ${store.id} no longer exists.`, retriable: false });
     return Ok({ ...store, credentials: current.credentials });
 }
-/** Why a store whose key the provider refused is in `error`. */
-export const CREDENTIALS_REJECTED_REASON = "The store no longer accepts the key it gave us (it was revoked, or the user who approved it was removed). Reconnect the store.";
 async function markCredentialsRejected(db, storeId) {
     await db.update(connectedStores).set({ status: "error", statusReason: CREDENTIALS_REJECTED_REASON, updatedAt: new Date() }).where(eq(connectedStores.id, storeId));
 }

package/dist/service.d.ts

@@ -701,6 +701,11 @@ export declare class ChannelConnectorService {
     private orderForRemote;
     /** Archives this store's product mapped to `externalId`, unless the platform owns its status. */
     private archiveMappedProduct;
+    /**
+     * Stock is a variant's. A provider can name a product and its only variant by the same id (a
+     * WooCommerce simple product is both), so the variant mapping wins over the entity one, as the
+     * paged sync's does; an entity mapping alone (a product imported with no variants) still takes it.
+     */
     private setMappedInventory;
     private setInventoryLevel;
     private createRefundRequest;
@@ -760,6 +765,11 @@ export declare class ChannelConnectorService {
     }>;
     getExport(orgId: string, id: string): Promise<PluginResult<ChannelOrderExport>>;
     listFailedExports(orgId: string): Promise<PluginResult<ChannelOrderExport[]>>;
+    /**
+     * The operator's retry of a failed export: it runs the push again, as a job. The connector looks for
+     * an order it may already have created before creating one (an unclear first answer is exactly what
+     * left the export failed), so a retry never puts a second order in the store.
+     */
     retryExport(orgId: string, exportId: string, changedBy: string): Promise<PluginResult<ChannelOrderExport>>;
     abandonExport(orgId: string, exportId: string, changedBy: string, reason?: string): Promise<PluginResult<ChannelOrderExport>>;
     resolveCatalogPushEntityIds(orgId: string, storeId: string, entityIds?: string[]): Promise<string[]>;

package/dist/service.js

@@ -3607,7 +3607,9 @@ export class ChannelConnectorService {
         const inventoryService = this.services.inventory;
         let inventoryUpdated = 0;
         for (const level of inventory.value) {
-            const mapping = levelled.find((entry) => entry.externalId === level.externalId);
+            // A product and its only variant can share an id (a WooCommerce simple product): stock is the variant's.
+            const mapping = levelled.find((entry) => entry.externalId === level.externalId && entry.kind === "variant")
+                ?? levelled.find((entry) => entry.externalId === level.externalId);
             if (!mapping)
                 continue;
             const current = existingLevels.find((entry) => entry.entityId === mapping.entityId && entry.variantId === (mapping.variantId ?? null));
@@ -4144,8 +4146,14 @@ export class ChannelConnectorService {
         const archived = await this.catalog.archive(mapping.entityId, actor);
         return archived.ok ? Ok([]) : PluginErr(archived.error.message);
     }
+    /**
+     * Stock is a variant's. A provider can name a product and its only variant by the same id (a
+     * WooCommerce simple product is both), so the variant mapping wins over the entity one, as the
+     * paged sync's does; an entity mapping alone (a product imported with no variants) still takes it.
+     */
     async setMappedInventory(orgId, storeId, externalId, quantity, actor) {
-        const [mapping] = await this.db.select().from(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.externalId, externalId)));
+        const rows = await this.db.select().from(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.externalId, externalId)));
+        const mapping = rows.find((row) => row.kind === "variant") ?? rows[0];
         if (!mapping)
             return;
         await this.setInventoryLevel(mapping.entityId, mapping.variantId, quantity, actor);
@@ -4601,8 +4609,21 @@ export class ChannelConnectorService {
             .where(and(eq(channelOrderExports.organizationId, orgId), eq(channelOrderExports.state, "failed")));
         return Ok(rows);
     }
-    retryExport(orgId, exportId, changedBy) {
-        return this.transitionExport(orgId, exportId, "exported", changedBy, "Manual retry requested.");
+    /**
+     * The operator's retry of a failed export: it runs the push again, as a job. The connector looks for
+     * an order it may already have created before creating one (an unclear first answer is exactly what
+     * left the export failed), so a retry never puts a second order in the store.
+     */
+    async retryExport(orgId, exportId, changedBy) {
+        const moved = await this.transitionExport(orgId, exportId, "exported", changedBy, "Manual retry requested.");
+        if (!moved.ok)
+            return moved;
+        const jobs = this.services.jobs;
+        if (!jobs)
+            return PluginErr("No jobs adapter is configured, so the retry cannot run.", "JOBS_UNAVAILABLE");
+        const { storeId, orderId } = moved.value;
+        await jobs.enqueue("channel/push-order", { orgId, storeId, orderId }, { organizationId: orgId, concurrencyKey: `push:${orderId}:${storeId}`, supersedes: true });
+        return moved;
     }
     abandonExport(orgId, exportId, changedBy, reason) {
         return this.transitionExport(orgId, exportId, "abandoned", changedBy, reason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@porulle/plugin-channel-connector",
-  "version": "0.74.1",
+  "version": "0.74.2",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -22,15 +22,15 @@
   "dependencies": {
     "@hono/zod-openapi": "^1.2.2",
     "hono": "^4.12.5",
-    "@porulle/core": "0.74.1"
+    "@porulle/core": "0.74.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/live-credentials.ts

@@ -19,12 +19,16 @@ import { connectedStores } from "./schema.js";
  * token lapsed. The store is then marked `error`, so it reads as "reconnect" instead of failing every
  * later call with a credential error nobody is shown.
  */
+/** Why a store whose key the provider refused is in `error`. */
+export const CREDENTIALS_REJECTED_REASON = "The store no longer accepts the key it gave us (it was revoked, or the user who approved it was removed). Reconnect the store.";
+
 export async function resolveLiveCredentials(connector: ChannelConnector, db: PluginDb, store: ChannelStore, options: { force?: boolean } = {}): Promise<Result<ChannelStore, ChannelConnectorError>> {
   if (!connector.liveCredentials) return Ok(store);
   const answer = await connector.liveCredentials(store, options);
   if (!answer.ok) {
     if (answer.error.retriable !== true) {
-      await db.update(connectedStores).set({ status: "error", updatedAt: new Date() }).where(eq(connectedStores.id, store.id));
+      const statusReason = answer.error.code === CHANNEL_CREDENTIALS_REJECTED ? CREDENTIALS_REJECTED_REASON : answer.error.message;
+      await db.update(connectedStores).set({ status: "error", statusReason, updatedAt: new Date() }).where(eq(connectedStores.id, store.id));
     }
     return answer;
   }
@@ -41,9 +45,6 @@ export async function resolveLiveCredentials(connector: ChannelConnector, db: Pl
 
 type StoreCall<A extends unknown[], T> = (store: ChannelStore, ...args: A) => Promise<Result<T, ChannelConnectorError>>;
 
-/** Why a store whose key the provider refused is in `error`. */
-export const CREDENTIALS_REJECTED_REASON = "The store no longer accepts the key it gave us (it was revoked, or the user who approved it was removed). Reconnect the store.";
-
 async function markCredentialsRejected(db: PluginDb, storeId: string): Promise<void> {
   await db.update(connectedStores).set({ status: "error", statusReason: CREDENTIALS_REJECTED_REASON, updatedAt: new Date() }).where(eq(connectedStores.id, storeId));
 }

package/src/service.ts

@@ -4698,7 +4698,9 @@ export class ChannelConnectorService {
     };
     let inventoryUpdated = 0;
     for (const level of inventory.value) {
-      const mapping = levelled.find((entry) => entry.externalId === level.externalId);
+      // A product and its only variant can share an id (a WooCommerce simple product): stock is the variant's.
+      const mapping = levelled.find((entry) => entry.externalId === level.externalId && entry.kind === "variant")
+        ?? levelled.find((entry) => entry.externalId === level.externalId);
       if (!mapping) continue;
       const current = existingLevels.find((entry) => entry.entityId === mapping.entityId && entry.variantId === (mapping.variantId ?? null));
       // Stock cannot sit below zero here, so negative remote stock compares as the zero it is stored as.
@@ -5289,8 +5291,14 @@ export class ChannelConnectorService {
     return archived.ok ? Ok([]) : PluginErr(archived.error.message);
   }
 
+  /**
+   * Stock is a variant's. A provider can name a product and its only variant by the same id (a
+   * WooCommerce simple product is both), so the variant mapping wins over the entity one, as the
+   * paged sync's does; an entity mapping alone (a product imported with no variants) still takes it.
+   */
   private async setMappedInventory(orgId: string, storeId: string, externalId: string, quantity: number, actor: Actor): Promise<void> {
-    const [mapping] = await this.db.select().from(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.externalId, externalId)));
+    const rows = await this.db.select().from(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.externalId, externalId)));
+    const mapping = rows.find((row) => row.kind === "variant") ?? rows[0];
     if (!mapping) return;
     await this.setInventoryLevel(mapping.entityId, mapping.variantId, quantity, actor);
   }
@@ -5818,12 +5826,23 @@ export class ChannelConnectorService {
     return Ok(rows as ChannelOrderExport[]);
   }
 
-  retryExport(
+  /**
+   * The operator's retry of a failed export: it runs the push again, as a job. The connector looks for
+   * an order it may already have created before creating one (an unclear first answer is exactly what
+   * left the export failed), so a retry never puts a second order in the store.
+   */
+  async retryExport(
     orgId: string,
     exportId: string,
     changedBy: string,
   ): Promise<PluginResult<ChannelOrderExport>> {
-    return this.transitionExport(orgId, exportId, "exported", changedBy, "Manual retry requested.");
+    const moved = await this.transitionExport(orgId, exportId, "exported", changedBy, "Manual retry requested.");
+    if (!moved.ok) return moved;
+    const jobs = this.services.jobs as JobsAdapter | undefined;
+    if (!jobs) return PluginErr("No jobs adapter is configured, so the retry cannot run.", "JOBS_UNAVAILABLE");
+    const { storeId, orderId } = moved.value;
+    await jobs.enqueue("channel/push-order", { orgId, storeId, orderId }, { organizationId: orgId, concurrencyKey: `push:${orderId}:${storeId}`, supersedes: true });
+    return moved;
   }
 
   abandonExport(