@pinelab/vendure-plugin-sendcloud 1.5.3 → 2.0.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+# 2.0.0 (2026-04-12)
+
+- **Breaking**: Removed all webhook handling. Sendcloud is responsible for fulfillment.
+- Added `fulfillSettledOrdersTask` scheduled task (opt-in) to fulfill settled orders to `Delivered` on a nightly basis.
+- Orders are no longer automatically fulfilled on placement. They stay in `PaymentSettled` until the scheduled task runs to prevent misaligned stock in Vendure.
+
+# 1.6.0 (2026-02-05)
+
+- Upgraded to Vendure 3.5.3
+
 # 1.5.3 (2025-11-13)
 
 - Documentation update

package/README.md

@@ -4,6 +4,12 @@
 
 This plugin syncs orders to the SendCloud fulfillment platform.
 
+## How it works
+
+1. When an order is placed, it is automatically sent to SendCloud as a parcel (for label creation).
+2. The order stays in `PaymentSettled` state in Vendure — **no fulfillment is created at this point**.
+3. Once an order has been sent to SendCloud, SendCloud is responsible for tracking status. The Vendure order will simply be transitioned to `Delivered` by the included scheduled task. This is because orders are sometimes cancelled and duplicated in Sendcloud, resulting in misaligned stock.
+
 ## Getting started
 
 1. Add the plugin to your `vendure-config.ts`:
