@pinelab/vendure-plugin-qls-fulfillment 1.0.0-beta.2 → 1.0.0-beta.21

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:
@@ -58,7 +85,12 @@ Make sure to monitor failed jobs: A job that failed after its retries were exhau
 1. An order was not pushed to QLS
 2. A product was not synced to QLS
 
-Monitor your logs for the string `QLS webhook error`. This means an incoming stock update webhook was not processed correctly.
+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
 

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

@@ -30,6 +30,9 @@ export type FulfillmentProduct = {
     collection_id: string | null;
     dimensions: unknown;
     article_number: string | null;
+    /**
+     * Main EAN of the product
+     */
     ean: string;
     name: string;
     sku: string;
@@ -53,8 +56,18 @@ export type FulfillmentProduct = {
     amount_blocked: number;
     status: string | null;
     suppliers: unknown[];
-    barcodes: string[];
+    barcodes: Array<{
+        id: number;
+        fulfillment_product_id: string;
+        company_id: string;
+        barcode: string;
+        created: string;
+        modified: string;
+    }>;
     image_url_handheld: string | null;
+    /**
+     * All EANs of the product, including the main EAN
+     */
     barcodes_and_ean: string[];
 };
 export interface FulfillmentOrderInput {

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,17 @@ 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>;
-    rawRequest<T>(method: 'POST' | 'GET' | 'PUT' | 'DELETE', action: string, data?: unknown): Promise<QlsApiResponse<T>>;
+    /**
+     * Add an extra barcode to a fulfillment product in QLS
+     */
+    addBarcode(productId: string, barcode: string): Promise<void>;
+    /**
+     * Add an extra barcode to a fulfillment product in QLS
+     */
+    removeBarcode(productId: string, barcodeId: number): Promise<void>;
+    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) {
@@ -50,25 +50,53 @@ class QlsClient {
             allProducts.push(...result.data);
             hasNextPage = result.pagination?.nextPage ?? false;
             page++;
-            await new Promise((resolve) => setTimeout(resolve, 1100)); // Limit to 55/minute, because the rate limit is 60/minute
+            core_1.Logger.info(`Fetched products ${allProducts.length}/${result.pagination?.count}`, constants_1.loggerCtx);
+            await new Promise((resolve) => setTimeout(resolve, 700)); // Limit to ~86/minute, because the rate limit is 500/5 minutes
         }
         return allProducts;
     }
     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;
     }
+    /**
+     * Add an extra barcode to a fulfillment product in QLS
+     */
+    async addBarcode(productId, barcode) {
+        await this.rawRequest('POST', `fulfillment/products/${productId}/barcodes`, {
+            barcode,
+        });
+    }
+    /**
+     * Add an extra barcode to a fulfillment product in QLS
+     */
+    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 = {
@@ -83,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 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>;
     /**
@@ -25,5 +25,6 @@ export declare class QlsOrderService implements OnModuleInit, OnApplicationBoots
      */
     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);
