@pinelab/vendure-plugin-qls-fulfillment 1.1.2 → 1.2.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 1.2.0 (2026-01-28)
+
+- Prevent accidently pushing orders multiple times by checking if the order is already synced to QLS.
+- Store combination of QLS order id and Vendure order id to prevent duplicate orders in QLS.
+- Emit event for failed product pushes, and log it as a warning instead of an error.
+- Store failed products as scheduled task data so they can be viewed in the Admin UI.
+- Allow specifying UI tab name where the QLS product ID custom field is shown on ProductVariant page.
+
+# 1.1.3 (2026-01-28)
+
+- Gracefully handle missing variants from incoming webhooks by logging instead of throwing an error.
+
 # 1.1.2 (2026-01-14)
 
 - Run scheduled full sync without job queue, because scheduled tasks already run in the worker only.

package/README.md

@@ -78,7 +78,7 @@ mutation {
 }
 ```
 
-## Monitoring failed orders
+## Monitoring failed orders and product syncs
 
 Whenever an order fails to be pushed to QLS, an event is emitted. You can listen to this event to monitor failed orders.
 
@@ -100,6 +100,8 @@ this.eventBus.ofType(QlsOrderFailedEvent).subscribe((event) => {
 });
 ```
 
+For product syncs, the same approach can be used, but with the `QlsProductSyncFailedEvent` instead.
+
 ## Manually pushing orders to QLS
 
 This plugin adds a button `push to QLS` to the order detail page in the Admin UI. This will push the order to QLS again. If the order has been pushed before, you need to uncheck the checkbox `synced to QLS` in the order custom fields first.

package/dist/api/api-extensions.js