@@ -31,17 +37,46 @@ AdminUiPlugin.init({
 3. Run a DB [migration](https://www.vendure.io/docs/developer-guide/migrations/) to add the new SendCloudConfigEntity to
    the database.
 4. Go to your SendCloud account and go to `Settings > Integrations` and create an integration.
-5. Write down the `secret` and `publicKey` of the created integration
-6. For the same integration, add the webhook `https://your-vendure-domain.io/sendcloud/webhook/your-channel-token`. This
-   will update orders when the status changes in SendCloud.
-7. Start Vendure and login as admin
-8. Make sure you have the permission `SetSendCloudConfig`
-9. Go to `Settings > SendCloud`
-10. You can fill in your SendCloud `secret` and `public key` here and click save.
-11. Additionally, you can set a fallback phone number, for when a customer hasn't filled out one. A phone number is
+5. Write down the `secret` and `publicKey` of the created integration.
+6. Start Vendure and login as admin.
+7. Make sure you have the permission `SetSendCloudConfig`.
+8. Go to `Settings > SendCloud`.
+9. Fill in your SendCloud `secret` and `public key` here and click save.
+10. Additionally, you can set a fallback phone number, for when a customer hasn't filled out one. A phone number is
     required by Sendcloud in some cases.
 
-Now, when an order is placed, it will be automatically fulfilled and send to SendCloud.
+## Scheduled task: fulfill settled orders
+
+An optional scheduled task `fulfillSettledOrdersTask` is included to automatically transition settled orders to `Delivered`.
+It is **not auto-registered** — you need to add it to your `schedulerOptions.tasks` yourself.
+
+The task runs nightly (default 2:00 AM) and processes all `PaymentSettled` orders placed within the last N days
+(default 7) that use the SendCloud fulfillment handler. Each qualifying order is fulfilled and transitioned to `Delivered`.
+
+Do not manually change order statuses in Vendure if you use this scheduled task. The task will fulfill orders and transition to delivered every night.
+
+```ts
+import { DefaultSchedulerPlugin } from '@vendure/core';
+import {
+  SendcloudPlugin,
+  fulfillSettledOrdersTask,
+} from '@pinelab/vendure-plugin-sendcloud';
+
+const config: VendureConfig = {
+  plugins: [SendcloudPlugin.init({}), DefaultSchedulerPlugin.init()],
+  schedulerOptions: {
+    tasks: [
+      // Use defaults (every day at 2:00 AM, look back 7 days)
+      fulfillSettledOrdersTask,
+      // Or configure the task
+      fulfillSettledOrdersTask.configure({
+        schedule: (cron) => cron.everyDayAt(3, 0),
+        params: { settledSinceDays: 14 },
+      }),
+    ],
+  },
+};
+```
 
 ## Additional configuration
 
@@ -49,10 +84,11 @@ You can choose to send additional info to SendCloud: `weight`, `hsCode`, `origin
 Parcel items will show up as rows on your SendCloud packaging slips.
 
 ```ts
-import 'SendCloudPlugin, getNrOfOrders';
+import {
+  SendcloudPlugin,
+  getNrOfOrders,
+} from '@pinelab/vendure-plugin-sendcloud';
 
-from;
-('vendure-plugin-sendcloud');
 plugins: [
   SendcloudPlugin.init({
     /**
@@ -77,6 +113,7 @@ plugins: [
      * This example adds the nr of previous orders of the current customer to SendCloud
      */
     additionalParcelItemsFn: async (ctx, injector, order) => {
+      const additionalInputs = [];
       additionalInputs.push(await getNrOfOrders(ctx, injector, order));
       return additionalInputs;
     },

package/dist/{vendure-plugin-sendcloud/src/api → api}/sendcloud.client.d.ts

@@ -3,16 +3,11 @@ import { Parcel, ParcelInput } from './types/sendcloud-api.types';
 export declare class SendcloudClient {
     private publicKey;
     private secret;
-    static signatureHeader: string;
     endpoint: string;
     headers: {
         [key: string]: string;
     };
     constructor(publicKey: string, secret: string);
     createParcel(parcelInput: ParcelInput): Promise<Parcel>;
-    /**
-     * Verifies if the incoming webhook is actually from SendCloud
-     */
-    isValidWebhook(body: string, signature: string): boolean;
     fetch(path: string, body: any): Promise<Response>;
 }

package/dist/{vendure-plugin-sendcloud/src/api → api}/sendcloud.client.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SendcloudClient = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
-const crypto_1 = __importDefault(require("crypto"));
 const core_1 = require("@vendure/core");
 const constants_1 = require("./constants");
 class SendcloudClient {
@@ -29,19 +28,6 @@ class SendcloudClient {
         core_1.Logger.info(`Created parcel in SendCloud with for order ${parcelInput.order_number}  with id ${json.parcel?.id}`, constants_1.loggerCtx);
         return json.parcel;
     }
-    /**
-     * Verifies if the incoming webhook is actually from SendCloud
-     */
-    isValidWebhook(body, signature) {
-        if (!body || !signature) {
-            return false;
-        }
-        const hash = crypto_1.default
-            .createHmac('sha256', this.secret)
-            .update(body)
-            .digest('hex');
-        return hash === signature;
-    }
     async fetch(path, body) {
         const res = await (0, node_fetch_1.default)(`${this.endpoint}/${path}`, {
             method: 'POST',
@@ -56,4 +42,3 @@ class SendcloudClient {
     }
 }
 exports.SendcloudClient = SendcloudClient;
-SendcloudClient.signatureHeader = 'sendcloud-signature';

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

@@ -4,7 +4,7 @@ import { ChannelService, EntityHydrator, EventBus, HistoryService, ID, JobQueueS
 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';
+import { SendcloudPluginOptions } from './types/sendcloud.types';
 export declare class SendcloudService implements OnApplicationBootstrap {
     private eventBus;
     private connection;
@@ -19,19 +19,6 @@ export declare class SendcloudService implements OnApplicationBootstrap {
     constructor(eventBus: EventBus, connection: TransactionalConnection, orderService: OrderService, channelService: ChannelService, jobQueueService: JobQueueService, moduleRef: ModuleRef, options: SendcloudPluginOptions, entityHydrator: EntityHydrator, historyService: HistoryService);
     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): Promise<void>;
-    /**
-     * Ship all items
-     */
-    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;
@@ -48,4 +35,33 @@ export declare class SendcloudService implements OnApplicationBootstrap {
      */
     private syncOrder;
     logHistoryEntry(ctx: RequestContext, orderId: ID, error?: unknown): Promise<void>;
+    /**
+     * Find orders placed within the last N days that use the SendCloud fulfillment handler
+     * and process them based on their current state:
+     * - PaymentAuthorized: create fulfillment only (no shipping transitions)
+     * - PaymentSettled: fulfill + transition to Shipped + transition to Delivered
+     * - Shipped: transition existing fulfillment(s) to Delivered
+     *
+     * Intended to be called by the `fulfillSettledOrdersTask` scheduled task.
+     */
+    fulfillPlacedOrders(settledSinceDays: number): Promise<{
+        fulfilled: number;
+        skipped: number;
+        failed: number;
+    }>;
+    /**
+     * Create a fulfillment for all order lines without any state transitions.
+     * Used for PaymentAuthorized orders where we only want to register the fulfillment.
+     */
+    private createFulfillmentOnly;
+    /**
+     * Fulfill all order lines and transition the fulfillment to Shipped then Delivered.
+     * Also works for orders that already have a fulfillment and/or are already Shipped
+     */
+    private fulfillOrderToDelivered;
+    /**
+     * Throws if a fulfillment state transition failed.
+     * Ignores errors where fromState === toState (already in the desired state).
+     */
+    private throwIfTransitionError;
 }

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

@@ -11,9 +11,6 @@ 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");
@@ -24,8 +21,6 @@ const constants_1 = require("./constants");
 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,
@@ -93,62 +88,6 @@ let SendcloudService = class SendcloudService {
             throw err;
         }
     }
-    /**
-     * Update order by given orderCode, returns undefined if no action was taken
-     * Returns order if transition was successful
-     */
-    async updateOrderStatus(ctx, sendcloudStatus, orderCode) {
-        let order = await this.connection
-            .getRepository(ctx, core_2.Order)
-            .findOne({ where: { code: orderCode }, relations: ['lines'] });
-        if (!order) {
-            core_2.Logger.warn(`Cannot update status from SendCloud: No order with code ${orderCode} found`, constants_1.loggerCtx);
-            throw Error(`Cannot update status from SendCloud: No order with code ${orderCode} found`);
-        }
-        if (order.state === sendcloudStatus.orderState) {
-            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);
-            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') {
-            await (0, src_1.transitionToDelivered)(this.orderService, ctx, order, {
-                code: sendcloud_handler_1.sendcloudHandler.code,
-                arguments: [],
-            });
-            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);
-    }
-    /**
-     * Ship all items
-     */
-    async shipAll(ctx, order) {
-        await (0, src_1.transitionToShipped)(this.orderService, ctx, order, {
-            code: sendcloud_handler_1.sendcloudHandler.code,
-            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({
@@ -216,7 +155,6 @@ 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) {
@@ -238,6 +176,160 @@ let SendcloudService = class SendcloudService {
             },
         }, false);
     }
+    /**
+     * Find orders placed within the last N days that use the SendCloud fulfillment handler
+     * and process them based on their current state:
+     * - PaymentAuthorized: create fulfillment only (no shipping transitions)
+     * - PaymentSettled: fulfill + transition to Shipped + transition to Delivered
+     * - Shipped: transition existing fulfillment(s) to Delivered
+     *
+     * Intended to be called by the `fulfillSettledOrdersTask` scheduled task.
+     */
+    async fulfillPlacedOrders(settledSinceDays) {
+        const ctx = await this.createContext((await this.channelService.getDefaultChannel()).token);
+        const channels = await this.channelService.findAll(ctx);
+        const summary = { fulfilled: 0, skipped: 0, failed: 0 };
+        const sinceDate = new Date();
+        sinceDate.setDate(sinceDate.getDate() - settledSinceDays);
+        for (const channel of channels.items) {
+            const channelCtx = new core_2.RequestContext({
+                apiType: 'admin',
+                channel,
+                isAuthorized: true,
+                authorizedAsOwnerOnly: false,
+            });
+            let skip = 0;
+            const take = 100;
+            while (true) {
+                const orderList = await this.orderService.findAll(channelCtx, {
+                    filter: {
+                        state: {
+                            in: ['PaymentAuthorized', 'PaymentSettled', 'Shipped'],
+                        },
+                        orderPlacedAt: { after: sinceDate.toISOString() },
+                    },
+                    skip,
+                    take,
+                }, ['lines', 'shippingLines', 'shippingLines.shippingMethod']);
+                for (const order of orderList.items) {
+                    const hasSendcloudHandler = order.shippingLines?.find((line) => line.shippingMethod?.fulfillmentHandlerCode ===
+                        sendcloud_handler_1.sendcloudHandler.code);
+                    if (!hasSendcloudHandler) {
+                        summary.skipped++;
+                        continue;
+                    }
+                    try {
+                        if (order.state === 'PaymentAuthorized') {
+                            await this.createFulfillmentOnly(channelCtx, order);
+                            core_2.Logger.info(`Created fulfillment for authorized order ${order.code}`, constants_1.loggerCtx);
+                            summary.fulfilled++;
+                            continue;
+                        }
+                        // Handle Shipped and PaymentSettled orders the same: fulfill + transition to Delivered
+                        await this.fulfillOrderToDelivered(channelCtx, order);
+                        core_2.Logger.info(`Fulfilled order ${order.code} (state: ${order.state}) to Delivered`, constants_1.loggerCtx);
+                        summary.fulfilled++;
+                    }
+                    catch (e) {
+                        summary.failed++;
+                        core_2.Logger.error(`Failed to process order ${order.code} (${order.state}): ${e?.message}`, constants_1.loggerCtx);
+                    }
+                }
+                if (orderList.items.length < take) {
+                    break;
+                }
+                skip += take;
+            }
+        }
+        core_2.Logger.info(`Finished: ${summary.fulfilled} fulfilled, ${summary.skipped} skipped, ${summary.failed} failed`, constants_1.loggerCtx);
+        return summary;
+    }
+    /**
+     * Create a fulfillment for all order lines without any state transitions.
+     * Used for PaymentAuthorized orders where we only want to register the fulfillment.
+     */
+    async createFulfillmentOnly(ctx, order) {
+        if (!order.lines?.length) {
+            const fullOrder = await this.orderService.findOne(ctx, order.id, [
+                'lines',
+            ]);
+            if (!fullOrder) {
+                throw new Error(`Order ${order.code} not found`);
+            }
+            order = fullOrder;
+        }
+        const lines = order.lines.map((line) => ({
+            orderLineId: line.id,
+            quantity: line.quantity,
+        }));
+        const fulfillmentResult = await this.orderService.createFulfillment(ctx, {
+            handler: { code: sendcloud_handler_1.sendcloudHandler.code, arguments: [] },
+            lines,
+        });
+        if (fulfillmentResult.errorCode ===
+            'ITEMS_ALREADY_FULFILLED_ERROR') {
+            return; // Already fulfilled, nothing to do
+        }
+        const error = fulfillmentResult;
+        if (error.errorCode) {
+            throw new Error(`${error.errorCode}: ${error.message}`);
+        }
+    }
+    /**
+     * Fulfill all order lines and transition the fulfillment to Shipped then Delivered.
+     * Also works for orders that already have a fulfillment and/or are already Shipped
+     */
+    async fulfillOrderToDelivered(ctx, order) {
+        if (!order.lines?.length) {
+            const fullOrder = await this.orderService.findOne(ctx, order.id, [
+                'lines',
+            ]);
+            if (!fullOrder) {
+                throw new Error(`Order ${order.code} not found`);
+            }
+            order = fullOrder;
+        }
+        const lines = order.lines.map((line) => ({
+            orderLineId: line.id,
+            quantity: line.quantity,
+        }));
+        const fulfillmentResult = await this.orderService.createFulfillment(ctx, {
+            handler: { code: sendcloud_handler_1.sendcloudHandler.code, arguments: [] },
+            lines,
+        });
+        let fulfillment;
+        if (fulfillmentResult.errorCode ===
+            'ITEMS_ALREADY_FULFILLED_ERROR') {
+            const fulfillments = await this.orderService.getOrderFulfillments(ctx, order);
+            fulfillment = fulfillments[0];
+        }
+        else {
+            const error = fulfillmentResult;
+            if (error.errorCode) {
+                throw new Error(`${error.errorCode}: ${error.message}`);
+            }
+            fulfillment = fulfillmentResult;
+        }
+        if (order.state !== 'Delivered') {
+            const shippedResult = await this.orderService.transitionFulfillmentToState(ctx, fulfillment.id, 'Shipped');
+            this.throwIfTransitionError(shippedResult);
+        }
+        const deliveredResult = await this.orderService.transitionFulfillmentToState(ctx, fulfillment.id, 'Delivered');
+        this.throwIfTransitionError(deliveredResult);
+    }
+    /**
+     * Throws if a fulfillment state transition failed.
+     * Ignores errors where fromState === toState (already in the desired state).
+     */
+    throwIfTransitionError(result) {
+        const stateError = result;
+        if (stateError.transitionError) {
+            if (stateError.fromState === stateError.toState) {
+                return;
+            }
+            throw new Error(`Transition error: ${stateError.fromState} -> ${stateError.toState}: ${stateError.transitionError}`);
+        }
+    }
 };
 exports.SendcloudService = SendcloudService;
 exports.SendcloudService = SendcloudService = __decorate([

package/dist/{vendure-plugin-sendcloud/src/api → api}/types/sendcloud-api.types.d.ts

@@ -75,8 +75,3 @@ export interface Status {
     id: number;
     message: string;
 }
-export interface IncomingWebhookBody {
-    action: 'parcel_status_changed' | string;
-    timestamp: number;
-    parcel?: Parcel;
-}

package/dist/{vendure-plugin-sendcloud/src/api → api}/types/sendcloud.types.d.ts

@@ -1,14 +1,5 @@
 import { Injector, Order, OrderLine, RequestContext } from '@vendure/core';
 import { ParcelInputItem } from './sendcloud-api.types';
-export interface SendcloudParcelStatus {
-    id: number;
-    message: string;
-    /**
-     * Corresponding orderState for the sendcloud status
-     */
-    orderState?: 'Shipped' | 'Delivered' | 'Cancelled';
-}
-export declare const sendcloudStates: SendcloudParcelStatus[];
 export interface SendcloudPluginOptions {
     /**
      * Function to specify the weight of a parcelItem

package/dist/api/types/sendcloud.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/fulfill-settled-orders-task.d.ts

@@ -0,0 +1,26 @@
+import { ScheduledTask } from '@vendure/core';
+/**
+ * Scheduled task that finds all PaymentSettled orders placed within the last N days
+ * that use the SendCloud fulfillment handler, and transitions them to Delivered.
+ *
+ * This task is opt-in: add it to `schedulerOptions.tasks` in your Vendure config.
+ *
+ * @example
+ * ```ts
+ * import { fulfillSettledOrdersTask } from '@pinelab/vendure-plugin-sendcloud';
+ *
+ * const config: VendureConfig = {
+ *   schedulerOptions: {
+ *     tasks: [
+ *       fulfillSettledOrdersTask.configure({
+ *         params: { settledSinceDays: 14 },
+ *       }),
+ *     ],
+ *   },
+ * };
+ * ```
+ */
+export declare const fulfillSettledOrdersTask: ScheduledTask<{
+    /** Number of days to look back for settled orders */
+    settledSinceDays: number;
+}>;

package/dist/config/fulfill-settled-orders-task.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fulfillSettledOrdersTask = void 0;
+const core_1 = require("@vendure/core");
+const sendcloud_service_1 = require("../api/sendcloud.service");
+/**
+ * Scheduled task that finds all PaymentSettled orders placed within the last N days
+ * that use the SendCloud fulfillment handler, and transitions them to Delivered.
+ *
+ * This task is opt-in: add it to `schedulerOptions.tasks` in your Vendure config.
+ *
+ * @example
+ * ```ts
+ * import { fulfillSettledOrdersTask } from '@pinelab/vendure-plugin-sendcloud';
+ *
+ * const config: VendureConfig = {
+ *   schedulerOptions: {
+ *     tasks: [
+ *       fulfillSettledOrdersTask.configure({
+ *         params: { settledSinceDays: 14 },
+ *       }),
+ *     ],
+ *   },
+ * };
+ * ```
+ */
+exports.fulfillSettledOrdersTask = new core_1.ScheduledTask({
+    id: 'sendcloud-fulfill-settled-orders',
+    description: 'Fulfill settled SendCloud orders to Delivered. Only processes orders in PaymentSettled state with the SendCloud handler.',
+    params: {
+        /** Number of days to look back for settled orders */
+        settledSinceDays: 90,
+    },
+    schedule: (cron) => cron.everyDayAt(2, 0),
+    async execute({ injector, params }) {
+        return injector
+            .get(sendcloud_service_1.SendcloudService)
+            .fulfillPlacedOrders(params.settledSinceDays);
+    },
+});

package/dist/{vendure-plugin-sendcloud/src/index.d.ts → index.d.ts}

@@ -3,3 +3,4 @@ export * from './api/sendcloud.handler';
 export * from './api/additional-parcel-input-items';
 export * from './api/types/sendcloud.types';
 export * from './api/types/sendcloud-api.types';
+export * from './config/fulfill-settled-orders-task';

package/dist/{vendure-plugin-sendcloud/src/index.js → index.js}

@@ -19,3 +19,4 @@ __exportStar(require("./api/sendcloud.handler"), exports);
 __exportStar(require("./api/additional-parcel-input-items"), exports);
 __exportStar(require("./api/types/sendcloud.types"), exports);
 __exportStar(require("./api/types/sendcloud-api.types"), exports);
+__exportStar(require("./config/fulfill-settled-orders-task"), exports);

package/dist/{vendure-plugin-sendcloud/src/sendcloud.plugin.js → sendcloud.plugin.js}

@@ -17,10 +17,8 @@ const path_1 = __importDefault(require("path"));
 const sendcloud_resolver_1 = require("./api/sendcloud.resolver");
 const sendcloud_service_1 = require("./api/sendcloud.service");
 const constants_1 = require("./api/constants");
-const sendcloud_controller_1 = require("./api/sendcloud.controller");
 const sendcloud_config_entity_1 = require("./api/sendcloud-config.entity");
 const sendcloud_handler_1 = require("./api/sendcloud.handler");
-const raw_body_middleware_1 = require("../../util/src/raw-body.middleware");
 let SendcloudPlugin = SendcloudPlugin_1 = class SendcloudPlugin {
     static init(options) {
         this.options = options;
@@ -80,18 +78,12 @@ exports.SendcloudPlugin = SendcloudPlugin = SendcloudPlugin_1 = __decorate([
             },
         ],
         imports: [core_1.PluginCommonModule],
-        controllers: [sendcloud_controller_1.SendcloudController],
         entities: [sendcloud_config_entity_1.SendcloudConfigEntity],
         configuration: (config) => {
-            config.apiOptions.middleware.push({
-                route: '/sendcloud/webhook*splat',
-                handler: raw_body_middleware_1.rawBodyMiddleware,
-                beforeListen: true,
-            });
             config.shippingOptions.fulfillmentHandlers.push(sendcloud_handler_1.sendcloudHandler);
             config.authOptions.customPermissions.push(sendcloud_resolver_1.sendcloudPermission);
             return config;
         },
-        compatibility: '>=3.2.0',
+        compatibility: '>=3.1.0',
     })
 ], SendcloudPlugin);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinelab/vendure-plugin-sendcloud",
-  "version": "1.5.3",
+  "version": "2.0.0",
   "description": "Vendure plugin for syncing orders with SendCloud",
   "author": "Martijn van de Brug <martijn@pinelab.studio>",
   "homepage": "https://plugins.pinelab.studio/",
@@ -10,18 +10,18 @@
   "publishConfig": {
     "access": "public"
   },
-  "main": "dist/vendure-plugin-sendcloud/src/index.js",
-  "types": "dist/vendure-plugin-sendcloud/src/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "README.md",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "rimraf dist && tsc && copyfiles -u 1 'src/ui/**/*' dist/vendure-plugin-sendcloud/src/",
+    "build": "rimraf dist && tsc && copyfiles -u 1 'src/ui/**/*' dist/",
     "test": "vitest run",
     "start": "yarn ts-node test/dev-server.ts",
     "lint": "echo 'No linting configured'"
   },
-  "gitHead": "ba4e499e13892b029fac2aa29082c03ec8032249"
+  "gitHead": "476f36da3aafea41fbf21c70774a30306f1d238f"
 }

package/dist/util/src/index.d.ts

@@ -1 +0,0 @@
-export * from './order-state-util';

package/dist/util/src/index.js

@@ -1,17 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./order-state-util"), exports);

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

@@ -1,22 +0,0 @@
-import { FulfillmentStateTransitionError, Order, OrderService, RequestContext } from '@vendure/core';
-import { AddFulfillmentToOrderResult, ConfigurableOperationInput } from '@vendure/common/lib/generated-types';
-import { Fulfillment } from '@vendure/core/dist/entity/fulfillment/fulfillment.entity';
-export declare const loggerCtx = "OrderStateUtil";
-/**
- * Create a fulfillment for all orderlines. Returns fulfillments[0] if already fulfilled
- */
-export declare function fulfillAll(ctx: RequestContext, orderService: OrderService, order: Order, handler: ConfigurableOperationInput): Promise<Fulfillment>;
-/**
- * Fulfills all items to shipped using transitionFulfillmentToState
- */
-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 | 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

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loggerCtx = void 0;
-exports.fulfillAll = fulfillAll;
-exports.transitionToShipped = transitionToShipped;
-exports.transitionToDelivered = transitionToDelivered;
-exports.throwIfTransitionFailed = throwIfTransitionFailed;
-const core_1 = require("@vendure/core");
-exports.loggerCtx = 'OrderStateUtil';
-/**
- * Create a fulfillment for all orderlines. Returns fulfillments[0] if already fulfilled
- */
-async function fulfillAll(ctx, orderService, order, handler) {
-    const lines = order.lines.map((line) => ({
-        orderLineId: line.id,
-        quantity: line.quantity,
-    }));
-    const fulfillment = await orderService.createFulfillment(ctx, {
-        handler,
-        lines,
-    });
-    if (fulfillment.errorCode ===
-        'ITEMS_ALREADY_FULFILLED_ERROR') {
-        const fulfillments = await orderService.getOrderFulfillments(ctx, order);
-        const fulfillment = fulfillments[0];
-        core_1.Logger.info(`Items already fulfilled for order ${order.code}. Returning fulfillment '${fulfillment.id}'. Existing fulfillments: ${fulfillments.map((f) => f.id).join(', ')}`, exports.loggerCtx);
-        return fulfillment;
-    }
-    throwIfTransitionFailed(fulfillment);
-    return fulfillment;
-}
-/**
- * Fulfills all items to shipped using transitionFulfillmentToState
- */
-async function transitionToShipped(orderService, ctx, order, handler) {
-    const fulfillment = await fulfillAll(ctx, orderService, order, handler);
-    const result = await orderService.transitionFulfillmentToState(ctx, fulfillment.id, 'Shipped');
-    throwIfTransitionFailed(result);
-    return result;
-}
-/**
- * Fulfills all items to shipped, then to delivered using transitionFulfillmentToState
- */
-async function transitionToDelivered(orderService, ctx, order, handler) {
-    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;
-}
-/**
- * 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;
-    if (stateError.transitionError &&
-        stateError.fromState === stateError.toState) {
-        return; // If already 'Shipped', don't count this as an error
-    }
-    // It's not a stateTransition error
-    const error = result;
-    if (error.errorCode) {
-        throw error;
-    }
-}

package/dist/util/src/raw-body.middleware.d.ts

@@ -1,9 +0,0 @@
-import type { Request } from 'express';
-export interface RequestWithRawBody extends Request {
-    rawBody: Buffer;
-}
-/**
- * Middleware which adds the raw request body to the incoming message object. This is needed by
- * Stripe to properly verify webhook events.
- */
-export declare const rawBodyMiddleware: import("connect").NextHandleFunction;

package/dist/util/src/raw-body.middleware.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rawBodyMiddleware = void 0;
-const body_parser_1 = require("body-parser");
-/**
- * Middleware which adds the raw request body to the incoming message object. This is needed by
- * Stripe to properly verify webhook events.
- */
-exports.rawBodyMiddleware = (0, body_parser_1.raw)({
-    type: '*/*',
-    verify(req, res, buf, encoding) {
-        if (Buffer.isBuffer(buf)) {
-            req.rawBody = Buffer.from(buf);
-        }
-        return true;
-    },
-});

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

@@ -1,7 +0,0 @@
-import { Request } from 'express';
-import { SendcloudService } from './sendcloud.service';
-export declare class SendcloudController {
-    private sendcloudService;
-    constructor(sendcloudService: SendcloudService);
-    webhook(req: Request, signature: string, channelToken: string): Promise<unknown>;
-}

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

@@ -1,80 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SendcloudController = void 0;
-const common_1 = require("@nestjs/common");
-const sendcloud_service_1 = require("./sendcloud.service");
-const sendcloud_client_1 = require("./sendcloud.client");
-const core_1 = require("@vendure/core");
-const constants_1 = require("./constants");
-const sendcloud_types_1 = require("./types/sendcloud.types");
-const util_1 = require("util");
-let SendcloudController = class SendcloudController {
-    constructor(sendcloudService) {
-        this.sendcloudService = sendcloudService;
-    }
-    async webhook(req, signature, channelToken) {
-        let body;
-        if (!Buffer.isBuffer(req.body)) {
-            core_1.Logger.warn(`Incoming webhook body is not a Buffer. This means the body was already parsed by some other middleware. This might cause problems when validating the incoming webhook signature.`, constants_1.loggerCtx);
-            body = req.body;
-        }
-        else {
-            // Else we try and parse the body
-            try {
-                body = JSON.parse(req.body.toString());
-            }
-            catch (e) {
-                core_1.Logger.error(`Error parsing incoming webhook body: ${e?.message ?? e}`, constants_1.loggerCtx, (0, util_1.inspect)(req.body));
-                return;
-            }
-        }
-        const rawBody = req.rawBody;
-        const ctx = await this.sendcloudService.createContext(channelToken);
-        const { client } = await this.sendcloudService.getClient(ctx);
-        if (!client.isValidWebhook(rawBody, signature)) {
-            core_1.Logger.warn(`Ignoring incoming webhook for channel ${channelToken}, because it has an invalid signature`, constants_1.loggerCtx);
-            return;
-        }
-        if (body.action !== 'parcel_status_changed') {
-            return core_1.Logger.info(`Incoming webhook: ${body.action}. skipping...`, constants_1.loggerCtx);
-        }
-        core_1.Logger.info(`Incoming Sendcloud webhook: ${body.action} - ${body.parcel?.id} - ${body.parcel?.order_number} - ${body.parcel?.status.id} (${body.parcel?.status.message})`, constants_1.loggerCtx);
-        const status = sendcloud_types_1.sendcloudStates.find((s) => s.id === body.parcel?.status?.id);
-        if (!status) {
-            return core_1.Logger.warn(`Unknown SendCloud status "${body.parcel?.status?.message}", not handling this webhook.`, constants_1.loggerCtx);
-        }
-        if (!status.orderState) {
-            return core_1.Logger.info(`Ignoring incoming webhook status "${body.parcel?.status?.message}", because we don't update Vendure order status for this sendcloud status.`, constants_1.loggerCtx);
-        }
-        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);
-    }
-};
-exports.SendcloudController = SendcloudController;
-__decorate([
-    (0, common_1.Post)('webhook/:channelToken'),
-    __param(0, (0, common_1.Req)()),
-    __param(1, (0, common_1.Headers)(sendcloud_client_1.SendcloudClient.signatureHeader)),
-    __param(2, (0, common_1.Param)('channelToken')),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, String, String]),
-    __metadata("design:returntype", Promise)
-], SendcloudController.prototype, "webhook", null);
-exports.SendcloudController = SendcloudController = __decorate([
-    (0, common_1.Controller)('sendcloud'),
-    __metadata("design:paramtypes", [sendcloud_service_1.SendcloudService])
-], SendcloudController);

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

@@ -1,157 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendcloudStates = void 0;
-exports.sendcloudStates = [
-    {
-        id: 62989,
-        message: 'The package has been held at customs',
-    },
-    {
-        id: 6,
-        message: 'Not sorted',
-        orderState: 'Shipped',
-    },
-    {
-        id: 15,
-        message: 'Error collecting',
-    },
-    {
-        id: 62990,
-        message: 'The package is in the sorting centre',
-        orderState: 'Shipped',
-    },
-    {
-        id: 62991,
-        message: 'The package was refused by the recipient when delivered',
-    },
-    {
-        id: 62992,
-        message: 'The package was returned to the sender due to an issue',
-    },
-    {
-        id: 62993,
-        message: 'The delivery method was changed by the request of the recipient or due to other circumstances.',
-    },
-    {
-        id: 1002,
-        message: 'Announcement failed',
-    },
-    {
-        id: 1999,
-        message: 'Cancellation requested',
-    },
-    {
-        id: 62994,
-        message: 'The delivery date was changed by the request of the recipient or due to other.',
-    },
-    {
-        id: 62995,
-        message: 'The delivery address was changed by the request of the recipient or due to other circumstances.',
-    },
-    {
-        id: 62996,
-        message: 'For unusual cases: lost, damaged, destroyed, etc.',
-    },
-    {
-        id: 1998,
-        message: 'Cancelled upstream',
-        orderState: 'Cancelled',
-    },
-    {
-        id: 1000,
-        message: 'Ready to send',
-        orderState: 'Shipped',
-    },
-    {
-        id: 62997,
-        message: 'The address is incorrect and the carrier needs address correction from the sender or the recipient.',
-    },
-    {
-        id: 12,
-        message: 'Awaiting customer pickup',
-        orderState: 'Shipped',
-    },
-    {
-        id: 11,
-        message: 'Delivered',
-        orderState: 'Delivered',
-    },
-    {
-        id: 93,
-        message: 'Shipment collected by customer',
-        orderState: 'Delivered',
-    },
-    {
-        id: 91,
-        message: 'Parcel en route',
-        orderState: 'Shipped',
-    },
-    {
-        id: 80,
-        message: 'Unable to deliver',
-    },
-    {
-        id: 22,
-        message: 'Shipment picked up by driver',
-        orderState: 'Shipped',
-    },
-    {
-        id: 13,
-        message: 'Announced: not collected',
-    },
-    {
-        id: 8,
-        message: 'Delivery attempt failed',
-    },
-    {
-        id: 7,
-        message: 'Being sorted',
-        orderState: 'Shipped',
-    },
-    {
-        id: 5,
-        message: 'Sorted',
-        orderState: 'Shipped',
-    },
-    {
-        id: 4,
-        message: 'Delivery delayed',
-    },
-    {
-        id: 3,
-        message: 'En route to sorting center',
-        orderState: 'Shipped',
-    },
-    {
-        id: 1,
-        message: 'Announced',
-        orderState: 'Shipped',
-    },
-    {
-        id: 1337,
-        message: 'Unknown status - check carrier track & trace page for more insights',
-    },
-    {
-        id: 999,
-        message: 'No label',
-    },
-    {
-        id: 1001,
-        message: 'Being announced',
-        orderState: 'Shipped',
-    },
-    {
-        id: 2000,
-        message: 'Cancelled',
-        orderState: 'Cancelled',
-    },
-    {
-        id: 2001,
-        message: 'Submitting cancellation request',
-    },
-    {
-        id: 92,
-        message: 'Driver en route',
-        orderState: 'Shipped',
-    },
-];