@pinelab/vendure-plugin-qls-fulfillment 1.0.0-beta.9 → 1.1.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
-# 1.0.0 (2025-11-07) ## CHANGE THIS DATE AND VERSION
+# 1.1.0 (2026-01-07)
+
+- Fix delivery options to be an array of objects with a tag property
+- Emit event for failed order push
+- Delay 10s before setting custom field `syncedToQls` to prevent race conditions.
+
+# 1.0.0 (2025-11-07)
 
 - Initial release

package/README.md

@@ -51,20 +51,57 @@ This plugin only uses Vendure's default stock location, that means you should ei
 
 Vendure assumes the first created stock location is the default stock location.
 
-## Monitoring
-
-Make sure to monitor failed jobs: A job that failed after its retries were exhausted, means:
-
-1. An order was not pushed to QLS
-2. A product was not synced to QLS
-
-Monitor your logs for the following text:
-
-- `QLS webhook error` - This means an incoming stock update webhook was not processed correctly.
-- `Error creating or updating variant` - This means a product was not synced to QLS.
-
-Make sure to filter by logger context `QlsPlugin`, to prevent false positive alerts.
-
-## Cancelling orders and manually pushing orders to QLS
-
-// TODO: Push will just create a new order in QLS, it will not cancel the existing order in QLS. Cancel existing order first via https://mijn.pakketdienstqls.nl/
+## Service Points
+
+You can use the query `qlsServicePoints(postalCode: String!): [QlsServicePoint!]!` to get the service points for a given postal code. You can use the `setOrderCustomFields` mutation to set the service point on an order.
+
+```graphql
+mutation {
+  setOrderCustomFields(
+    input: {
+      customFields: {
+        qlsServicePointId: "12232" # This is the ID of one of the points returned by the query above
+        qlsServicePointDetails: "Some details about the service point for admin users" # This is just for admin users in Vendure
+      }
+    }
+  ) {
+    __typename
+    ... on Order {
+      id
+      code
+      customFields {
+        qlsServicePointId
+        qlsServicePointDetails
+      }
+    }
+  }
+}
+```
+
+## Monitoring failed orders
+
+Whenever an order fails to be pushed to QLS, an event is emitted. You can listen to this event to monitor failed orders.
+
+```ts
+this.eventBus.ofType(QlsOrderFailedEvent).subscribe((event) => {
+  console.log('Order failed to be pushed to QLS:', event.order.code);
+});
+```
+
+Because a job can be retried, this event can be emitted multiple times for the same order. You can use the date field together with the order code to determine if you have already processed this event.
+
+```ts
+this.eventBus.ofType(QlsOrderFailedEvent).subscribe((event) => {
+  // Determine if we have already processed this event.
+  const uniqueEventId = `${event.order.code}_${
+    event.failedAt.toISOString().split('T')[0]
+  }`; // "JHD82JS8868_2026-01-01"
+  console.log('Order failed to be pushed to QLS:', event.order.code);
+});
+```
+
+## Manually pushing orders to QLS
+
+This plugin adds a button `push to QLS` to the order detail page in the Admin UI. This will push the order to QLS again. If the order has been pushed before, you need to uncheck the checkbox `synced to QLS` in the order custom fields first.
+
+Pushing an order to QLS again will not cancel the existing order in QLS. Cancel existing orders first via https://mijn.pakketdienstqls.nl/.

package/dist/api/api-extensions.d.ts

@@ -1 +1,2 @@
 export declare const adminApiExtensions: import("graphql").DocumentNode;
+export declare const shopApiExtensions: import("graphql").DocumentNode;

