@porulle/plugin-channel-connector 0.70.1 → 0.71.0

package/dist/service.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
-import { CommerceInvalidTransitionError, CommerceNotFoundError, CommerceValidationError, Ok, PluginErr, createTxContext, createSystemActor, linkFieldPaths, removeEntityLinks, writeEntityLinks, } from "@porulle/core";
+import { CHANNEL_OUT_OF_STOCK, CommerceInvalidTransitionError, CommerceNotFoundError, CommerceValidationError, Ok, PluginErr, createTxContext, createSystemActor, linkFieldPaths, removeEntityLinks, writeEntityLinks, } from "@porulle/core";
 import { isValidFieldPath, requireUserId } from "@porulle/core";
 import { CHANNEL_CONVERGENCE_CTX } from "./catalog-push-trigger.js";
 import { resolveLiveCredentials, withLiveCredentials } from "./live-credentials.js";
@@ -4226,8 +4226,12 @@ export class ChannelConnectorService {
         await this.db.insert(channelRefundEvents).values({ organizationId: orgId, requestId: request.id, fromState: null, toState: request.state, reason: auto ? "Automatic guarded refund" : "Operator approval required", changedBy: requireUserId(actor) });
         if (auto) {
             const result = await this.executeRefund(request, refundLines, actor);
-            if (!result.ok)
-                return PluginErr(result.error);
+            if (!result.ok) {
+                // Nothing moved: an operator decides instead, rather than the request sticking as approved.
+                await this.db.update(channelRefundRequests).set({ state: "requested", approvedBy: null, updatedAt: new Date() }).where(and(eq(channelRefundRequests.organizationId, orgId), eq(channelRefundRequests.id, request.id), eq(channelRefundRequests.state, "approved")));
+                await this.db.insert(channelRefundEvents).values({ organizationId: orgId, requestId: request.id, fromState: "approved", toState: "requested", reason: `Automatic refund failed: ${result.error}`, changedBy: requireUserId(actor) });
+                return Ok({ ...request, state: "requested" });
+            }
         }
         return Ok(request);
     }