@@ -6,6 +6,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.shopApiExtensions = exports.adminApiExtensions = void 0;
 const graphql_tag_1 = __importDefault(require("graphql-tag"));
 exports.adminApiExtensions = (0, graphql_tag_1.default) `
+  extend type Order {
+    """
+    QLS order id(s) for this Vendure order.
+    """
+    qlsOrderIds: [String!]!
+  }
+
   extend type Mutation {
     """
     Trigger a sync to create or update all products in Vendure to QLS, and pull in stock levels from QLS.

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

@@ -29,6 +29,11 @@ export type Mutation = {
 export type MutationPushOrderToQlsArgs = {
     orderId: Scalars['ID'];
 };
+export type Order = {
+    __typename?: 'Order';
+    /** QLS order id(s) for this Vendure order. */
+    qlsOrderIds: Array<Scalars['String']>;
+};
 export type QlsServicePoint = {
     __typename?: 'QlsServicePoint';
     address: QlsServicePointAddress;

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

@@ -1,11 +1,12 @@
-import { RequestContext } from '@vendure/core';
+import { Order, RequestContext } from '@vendure/core';
+import { QlsOrderService } from '../services/qls-order.service';
 import { QlsProductService } from '../services/qls-product.service';
 import { MutationPushOrderToQlsArgs } from './generated/graphql';
-import { QlsOrderService } from '../services/qls-order.service';
 export declare class QlsAdminResolver {
     private qlsProductService;
     private qlsOrderService;
     constructor(qlsProductService: QlsProductService, qlsOrderService: QlsOrderService);
+    qlsOrderIds(ctx: RequestContext, order: Order): Promise<string[]>;
     triggerQlsProductSync(ctx: RequestContext): Promise<boolean>;
     pushOrderToQls(ctx: RequestContext, input: MutationPushOrderToQlsArgs): Promise<string>;
 }

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

@@ -15,23 +15,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QlsAdminResolver = void 0;
 const graphql_1 = require("@nestjs/graphql");
 const core_1 = require("@vendure/core");
-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");
+const qls_order_service_1 = require("../services/qls-order.service");
+const qls_product_service_1 = require("../services/qls-product.service");
 let QlsAdminResolver = class QlsAdminResolver {
     constructor(qlsProductService, qlsOrderService) {
         this.qlsProductService = qlsProductService;
         this.qlsOrderService = qlsOrderService;
     }
+    async qlsOrderIds(ctx, order) {
+        return this.qlsOrderService.getQlsOrderIdsForOrder(ctx, order.id);
+    }
     async triggerQlsProductSync(ctx) {
         await this.qlsProductService.triggerFullSync(ctx);
         return true;
     }
     async pushOrderToQls(ctx, input) {
-        return await this.qlsOrderService.pushOrderToQls(ctx, input.orderId);
+        return await this.qlsOrderService.pushOrderToQls(ctx, input.orderId, true);
     }
 };
 exports.QlsAdminResolver = QlsAdminResolver;
+__decorate([
+    (0, graphql_1.ResolveField)(),
+    (0, graphql_1.Resolver)('Order'),
+    (0, core_1.Allow)(permissions_1.qlsPushOrderPermission.Permission),
+    (0, core_1.Allow)(core_1.Permission.UpdateAdministrator),
+    __param(0, (0, core_1.Ctx)()),
+    __param(1, (0, graphql_1.Parent)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext,
+        core_1.Order]),
+    __metadata("design:returntype", Promise)
+], QlsAdminResolver.prototype, "qlsOrderIds", null);
 __decorate([
     (0, graphql_1.Mutation)(),
     (0, core_1.Transaction)(),

package/dist/config/sync-products-scheduled-task.js

@@ -19,7 +19,12 @@ exports.qlsSyncAllProductsTask = new core_1.ScheduledTask({
             apiType: 'admin',
         });
         const channels = await injector.get(core_1.ChannelService).findAll(ctx);
-        let fullSyncCompleted = 0;
+        const aggregatedResult = {
+            updatedInQls: 0,
+            createdInQls: 0,
+            updatedStock: 0,
+            failed: 0,
+        };
         for (const channel of channels.items) {
             // Create ctx for channel
             const channelCtx = new core_1.RequestContext({
@@ -35,11 +40,12 @@ exports.qlsSyncAllProductsTask = new core_1.ScheduledTask({
                 core_1.Logger.info(`QLS not enabled for channel ${channel.token}`, constants_1.loggerCtx);
                 continue;
             }
-            await qlsProductService.runFullSync(channelCtx);
-            fullSyncCompleted += 1;
+            const result = await qlsProductService.runFullSync(channelCtx);
+            aggregatedResult.updatedInQls += result.updatedInQls.length;
+            aggregatedResult.createdInQls += result.createdInQls.length;
+            aggregatedResult.updatedStock += result.updatedStock.length;
+            aggregatedResult.failed += result.failed.length;
         }
-        return {
-            message: `Finnished full sync for ${fullSyncCompleted} channels`,
-        };
+        return aggregatedResult;
     },
 });

package/dist/custom-fields.d.ts

@@ -6,8 +6,8 @@ declare module '@vendure/core' {
     interface CustomOrderFields {
         qlsServicePointId?: string;
         qlsServicePointDetails?: string;
-        syncedToQls?: boolean;
     }
 }
-export declare const variantCustomFields: CustomFieldConfig[];
+/** Returns variant custom fields with the given Admin UI tab name. */
+export declare function getVariantCustomFields(uiTab: string): CustomFieldConfig[];
 export declare const orderCustomFields: CustomFieldConfig[];

package/dist/custom-fields.js

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.orderCustomFields = exports.variantCustomFields = void 0;
+exports.orderCustomFields = void 0;
+exports.getVariantCustomFields = getVariantCustomFields;
 const core_1 = require("@vendure/core");
-exports.variantCustomFields = [
-    {
-        name: 'qlsProductId',
-        type: 'string',
-        label: [{ value: 'QLS Product ID', languageCode: core_1.LanguageCode.en }],
-        nullable: true,
-        public: false,
-        readonly: true,
-        ui: { tab: 'QLS' },
-    },
-];
+/** Returns variant custom fields with the given Admin UI tab name. */
+function getVariantCustomFields(uiTab) {
+    return [
+        {
+            name: 'qlsProductId',
+            type: 'string',
+            label: [{ value: 'QLS Product ID', languageCode: core_1.LanguageCode.en }],
+            nullable: true,
+            public: false,
+            readonly: true,
+            ui: { tab: uiTab },
+        },
+    ];
+}
 exports.orderCustomFields = [
     {
         name: 'qlsServicePointId',
@@ -23,28 +27,6 @@ exports.orderCustomFields = [
         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',

package/dist/entities/qls-order-entity.entity.d.ts

@@ -0,0 +1,9 @@
+import { DeepPartial, ID, VendureEntity } from '@vendure/core';
+/**
+ * Simple entity to keep track of what QLS orders were created for what Vendure orders.
+ */
+export declare class QlsOrderEntity extends VendureEntity {
+    constructor(input?: DeepPartial<QlsOrderEntity>);
+    qlsOrderId: ID;
+    vendureOrderId: ID;
+}

package/dist/entities/qls-order-entity.entity.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QlsOrderEntity = void 0;
+const core_1 = require("@vendure/core");
+const typeorm_1 = require("typeorm");
+/**
+ * Simple entity to keep track of what QLS orders were created for what Vendure orders.
+ */
+let QlsOrderEntity = class QlsOrderEntity extends core_1.VendureEntity {
+    constructor(input) {
+        super(input);
+    }
+};
+exports.QlsOrderEntity = QlsOrderEntity;
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: false, unique: true }),
+    __metadata("design:type", Object)
+], QlsOrderEntity.prototype, "qlsOrderId", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: 'text', nullable: false }),
+    __metadata("design:type", Object)
+], QlsOrderEntity.prototype, "vendureOrderId", void 0);
+exports.QlsOrderEntity = QlsOrderEntity = __decorate([
+    (0, typeorm_1.Entity)(),
+    __metadata("design:paramtypes", [Object])
+], QlsOrderEntity);

package/dist/qls-plugin.js

@@ -22,11 +22,13 @@ const constants_1 = require("./constants");
 const custom_fields_1 = require("./custom-fields");
 const qls_order_service_1 = require("./services/qls-order.service");
 const qls_product_service_1 = require("./services/qls-product.service");
+const qls_order_entity_entity_1 = require("./entities/qls-order-entity.entity");
 let QlsPlugin = QlsPlugin_1 = class QlsPlugin {
     static init(options) {
         this.options = {
             synchronizeStockLevels: true,
             autoPushOrders: true,
+            qlsProductIdUiTab: 'QLS',
             ...options,
         };
         return QlsPlugin_1;
@@ -53,7 +55,7 @@ exports.QlsPlugin = QlsPlugin = QlsPlugin_1 = __decorate([
         configuration: (config) => {
             config.authOptions.customPermissions.push(permissions_1.qlsFullSyncPermission);
             config.authOptions.customPermissions.push(permissions_1.qlsPushOrderPermission);
-            config.customFields.ProductVariant.push(...custom_fields_1.variantCustomFields);
+            config.customFields.ProductVariant.push(...(0, custom_fields_1.getVariantCustomFields)(QlsPlugin.options?.qlsProductIdUiTab ?? 'QLS'));
             config.customFields.Order.push(...custom_fields_1.orderCustomFields);
             return config;
         },
@@ -66,5 +68,6 @@ exports.QlsPlugin = QlsPlugin = QlsPlugin_1 = __decorate([
             schema: api_extensions_1.shopApiExtensions,
             resolvers: [qls_shop_resolver_1.QlsShopResolver],
         },
+        entities: [qls_order_entity_entity_1.QlsOrderEntity],
     })
 ], QlsPlugin);

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

@@ -1,6 +1,6 @@
 import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
 import { ModuleRef } from '@nestjs/core';
-import { EventBus, ID, Job, JobQueueService, OrderService, RequestContext } from '@vendure/core';
+import { EventBus, ID, Job, JobQueueService, OrderService, RequestContext, TransactionalConnection } from '@vendure/core';
 import { QlsServicePoint, QlsServicePointSearchInput } from '../api/generated/graphql';
 import { IncomingOrderWebhook } from '../lib/client-types';
 import { QlsOrderJobData, QlsPluginOptions } from '../types';
@@ -10,8 +10,9 @@ export declare class QlsOrderService implements OnModuleInit, OnApplicationBoots
     private eventBus;
     private orderService;
     private moduleRef;
+    private readonly connection;
     private orderJobQueue;
-    constructor(options: QlsPluginOptions, jobQueueService: JobQueueService, eventBus: EventBus, orderService: OrderService, moduleRef: ModuleRef);
+    constructor(options: QlsPluginOptions, jobQueueService: JobQueueService, eventBus: EventBus, orderService: OrderService, moduleRef: ModuleRef, connection: TransactionalConnection);
     onApplicationBootstrap(): void;
     onModuleInit(): Promise<void>;
     /**
@@ -22,13 +23,19 @@ export declare class QlsOrderService implements OnModuleInit, OnApplicationBoots
     /**
      * Push an order to QLS by id.
      * Returns a human-readable message describing the result of the operation (Used as job result).
+     *
+     * `force` can be used to force the push of an order even if one already exists in QLS.
      */
-    pushOrderToQls(ctx: RequestContext, orderId: ID): Promise<string>;
+    pushOrderToQls(ctx: RequestContext, orderId: ID, force?: boolean): 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>;
+    /**
+     * Get QLS order id(s) for a Vendure order (for Order.qlsOrderIds field).
+     */
+    getQlsOrderIdsForOrder(ctx: RequestContext, orderId: ID): Promise<string[]>;
     getServicePoints(ctx: RequestContext, input: QlsServicePointSearchInput): Promise<QlsServicePoint[]>;
     private getVendureOrderState;
 }

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

@@ -24,13 +24,15 @@ const util_1 = __importDefault(require("util"));
 const constants_1 = require("../constants");
 const qls_client_1 = require("../lib/qls-client");
 const qls_order_failed_event_1 = require("./qls-order-failed-event");
+const qls_order_entity_entity_1 = require("../entities/qls-order-entity.entity");
 let QlsOrderService = class QlsOrderService {
-    constructor(options, jobQueueService, eventBus, orderService, moduleRef) {
+    constructor(options, jobQueueService, eventBus, orderService, moduleRef, connection) {
         this.options = options;
         this.jobQueueService = jobQueueService;
         this.eventBus = eventBus;
         this.orderService = orderService;
         this.moduleRef = moduleRef;
+        this.connection = connection;
     }
     onApplicationBootstrap() {
         // Listen for OrderPlacedEvent and add a job to the queue
@@ -79,8 +81,10 @@ let QlsOrderService = class QlsOrderService {
     /**
      * Push an order to QLS by id.
      * Returns a human-readable message describing the result of the operation (Used as job result).
+     *
+     * `force` can be used to force the push of an order even if one already exists in QLS.
      */
-    async pushOrderToQls(ctx, orderId) {
+    async pushOrderToQls(ctx, orderId, force = false) {
         const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
         if (!client) {
             // Jobs are only added when QLS is enabled for the channel, so if we cant get a client here, something is wrong
@@ -90,8 +94,17 @@ 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`);
+        if (!force) {
+            const existingQlsOrder = await this.connection
+                .getRepository(ctx, qls_order_entity_entity_1.QlsOrderEntity)
+                .findOne({
+                where: {
+                    vendureOrderId: orderId,
+                },
+            });
+            if (existingQlsOrder) {
+                throw new core_2.UserInputError(`Order '${order.code}' has already been synced to QLS`);
+            }
         }
         try {
             // Map variants to QLS products
@@ -159,32 +172,49 @@ let QlsOrderService = class QlsOrderService {
             };
             const result = await client.createFulfillmentOrder(qlsOrder);
             core_2.Logger.info(`Successfully created order '${order.code}' in QLS with id '${result.id}'`, constants_1.loggerCtx);
-            await this.orderService.addNoteToOrder(ctx, {
+            // Add note but catch any errors, because we don't want the job to fail and retry when adding a note fails
+            await this.orderService
+                .addNoteToOrder(ctx, {
                 id: orderId,
                 isPublic: false,
                 note: `Created order '${result.id}' in QLS`,
+            })
+                .catch((e) => {
+                const error = (0, catch_unknown_1.asError)(e);
+                core_2.Logger.error(`Error adding note to order '${order.code}': ${error.message}`, constants_1.loggerCtx, error.stack);
             });
-            // Delayed custom field update to prevent race conditions: OrderPlacedEvent is emitted before transition to PaymentSettled is complete
-            await new Promise((resolve) => setTimeout(resolve, 5000));
-            await this.orderService
-                .updateCustomFields(ctx, orderId, {
-                syncedToQls: true,
+            await this.connection
+                .getRepository(ctx, qls_order_entity_entity_1.QlsOrderEntity)
+                .save({
+                qlsOrderId: result.id,
+                vendureOrderId: orderId,
             })
                 .catch((e) => {
-                // catch any errors, because we don't want the job to fail and retry when custom field update fails
+                // Catch any errors, because we don't want the job to fail and retry when custom field update fails
                 const error = (0, catch_unknown_1.asError)(e);
-                core_2.Logger.error(`Error updating custom field 'syncedToQls: true' for order '${order.code}': ${error.message}`, constants_1.loggerCtx, error.stack);
+                core_2.Logger.error(`Error saving QLS order entity for order '${order.code}': ${error.message}`, constants_1.loggerCtx, error.stack);
             });
             return `Order '${order.code}' created in QLS with id '${result.id}'`;
         }
         catch (e) {
             const error = (0, catch_unknown_1.asError)(e);
-            await this.orderService.addNoteToOrder(ctx, {
+            await this.orderService
+                .addNoteToOrder(ctx, {
                 id: orderId,
                 isPublic: false,
                 note: `Failed to create order '${order.code}' in QLS: ${error.message}`,
+            })
+                .catch((e) => {
+                const error = (0, catch_unknown_1.asError)(e);
+                core_2.Logger.error(`Error adding note to order '${order.code}': ${error.message}`, constants_1.loggerCtx, error.stack);
+            });
+            await this.eventBus
+                .publish(new qls_order_failed_event_1.QlsOrderFailedEvent(ctx, order, new Date(), error.message))
+                .catch((e) => {
+                // Don't swallow original error, so catch and log this one
+                const error = (0, catch_unknown_1.asError)(e);
+                core_2.Logger.error(`Error publishing QlsOrderFailedEvent for order '${order.code}': ${error.message}`, constants_1.loggerCtx, error.stack);
             });
-            await this.eventBus.publish(new qls_order_failed_event_1.QlsOrderFailedEvent(ctx, order, new Date(), error.message));
             throw error;
         }
     }
@@ -223,6 +253,17 @@ let QlsOrderService = class QlsOrderService {
             orderId,
         }, { retries: 3 });
     }
+    /**
+     * Get QLS order id(s) for a Vendure order (for Order.qlsOrderIds field).
+     */
+    async getQlsOrderIdsForOrder(ctx, orderId) {
+        const entities = await this.connection
+            .getRepository(ctx, qls_order_entity_entity_1.QlsOrderEntity)
+            .find({
+            where: { vendureOrderId: orderId },
+        });
+        return entities.map((e) => String(e.qlsOrderId));
+    }
     async getServicePoints(ctx, input) {
         const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
         if (!client) {
@@ -252,5 +293,6 @@ exports.QlsOrderService = QlsOrderService = __decorate([
     __metadata("design:paramtypes", [Object, core_2.JobQueueService,
         core_2.EventBus,
         core_2.OrderService,
-        core_1.ModuleRef])
+        core_1.ModuleRef,
+        core_2.TransactionalConnection])
 ], QlsOrderService);

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

@@ -24,6 +24,7 @@ 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 qls_variant_sync_failed_event_1 = require("./qls-variant-sync-failed-event");
 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));
@@ -141,6 +142,7 @@ let QlsProductService = class QlsProductService {
                     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 this.eventBus.publish(new qls_variant_sync_failed_event_1.QlsVariantSyncFailedEvent(ctx, variant, new Date(), e));
                     await waitToPreventRateLimit();
                 }
             }