@@ -82,9 +85,20 @@ 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) => {
+            const qlsProducts = order.lines
+                .filter((line) => {
+                if (this.options.excludeVariantFromSync?.(ctx, 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 false;
+                }
+                return true;
+            })
+                .map((line) => {
                 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.`);
                 }
@@ -112,15 +126,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 +149,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,
@@ -182,7 +202,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 +229,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

@@ -1,12 +1,13 @@
 import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
-import { EventBus, ID, Job, JobQueueService, ProductVariant, ProductVariantService, RequestContext, StockLevelService, StockLocationService, TransactionalConnection } from '@vendure/core';
+import { EventBus, ID, Job, JobQueueService, ListQueryBuilder, ProductPriceApplicator, ProductVariant, ProductVariantService, RequestContext, StockLevelService, StockLocationService, TransactionalConnection } from '@vendure/core';
+import { FulfillmentProduct } from '../lib/client-types';
 import { QlsClient } from '../lib/qls-client';
 import { QlsPluginOptions, QlsProductJobData } from '../types';
-import { FulfillmentProduct } from '../lib/client-types';
-type SyncProductsJobResult = {
-    updatedInQls: number;
-    createdInQls: number;
-    updatedStock: number;
+type SyncProductsResult = {
+    updatedInQls: Partial<ProductVariant>[];
+    createdInQls: Partial<ProductVariant>[];
+    updatedStock: Partial<ProductVariant>[];
+    failed: Partial<ProductVariant>[];
 };
 export declare class QlsProductService implements OnModuleInit, OnApplicationBootstrap {
     private connection;
@@ -16,8 +17,10 @@ export declare class QlsProductService implements OnModuleInit, OnApplicationBoo
     private readonly variantService;
     private readonly stockLocationService;
     private readonly eventBus;
+    private readonly listQueryBuilder;
+    private readonly productPriceApplicator;
     private productJobQueue;
-    constructor(connection: TransactionalConnection, options: QlsPluginOptions, jobQueueService: JobQueueService, stockLevelService: StockLevelService, variantService: ProductVariantService, stockLocationService: StockLocationService, eventBus: EventBus);
+    constructor(connection: TransactionalConnection, options: QlsPluginOptions, jobQueueService: JobQueueService, stockLevelService: StockLevelService, variantService: ProductVariantService, stockLocationService: StockLocationService, eventBus: EventBus, listQueryBuilder: ListQueryBuilder, productPriceApplicator: ProductPriceApplicator);
     onApplicationBootstrap(): void;
     onModuleInit(): Promise<void>;
     /**
@@ -32,11 +35,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
      */
@@ -53,6 +61,10 @@ export declare class QlsProductService implements OnModuleInit, OnApplicationBoo
      * Determines if a product needs to be created or updated in QLS based on the given variant and existing QLS product.
      */
     createOrUpdateProductInQls(ctx: RequestContext, client: QlsClient, variant: ProductVariant, existingProduct: FulfillmentProduct | null): Promise<'created' | 'updated' | 'not-changed'>;
+    /**
+     * Update the additional EANs/barcodes for a product in QLS if needed
+     */
+    private updateAdditionalEANs;
     /**
      * Determine if a product needs to be updated in QLS based on the given variant and QLS product.
      */

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

@@ -19,11 +19,15 @@ exports.QlsProductService = void 0;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@vendure/core");
 const catch_unknown_1 = require("catch-unknown");
+const typeorm_1 = require("typeorm");
 const util_1 = __importDefault(require("util"));
 const constants_1 = require("../constants");
 const qls_client_1 = require("../lib/qls-client");
+const util_2 = require("./util");
+// 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) {
+    constructor(connection, options, jobQueueService, stockLevelService, variantService, stockLocationService, eventBus, listQueryBuilder, productPriceApplicator) {
         this.connection = connection;
         this.options = options;
         this.jobQueueService = jobQueueService;
@@ -31,6 +35,8 @@ let QlsProductService = class QlsProductService {
         this.variantService = variantService;
         this.stockLocationService = stockLocationService;
         this.eventBus = eventBus;
+        this.listQueryBuilder = listQueryBuilder;
+        this.productPriceApplicator = productPriceApplicator;
     }
     onApplicationBootstrap() {
         // Listen for ProductVariantEvent and add a job to the queue
@@ -60,7 +66,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);
@@ -95,34 +107,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;
+            const createdQlsProducts = [];
+            const updatedQlsProducts = [];
+            const failed = [];
             for (const variant of allVariants) {
-                const existingQlsProduct = allQlsProducts.find((p) => p.sku == variant.sku);
-                const result = await this.createOrUpdateProductInQls(ctx, client, variant, existingQlsProduct ?? null);
-                if (result === 'created') {
-                    createdQlsProductsCount += 1;
+                try {
+                    const existingQlsProduct = allQlsProducts.find((p) => p.sku == variant.sku);
+                    const result = await this.createOrUpdateProductInQls(ctx, client, variant, existingQlsProduct ?? null);
+                    if (result === 'created') {
+                        createdQlsProducts.push(variant);
+                    }
+                    else if (result === 'updated') {
+                        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();
+                    }
                 }
-                else if (result === 'updated') {
-                    updatedQlsProductsCount += 1;
+                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);
+                    failed.push(variant);
+                    await waitToPreventRateLimit();
                 }
             }
-            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(`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,
+                updatedInQls: updatedQlsProducts,
+                createdInQls: createdQlsProducts,
+                updatedStock,
+                failed,
             };
         }
         catch (e) {
@@ -131,6 +158,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.
      */
@@ -139,32 +184,47 @@ 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,
+                updatedInQls: [],
+                createdInQls: [],
+                updatedStock: [],
+                failed: [],
             };
         }
-        let updatedInQls = 0;
-        let createdInQls = 0;
+        const updatedInQls = [];
+        const createdInQls = [];
+        const failed = [];
         for (const variantId of productVariantIds) {
-            const variant = await this.variantService.findOne(ctx, variantId);
-            if (!variant) {
-                core_1.Logger.error(`Variant with id ${variantId} not found. Not creating or updating product in QLS.`, constants_1.loggerCtx);
-                continue;
-            }
-            const existingQlsProduct = await client.getFulfillmentProductBySku(variant.sku);
-            const result = await this.createOrUpdateProductInQls(ctx, client, variant, existingQlsProduct ?? null);
-            if (result === 'created') {
-                createdInQls += 1;
+            try {
+                const variant = await this.variantService.findOne(ctx, variantId, [
+                    'featuredAsset',
+                    'taxCategory',
+                    'channels',
+                    'product.featuredAsset',
+                ]);
+                if (!variant) {
+                    core_1.Logger.error(`Variant with id ${variantId} not found. Not creating or updating product in QLS.`, constants_1.loggerCtx);
+                    continue;
+                }
+                const existingQlsProduct = await client.getFulfillmentProductBySku(variant.sku);
+                const result = await this.createOrUpdateProductInQls(ctx, client, variant, existingQlsProduct ?? null);
+                if (result === 'created') {
+                    createdInQls.push(variant);
+                }
+                else if (result === 'updated') {
+                    updatedInQls.push(variant);
+                }
             }
-            else if (result === 'updated') {
-                updatedInQls += 1;
+            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);
+                failed.push({ id: variantId });
             }
         }
         return {
             updatedInQls,
             createdInQls,
-            updatedStock: 0,
+            updatedStock: [],
+            failed,
         };
     }
     /**
@@ -189,7 +249,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
@@ -211,45 +271,92 @@ 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) {
-        let qlsProductId = existingProduct?.id;
+        if (this.options.excludeVariantFromSync?.(ctx, 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);
         if (!existingProduct) {
             const result = await client.createFulfillmentProduct({
                 name: variant.name,
                 sku: variant.sku,
-                ...this.options.getAdditionalVariantFields?.(ctx, variant),
+                ...additionalVariantFields,
             });
-            qlsProductId = result.id;
+            qlsProduct = result;
             core_1.Logger.info(`Created product '${variant.sku}' in QLS`, constants_1.loggerCtx);
             createdOrUpdated = 'created';
         }
-        else if (this.shouldUpdateProductInQls(ctx, variant, existingProduct)) {
+        else if (this.shouldUpdateProductInQls(variant, existingProduct, additionalVariantFields)) {
             await client.updateFulfillmentProduct(existingProduct.id, {
                 sku: variant.sku,
                 name: variant.name,
-                ...this.options.getAdditionalVariantFields?.(ctx, variant),
+                ...additionalVariantFields,
             });
             core_1.Logger.info(`Updated product '${variant.sku}' in QLS`, constants_1.loggerCtx);
             createdOrUpdated = 'updated';
         }
-        if (qlsProductId !== variant.customFields.qlsProductId) {
+        if (qlsProduct && qlsProduct?.id !== variant.customFields.qlsProductId) {
             // Update variant with QLS product ID if it changed
             // Do not use variantService.update because it will trigger a change event and cause an infinite loop
             await this.connection
                 .getRepository(ctx, core_1.ProductVariant)
-                .update({ id: variant.id }, { customFields: { qlsProductId } });
-            core_1.Logger.info(`Set QLS product ID for variant '${variant.sku}' to ${qlsProductId}`, constants_1.loggerCtx);
+                .update({ id: variant.id }, { customFields: { qlsProductId: qlsProduct.id } });
+            core_1.Logger.info(`Set QLS product ID for variant '${variant.sku}' to ${qlsProduct.id}`, constants_1.loggerCtx);
+        }
+        if (qlsProduct) {
+            const updatedEANs = await this.updateAdditionalEANs(ctx, client, qlsProduct, additionalEANs);
+            if (createdOrUpdated === 'not-changed' && updatedEANs) {
+                // If nothing changed so far, but EANs changed, then we did update the product in QLS
+                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;
     }
+    /**
+     * Update the additional EANs/barcodes for a product in QLS if needed
+     */
+    async updateAdditionalEANs(ctx, client, qlsProduct, additionalEANs) {
+        const existingAdditionalEANs = qlsProduct?.barcodes_and_ean.filter((ean) => ean !== qlsProduct.ean); // Remove the main EAN
+        const eansToUpdate = (0, util_2.getEansToUpdate)({
+            existingEans: existingAdditionalEANs,
+            desiredEans: additionalEANs,
+        });
+        if (!eansToUpdate ||
+            (eansToUpdate.eansToAdd.length === 0 &&
+                eansToUpdate.eansToRemove.length === 0)) {
+            // No updates needed
+            return false;
+        }
+        // Add additional EANs
+        eansToUpdate.eansToAdd = (0, util_2.normalizeEans)(eansToUpdate.eansToAdd);
+        await Promise.all(eansToUpdate.eansToAdd.map((ean) => client.addBarcode(qlsProduct.id, ean)));
+        if (eansToUpdate.eansToAdd.length > 0) {
+            core_1.Logger.info(`Added additional EANs: ${eansToUpdate.eansToAdd.join(',')} to product '${qlsProduct.sku}' in QLS`, constants_1.loggerCtx);
+        }
+        // Remove EANs, normalize first
+        eansToUpdate.eansToRemove = (0, util_2.normalizeEans)(eansToUpdate.eansToRemove);
+        // get barcode ID's to remove, because deletion goes via barcode ID, not barcode value
+        const barcodeIdsToRemove = qlsProduct.barcodes
+            .filter((barcode) => eansToUpdate.eansToRemove.includes(barcode.barcode))
+            .map((barcode) => barcode.id);
+        await Promise.all(barcodeIdsToRemove.map((barcodeId) => client.removeBarcode(qlsProduct.id, barcodeId)));
+        if (eansToUpdate.eansToRemove.length > 0) {
+            core_1.Logger.info(`Removed EANs '${eansToUpdate.eansToRemove.join(',')} from product '${qlsProduct.sku}' in QLS`, constants_1.loggerCtx);
+        }
+        return true;
+    }
     /**
      * Determine if a product needs to be updated in QLS based on the given variant and QLS product.
      */