@@ -4248,7 +4252,13 @@ export class ChannelConnectorService {
         if (!request)
             return PluginErr("Refund request not found or already handled.", "NOT_FOUND");
         const lines = await this.refundLinesForRequest(request);
-        return this.executeRefund(request, lines, createSystemActor(orgId));
+        const executed = await this.executeRefund(request, lines, createSystemActor(orgId));
+        if (!executed.ok) {
+            // Nothing moved: back to `requested`, so the operator can approve again once the cause is fixed.
+            await this.db.update(channelRefundRequests).set({ state: "requested", approvedBy: null, updatedAt: new Date() }).where(and(eq(channelRefundRequests.organizationId, orgId), eq(channelRefundRequests.id, id), eq(channelRefundRequests.state, "approved")));
+            await this.db.insert(channelRefundEvents).values({ organizationId: orgId, requestId: id, fromState: "approved", toState: "requested", reason: `Execution failed: ${executed.error}`, changedBy: actor.userId });
+        }
+        return executed;
     }
     async rejectRefund(orgId, id, actor) {
         const [request] = await this.db.update(channelRefundRequests).set({ state: "rejected", approvedBy: actor.userId, updatedAt: new Date() }).where(and(eq(channelRefundRequests.organizationId, orgId), eq(channelRefundRequests.id, id), eq(channelRefundRequests.state, "requested"))).returning();
@@ -4442,7 +4452,14 @@ export class ChannelConnectorService {
             .where(and(eq(channelOrderExports.organizationId, orgId), eq(channelOrderExports.id, created.value.id)));
         const pushed = await connector.pushOrder(store, slice);
         if (!pushed.ok) {
-            return this.transitionExport(orgId, created.value.id, "failed", requireUserId(actor), pushed.error.message, pushed.error.retriable === true ? "transient" : "definitive");
+            const failed = await this.transitionExport(orgId, created.value.id, "failed", requireUserId(actor), pushed.error.message, pushed.error.retriable === true ? "transient" : "definitive");
+            if (pushed.error.code === CHANNEL_OUT_OF_STOCK) {
+                // The store has said nobody will send these goods: cancel, and let the host's cancel path
+                // refund the shopper. Any other refusal can be fixed and retried, so it waits for an operator.
+                const ordersService = this.services.orders;
+                await ordersService.changeStatus({ orderId: slice.orderId, newStatus: "cancelled", reason: "channel_out_of_stock" }, actor);
+            }
+            return failed;
         }
         await this.db
             .update(channelOrderExports)

package/package.json

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

package/src/service.ts

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import {
+  CHANNEL_OUT_OF_STOCK,
   CommerceInvalidTransitionError,
   CommerceNotFoundError,
   CommerceValidationError,
@@ -5350,7 +5351,12 @@ export class ChannelConnectorService {
     await this.db.insert(channelRefundEvents).values({ organizationId: orgId, requestId: request.id, fromState: null, toState: request.state, reason: auto ? "Automatic guarded refund" : "Operator approval required", changedBy: requireUserId(actor) });
     if (auto) {
       const result = await this.executeRefund(request, refundLines, actor);
-      if (!result.ok) return PluginErr(result.error);
+      if (!result.ok) {
+        // Nothing moved: an operator decides instead, rather than the request sticking as approved.
+        await this.db.update(channelRefundRequests).set({ state: "requested", approvedBy: null, updatedAt: new Date() }).where(and(eq(channelRefundRequests.organizationId, orgId), eq(channelRefundRequests.id, request.id), eq(channelRefundRequests.state, "approved")));
+        await this.db.insert(channelRefundEvents).values({ organizationId: orgId, requestId: request.id, fromState: "approved", toState: "requested", reason: `Automatic refund failed: ${result.error}`, changedBy: requireUserId(actor) });
+        return Ok({ ...request, state: "requested" });
+      }
     }
     return Ok(request);
   }
@@ -5372,7 +5378,13 @@ export class ChannelConnectorService {
     const [request] = await this.db.update(channelRefundRequests).set({ state: "approved", approvedBy: actor.userId, updatedAt: new Date() }).where(and(eq(channelRefundRequests.organizationId, orgId), eq(channelRefundRequests.id, id), eq(channelRefundRequests.state, "requested"))).returning();
     if (!request) return PluginErr("Refund request not found or already handled.", "NOT_FOUND");
     const lines = await this.refundLinesForRequest(request as ChannelRefundRequest);
-    return this.executeRefund(request as ChannelRefundRequest, lines, createSystemActor(orgId));
+    const executed = await this.executeRefund(request as ChannelRefundRequest, lines, createSystemActor(orgId));
+    if (!executed.ok) {
+      // Nothing moved: back to `requested`, so the operator can approve again once the cause is fixed.
+      await this.db.update(channelRefundRequests).set({ state: "requested", approvedBy: null, updatedAt: new Date() }).where(and(eq(channelRefundRequests.organizationId, orgId), eq(channelRefundRequests.id, id), eq(channelRefundRequests.state, "approved")));
+      await this.db.insert(channelRefundEvents).values({ organizationId: orgId, requestId: id, fromState: "approved", toState: "requested", reason: `Execution failed: ${executed.error}`, changedBy: actor.userId });
+    }
+    return executed;
   }
 
   async rejectRefund(orgId: string, id: string, actor: { userId: string }): Promise<PluginResult<ChannelRefundRequest>> {
@@ -5602,7 +5614,7 @@ export class ChannelConnectorService {
 
     const pushed = await connector.pushOrder(store as ChannelStore, slice);
     if (!pushed.ok) {
-      return this.transitionExport(
+      const failed = await this.transitionExport(
         orgId,
         created.value.id,
         "failed",
@@ -5610,6 +5622,13 @@ export class ChannelConnectorService {
         pushed.error.message,
         pushed.error.retriable === true ? "transient" : "definitive",
       );
+      if (pushed.error.code === CHANNEL_OUT_OF_STOCK) {
+        // The store has said nobody will send these goods: cancel, and let the host's cancel path
+        // refund the shopper. Any other refusal can be fixed and retried, so it waits for an operator.
+        const ordersService = this.services.orders as { changeStatus(input: { orderId: string; newStatus: "cancelled"; reason: string }, actor: Actor): Promise<{ ok: boolean }> };
+        await ordersService.changeStatus({ orderId: slice.orderId, newStatus: "cancelled", reason: "channel_out_of_stock" }, actor);
+      }
+      return failed;
     }
 
     await this.db