package/dist/api/api-extensions.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.adminApiExtensions = void 0;
+exports.shopApiExtensions = exports.adminApiExtensions = void 0;
 const graphql_tag_1 = __importDefault(require("graphql-tag"));
 exports.adminApiExtensions = (0, graphql_tag_1.default) `
   extend type Mutation {
@@ -18,3 +18,47 @@ exports.adminApiExtensions = (0, graphql_tag_1.default) `
     pushOrderToQls(orderId: ID!): String!
   }
 `;
+exports.shopApiExtensions = (0, graphql_tag_1.default) `
+  type QlsServicePoint {
+    servicepoint_code: String!
+    name: String!
+    address: QlsServicePointAddress!
+    geo: QlsServicePointGeo!
+    times: [QlsServicePointTime!]!
+    needsPostNumber: Boolean!
+    productId: Int!
+    productName: String!
+  }
+
+  type QlsServicePointAddress {
+    country: String!
+    postalcode: String!
+    locality: String!
+    street: String!
+    housenumber: String!
+  }
+
+  type QlsServicePointGeo {
+    lat: Float!
+    long: Float!
+  }
+
+  type QlsServicePointTime {
+    weekday: Int!
+    formatted: String!
+    from: String!
+    to: String!
+  }
+
+  input QlsServicePointSearchInput {
+    countryCode: String!
+    postalCode: String!
+  }
+
+  extend type Query {
+    """
+    Get the service points for a given postal code
+    """
+    qlsServicePoints(input: QlsServicePointSearchInput!): [QlsServicePoint!]!
+  }
+`;

package/dist/api/generated/graphql.d.ts

@@ -29,3 +29,46 @@ export type Mutation = {
 export type MutationPushOrderToQlsArgs = {
     orderId: Scalars['ID'];
 };
+export type QlsServicePoint = {
+    __typename?: 'QlsServicePoint';
+    address: QlsServicePointAddress;
+    geo: QlsServicePointGeo;
+    name: Scalars['String'];
+    needsPostNumber: Scalars['Boolean'];
+    productId: Scalars['Int'];
+    productName: Scalars['String'];
+    servicepoint_code: Scalars['String'];
+    times: Array<QlsServicePointTime>;
+};
+export type QlsServicePointAddress = {
+    __typename?: 'QlsServicePointAddress';
+    country: Scalars['String'];
+    housenumber: Scalars['String'];
+    locality: Scalars['String'];
+    postalcode: Scalars['String'];
+    street: Scalars['String'];
+};
+export type QlsServicePointGeo = {
+    __typename?: 'QlsServicePointGeo';
+    lat: Scalars['Float'];
+    long: Scalars['Float'];
+};
+export type QlsServicePointSearchInput = {
+    countryCode: Scalars['String'];
+    postalCode: Scalars['String'];
+};
+export type QlsServicePointTime = {
+    __typename?: 'QlsServicePointTime';
+    formatted: Scalars['String'];
+    from: Scalars['String'];
+    to: Scalars['String'];
+    weekday: Scalars['Int'];
+};
+export type Query = {
+    __typename?: 'Query';
+    /** Get the service points for a given postal code */
+    qlsServicePoints: Array<QlsServicePoint>;
+};
+export type QueryQlsServicePointsArgs = {
+    input: QlsServicePointSearchInput;
+};

package/dist/api/qls-admin.resolver.d.ts

@@ -3,9 +3,9 @@ import { QlsProductService } from '../services/qls-product.service';
 import { MutationPushOrderToQlsArgs } from './generated/graphql';
 import { QlsOrderService } from '../services/qls-order.service';
 export declare class QlsAdminResolver {
-    private qlsService;
+    private qlsProductService;
     private qlsOrderService;
-    constructor(qlsService: QlsProductService, qlsOrderService: QlsOrderService);
+    constructor(qlsProductService: QlsProductService, qlsOrderService: QlsOrderService);
     triggerQlsProductSync(ctx: RequestContext): Promise<boolean>;
     pushOrderToQls(ctx: RequestContext, input: MutationPushOrderToQlsArgs): Promise<string>;
 }

package/dist/api/qls-admin.resolver.js

@@ -19,12 +19,12 @@ const qls_product_service_1 = require("../services/qls-product.service");
 const qls_order_service_1 = require("../services/qls-order.service");
 const permissions_1 = require("../config/permissions");
 let QlsAdminResolver = class QlsAdminResolver {
-    constructor(qlsService, qlsOrderService) {
-        this.qlsService = qlsService;
+    constructor(qlsProductService, qlsOrderService) {
+        this.qlsProductService = qlsProductService;
         this.qlsOrderService = qlsOrderService;
     }
     async triggerQlsProductSync(ctx) {
-        await this.qlsService.triggerFullSync(ctx);
+        await this.qlsProductService.triggerFullSync(ctx);
         return true;
     }
     async pushOrderToQls(ctx, input) {

package/dist/api/qls-shop.resolver.d.ts

@@ -0,0 +1,8 @@
+import { RequestContext } from '@vendure/core';
+import { QlsOrderService } from '../services/qls-order.service';
+import { QlsServicePoint, QlsServicePointSearchInput } from './generated/graphql';
+export declare class QlsShopResolver {
+    private qlsOrderService;
+    constructor(qlsOrderService: QlsOrderService);
+    qlsServicePoints(ctx: RequestContext, input: QlsServicePointSearchInput): Promise<QlsServicePoint[]>;
+}

package/dist/api/qls-shop.resolver.js

@@ -0,0 +1,39 @@
+"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.QlsShopResolver = void 0;
+const graphql_1 = require("@nestjs/graphql");
+const core_1 = require("@vendure/core");
+const qls_order_service_1 = require("../services/qls-order.service");
+let QlsShopResolver = class QlsShopResolver {
+    constructor(qlsOrderService) {
+        this.qlsOrderService = qlsOrderService;
+    }
+    async qlsServicePoints(ctx, input) {
+        return await this.qlsOrderService.getServicePoints(ctx, input);
+    }
+};
+exports.QlsShopResolver = QlsShopResolver;
+__decorate([
+    (0, graphql_1.Query)(),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Args)('input')),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], QlsShopResolver.prototype, "qlsServicePoints", null);
+exports.QlsShopResolver = QlsShopResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [qls_order_service_1.QlsOrderService])
+], QlsShopResolver);

package/dist/api/qls-webhooks-controller.js

@@ -31,7 +31,8 @@ let QlsWebhooksController = class QlsWebhooksController {
      */
     async events(channelToken, webhookSecret, request, body) {
         if (webhookSecret !== this.options.webhookSecret) {
-            return core_1.Logger.warn(`Incoming webhook with invalid secret for channel '${channelToken}' to '${request.url}'`, constants_1.loggerCtx);
+            core_1.Logger.warn(`Incoming webhook with invalid secret for channel '${channelToken}' to '${request.url}'`, constants_1.loggerCtx);
+            throw new core_1.ForbiddenError();
         }
         try {
             const ctx = await this.getCtxForChannel(channelToken);

package/dist/custom-fields.d.ts

@@ -3,5 +3,11 @@ declare module '@vendure/core' {
     interface CustomProductVariantFields {
         qlsProductId?: string;
     }
+    interface CustomOrderFields {
+        qlsServicePointId?: string;
+        qlsServicePointDetails?: string;
+        syncedToQls?: boolean;
+    }
 }
 export declare const variantCustomFields: CustomFieldConfig[];
+export declare const orderCustomFields: CustomFieldConfig[];

package/dist/custom-fields.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.variantCustomFields = void 0;
+exports.orderCustomFields = exports.variantCustomFields = void 0;
 const core_1 = require("@vendure/core");
 exports.variantCustomFields = [
     {
@@ -13,3 +13,53 @@ exports.variantCustomFields = [
         ui: { tab: 'QLS' },
     },
 ];
+exports.orderCustomFields = [
+    {
+        name: 'qlsServicePointId',
+        type: 'string',
+        label: [{ value: 'QLS Service Point ID', languageCode: core_1.LanguageCode.en }],
+        nullable: true,
+        public: true,
+        readonly: false,
+        ui: { tab: 'QLS' },
+    },
+    {
+        name: 'syncedToQls',
+        type: 'boolean',
+        label: [
+            { value: 'Created in QLS', languageCode: core_1.LanguageCode.en },
+            { value: 'Aangemaakt in QLS', languageCode: core_1.LanguageCode.nl },
+        ],
+        description: [
+            {
+                value: 'Uncheck this to be able to push the order to QLS again',
+                languageCode: core_1.LanguageCode.en,
+            },
+            {
+                value: 'Vink dit uit om de order opnieuw naar QLS te sturen',
+                languageCode: core_1.LanguageCode.nl,
+            },
+        ],
+        nullable: true,
+        public: false,
+        readonly: false,
+        ui: { tab: 'QLS' },
+    },
+    {
+        name: 'qlsServicePointDetails',
+        type: 'string',
+        label: [
+            { value: 'QLS Service Point Details', languageCode: core_1.LanguageCode.en },
+        ],
+        description: [
+            {
+                value: 'Only used for display purposes.',
+                languageCode: core_1.LanguageCode.en,
+            },
+        ],
+        nullable: true,
+        public: true,
+        readonly: false,
+        ui: { tab: 'QLS' },
+    },
+];

package/dist/lib/client-types.d.ts

@@ -79,7 +79,9 @@ export interface FulfillmentOrderInput {
     receiver_contact: FulfillmentOrderReceiverContactInput;
     custom_values?: CustomValue[];
     products: FulfillmentOrderLineInput[];
-    delivery_options: string[];
+    delivery_options: {
+        tag: string;
+    }[];
 }
 export interface FulfillmentOrderReceiverContactInput {
     name: string;

package/dist/lib/qls-client.d.ts

@@ -1,6 +1,7 @@
 import { RequestContext } from '@vendure/core';
 import { QlsClientConfig, QlsPluginOptions } from '../types';
 import type { FulfillmentOrder, FulfillmentOrderInput, FulfillmentProduct, FulfillmentProductInput, QlsApiResponse } from './client-types';
+import { QlsServicePoint } from '../api/generated/graphql';
 export declare function getQlsClient(ctx: RequestContext, pluginOptions: QlsPluginOptions): Promise<QlsClient | undefined>;
 /**
  * Wrapper around the QLS Rest API.
@@ -20,7 +21,8 @@ export declare class QlsClient {
      */
     getAllFulfillmentProducts(): Promise<FulfillmentProduct[]>;
     createFulfillmentProduct(data: FulfillmentProductInput): Promise<FulfillmentProduct>;
-    updateFulfillmentProduct(fulfillmentProductId: string, data: FulfillmentProductInput): Promise<FulfillmentProduct>;
+    updateFulfillmentProduct(fulfillmentProductId: string, data: FulfillmentProductInput): Promise<void>;
+    deleteFulfillmentProduct(fulfillmentProductId: string): Promise<void>;
     createFulfillmentOrder(data: Omit<FulfillmentOrderInput, 'brand_id'>): Promise<FulfillmentOrder>;
     /**
      * Add an extra barcode to a fulfillment product in QLS
@@ -30,5 +32,6 @@ export declare class QlsClient {
      * Add an extra barcode to a fulfillment product in QLS
      */
     removeBarcode(productId: string, barcodeId: number): Promise<void>;
-    rawRequest<T>(method: 'POST' | 'GET' | 'PUT' | 'DELETE', action: string, data?: unknown): Promise<QlsApiResponse<T>>;
+    getServicePoints(countryCode: string, postalCode: string): Promise<QlsServicePoint[]>;
+    rawRequest<T>(method: 'POST' | 'GET' | 'PUT' | 'DELETE', action: string, data?: unknown): Promise<QlsApiResponse<T | undefined>>;
 }

package/dist/lib/qls-client.js

@@ -26,7 +26,7 @@ class QlsClient {
      */
     async getFulfillmentProductBySku(sku) {
         const result = await this.rawRequest('GET', `fulfillment/products?filter%5Bsku%5D=${encodeURIComponent(sku)}`);
-        if (result.data.length === 0) {
+        if (!result.data || result.data.length === 0) {
             return undefined;
         }
         if (result.data.length > 1) {
@@ -57,17 +57,25 @@ class QlsClient {
     }
     async createFulfillmentProduct(data) {
         const response = await this.rawRequest('POST', 'fulfillment/products', data);
+        if (!response.data) {
+            throw new Error('Failed to create fulfillment product. Got empty response.');
+        }
         return response.data;
     }
     async updateFulfillmentProduct(fulfillmentProductId, data) {
-        const response = await this.rawRequest('PUT', `fulfillment/products/${fulfillmentProductId}`, data);
-        return response.data;
+        await this.rawRequest('PUT', `fulfillment/products/${fulfillmentProductId}`, data);
+    }
+    async deleteFulfillmentProduct(fulfillmentProductId) {
+        await this.rawRequest('DELETE', `fulfillment/products/${fulfillmentProductId}`);
     }
     async createFulfillmentOrder(data) {
         const response = await this.rawRequest('POST', 'fulfillment/orders', {
             ...data,
             brand_id: this.config.brandId,
         });
+        if (!response.data) {
+            throw new Error('Failed to create fulfillment order. Got empty response.');
+        }
         return response.data;
     }
     /**
@@ -84,6 +92,11 @@ class QlsClient {
     async removeBarcode(productId, barcodeId) {
         await this.rawRequest('DELETE', `fulfillment/products/${productId}/barcodes/${barcodeId}`);
     }
+    async getServicePoints(countryCode, postalCode) {
+        countryCode = countryCode.toUpperCase();
+        const result = await this.rawRequest('GET', `service-points/${countryCode}/${postalCode}`);
+        return result.data ?? [];
+    }
     async rawRequest(method, action, data) {
         // Set headers
         const headers = {
@@ -98,10 +111,19 @@ class QlsClient {
             headers,
             body,
         });
+        if (response.status === 204) {
+            // 204 No Content
+            return {
+                data: undefined,
+                meta: {
+                    code: response.status,
+                },
+            };
+        }
         if (!response.ok) {
             const errorText = await response.text();
             // Log error including the request body
-            core_1.Logger.error(`QLS request to '${url}' failed: ${response.status} ${response.statusText} - ${errorText}`, constants_1.loggerCtx, data ? JSON.stringify(data, null, 2) : undefined);
+            core_1.Logger.error(`[QLS] '${method}' request to '${url}' failed: ${response.status} ${response.statusText} - ${errorText}`, constants_1.loggerCtx, data ? JSON.stringify(data, null, 2) : undefined);
             throw new Error(errorText);
         }
         const contentType = response.headers.get('content-type') ?? '';

package/dist/qls-plugin.js

@@ -15,6 +15,7 @@ const core_1 = require("@vendure/core");
 const path_1 = __importDefault(require("path"));
 const api_extensions_1 = require("./api/api-extensions");
 const qls_admin_resolver_1 = require("./api/qls-admin.resolver");
+const qls_shop_resolver_1 = require("./api/qls-shop.resolver");
 const qls_webhooks_controller_1 = require("./api/qls-webhooks-controller");
 const permissions_1 = require("./config/permissions");
 const constants_1 = require("./constants");
@@ -23,7 +24,11 @@ const qls_order_service_1 = require("./services/qls-order.service");
 const qls_product_service_1 = require("./services/qls-product.service");
 let QlsPlugin = QlsPlugin_1 = class QlsPlugin {
     static init(options) {
-        this.options = options;
+        this.options = {
+            synchronizeStockLevels: true,
+            autoPushOrders: true,
+            ...options,
+        };
         return QlsPlugin_1;
     }
 };
@@ -49,6 +54,7 @@ exports.QlsPlugin = QlsPlugin = QlsPlugin_1 = __decorate([
             config.authOptions.customPermissions.push(permissions_1.qlsFullSyncPermission);
             config.authOptions.customPermissions.push(permissions_1.qlsPushOrderPermission);
             config.customFields.ProductVariant.push(...custom_fields_1.variantCustomFields);
+            config.customFields.Order.push(...custom_fields_1.orderCustomFields);
             return config;
         },
         compatibility: '>=3.2.0',
@@ -56,5 +62,9 @@ exports.QlsPlugin = QlsPlugin = QlsPlugin_1 = __decorate([
             schema: api_extensions_1.adminApiExtensions,
             resolvers: [qls_admin_resolver_1.QlsAdminResolver],
         },
+        shopApiExtensions: {
+            schema: api_extensions_1.shopApiExtensions,
+            resolvers: [qls_shop_resolver_1.QlsShopResolver],
+        },
     })
 ], QlsPlugin);

package/dist/services/qls-order-failed-event.d.ts

@@ -0,0 +1,35 @@
+import { Order, RequestContext, VendureEvent } from '@vendure/core';
+export declare enum QLSOrderError {
+    INCORRECT_POSTAL_CODE = "INCORRECT_POSTAL_CODE",
+    INCORRECT_HOUSE_NUMBER = "INCORRECT_HOUSE_NUMBER",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+/**
+ * This event is emitted when an order fails to be pushed to QLS.
+ */
+export declare class QlsOrderFailedEvent extends VendureEvent {
+    ctx: RequestContext;
+    order: Order;
+    /**
+     * The date and time the order failed to be pushed to QLS.
+     */
+    failedAt: Date;
+    /**
+     * The full error response JSON from QLS.
+     */
+    fullError: unknown;
+    /**
+     * The error code that caused the order to fail to be pushed to QLS.
+     */
+    errorCode: QLSOrderError;
+    constructor(ctx: RequestContext, order: Order, 
+    /**
+     * The date and time the order failed to be pushed to QLS.
+     */
+    failedAt: Date, 
+    /**
+     * The full error response JSON from QLS.
+     */
+    fullError: unknown);
+}
+export declare function getQLSErrorCode(errorResponse: unknown): QLSOrderError;

package/dist/services/qls-order-failed-event.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QlsOrderFailedEvent = exports.QLSOrderError = void 0;
+exports.getQLSErrorCode = getQLSErrorCode;
+const core_1 = require("@vendure/core");
+var QLSOrderError;
+(function (QLSOrderError) {
+    QLSOrderError["INCORRECT_POSTAL_CODE"] = "INCORRECT_POSTAL_CODE";
+    QLSOrderError["INCORRECT_HOUSE_NUMBER"] = "INCORRECT_HOUSE_NUMBER";
+    QLSOrderError["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(QLSOrderError || (exports.QLSOrderError = QLSOrderError = {}));
+/**
+ * This event is emitted when an order fails to be pushed to QLS.
+ */
+class QlsOrderFailedEvent extends core_1.VendureEvent {
+    constructor(ctx, order, 
+    /**
+     * The date and time the order failed to be pushed to QLS.
+     */
+    failedAt, 
+    /**
+     * The full error response JSON from QLS.
+     */
+    fullError) {
+        super();
+        this.ctx = ctx;
+        this.order = order;
+        this.failedAt = failedAt;
+        this.fullError = fullError;
+        this.errorCode = getQLSErrorCode(fullError);
+    }
+}
+exports.QlsOrderFailedEvent = QlsOrderFailedEvent;
+function getQLSErrorCode(errorResponse) {
+    const errorString = JSON.stringify(errorResponse);
+    if (errorString.includes('containsNumber')) {
+        return QLSOrderError.INCORRECT_HOUSE_NUMBER;
+    }
+    if (errorString.includes('validPostalCode') ||
+        errorString.includes('needPostalCodeVerification')) {
+        return QLSOrderError.INCORRECT_POSTAL_CODE;
+    }
+    return QLSOrderError.UNKNOWN_ERROR;
+}

package/dist/services/qls-order-failed-event.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/qls-order-failed-event.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const qls_order_failed_event_1 = require("./qls-order-failed-event");
+(0, vitest_1.describe)('QlsOrderFailedEvent', () => {
+    const mockCtx = {};
+    const mockOrder = { id: 1, code: 'ORDER-001' };
+    const mockFailedAt = new Date('2026-01-03T04:34:52.473Z');
+    (0, vitest_1.it)('sets errorCode to INCORRECT_HOUSE_NUMBER for containsNumber error', () => {
+        const fullError = {
+            errors: {
+                receiver_contact: {
+                    housenumber: { containsNumber: 'Huisnummer bevat geen nummer' },
+                },
+            },
+            pagination: null,
+        };
+        const event = new qls_order_failed_event_1.QlsOrderFailedEvent(mockCtx, mockOrder, mockFailedAt, fullError);
+        (0, vitest_1.expect)(event.errorCode).toBe(qls_order_failed_event_1.QLSOrderError.INCORRECT_HOUSE_NUMBER);
+        (0, vitest_1.expect)(event.ctx).toBe(mockCtx);
+        (0, vitest_1.expect)(event.order).toBe(mockOrder);
+        (0, vitest_1.expect)(event.failedAt).toBe(mockFailedAt);
+        (0, vitest_1.expect)(event.fullError).toBe(fullError);
+    });
+    (0, vitest_1.it)('sets errorCode to INCORRECT_POSTAL_CODE for validPostalCode error', () => {
+        const fullError = {
+            errors: {
+                receiver_contact: {
+                    postalcode: { validPostalCode: 'Ongeldige indeling (NNNN)' },
+                },
+            },
+            pagination: null,
+        };
+        const event = new qls_order_failed_event_1.QlsOrderFailedEvent(mockCtx, mockOrder, mockFailedAt, fullError);
+        (0, vitest_1.expect)(event.errorCode).toBe(qls_order_failed_event_1.QLSOrderError.INCORRECT_POSTAL_CODE);
+    });
+    (0, vitest_1.it)('sets errorCode to INCORRECT_POSTAL_CODE for needPostalCodeVerification error', () => {
+        const fullError = {
+            errors: {
+                receiver_contact: {
+                    postalcode: { needPostalCodeVerification: 'Ongeldige postcode' },
+                },
+            },
+            pagination: null,
+        };
+        const event = new qls_order_failed_event_1.QlsOrderFailedEvent(mockCtx, mockOrder, mockFailedAt, fullError);
+        (0, vitest_1.expect)(event.errorCode).toBe(qls_order_failed_event_1.QLSOrderError.INCORRECT_POSTAL_CODE);
+    });
+    (0, vitest_1.it)('sets errorCode to INCORRECT_POSTAL_CODE for combined postal code errors', () => {
+        const fullError = {
+            errors: {
+                receiver_contact: {
+                    postalcode: {
+                        needPostalCodeVerification: 'Ongeldige postcode',
+                        validPostalCode: 'Ongeldige indeling (NNNN LL)',
+                    },
+                },
+            },
+            pagination: null,
+        };
+        const event = new qls_order_failed_event_1.QlsOrderFailedEvent(mockCtx, mockOrder, mockFailedAt, fullError);
+        (0, vitest_1.expect)(event.errorCode).toBe(qls_order_failed_event_1.QLSOrderError.INCORRECT_POSTAL_CODE);
+    });
+    (0, vitest_1.it)('sets errorCode to UNKNOWN_ERROR for 502 Bad Gateway HTML response', () => {
+        const fullError = {
+            html: '<html> <head><title>502 Bad Gateway</title></head> <body> <center><h1>502 Bad Gateway</h1></center> <hr><center>nginx</center> </body> </html>',
+        };
+        const event = new qls_order_failed_event_1.QlsOrderFailedEvent(mockCtx, mockOrder, mockFailedAt, fullError);
+        (0, vitest_1.expect)(event.errorCode).toBe(qls_order_failed_event_1.QLSOrderError.UNKNOWN_ERROR);
+    });
+    (0, vitest_1.it)('sets errorCode to UNKNOWN_ERROR for unknown error format', () => {
+        const fullError = {
+            meta: { code: 500 },
+            errors: { unknown: 'Some other error' },
+        };
+        const event = new qls_order_failed_event_1.QlsOrderFailedEvent(mockCtx, mockOrder, mockFailedAt, fullError);
+        (0, vitest_1.expect)(event.errorCode).toBe(qls_order_failed_event_1.QLSOrderError.UNKNOWN_ERROR);
+    });
+});

package/dist/services/qls-order.service.d.ts

@@ -1,17 +1,17 @@
 import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { EventBus, ID, Job, JobQueueService, OrderService, RequestContext, TransactionalConnection } from '@vendure/core';
+import { EventBus, ID, Job, JobQueueService, OrderService, RequestContext } from '@vendure/core';
+import { QlsServicePoint, QlsServicePointSearchInput } from '../api/generated/graphql';
 import { IncomingOrderWebhook } from '../lib/client-types';
 import { QlsOrderJobData, QlsPluginOptions } from '../types';
 export declare class QlsOrderService implements OnModuleInit, OnApplicationBootstrap {
-    private connection;
     private options;
     private jobQueueService;
     private eventBus;
     private orderService;
     private moduleRef;
     private orderJobQueue;
-    constructor(connection: TransactionalConnection, options: QlsPluginOptions, jobQueueService: JobQueueService, eventBus: EventBus, orderService: OrderService, moduleRef: ModuleRef);
+    constructor(options: QlsPluginOptions, jobQueueService: JobQueueService, eventBus: EventBus, orderService: OrderService, moduleRef: ModuleRef);
     onApplicationBootstrap(): void;
     onModuleInit(): Promise<void>;
     /**
@@ -19,11 +19,16 @@ export declare class QlsOrderService implements OnModuleInit, OnApplicationBoots
      * Returns the result of the job, which will be stored in the job record.
      */
     handleOrderJob(job: Job<QlsOrderJobData>): Promise<unknown>;
+    /**
+     * Push an order to QLS by id.
+     * Returns a human-readable message describing the result of the operation (Used as job result).
+     */
     pushOrderToQls(ctx: RequestContext, orderId: ID): Promise<string>;
     /**
      * Update the status of an order in QLS based on the given order code and status
      */
     handleOrderStatusUpdate(ctx: RequestContext, body: IncomingOrderWebhook): Promise<void>;
     triggerPushOrder(ctx: RequestContext, orderId: ID, orderCode?: string): Promise<Job<QlsOrderJobData> | undefined>;
+    getServicePoints(ctx: RequestContext, input: QlsServicePointSearchInput): Promise<QlsServicePoint[]>;
     private getVendureOrderState;
 }

package/dist/services/qls-order.service.js

@@ -23,9 +23,9 @@ const catch_unknown_1 = require("catch-unknown");
 const util_1 = __importDefault(require("util"));
 const constants_1 = require("../constants");
 const qls_client_1 = require("../lib/qls-client");
+const qls_order_failed_event_1 = require("./qls-order-failed-event");
 let QlsOrderService = class QlsOrderService {
-    constructor(connection, options, jobQueueService, eventBus, orderService, moduleRef) {
-        this.connection = connection;
+    constructor(options, jobQueueService, eventBus, orderService, moduleRef) {
         this.options = options;
         this.jobQueueService = jobQueueService;
         this.eventBus = eventBus;
@@ -35,6 +35,10 @@ let QlsOrderService = class QlsOrderService {
     onApplicationBootstrap() {
         // Listen for OrderPlacedEvent and add a job to the queue
         this.eventBus.ofType(core_2.OrderPlacedEvent).subscribe((event) => {
+            if (!this.options.autoPushOrders) {
+                core_2.Logger.info(`Auto push orders disabled, not triggering push order job for order ${event.order.code}`, constants_1.loggerCtx);
+                return;
+            }
             this.triggerPushOrder(event.ctx, event.order.id, event.order.code).catch((e) => {
                 const error = (0, catch_unknown_1.asError)(e);
                 core_2.Logger.error(`Failed to trigger push order job for order ${event.order.code}: ${error.message}`, constants_1.loggerCtx, error.stack);
@@ -72,6 +76,10 @@ let QlsOrderService = class QlsOrderService {
             throw error;
         }
     }
+    /**
+     * Push an order to QLS by id.
+     * Returns a human-readable message describing the result of the operation (Used as job result).
+     */
     async pushOrderToQls(ctx, orderId) {
         const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
         if (!client) {
@@ -82,18 +90,33 @@ let QlsOrderService = class QlsOrderService {
         if (!order) {
             throw new Error(`No order with id ${orderId} not found`);
         }
+        if (order.customFields.syncedToQls) {
+            throw new core_2.UserInputError(`Order '${order.code}' has already been synced to QLS`);
+        }
         try {
-            // Check if all products are available in QLS
-            const qlsProducts = order.lines.map((line) => {
+            // Map variants to QLS products
+            const qlsProducts = [];
+            await Promise.all(order.lines.map(async (line) => {
+                // Check if product variant should be excluded from sync
+                if (await this.options.excludeVariantFromSync?.(ctx, new core_2.Injector(this.moduleRef), line.productVariant)) {
+                    core_2.Logger.info(`Product variant '${line.productVariant.sku}' not sent to QLS in order '${order.code}' because it is excluded from sync.`, constants_1.loggerCtx);
+                    return;
+                }
+                // Check if product is available in QLS
                 if (!line.productVariant.customFields.qlsProductId) {
                     throw new Error(`Product variant '${line.productVariant.sku}' does not have a QLS product ID set. Unable to push order '${order.code}' to QLS.`);
                 }
-                return {
+                qlsProducts.push({
                     amount_ordered: line.quantity,
                     product_id: line.productVariant.customFields.qlsProductId,
                     name: line.productVariant.name,
-                };
-            });
+                });
+            }));
+            if (qlsProducts.length === 0) {
+                const message = `No products to push to QLS for order '${order.code}'. Ignoring order.`;
+                core_2.Logger.info(message, constants_1.loggerCtx);
+                return message;
+            }
             const additionalOrderFields = await this.options.getAdditionalOrderFields?.(ctx, new core_2.Injector(this.moduleRef), order);
             const customerName = [order.customer?.firstName, order.customer?.lastName]
                 .filter(Boolean)
@@ -112,15 +135,17 @@ let QlsOrderService = class QlsOrderService {
                 !order.shippingAddress.countryCode) {
                 throw new Error(`Shipping address for order '${order.code}' is missing one of required fields: streetLine1, postalCode, city, streetLine2, countryCode. Can not push order to QLS.`);
             }
+            const processable = (await this.options.processOrderFrom?.(ctx, order)) ?? new Date();
+            const receiverContact = this.options.getReceiverContact?.(ctx, order);
             const qlsOrder = {
                 customer_reference: order.code,
-                processable: new Date().toISOString(), // Processable starting now
-                servicepoint_code: additionalOrderFields?.servicepoint_code,
+                processable: processable.toISOString(),
+                servicepoint_code: order.customFields?.qlsServicePointId,
                 delivery_options: additionalOrderFields?.delivery_options ?? [],
                 total_price: order.totalWithTax,
-                receiver_contact: {
+                receiver_contact: receiverContact ?? {
                     name: order.shippingAddress.fullName || customerName,
-                    companyname: order.shippingAddress.company,
+                    companyname: order.shippingAddress.company ?? '',
                     street: order.shippingAddress.streetLine1,
                     housenumber: order.shippingAddress.streetLine2,
                     postalcode: order.shippingAddress.postalCode,
@@ -133,11 +158,23 @@ let QlsOrderService = class QlsOrderService {
                 ...(additionalOrderFields ?? {}),
             };
             const result = await client.createFulfillmentOrder(qlsOrder);
+            core_2.Logger.info(`Successfully created order '${order.code}' in QLS with id '${result.id}'`, constants_1.loggerCtx);
             await this.orderService.addNoteToOrder(ctx, {
                 id: orderId,
                 isPublic: false,
                 note: `Created order '${result.id}' in QLS`,
             });
+            // Delay 10s to prevent race conditions: OrderPlacedEvent is emitted before transition to PaymentSettled is complete
+            setTimeout(() => {
+                this.orderService
+                    .updateCustomFields(ctx, orderId, {
+                    syncedToQls: true,
+                })
+                    .catch((e) => {
+                    const error = (0, catch_unknown_1.asError)(e);
+                    core_2.Logger.error(`Error updating custom field 'syncedToQls: true' for order '${order.code}': ${error.message}`, constants_1.loggerCtx, error.stack);
+                });
+            }, 10000);
             return `Order '${order.code}' created in QLS with id '${result.id}'`;
         }
         catch (e) {
@@ -147,6 +184,7 @@ let QlsOrderService = class QlsOrderService {
                 isPublic: false,
                 note: `Failed to create order '${order.code}' in QLS: ${error.message}`,
             });
+            await this.eventBus.publish(new qls_order_failed_event_1.QlsOrderFailedEvent(ctx, order, new Date(), error.message));
             throw error;
         }
     }
@@ -154,6 +192,7 @@ let QlsOrderService = class QlsOrderService {
      * Update the status of an order in QLS based on the given order code and status
      */
     async handleOrderStatusUpdate(ctx, body) {
+        core_2.Logger.info(`Handling QLS order status update for order '${body.customer_reference}' with status '${body.status} and amount_delivered '${body.amount_delivered}' and amount_total '${body.amount_total}'`, constants_1.loggerCtx);
         const orderCode = body.customer_reference;
         const order = await this.orderService.findOneByCode(ctx, orderCode, []);
         if (!order) {
@@ -182,7 +221,14 @@ let QlsOrderService = class QlsOrderService {
             action: 'push-order',
             ctx: ctx.serialize(),
             orderId,
-        }, { retries: 5 });
+        }, { retries: 3 });
+    }
+    async getServicePoints(ctx, input) {
+        const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
+        if (!client) {
+            throw new core_2.UserInputError(`QLS not enabled for channel ${ctx.channel.token}`);
+        }
+        return await client.getServicePoints(input.countryCode, input.postalCode);
     }
     getVendureOrderState(body) {
         if (body.cancelled) {
@@ -202,8 +248,8 @@ let QlsOrderService = class QlsOrderService {
 exports.QlsOrderService = QlsOrderService;
 exports.QlsOrderService = QlsOrderService = __decorate([
     (0, common_1.Injectable)(),
-    __param(1, (0, common_1.Inject)(constants_1.PLUGIN_INIT_OPTIONS)),
-    __metadata("design:paramtypes", [core_2.TransactionalConnection, Object, core_2.JobQueueService,
+    __param(0, (0, common_1.Inject)(constants_1.PLUGIN_INIT_OPTIONS)),
+    __metadata("design:paramtypes", [Object, core_2.JobQueueService,
         core_2.EventBus,
         core_2.OrderService,
         core_1.ModuleRef])

package/dist/services/qls-product.service.d.ts

@@ -3,11 +3,12 @@ import { EventBus, ID, Job, JobQueueService, ListQueryBuilder, ProductPriceAppli
 import { FulfillmentProduct } from '../lib/client-types';
 import { QlsClient } from '../lib/qls-client';
 import { QlsPluginOptions, QlsProductJobData } from '../types';
-type SyncProductsJobResult = {
-    updatedInQls: number;
-    createdInQls: number;
-    updatedStock: number;
-    failed: number;
+import { ModuleRef } from '@nestjs/core';
+type SyncProductsResult = {
+    updatedInQls: Partial<ProductVariant>[];
+    createdInQls: Partial<ProductVariant>[];
+    updatedStock: Partial<ProductVariant>[];
+    failed: Partial<ProductVariant>[];
 };
 export declare class QlsProductService implements OnModuleInit, OnApplicationBootstrap {
     private connection;
@@ -19,8 +20,9 @@ export declare class QlsProductService implements OnModuleInit, OnApplicationBoo
     private readonly eventBus;
     private readonly listQueryBuilder;
     private readonly productPriceApplicator;
+    private readonly moduleRef;
     private productJobQueue;
-    constructor(connection: TransactionalConnection, options: QlsPluginOptions, jobQueueService: JobQueueService, stockLevelService: StockLevelService, variantService: ProductVariantService, stockLocationService: StockLocationService, eventBus: EventBus, listQueryBuilder: ListQueryBuilder, productPriceApplicator: ProductPriceApplicator);
+    constructor(connection: TransactionalConnection, options: QlsPluginOptions, jobQueueService: JobQueueService, stockLevelService: StockLevelService, variantService: ProductVariantService, stockLocationService: StockLocationService, eventBus: EventBus, listQueryBuilder: ListQueryBuilder, productPriceApplicator: ProductPriceApplicator, moduleRef: ModuleRef);
     onApplicationBootstrap(): void;
     onModuleInit(): Promise<void>;
     /**
@@ -35,11 +37,16 @@ export declare class QlsProductService implements OnModuleInit, OnApplicationBoo
      * 3. Creates products in QLS if needed
      * 4. Updates products in QLS if needed
      */
-    runFullSync(ctx: RequestContext): Promise<SyncProductsJobResult>;
+    runFullSync(ctx: RequestContext): Promise<SyncProductsResult>;
+    /**
+     * Utility function to remove all products from QLS.
+     * You might need to cancel active orders in QLS first, because products cannot be deleted if they are in an active order.
+     */
+    removeAllProductsFromQls(ctx: RequestContext): Promise<void>;
     /**
      * Creates or updates the fulfillment products in QLS for the given product variants.
      */
-    syncVariants(ctx: RequestContext, productVariantIds: ID[]): Promise<SyncProductsJobResult>;
+    syncVariants(ctx: RequestContext, productVariantIds: ID[]): Promise<SyncProductsResult>;
     /**
      * Trigger a full product sync job
      */

package/dist/services/qls-product.service.js

@@ -24,8 +24,11 @@ const util_1 = __importDefault(require("util"));
 const constants_1 = require("../constants");
 const qls_client_1 = require("../lib/qls-client");
 const util_2 = require("./util");
+const core_2 = require("@nestjs/core");
+// Wait for 700ms to avoid rate limit of 500/5 minutes
+const waitToPreventRateLimit = () => new Promise((resolve) => setTimeout(resolve, 700));
 let QlsProductService = class QlsProductService {
-    constructor(connection, options, jobQueueService, stockLevelService, variantService, stockLocationService, eventBus, listQueryBuilder, productPriceApplicator) {
+    constructor(connection, options, jobQueueService, stockLevelService, variantService, stockLocationService, eventBus, listQueryBuilder, productPriceApplicator, moduleRef) {
         this.connection = connection;
         this.options = options;
         this.jobQueueService = jobQueueService;
@@ -35,6 +38,7 @@ let QlsProductService = class QlsProductService {
         this.eventBus = eventBus;
         this.listQueryBuilder = listQueryBuilder;
         this.productPriceApplicator = productPriceApplicator;
+        this.moduleRef = moduleRef;
     }
     onApplicationBootstrap() {
         // Listen for ProductVariantEvent and add a job to the queue
@@ -64,7 +68,13 @@ let QlsProductService = class QlsProductService {
         try {
             const ctx = core_1.RequestContext.deserialize(job.data.ctx);
             if (job.data.action === 'full-sync-products') {
-                return await this.runFullSync(ctx);
+                const result = await this.runFullSync(ctx);
+                return {
+                    updatedInQls: result.updatedInQls.length,
+                    createdInQls: result.createdInQls.length,
+                    updatedStock: result.updatedStock.length,
+                    failed: result.failed.length,
+                };
             }
             else if (job.data.action === 'sync-products') {
                 return await this.syncVariants(ctx, job.data.productVariantIds);
@@ -99,45 +109,49 @@ let QlsProductService = class QlsProductService {
             const allVariants = await this.getAllVariants(ctx);
             core_1.Logger.info(`Running full sync for ${allQlsProducts.length} QLS products and ${allVariants.length} Vendure variants`, constants_1.loggerCtx);
             // Update stock in Vendure based on QLS products
-            let updateStockCount = 0;
+            const updatedStock = [];
             for (const variant of allVariants) {
                 const qlsProduct = allQlsProducts.find((p) => p.sku == variant.sku);
                 if (qlsProduct) {
                     await this.updateStock(ctx, variant.id, qlsProduct.amount_available);
-                    updateStockCount += 1;
+                    updatedStock.push(variant);
                 }
             }
-            core_1.Logger.info(`Updated stock for ${updateStockCount} variants based on QLS stock levels`, constants_1.loggerCtx);
+            core_1.Logger.info(`Updated stock for ${updatedStock.length} variants based on QLS stock levels`, constants_1.loggerCtx);
             // Create or update products in QLS
-            let createdQlsProductsCount = 0;
-            let updatedQlsProductsCount = 0;
-            let failedCount = 0;
+            const createdQlsProducts = [];
+            const updatedQlsProducts = [];
+            const failed = [];
             for (const variant of allVariants) {
                 try {
                     const existingQlsProduct = allQlsProducts.find((p) => p.sku == variant.sku);
                     const result = await this.createOrUpdateProductInQls(ctx, client, variant, existingQlsProduct ?? null);
                     if (result === 'created') {
-                        createdQlsProductsCount += 1;
+                        createdQlsProducts.push(variant);
                     }
                     else if (result === 'updated') {
-                        updatedQlsProductsCount += 1;
+                        updatedQlsProducts.push(variant);
+                    }
+                    if (result === 'created' || result === 'updated') {
+                        // Wait only if we created or updated a product, otherwise no calls have been made yet.
+                        await waitToPreventRateLimit();
                     }
                 }
                 catch (e) {
                     const error = (0, catch_unknown_1.asError)(e);
                     core_1.Logger.error(`Error creating or updating variant '${variant.sku}' in QLS: ${error.message}`, constants_1.loggerCtx, error.stack);
-                    failedCount += 1;
+                    failed.push(variant);
+                    await waitToPreventRateLimit();
                 }
-                await new Promise((resolve) => setTimeout(resolve, 700)); // Avoid rate limit of 500/5 minutes (700ms delay = 85/minute)
             }
-            core_1.Logger.info(`Created ${createdQlsProductsCount} products in QLS`, constants_1.loggerCtx);
-            core_1.Logger.info(`Updated ${updatedQlsProductsCount} products in QLS`, constants_1.loggerCtx);
-            core_1.Logger.info(`Finished full sync with ${failedCount} failures`, constants_1.loggerCtx);
+            core_1.Logger.info(`Created ${createdQlsProducts.length} products in QLS`, constants_1.loggerCtx);
+            core_1.Logger.info(`Updated ${updatedQlsProducts.length} products in QLS`, constants_1.loggerCtx);
+            core_1.Logger.info(`Finished full sync with ${failed.length} failures`, constants_1.loggerCtx);
             return {
-                updatedInQls: updatedQlsProductsCount,
-                createdInQls: createdQlsProductsCount,
-                updatedStock: updateStockCount,
-                failed: failedCount,
+                updatedInQls: updatedQlsProducts,
+                createdInQls: createdQlsProducts,
+                updatedStock,
+                failed,
             };
         }
         catch (e) {
@@ -146,6 +160,24 @@ let QlsProductService = class QlsProductService {
             throw error;
         }
     }
+    /**
+     * Utility function to remove all products from QLS.
+     * You might need to cancel active orders in QLS first, because products cannot be deleted if they are in an active order.
+     */
+    async removeAllProductsFromQls(ctx) {
+        const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
+        if (!client) {
+            throw new Error(`QLS not enabled for channel ${ctx.channel.token}`);
+        }
+        core_1.Logger.warn(`Removing all products from QLS for channel ${ctx.channel.token}...`, constants_1.loggerCtx);
+        const allProducts = await client.getAllFulfillmentProducts();
+        for (const product of allProducts) {
+            await client.deleteFulfillmentProduct(product.id);
+            core_1.Logger.info(`Removed product '${product.sku}' (${product.id}) from QLS`, constants_1.loggerCtx);
+            await waitToPreventRateLimit();
+        }
+        core_1.Logger.warn(`Removed ${allProducts.length} products from QLS for channel ${ctx.channel.token}`, constants_1.loggerCtx);
+    }
     /**
      * Creates or updates the fulfillment products in QLS for the given product variants.
      */
@@ -154,15 +186,15 @@ let QlsProductService = class QlsProductService {
         if (!client) {
             core_1.Logger.debug(`QLS not enabled for channel ${ctx.channel.token}. Not handling product update/create.`, constants_1.loggerCtx);
             return {
-                updatedInQls: 0,
-                createdInQls: 0,
-                updatedStock: 0,
-                failed: 0,
+                updatedInQls: [],
+                createdInQls: [],
+                updatedStock: [],
+                failed: [],
             };
         }
-        let updatedInQls = 0;
-        let createdInQls = 0;
-        let failedCount = 0;
+        const updatedInQls = [];
+        const createdInQls = [];
+        const failed = [];
         for (const variantId of productVariantIds) {
             try {
                 const variant = await this.variantService.findOne(ctx, variantId, [
@@ -178,23 +210,23 @@ let QlsProductService = class QlsProductService {
                 const existingQlsProduct = await client.getFulfillmentProductBySku(variant.sku);
                 const result = await this.createOrUpdateProductInQls(ctx, client, variant, existingQlsProduct ?? null);
                 if (result === 'created') {
-                    createdInQls += 1;
+                    createdInQls.push(variant);
                 }
                 else if (result === 'updated') {
-                    updatedInQls += 1;
+                    updatedInQls.push(variant);
                 }
             }
             catch (e) {
                 const error = (0, catch_unknown_1.asError)(e);
                 core_1.Logger.error(`Error syncing variant ${variantId} to QLS: ${error.message}`, constants_1.loggerCtx, error.stack);
-                failedCount += 1;
+                failed.push({ id: variantId });
             }
         }
         return {
             updatedInQls,
             createdInQls,
-            updatedStock: 0,
-            failed: failedCount,
+            updatedStock: [],
+            failed,
         };
     }
     /**
@@ -219,7 +251,7 @@ let QlsProductService = class QlsProductService {
             action: 'sync-products',
             ctx: ctx.serialize(),
             productVariantIds,
-        }, { retries: 5 });
+        }, { retries: 1 });
     }
     /**
      * Update the stock level for a variant based on the given available stock
@@ -241,6 +273,10 @@ let QlsProductService = class QlsProductService {
      * Determines if a product needs to be created or updated in QLS based on the given variant and existing QLS product.
      */
     async createOrUpdateProductInQls(ctx, client, variant, existingProduct) {
+        if (await this.options.excludeVariantFromSync?.(ctx, new core_1.Injector(this.moduleRef), variant)) {
+            core_1.Logger.info(`Variant '${variant.sku}' excluded from sync to QLS.`, constants_1.loggerCtx);
+            return 'not-changed';
+        }
         let qlsProduct = existingProduct;
         let createdOrUpdated = 'not-changed';
         const { additionalEANs, ...additionalVariantFields } = this.options.getAdditionalVariantFields(ctx, variant);
@@ -292,7 +328,9 @@ let QlsProductService = class QlsProductService {
             existingEans: existingAdditionalEANs,
             desiredEans: additionalEANs,
         });
-        if (!eansToUpdate || eansToUpdate.eansToAdd.length === 0 && eansToUpdate.eansToRemove.length === 0) {
+        if (!eansToUpdate ||
+            (eansToUpdate.eansToAdd.length === 0 &&
+                eansToUpdate.eansToRemove.length === 0)) {
             // No updates needed
             return false;
         }
@@ -366,7 +404,7 @@ let QlsProductService = class QlsProductService {
      * Update stock level for a variant based on the given available stock
      */
     async updateStock(ctx, variantId, availableStock) {
-        if (this.options.disableStockSync) {
+        if (!this.options.synchronizeStockLevels) {
             core_1.Logger.warn(`Stock sync disabled. Not updating stock for variant '${variantId}'`, constants_1.loggerCtx);
             return;
         }
@@ -393,5 +431,6 @@ exports.QlsProductService = QlsProductService = __decorate([
         core_1.StockLocationService,
         core_1.EventBus,
         core_1.ListQueryBuilder,
-        core_1.ProductPriceApplicator])
+        core_1.ProductPriceApplicator,
+        core_2.ModuleRef])
 ], QlsProductService);

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import { ID, Injector, Order, ProductVariant, RequestContext, SerializedRequestContext } from '@vendure/core';
-import { CustomValue, FulfillmentProductInput } from './lib/client-types';
+import { CustomValue, FulfillmentOrderInput, FulfillmentProductInput } from './lib/client-types';
 export interface QlsPluginOptions {
     /**
      * Get the QLS client config for the current channel based on given context
@@ -21,10 +21,32 @@ export interface QlsPluginOptions {
      */
     webhookSecret: string;
     /**
-     * Disable the pulling in of stock levels from QLS. When disabled, stock in Vendure will not be modified based on QLS stock levels.
-     * Useful for testing out order sync separately, or testing against a QLS test env that has no stock for example
+     * Allows you to disable the pulling in of stock levels from QLS. When disabled, stock in Vendure will not be modified based on QLS stock levels.
+     * Defaults to true.
      */
-    disableStockSync?: boolean;
+    synchronizeStockLevels?: boolean;
+    /**
+     * Allows you to disable the automatic pushing of orders to QLS. You can still push orders manually via the Admin UI.
+     * Defaults to true.
+     */
+    autoPushOrders?: boolean;
+    /**
+     * Allows you to define a date from when the order should be processed by QLS.
+     * You can for example make orders processable 2 hours from now, so that you can still edit the order in QLS
+     * Defaults to now.
+     */
+    processOrderFrom?: (ctx: RequestContext, order: Order) => Date | Promise<Date>;
+    /**
+     * Optional function to determine if a product variant should be excluded from syncing to QLS.
+     * Return true to exclude the variant from sync, false or undefined to include it.
+     */
+    excludeVariantFromSync?: (ctx: RequestContext, injector: Injector, variant: ProductVariant) => boolean | Promise<boolean>;
+    /**
+     * Optional function to customize the receiver contact details when creating a QLS order.
+     * Allows you to set different fields or override default mapping from the order's shipping address and customer.
+     * If not provided, default mapping will be used.
+     */
+    getReceiverContact?: (ctx: RequestContext, order: Order) => FulfillmentOrderInput['receiver_contact'] | undefined;
 }
 /**
  * Additional fields for a product variant that are used to create or update a product in QLS
@@ -35,7 +57,9 @@ export type AdditionalVariantFields = Partial<FulfillmentProductInput & {
 }>;
 export interface AdditionalOrderFields {
     servicepoint_code?: string;
-    delivery_options?: string[];
+    delivery_options?: {
+        tag: string;
+    }[];
     custom_values?: CustomValue[];
 }
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinelab/vendure-plugin-qls-fulfillment",
-  "version": "1.0.0-beta.9",
+  "version": "1.1.0",
   "description": "Vendure plugin to fulfill orders via QLS.",
   "keywords": [
     "fulfillment",
@@ -31,5 +31,6 @@
   },
   "dependencies": {
     "catch-unknown": "^2.0.0"
-  }
+  },
+  "gitHead": "8f5d76680b66b12b9fb3732a4205b4ce20686076"
 }