@@ -196,17 +198,18 @@ let QlsProductService = class QlsProductService {
         const createdInQls = [];
         const failed = [];
         for (const variantId of productVariantIds) {
+            const variant = await this.variantService.findOne(ctx, variantId, [
+                'featuredAsset',
+                'taxCategory',
+                'channels',
+                'product.featuredAsset',
+            ]);
+            if (!variant) {
+                // Can happen when a variant is deleted from Vendure after the job was triggered
+                core_1.Logger.info(`Variant with id ${variantId} not found. Not creating or updating product in QLS.`, constants_1.loggerCtx);
+                continue;
+            }
             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') {
@@ -218,8 +221,10 @@ let QlsProductService = class QlsProductService {
             }
             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);
+                // Log as warning, because this is probably a functional mistake, i.e. duplicate barcodes or EANs
+                core_1.Logger.warn(`Error syncing variant ${variantId} (${variant.sku}) to QLS: ${error.message}`, constants_1.loggerCtx);
                 failed.push({ id: variantId });
+                await this.eventBus.publish(new qls_variant_sync_failed_event_1.QlsVariantSyncFailedEvent(ctx, variant, new Date(), e));
             }
         }
         return {
@@ -261,13 +266,13 @@ let QlsProductService = class QlsProductService {
             filter: { sku: { eq: sku } },
         });
         if (!result.items.length) {
-            throw new Error(`Variant with sku '${sku}' not found`);
+            return core_1.Logger.info(`Variant with sku '${sku}' not found, not updating stock`, constants_1.loggerCtx);
         }
         const variant = result.items[0];
         if (result.items.length > 1) {
             core_1.Logger.error(`Multiple variants found for sku '${sku}', using '${variant.id}'`, constants_1.loggerCtx);
         }