-    shouldUpdateProductInQls(ctx, variant, qlsProduct) {
-        const additionalFields = this.options.getAdditionalVariantFields?.(ctx, variant);
+    shouldUpdateProductInQls(variant, qlsProduct, additionalVariantFields) {
         if (qlsProduct.name !== variant.name ||
-            qlsProduct.ean !== additionalFields?.ean ||
-            qlsProduct.image_url !== additionalFields?.image_url) {
+            qlsProduct.ean !== additionalVariantFields?.ean ||
+            qlsProduct.image_url !== additionalVariantFields?.image_url) {
             // If name or ean has changed, product should be updated in QLS
             return true;
         }
@@ -264,16 +371,27 @@ let QlsProductService = class QlsProductService {
         const take = 100;
         let hasMore = true;
         while (hasMore) {
-            const result = await this.variantService.findAll(ctx, {
-                filter: { deletedAt: { isNull: true } },
+            const relations = [
+                'featuredAsset',
+                'taxCategory',
+                'channels',
+                'product.featuredAsset',
+            ];
+            const [items, totalItems] = await this.listQueryBuilder
+                .build(core_1.ProductVariant, {
                 skip,
                 take,
-            });
-            if (!result.items.length) {
-                break;
-            }
-            allVariants.push(...result.items);
-            if (allVariants.length >= result.totalItems) {
+            }, {
+                relations,
+                channelId: ctx.channelId,
+                where: { deletedAt: (0, typeorm_1.IsNull)() },
+                ctx,
+            })
+                .getManyAndCount();
+            let variants = await Promise.all(items.map(async (item) => this.productPriceApplicator.applyChannelPriceAndTax(item, ctx, undefined, false)));
+            variants = variants.map((v) => (0, core_1.translateDeep)(v, ctx.languageCode));
+            allVariants.push(...variants);
+            if (allVariants.length >= totalItems) {
                 hasMore = false;
             }
             skip += take;
@@ -284,6 +402,10 @@ let QlsProductService = class QlsProductService {
      * Update stock level for a variant based on the given available stock
      */
     async updateStock(ctx, variantId, availableStock) {
+        if (!this.options.synchronizeStockLevels) {
+            core_1.Logger.warn(`Stock sync disabled. Not updating stock for variant '${variantId}'`, constants_1.loggerCtx);
+            return;
+        }
         // Find default Stock Location
         const defaultStockLocation = await this.stockLocationService.defaultStockLocation(ctx);
         // Get current stock level id
@@ -305,5 +427,7 @@ exports.QlsProductService = QlsProductService = __decorate([
         core_1.StockLevelService,
         core_1.ProductVariantService,
         core_1.StockLocationService,
-        core_1.EventBus])
+        core_1.EventBus,
+        core_1.ListQueryBuilder,
+        core_1.ProductPriceApplicator])
 ], QlsProductService);

package/dist/services/util.d.ts

@@ -0,0 +1,15 @@
+export interface EanUpdate {
+    eansToAdd: string[];
+    eansToRemove: string[];
+}
+/**
+ * Get the EANs to add or remove
+ */
+export declare function getEansToUpdate({ existingEans, desiredEans, }: {
+    existingEans?: (string | undefined | null)[];
+    desiredEans?: (string | undefined | null)[];
+}): EanUpdate | false;
+/**
+ * Normalize the EANs by filtering out null, undefined and empty strings and sorting them
+ */
+export declare function normalizeEans(eans?: (string | undefined | null)[]): string[];

package/dist/services/util.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEansToUpdate = getEansToUpdate;
+exports.normalizeEans = normalizeEans;
+/**
+ * Get the EANs to add or remove
+ */
+function getEansToUpdate({ existingEans, desiredEans, }) {
+    const normalizedExisting = normalizeEans(existingEans);
+    const normalizedDesired = normalizeEans(desiredEans);
+    // Find out what EANs to add
+    const eansToAdd = normalizedDesired.filter((ean) => !normalizedExisting.includes(ean));
+    // Find out what EANs to remove
+    const eansToRemove = normalizedExisting.filter((ean) => !normalizedDesired.includes(ean));
+    if (eansToAdd.length === 0 && eansToRemove.length === 0) {
+        return false;
+    }
+    return {
+        eansToAdd,
+        eansToRemove,
+    };
+}
+/**
+ * Normalize the EANs by filtering out null, undefined and empty strings and sorting them
+ */
+function normalizeEans(eans) {
+    return (eans ?? [])
+        .filter((ean) => !!ean && ean.trim().length > 0)
+        .map((ean) => ean.trim())
+        .sort();
+}

package/dist/services/util.spec.d.ts

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

package/dist/services/util.spec.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const util_1 = require("./util");
+(0, vitest_1.describe)('getEansToUpdate', () => {
+    (0, vitest_1.it)('returns false for identical EAN arrays', () => {
+        (0, vitest_1.expect)((0, util_1.getEansToUpdate)({
+            existingEans: ['123', '456'],
+            desiredEans: ['456', '123'],
+        })).toBe(false);
+    });
+    (0, vitest_1.it)('ignores ordering, whitespace, null/undefined and empty stringswhen determining additions', () => {
+        (0, vitest_1.expect)((0, util_1.getEansToUpdate)({
+            existingEans: [null, '123', ''],
+            desiredEans: [' 123', '456 ', undefined, null],
+        })).toEqual({
+            eansToAdd: ['456'],
+            eansToRemove: [],
+        });
+    });
+    (0, vitest_1.it)('returns removals when desired array is missing values', () => {
+        (0, vitest_1.expect)((0, util_1.getEansToUpdate)({
+            existingEans: ['123', '456', null],
+            desiredEans: ['123'],
+        })).toEqual({
+            eansToAdd: [],
+            eansToRemove: ['456'],
+        });
+    });
+    (0, vitest_1.it)('returns both additions and removals when values differ', () => {
+        (0, vitest_1.expect)((0, util_1.getEansToUpdate)({
+            existingEans: ['123', '456'],
+            desiredEans: ['123', '789'],
+        })).toEqual({
+            eansToAdd: ['789'],
+            eansToRemove: ['456'],
+        });
+    });
+    (0, vitest_1.it)('treats undefined arrays as equal', () => {
+        (0, vitest_1.expect)((0, util_1.getEansToUpdate)({ existingEans: undefined, desiredEans: undefined })).toBe(false);
+    });
+    (0, vitest_1.it)('treats undefined and empty array as equal', () => {
+        // This is the case when creating a new product in QLS
+        (0, vitest_1.expect)((0, util_1.getEansToUpdate)({ existingEans: undefined, desiredEans: [] })).toBe(false);
+    });
+});
+(0, vitest_1.describe)('normalizeEans', () => {
+    (0, vitest_1.it)('filters and trims invalid values', () => {
+        (0, vitest_1.expect)((0, util_1.normalizeEans)([' 123', '', undefined, null, '456 '])).toEqual([
+            '123',
+            '456',
+        ]);
+    });
+    (0, vitest_1.it)('returns empty array for undefined input', () => {
+        (0, vitest_1.expect)((0, util_1.normalizeEans)(undefined)).toEqual([]);
+    });
+    (0, vitest_1.it)('sorts resulting values alphabetically', () => {
+        (0, vitest_1.expect)((0, util_1.normalizeEans)(['789', '123'])).toEqual(['123', '789']);
+    });
+});

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
@@ -9,7 +9,7 @@ export interface QlsPluginOptions {
      * Required to get the EAN and image URL for a product variant.
      * Also allows you to override other product attributes like name, price, etc.
      */
-    getAdditionalVariantFields?: (ctx: RequestContext, variant: ProductVariant) => Partial<FulfillmentProductInput>;
+    getAdditionalVariantFields: (ctx: RequestContext, variant: ProductVariant) => AdditionalVariantFields;
     /**
      * Function to get the set service point code for an order.
      * Return undefined to not use a service point at all.
@@ -20,7 +20,41 @@ export interface QlsPluginOptions {
      * Set this to a random string
      */
     webhookSecret: string;
+    /**
+     * 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.
+     */
+    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, 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
+ */
+export type AdditionalVariantFields = Partial<FulfillmentProductInput & {
+    ean: string;
+    additionalEANs?: string[];
+}>;
 export interface AdditionalOrderFields {
     servicepoint_code?: string;
     delivery_options?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinelab/vendure-plugin-qls-fulfillment",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.21",
   "description": "Vendure plugin to fulfill orders via QLS.",
   "keywords": [
     "fulfillment",