@pinelab/vendure-plugin-sendcloud 0.0.3

package/README.md

@@ -0,0 +1,87 @@
+# Vendure SendCloud plugin
+
+![Vendure version](https://img.shields.io/npm/dependency-version/vendure-plugin-sendcloud/dev/@vendure/core)
+
+### Visit [pinelab-plugins.com](https://pinelab-plugins.com/plugin/vendure-plugin-sendcloud) for more documentation and examples.
+
+This plugin syncs orders to the SendCloud fulfillment platform.
+
+## Getting started
+
+1. Add the plugin to your `vendure-config.ts`:
+
+```ts
+plugins: [
+  SendcloudPlugin.init({}),
+  ...
+]
+```
+
+2. Add the SendCloud Ui to the Vendure admin:
+
+```ts
+AdminUiPlugin.init({
+  port: 3002,
+  route: 'admin',
+  app: compileUiExtensions({
+    outputPath: path.join(__dirname, '__admin-ui'),
+    extensions: [SendcloudPlugin.ui],
+  }),
+}),
+```
+
+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
+    required by Sendcloud in some cases.
+
+Now, when an order is placed, it will be automatically fulfilled and send to SendCloud.
+
+## Additional configuration
+
+You can choose to send additional info to SendCloud: `weight`, `hsCode`, `origin_country` and additional parcel items.
+Parcel items will show up as rows on your SendCloud packaging slips.
+
+```ts
+import 'SendCloudPlugin, getNrOfOrders';
+
+from;
+('vendure-plugin-sendcloud');
+plugins: [
+  SendcloudPlugin.init({
+    /**
+     * Implement the weightFn to determine the weight of a parcel item,
+     * or set a default value
+     */
+    weightFn: (line) =>
+      (line.productVariant.product?.customFields as any)?.weight || 5,
+    /**
+     * Implement the hsCodeFn to set the hsCode of a parcel item,
+     * or set a default value
+     */
+    hsCodeFn: (line) =>
+      (line.productVariant.product?.customFields as any)?.hsCode || 'test hs',
+    /**
+     * Implement the originCountryFn to set the origin_country of a parcel item,
+     * or set a default value
+     */
+    originCountryFn: (line) => 'NL',
+    /**
+     * Implement the additionalParcelItemsFn to add additional rows to the SendCloud order.
+     * This example adds the nr of previous orders of the current customer to SendCloud
+     */
+    additionalParcelItemsFn: async (ctx, injector, order) => {
+      additionalInputs.push(await getNrOfOrders(ctx, injector, order));
+      return additionalInputs;
+    },
+  }),
+];
+```

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

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

package/dist/util/src/index.js

@@ -0,0 +1,17 @@
+"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

@@ -0,0 +1,19 @@
+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';
+/**
+ * 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>;
+/**
+ * Fulfills all items to shipped, then to delivered using transitionFulfillmentToState
+ */
+export declare function transitionToDelivered(orderService: OrderService, ctx: RequestContext, order: Order, handler: ConfigurableOperationInput): Promise<Fulfillment>;
+/**
+ * Throw an error if the transition failed
+ */
+export declare function throwIfTransitionFailed(result: FulfillmentStateTransitionError | Fulfillment | AddFulfillmentToOrderResult): void;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwIfTransitionFailed = exports.transitionToDelivered = exports.transitionToShipped = exports.fulfillAll = void 0;
+/**
+ * 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);
+        return fulfillments[0];
+    }
+    throwIfTransitionFailed(fulfillment);
+    return fulfillment;
+}
+exports.fulfillAll = fulfillAll;
+/**
+ * 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;
+}
+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;
+}
+exports.transitionToDelivered = transitionToDelivered;
+/**
+ * Throw an error if the transition failed
+ */
+function throwIfTransitionFailed(result) {
+    const stateError = result;
+    if (stateError.transitionError) {
+        if (stateError.fromState === stateError.toState) {
+            return; // If already 'Shipped', don't count this as an error
+        }
+        throw Error(`${stateError.message} - from ${stateError.fromState} to ${stateError.toState} - ${stateError.transitionError}`);
+    }
+    // It's not a stateTransition error
+    const error = result;
+    if (error.errorCode) {
+        throw Error(`${error.errorCode}: ${error.message}`);
+    }
+}
+exports.throwIfTransitionFailed = throwIfTransitionFailed;

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

@@ -0,0 +1,6 @@
+import { Middleware } from '@vendure/core';
+/**
+ * Set req.rawBody before any other middleware changes the body. Used to verify incoming request signatures for example.
+ * @param route
+ */
+export declare function createRawBodyMiddleWare(route: string): Middleware;

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

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRawBodyMiddleWare = void 0;
+const body_parser_1 = __importDefault(require("body-parser"));
+/**
+ * Set req.rawBody before any other middleware changes the body. Used to verify incoming request signatures for example.
+ * @param route
+ */
+function createRawBodyMiddleWare(route) {
+    return {
+        route,
+        beforeListen: true,
+        handler: body_parser_1.default.json({
+            verify(req, _, buf) {
+                if (Buffer.isBuffer(buf)) {
+                    req.rawBody = Buffer.from(buf);
+                }
+                return true;
+            },
+        }),
+    };
+}
+exports.createRawBodyMiddleWare = createRawBodyMiddleWare;

package/dist/vendure-plugin-sendcloud/src/api/additional-parcel-input-items.d.ts

@@ -0,0 +1,10 @@
+import { Injector, Order, RequestContext } from '@vendure/core';
+import { ParcelInputItem } from './types/sendcloud-api.types';
+/**
+ * Add nr of previously placed orders for this customer as parcelItem
+ */
+export declare function getNrOfOrders(ctx: RequestContext, injector: Injector, order: Order): Promise<ParcelInputItem>;
+/**
+ * Return couponCodes as Sendcloud parcelInputItem
+ */
+export declare function getCouponCodes(order: Order): ParcelInputItem | undefined;

package/dist/vendure-plugin-sendcloud/src/api/additional-parcel-input-items.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCouponCodes = exports.getNrOfOrders = void 0;
+const core_1 = require("@vendure/core");
+/**
+ * Add nr of previously placed orders for this customer as parcelItem
+ */
+async function getNrOfOrders(ctx, injector, order) {
+    let nrOfOrders = 0;
+    if (order.customer?.id) {
+        const orders = await injector
+            .get(core_1.TransactionalConnection)
+            .getRepository(ctx, core_1.Order)
+            .find({
+            where: {
+                customer: { id: order.customer.id },
+                state: 'Delivered',
+            },
+        });
+        nrOfOrders = orders.length;
+    }
+    return {
+        description: String(nrOfOrders),
+        quantity: 1,
+        weight: '0.1',
+        sku: `Nr of orders`,
+        value: '0',
+    };
+}
+exports.getNrOfOrders = getNrOfOrders;
+/**
+ * Return couponCodes as Sendcloud parcelInputItem
+ */
+function getCouponCodes(order) {
+    if (!order.couponCodes || order.couponCodes.length === 0) {
+        return;
+    }
+    const couponCodesString = order.couponCodes.join(',');
+    return {
+        description: couponCodesString,
+        quantity: 1,
+        weight: '0.1',
+        sku: `Couponcodes`,
+        value: '0',
+    };
+}
+exports.getCouponCodes = getCouponCodes;

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

@@ -0,0 +1,2 @@
+export declare const loggerCtx = "SendcloudPlugin";
+export declare const PLUGIN_OPTIONS: unique symbol;

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_OPTIONS = exports.loggerCtx = void 0;
+exports.loggerCtx = 'SendcloudPlugin';
+exports.PLUGIN_OPTIONS = Symbol('SENDCLOUD_OPTIONS');

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

@@ -0,0 +1,8 @@
+import { DeepPartial, VendureEntity } from '@vendure/core';
+export declare class SendcloudConfigEntity extends VendureEntity {
+    constructor(input?: DeepPartial<SendcloudConfigEntity>);
+    channelId: string;
+    secret?: string;
+    publicKey?: string;
+    defaultPhoneNr?: string;
+}

package/dist/vendure-plugin-sendcloud/src/api/sendcloud-config.entity.js

@@ -0,0 +1,40 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendcloudConfigEntity = void 0;
+const core_1 = require("@vendure/core");
+const typeorm_1 = require("typeorm");
+let SendcloudConfigEntity = class SendcloudConfigEntity extends core_1.VendureEntity {
+    constructor(input) {
+        super(input);
+    }
+};
+__decorate([
+    (0, typeorm_1.Column)({ unique: true }),
+    __metadata("design:type", String)
+], SendcloudConfigEntity.prototype, "channelId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SendcloudConfigEntity.prototype, "secret", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SendcloudConfigEntity.prototype, "publicKey", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ nullable: true }),
+    __metadata("design:type", String)
+], SendcloudConfigEntity.prototype, "defaultPhoneNr", void 0);
+SendcloudConfigEntity = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [Object])
+], SendcloudConfigEntity);
+exports.SendcloudConfigEntity = SendcloudConfigEntity;

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