-        return this.updateStock(ctx, variant.id, availableStock);
+        await this.updateStock(ctx, variant.id, availableStock);
     }
     /**
      * Determines if a product needs to be created or updated in QLS based on the given variant and existing QLS product.

package/dist/services/qls-variant-sync-failed-event.d.ts

@@ -0,0 +1,17 @@
+import { ProductVariant, RequestContext, VendureEvent } from '@vendure/core';
+/**
+ * Emitted when a variant failed to sync to QLS.
+ */
+export declare class QlsVariantSyncFailedEvent extends VendureEvent {
+    ctx: RequestContext;
+    /** The variant that failed to sync (at least id, may be full variant). */
+    variant: Partial<ProductVariant>;
+    failedAt: Date;
+    /** The error that caused the sync to fail. */
+    fullError: unknown;
+    constructor(ctx: RequestContext, 
+    /** The variant that failed to sync (at least id, may be full variant). */
+    variant: Partial<ProductVariant>, failedAt: Date, 
+    /** The error that caused the sync to fail. */
+    fullError: unknown);
+}

package/dist/services/qls-variant-sync-failed-event.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QlsVariantSyncFailedEvent = void 0;
+const core_1 = require("@vendure/core");
+/**
+ * Emitted when a variant failed to sync to QLS.
+ */
+class QlsVariantSyncFailedEvent extends core_1.VendureEvent {
+    constructor(ctx, 
+    /** The variant that failed to sync (at least id, may be full variant). */
+    variant, failedAt, 
+    /** The error that caused the sync to fail. */
+    fullError) {
+        super();
+        this.ctx = ctx;
+        this.variant = variant;
+        this.failedAt = failedAt;
+        this.fullError = fullError;
+    }
+}
+exports.QlsVariantSyncFailedEvent = QlsVariantSyncFailedEvent;

