@pinelab/vendure-plugin-sendcloud 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.2.1 (2022-01-16)
+
+- Correctly transition order to Delivered after it has been Shipped
+
+# 1.2.0 (2023-11-16)
+
+- Fulfill on order placement, to prevent stock levels going out of sync
+
 # 1.1.0 (2023-10-24)
 
 - Updated vendure to 2.1.1

package/README.md

@@ -1,8 +1,6 @@
 # Vendure SendCloud plugin
 
-![Vendure version](https://img.shields.io/badge/dynamic/json.svg?url=https%3A%2F%2Fraw.githubusercontent.com%2FPinelab-studio%2Fpinelab-vendure-plugins%2Fmain%2Fpackage.json&query=$.devDependencies[%27@vendure/core%27]&colorB=blue&label=Built%20on%20Vendure)
-
-### Visit [pinelab-plugins.com](https://pinelab-plugins.com/plugin/vendure-plugin-sendcloud) for more documentation and examples.
+### [Official documentation here](https://pinelab-plugins.com/plugin/vendure-plugin-sendcloud)
 
 This plugin syncs orders to the SendCloud fulfillment platform.
 

package/dist/util/src/order-state-util.d.ts

@@ -8,12 +8,14 @@ export declare function fulfillAll(ctx: RequestContext, orderService: OrderServi
 /**
  * Fulfills all items to shipped using transitionFulfillmentToState
  */
-export declare function transitionToShipped(orderService: OrderService, ctx: RequestContext, order: Order, handler: ConfigurableOperationInput): Promise<Fulfillment>;
+export declare function transitionToShipped(orderService: OrderService, ctx: RequestContext, order: Order, handler: ConfigurableOperationInput): Promise<Fulfillment | FulfillmentStateTransitionError>;
 /**
  * Fulfills all items to shipped, then to delivered using transitionFulfillmentToState
  */
-export declare function transitionToDelivered(orderService: OrderService, ctx: RequestContext, order: Order, handler: ConfigurableOperationInput): Promise<Fulfillment>;
+export declare function transitionToDelivered(orderService: OrderService, ctx: RequestContext, order: Order, handler: ConfigurableOperationInput): Promise<(Fulfillment | FulfillmentStateTransitionError)[]>;
 /**
  * Throws the error result if the transition failed
+ * Ignores transition errors where from and to state are the same,
+ * because that still results in the situation we want
  */
 export declare function throwIfTransitionFailed(result: FulfillmentStateTransitionError | Fulfillment | AddFulfillmentToOrderResult): void;

package/dist/util/src/order-state-util.js

@@ -36,14 +36,28 @@ exports.transitionToShipped = transitionToShipped;
  * Fulfills all items to shipped, then to delivered using transitionFulfillmentToState
  */
 async function transitionToDelivered(orderService, ctx, order, handler) {
-    const fulfillment = await transitionToShipped(orderService, ctx, order, handler);
-    const result = await orderService.transitionFulfillmentToState(ctx, fulfillment.id, 'Delivered');
-    throwIfTransitionFailed(result);
-    return result;
+    const shippedResult = await transitionToShipped(orderService, ctx, order, handler);
+    let fulfillments = [];
+    if (shippedResult.errorCode) {
+        fulfillments = await orderService.getOrderFulfillments(ctx, order);
+    }
+    else {
+        // if not an error, shippedResult is the only fulfillment
+        fulfillments.push(shippedResult);
+    }
+    const results = [];
+    for (const fulfillment of fulfillments) {
+        const result = await orderService.transitionFulfillmentToState(ctx, fulfillment.id, 'Delivered');
+        throwIfTransitionFailed(result);
+        results.push(result);
+    }
+    return results;
 }
 exports.transitionToDelivered = transitionToDelivered;
 /**
  * Throws the error result if the transition failed
+ * Ignores transition errors where from and to state are the same,
+ * because that still results in the situation we want
  */
 function throwIfTransitionFailed(result) {
     const stateError = result;

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.controller.js

@@ -46,7 +46,7 @@ let SendcloudController = class SendcloudController {
         if (!body.parcel?.order_number) {
             return core_1.Logger.warn(`No order_number in incoming Sendcloud webhook: ${JSON.stringify(body.parcel)}`, constants_1.loggerCtx);
         }
-        await this.sendcloudService.updateOrderStatus(ctx, status, body.parcel.order_number, body.parcel.tracking_number);
+        await this.sendcloudService.updateOrderStatus(ctx, status, body.parcel.order_number);
     }
 };
 __decorate([

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.handler.d.ts

@@ -1,7 +1,2 @@
 import { FulfillmentHandler } from '@vendure/core';
-export declare const sendcloudHandler: FulfillmentHandler<{
-    trackingNumber: {
-        type: "string";
-        required: false;
-    };
-}>;
+export declare const sendcloudHandler: FulfillmentHandler<{}>;

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.handler.js

@@ -11,18 +11,12 @@ exports.sendcloudHandler = new core_1.FulfillmentHandler({
             value: 'Send order to SendCloud',
         },
     ],
-    args: {
-        trackingNumber: {
-            type: 'string',
-            required: false,
-        },
-    },
+    args: {},
     createFulfillment: async (ctx, orders, orderItems, args) => {
         const orderCodes = orders.map((o) => o.code);
         core_1.Logger.info(`Fulfilled orders ${orderCodes.join(',')}`, constants_1.loggerCtx);
         return {
-            method: `SendCloud - ${args.trackingNumber || orderCodes.join(',')} `,
-            trackingCode: args.trackingNumber,
+            method: `SendCloud - ${orderCodes.join(',')} `,
         };
     },
 });

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.service.d.ts

@@ -1,11 +1,11 @@
-import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
+import { OnApplicationBootstrap } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
 import { ChannelService, EntityHydrator, EventBus, HistoryService, ID, JobQueueService, Order, OrderService, RequestContext, TransactionalConnection } from '@vendure/core';
 import { SendcloudConfigEntity } from './sendcloud-config.entity';
 import { SendcloudClient } from './sendcloud.client';
 import { Parcel } from './types/sendcloud-api.types';
 import { SendcloudParcelStatus, SendcloudPluginOptions } from './types/sendcloud.types';
-export declare class SendcloudService implements OnApplicationBootstrap, OnModuleInit {
+export declare class SendcloudService implements OnApplicationBootstrap {
     private eventBus;
     private connection;
     private orderService;
@@ -17,18 +17,21 @@ export declare class SendcloudService implements OnApplicationBootstrap, OnModul
     private historyService;
     private jobQueue;
     constructor(eventBus: EventBus, connection: TransactionalConnection, orderService: OrderService, channelService: ChannelService, jobQueueService: JobQueueService, moduleRef: ModuleRef, options: SendcloudPluginOptions, entityHydrator: EntityHydrator, historyService: HistoryService);
-    onModuleInit(): Promise<void>;
-    onApplicationBootstrap(): void;
+    onApplicationBootstrap(): Promise<void>;
     createOrderInSendcloud(userCtx: RequestContext, order: Order): Promise<Parcel | undefined>;
     /**
      * Update order by given orderCode, returns undefined if no action was taken
      * Returns order if transition was successful
      */
-    updateOrderStatus(ctx: RequestContext, sendcloudStatus: SendcloudParcelStatus, orderCode: string, trackingNumber: string): Promise<void>;
+    updateOrderStatus(ctx: RequestContext, sendcloudStatus: SendcloudParcelStatus, orderCode: string): Promise<void>;
     /**
-     * Fulfill and ship all items
+     * Ship all items
      */
-    shipAll(ctx: RequestContext, order: Order, trackingNumber: string): Promise<void>;
+    shipAll(ctx: RequestContext, order: Order): Promise<void>;
+    /**
+     * Fulfill without throwing errors. Logs an error if fulfilment fails
+     */
+    private safeFulfill;
     upsertConfig(ctx: RequestContext, config: {
         secret: string;
         publicKey: string;

package/dist/vendure-plugin-sendcloud/src/api/sendcloud.service.js

@@ -11,6 +11,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SendcloudService = void 0;
 const common_1 = require("@nestjs/common");
@@ -22,6 +25,7 @@ const sendcloud_config_entity_1 = require("./sendcloud-config.entity");
 const sendcloud_client_1 = require("./sendcloud.client");
 const sendcloud_handler_1 = require("./sendcloud.handler");
 const src_1 = require("../../../util/src");
+const util_1 = __importDefault(require("util"));
 let SendcloudService = class SendcloudService {
     constructor(eventBus, connection, 
     // private rawConnection: Connection,
@@ -36,7 +40,15 @@ let SendcloudService = class SendcloudService {
         this.entityHydrator = entityHydrator;
         this.historyService = historyService;
     }
-    async onModuleInit() {
+    async onApplicationBootstrap() {
+        // Listen for Settled orders to sync to sendcloud
+        this.eventBus.ofType(core_2.OrderPlacedEvent).subscribe(async (event) => {
+            await this.jobQueue.add({
+                orderCode: event.order.code,
+                ctx: event.ctx.serialize(),
+            }, { retries: 20 });
+        });
+        // Handle jobs
         this.jobQueue = await this.jobQueueService.createQueue({
             name: 'sendcloud',
             process: async ({ data }) => {
@@ -51,15 +63,6 @@ let SendcloudService = class SendcloudService {
             },
         });
     }
-    onApplicationBootstrap() {
-        // Listen for Settled orders to sync to sendcloud
-        this.eventBus.ofType(core_2.OrderPlacedEvent).subscribe(async (event) => {
-            await this.jobQueue.add({
-                orderCode: event.order.code,
-                ctx: event.ctx.serialize(),
-            }, { retries: 20 });
-        });
-    }
     async createOrderInSendcloud(userCtx, order) {
         if (this.options.disabled) {
             core_2.Logger.info(`Plugin is disabled, not syncing order ${order.code}`, constants_1.loggerCtx);
@@ -94,7 +97,7 @@ let SendcloudService = class SendcloudService {
      * Update order by given orderCode, returns undefined if no action was taken
      * Returns order if transition was successful
      */
-    async updateOrderStatus(ctx, sendcloudStatus, orderCode, trackingNumber) {
+    async updateOrderStatus(ctx, sendcloudStatus, orderCode) {
         let order = await this.connection
             .getRepository(ctx, core_2.Order)
             .findOne({ where: { code: orderCode }, relations: ['lines'] });
@@ -106,42 +109,46 @@ let SendcloudService = class SendcloudService {
             return core_2.Logger.info(`Not updating order with code ${orderCode}: Order already has state ${order.state}`, constants_1.loggerCtx);
         }
         if (sendcloudStatus.orderState === 'Shipped') {
-            await this.shipAll(ctx, order, trackingNumber);
-            return core_2.Logger.info(`Successfully update order ${orderCode} to ${sendcloudStatus.orderState}`, constants_1.loggerCtx);
+            await this.shipAll(ctx, order);
+            return core_2.Logger.info(`Successfully updated order ${orderCode} to Shipped`, constants_1.loggerCtx);
         }
         order = await this.connection
             .getRepository(ctx, core_2.Order)
             .findOneOrFail({ where: { code: orderCode }, relations: ['lines'] }); // Refetch in case state was updated
         if (sendcloudStatus.orderState === 'Delivered') {
-            //FIX ME
             await (0, src_1.transitionToDelivered)(this.orderService, ctx, order, {
                 code: sendcloud_handler_1.sendcloudHandler.code,
-                arguments: [
-                    {
-                        name: 'trackingNumber',
-                        value: trackingNumber,
-                    },
-                ],
+                arguments: [],
             });
-            return core_2.Logger.info(`Successfully update order ${orderCode} to ${sendcloudStatus.orderState}`, constants_1.loggerCtx);
+            return core_2.Logger.info(`Successfully updated order ${orderCode} to Delivered`, constants_1.loggerCtx);
         }
         // Fall through, means unhandled state
         core_2.Logger.info(`Not handling state ${sendcloudStatus.orderState}`, constants_1.loggerCtx);
     }
     /**
-     * Fulfill and ship all items
+     * Ship all items
      */
-    async shipAll(ctx, order, trackingNumber) {
+    async shipAll(ctx, order) {
         await (0, src_1.transitionToShipped)(this.orderService, ctx, order, {
             code: sendcloud_handler_1.sendcloudHandler.code,
-            arguments: [
-                {
-                    name: 'trackingNumber',
-                    value: trackingNumber,
-                },
-            ],
+            arguments: [],
         });
     }
+    /**
+     * Fulfill without throwing errors. Logs an error if fulfilment fails
+     */
+    async safeFulfill(ctx, order) {
+        try {
+            const fulfillment = await (0, src_1.fulfillAll)(ctx, this.orderService, order, {
+                code: sendcloud_handler_1.sendcloudHandler.code,
+                arguments: [],
+            });
+            core_2.Logger.info(`Created fulfillment (${fulfillment.id}) for order ${order.code}`, constants_1.loggerCtx);
+        }
+        catch (e) {
+            core_2.Logger.error(`Failed to fulfill order ${order.code}: ${e?.message}. Transition this order manually to 'Delivered' after checking that it exists in Sendcloud.`, constants_1.loggerCtx, util_1.default.inspect(e));
+        }
+    }
     async upsertConfig(ctx, config) {
         const repo = this.connection.getRepository(ctx, sendcloud_config_entity_1.SendcloudConfigEntity);
         const existing = await repo.findOne({
@@ -209,6 +216,7 @@ let SendcloudService = class SendcloudService {
         if (!hasSendcloudHandler) {
             return core_2.Logger.info(`Order ${order.code} does not have SendCloud set as handler. Not syncing this order.`, constants_1.loggerCtx);
         }
+        await this.safeFulfill(ctx, order);
         core_2.Logger.info(`Syncing order ${orderCode} for channel ${ctx.channel.token}`, constants_1.loggerCtx);
         const result = await this.createOrderInSendcloud(ctx, order);
         if (result) {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@pinelab/vendure-plugin-sendcloud",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Vendure plugin for syncing orders with SendCloud",
+  "icon": "truck",
   "author": "Martijn van de Brug <martijn@pinelab.studio>",
   "homepage": "https://pinelab-plugins.com/",
   "repository": "https://github.com/Pinelab-studio/pinelab-vendure-plugins",
@@ -22,5 +23,5 @@
     "test": "vitest run",
     "start": "yarn ts-node test/dev-server.ts"
   },
-  "gitHead": "985a9e6ffd5cec67d1a3a4d924c9bd4bf7faa982"
+  "gitHead": "f2584b3c12624d023dcf9a10383e1c074e35b5d5"
 }