@@ -0,0 +1,11 @@
+import { Order, OrderLine } from '@vendure/core';
+import { ParcelInput, ParcelInputItem } from './types/sendcloud-api.types';
+import { SendcloudPluginOptions } from './types/sendcloud.types';
+/**
+ * Transforms order and variants to ParcelInput
+ * @param order including lines, shippingaddress and customer
+ * @param options
+ */
+export declare function toParcelInput(order: Order, options: SendcloudPluginOptions, defaultPhoneNr?: string): ParcelInput;
+export declare function toParcelInputItem(line: OrderLine, options: SendcloudPluginOptions): ParcelInputItem;
+export declare function getTotalWeight(items: ParcelInputItem[]): string;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTotalWeight = exports.toParcelInputItem = exports.toParcelInput = void 0;
+/**
+ * Transforms order and variants to ParcelInput
+ * @param order including lines, shippingaddress and customer
+ * @param options
+ */
+function toParcelInput(order, options, defaultPhoneNr) {
+    const items = order.lines
+        .filter((line) => line.quantity >= 1)
+        .map((line) => toParcelInputItem(line, options));
+    return {
+        name: order.shippingAddress.fullName || '-',
+        company_name: order.shippingAddress.company,
+        address: order.shippingAddress.streetLine1,
+        house_number: order.shippingAddress.streetLine2,
+        city: order.shippingAddress.city,
+        postal_code: order.shippingAddress.postalCode,
+        country: order.shippingAddress.countryCode.toUpperCase(),
+        telephone: order.customer?.phoneNumber || defaultPhoneNr,
+        request_label: false,
+        email: order.customer?.emailAddress,
+        order_number: order.code,
+        parcel_items: items,
+        weight: getTotalWeight(items),
+        shipping_method_checkout_name: order.shippingLines?.[0].shippingMethod?.code,
+    };
+}
+exports.toParcelInput = toParcelInput;
+function toParcelInputItem(line, options) {
+    const variant = line.productVariant;
+    let weightPerUnit = options.weightFn?.(line) || 0;
+    let hsCode = options.hsCodeFn?.(line);
+    if (weightPerUnit < 0.001) {
+        weightPerUnit = 0.001;
+    }
+    const parcelInput = {
+        description: variant.name,
+        quantity: line.quantity,
+        weight: weightPerUnit.toFixed(3),
+        sku: variant.sku,
+        value: (line.unitPriceWithTax / 100).toFixed(2),
+    };
+    const originCountry = options.originCountryFn?.(line);
+    if (originCountry) {
+        parcelInput.origin_country = originCountry;
+    }
+    if (hsCode && hsCode.length > 1) {
+        parcelInput.hs_code = hsCode;
+    }
+    return parcelInput;
+}
+exports.toParcelInputItem = toParcelInputItem;
+function getTotalWeight(items) {
+    let totalWeight = 0;
+    items.forEach((item) => {
+        totalWeight += parseFloat(item.weight) * item.quantity;
+    });
+    return totalWeight.toFixed(3);
+}
+exports.getTotalWeight = getTotalWeight;

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

