@pinelab/vendure-plugin-qls-fulfillment 1.0.0-beta.8 → 1.0.1

package/README.md

@@ -51,6 +51,33 @@ 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.
 
+## 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
 
 Make sure to monitor failed jobs: A job that failed after its retries were exhausted, means:

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/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.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

@@ -24,8 +24,7 @@ const util_1 = __importDefault(require("util"));
 const constants_1 = require("../constants");
 const qls_client_1 = require("../lib/qls-client");
 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 +34,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 +75,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 +89,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 +134,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,6 +157,10 @@ let QlsOrderService = class QlsOrderService {
                 ...(additionalOrderFields ?? {}),
             };
             const result = await client.createFulfillmentOrder(qlsOrder);
+            await this.orderService.updateCustomFields(ctx, orderId, {
+                syncedToQls: true,
+            });
+            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,
@@ -154,6 +182,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 +211,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 +238,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);
@@ -278,6 +314,9 @@ let QlsProductService = class QlsProductService {
                 createdOrUpdated = 'updated';
             }
         }
+        if (createdOrUpdated === 'not-changed') {
+            core_1.Logger.info(`Variant '${variant.sku}' not updated in QLS, because no changes were found.`, constants_1.loggerCtx);
+        }
         return createdOrUpdated;
     }
     /**
@@ -289,7 +328,9 @@ let QlsProductService = class QlsProductService {
             existingEans: existingAdditionalEANs,
             desiredEans: additionalEANs,
         });
-        if (!eansToUpdate) {
+        if (!eansToUpdate ||
+            (eansToUpdate.eansToAdd.length === 0 &&
+                eansToUpdate.eansToRemove.length === 0)) {
             // No updates needed
             return false;
         }
@@ -363,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;
         }
@@ -390,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

package/package.json

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