package/dist/types.d.ts

@@ -47,6 +47,11 @@ export interface QlsPluginOptions {
      * If not provided, default mapping will be used.
      */
     getReceiverContact?: (ctx: RequestContext, order: Order) => FulfillmentOrderInput['receiver_contact'] | undefined;
+    /**
+     * Admin UI tab name where the QLS Product ID custom field is shown on ProductVariant.
+     * Defaults to 'QLS'.
+     */
+    qlsProductIdUiTab?: string;
 }
 /**
  * Additional fields for a product variant that are used to create or update a product in QLS

package/dist/ui/providers.ts

@@ -1,4 +1,8 @@
-import { addActionBarDropdownMenuItem } from '@vendure/admin-ui/core';
+import {
+  addActionBarDropdownMenuItem,
+  ModalService,
+} from '@vendure/admin-ui/core';
+import { firstValueFrom } from 'rxjs';
 import gql from 'graphql-tag';
 
 export default [
@@ -42,7 +46,39 @@ export default [
     icon: 'resistor',
     requiresPermission: ['QLSFullSync'],
     hasDivider: true,
-    onClick: (_, { route, dataService, notificationService }) => {
+    onClick: async (
+      _,
+      { route, dataService, notificationService, injector }
+    ) => {
+      const orderId = route.snapshot.params.id;
+      const res = await firstValueFrom(
+        dataService.query(
+          gql`
+            query Order($orderId: ID!) {
+              order(id: $orderId) {
+                id
+                qlsOrderIds
+              }
+            }
+          `,
+          { orderId }
+        ).single$
+      );
+      if ((res as any).order.qlsOrderIds.length > 0) {
+        const modalService = injector.get(ModalService);
+        const confirmed = await firstValueFrom(
+          modalService.dialog({
+            title: 'Push order to QLS',
+            body: 'This order already exists in QLS. Are you sure you want to push it again?',
+            buttons: [
+              { type: 'secondary', label: 'Cancel', returnValue: false },
+              { type: 'primary', label: 'Push to QLS', returnValue: true },
+            ],
+          })
+        );
+        if (!confirmed) return;
+      }
+
       dataService
         .mutate(
           gql`
@@ -50,13 +86,10 @@ export default [
               pushOrderToQls(orderId: $orderId)
             }
           `,
-          {
-            orderId: route.snapshot.params.id,
-          }
+          { orderId }
         )
         .subscribe({
           next: (result) => {
-            console.log(result);
             notificationService.notify({
               message: (result as any).pushOrderToQls,
               type: 'success',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pinelab/vendure-plugin-qls-fulfillment",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Vendure plugin to fulfill orders via QLS.",
   "keywords": [
     "fulfillment",
@@ -32,5 +32,5 @@
   "dependencies": {
     "catch-unknown": "^2.0.0"
   },
-  "gitHead": "2e1abb0be4b76adacee78bedad19af28961acfaa"
+  "gitHead": "60255d8c40e4068a9f87601fbcedea27719e8385"
 }