@@ -0,0 +1,18 @@
+import { Response } from 'node-fetch';
+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/sendcloud.client.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 {
+    constructor(publicKey, secret) {
+        this.publicKey = publicKey;
+        this.secret = secret;
+        this.endpoint = 'https://panel.sendcloud.sc/api/v2';
+        this.headers = {
+            'Content-Type': 'application/json',
+            Authorization: 'Basic ' +
+                Buffer.from(`${this.publicKey}:${this.secret}`).toString('base64'),
+        };
+    }
+    async createParcel(parcelInput) {
+        const body = { parcel: parcelInput };
+        const res = await this.fetch('parcels', body);
+        if (!res.ok) {
+            throw Error(res.statusText);
+        }
+        const json = (await res.json());
+        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',
+            headers: this.headers,
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const json = (await res.json());
+            throw Error(`${res.statusText}: ${json.error?.message}`);
+        }
+        return res;
+    }
+}
+exports.SendcloudClient = SendcloudClient;
+SendcloudClient.signatureHeader = 'sendcloud-signature';

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

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

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

@@ -0,0 +1,65 @@
+"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");
+let SendcloudController = class SendcloudController {
+    constructor(sendcloudService) {
+        this.sendcloudService = sendcloudService;
+    }
+    async webhook(req, body, signature, channelToken) {
+        const rawBody = req.rawBody || JSON.stringify(body); // TestEnvironment doesnt have middleware applied, so no rawBody available
+        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, body.parcel.tracking_number);
+    }
+};
+__decorate([
+    (0, common_1.Post)('webhook/:channelToken'),
+    __param(0, (0, common_1.Req)()),
+    __param(1, (0, common_1.Body)()),
+    __param(2, (0, common_1.Headers)(sendcloud_client_1.SendcloudClient.signatureHeader)),
+    __param(3, (0, common_1.Param)('channelToken')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, String, String]),
+    __metadata("design:returntype", Promise)
+], SendcloudController.prototype, "webhook", null);
+SendcloudController = __decorate([
+    (0, common_1.Controller)('sendcloud'),
+    __metadata("design:paramtypes", [sendcloud_service_1.SendcloudService])
+], SendcloudController);
+exports.SendcloudController = SendcloudController;

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendcloudHandler = void 0;
+const core_1 = require("@vendure/core");
+const constants_1 = require("./constants");
+exports.sendcloudHandler = new core_1.FulfillmentHandler({
+    code: 'sendcloud',
+    description: [
+        {
+            languageCode: core_1.LanguageCode.en,
+            value: 'Send order to SendCloud',
+        },
+    ],
+    args: {
+        trackingNumber: {
+            type: 'string',
+            required: false,
+        },
+    },
+    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,
+        };
+    },
+});

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

@@ -0,0 +1,16 @@
+import { OrderService, RequestContext, PermissionDefinition } from '@vendure/core';
+import { SendcloudService } from './sendcloud.service';
+import { SendcloudConfigEntity } from './sendcloud-config.entity';
+export declare const sendcloudPermission: PermissionDefinition;
+export declare class SendcloudResolver {
+    private service;
+    private orderService;
+    constructor(service: SendcloudService, orderService: OrderService);
+    sendToSendCloud(ctx: RequestContext, orderId: string): Promise<boolean>;
+    sendCloudConfig(ctx: RequestContext): Promise<SendcloudConfigEntity | null>;
+    updateSendCloudConfig(ctx: RequestContext, input: {
+        secret: string;
+        publicKey: string;
+        defaultPhoneNr: string;
+    }): Promise<SendcloudConfigEntity>;
+}