@pinelab/vendure-plugin-qls-fulfillment 1.0.0-beta.1

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

@@ -0,0 +1,309 @@
+"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); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QlsProductService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const catch_unknown_1 = require("catch-unknown");
+const util_1 = __importDefault(require("util"));
+const constants_1 = require("../constants");
+const qls_client_1 = require("../lib/qls-client");
+let QlsProductService = class QlsProductService {
+    constructor(connection, options, jobQueueService, stockLevelService, variantService, stockLocationService, eventBus) {
+        this.connection = connection;
+        this.options = options;
+        this.jobQueueService = jobQueueService;
+        this.stockLevelService = stockLevelService;
+        this.variantService = variantService;
+        this.stockLocationService = stockLocationService;
+        this.eventBus = eventBus;
+    }
+    onApplicationBootstrap() {
+        // Listen for ProductVariantEvent and add a job to the queue
+        this.eventBus.ofType(core_1.ProductVariantEvent).subscribe((event) => {
+            if (event.type !== 'created' && event.type !== 'updated') {
+                return;
+            }
+            this.triggerSyncVariants(event.ctx, event.entity.map((v) => v.id)).catch((e) => {
+                const error = (0, catch_unknown_1.asError)(e);
+                core_1.Logger.error(`Error adding job to queue: ${error.message}`, constants_1.loggerCtx, error.stack);
+            });
+        });
+    }
+    async onModuleInit() {
+        this.productJobQueue = await this.jobQueueService.createQueue({
+            name: 'qls-product-jobs',
+            process: (job) => {
+                return this.handleProductJob(job);
+            },
+        });
+    }
+    /**
+     * Decide what kind of job it is and handle accordingly.
+     * Returns the result of the job, which will be stored in the job record.
+     */
+    async handleProductJob(job) {
+        try {
+            const ctx = core_1.RequestContext.deserialize(job.data.ctx);
+            if (job.data.action === 'full-sync-products') {
+                return await this.runFullSync(ctx);
+            }
+            else if (job.data.action === 'sync-products') {
+                return await this.syncVariants(ctx, job.data.productVariantIds);
+            }
+            throw new Error(`Unknown job action: ${job.data.action}`);
+        }
+        catch (e) {
+            const error = (0, catch_unknown_1.asError)(e);
+            const dataWithoutCtx = {
+                ...job.data,
+                ctx: undefined,
+            };
+            core_1.Logger.error(`Error handling job ${job.data.action}: ${error}`, constants_1.loggerCtx, util_1.default.inspect(dataWithoutCtx, false, 5));
+            throw error;
+        }
+    }
+    /**
+     * Create fulfillment products in QLS for all product variants (full push)
+     * 1. Fetches all products from QLS
+     * 2. Updates stock levels in Vendure based on the QLS products
+     * 3. Creates products in QLS if needed
+     * 4. Updates products in QLS if needed
+     */
+    async runFullSync(ctx) {
+        try {
+            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.info(`Running full sync for channel ${ctx.channel.token}`, constants_1.loggerCtx);
+            const allQlsProducts = await client.getAllFulfillmentProducts();
+            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;
+            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;
+                }
+            }
+            core_1.Logger.info(`Updated stock for ${updateStockCount} variants based on QLS stock levels`, constants_1.loggerCtx);
+            // Create or update products in QLS
+            let createdQlsProductsCount = 0;
+            let updatedQlsProductsCount = 0;
+            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;
+                }
+                else if (result === 'updated') {
+                    updatedQlsProductsCount += 1;
+                }
+            }
+            core_1.Logger.info(`Created ${createdQlsProductsCount} products in QLS`, constants_1.loggerCtx);
+            core_1.Logger.info(`Updated ${updatedQlsProductsCount} products in QLS`, constants_1.loggerCtx);
+            return {
+                updatedInQls: updatedQlsProductsCount,
+                createdInQls: createdQlsProductsCount,
+                updatedStock: updateStockCount,
+            };
+        }
+        catch (e) {
+            const error = (0, catch_unknown_1.asError)(e);
+            core_1.Logger.error(`Error running full sync: ${error.message}`, constants_1.loggerCtx, error.stack);
+            throw error;
+        }
+    }
+    /**
+     * Creates or updates the fulfillment products in QLS for the given product variants.
+     */
+    async syncVariants(ctx, productVariantIds) {
+        const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
+        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,
+            };
+        }
+        let updatedInQls = 0;
+        let createdInQls = 0;
+        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;
+            }
+            else if (result === 'updated') {
+                updatedInQls += 1;
+            }
+        }
+        return {
+            updatedInQls,
+            createdInQls,
+            updatedStock: 0,
+        };
+    }
+    /**
+     * Trigger a full product sync job
+     */
+    async triggerFullSync(ctx) {
+        return this.productJobQueue.add({
+            action: 'full-sync-products',
+            ctx: ctx.serialize(),
+        }, { retries: 5 });
+    }
+    /**
+     * Trigger a product sync job for particular product variants
+     */
+    async triggerSyncVariants(ctx, productVariantIds) {
+        const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
+        if (!client) {
+            core_1.Logger.debug(`QLS not enabled for channel ${ctx.channel.token}. Not triggering product sync.`, constants_1.loggerCtx);
+            return;
+        }
+        return this.productJobQueue.add({
+            action: 'sync-products',
+            ctx: ctx.serialize(),
+            productVariantIds,
+        }, { retries: 5 });
+    }
+    /**
+     * Update the stock level for a variant based on the given available stock
+     */
+    async updateStockBySku(ctx, sku, availableStock) {
+        const result = await this.variantService.findAll(ctx, {
+            filter: { sku: { eq: sku } },
+        });
+        if (!result.items.length) {
+            throw new Error(`Variant with sku '${sku}' not found`);
+        }
+        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);
+    }
+    /**
+     * 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;
+        let createdOrUpdated = 'not-changed';
+        if (!existingProduct) {
+            const result = await client.createFulfillmentProduct({
+                name: variant.name,
+                sku: variant.sku,
+                ...this.options.getAdditionalVariantFields?.(ctx, variant),
+            });
+            qlsProductId = result.id;
+            core_1.Logger.info(`Created product '${variant.sku}' in QLS`, constants_1.loggerCtx);
+            createdOrUpdated = 'created';
+        }
+        else if (this.shouldUpdateProductInQls(ctx, variant, existingProduct)) {
+            await client.updateFulfillmentProduct(existingProduct.id, {
+                sku: variant.sku,
+                name: variant.name,
+                ...this.options.getAdditionalVariantFields?.(ctx, variant),
+            });
+            core_1.Logger.info(`Updated product '${variant.sku}' in QLS`, constants_1.loggerCtx);
+            createdOrUpdated = 'updated';
+        }
+        if (qlsProductId !== 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);
+        }
+        return createdOrUpdated;
+    }
+    /**
+     * 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);
+        if (qlsProduct.name !== variant.name ||
+            qlsProduct.ean !== additionalFields?.ean ||
+            qlsProduct.image_url !== additionalFields?.image_url) {
+            // If name or ean has changed, product should be updated in QLS
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get all variants for the current channel in batches
+     */
+    async getAllVariants(ctx) {
+        const allVariants = [];
+        let skip = 0;
+        const take = 100;
+        let hasMore = true;
+        while (hasMore) {
+            const result = await this.variantService.findAll(ctx, {
+                filter: { deletedAt: { isNull: true } },
+                skip,
+                take,
+            });
+            if (!result.items.length) {
+                break;
+            }
+            allVariants.push(...result.items);
+            if (allVariants.length >= result.totalItems) {
+                hasMore = false;
+            }
+            skip += take;
+        }
+        return allVariants;
+    }
+    /**
+     * Update stock level for a variant based on the given available stock
+     */
+    async updateStock(ctx, variantId, availableStock) {
+        // Find default Stock Location
+        const defaultStockLocation = await this.stockLocationService.defaultStockLocation(ctx);
+        // Get current stock level id
+        const { id: stockLevelId } = await this.stockLevelService.getStockLevel(ctx, variantId, defaultStockLocation.id);
+        // Update stock level
+        await this.connection.getRepository(ctx, core_1.StockLevel).save({
+            id: stockLevelId,
+            stockOnHand: availableStock,
+            stockAllocated: 0, // Reset allocations, because allocation is handled by QLS
+        });
+        core_1.Logger.info(`Updated stock for variant ${variantId} to ${availableStock}`, constants_1.loggerCtx);
+    }
+};
+exports.QlsProductService = QlsProductService;
+exports.QlsProductService = QlsProductService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(constants_1.PLUGIN_INIT_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.TransactionalConnection, Object, core_1.JobQueueService,
+        core_1.StockLevelService,
+        core_1.ProductVariantService,
+        core_1.StockLocationService,
+        core_1.EventBus])
+], QlsProductService);

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+import { ID, Injector, Order, ProductVariant, RequestContext, SerializedRequestContext } from '@vendure/core';
+import { CustomValue, FulfillmentProductInput } from './lib/client-types';
+export interface QlsPluginOptions {
+    /**
+     * Get the QLS client config for the current channel based on given context
+     */
+    getConfig: (ctx: RequestContext) => QlsClientConfig | undefined | Promise<QlsClientConfig | undefined>;
+    /**
+     * 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>;
+    /**
+     * Function to get the set service point code for an order.
+     * Return undefined to not use a service point at all.
+     */
+    getAdditionalOrderFields?: (ctx: RequestContext, injector: Injector, order: Order) => Promise<AdditionalOrderFields | undefined> | AdditionalOrderFields | undefined;
+    /**
+     * A key used to verify if the caller is authorized to call the webhook.
+     * Set this to a random string
+     */
+    webhookSecret: string;
+}
+export interface AdditionalOrderFields {
+    servicepoint_code?: string;
+    delivery_options?: string[];
+    custom_values?: CustomValue[];
+}
+/**
+ * Job data required for pushing an order to QLS
+ */
+export interface QlsOrderJobData {
+    action: 'push-order';
+    ctx: SerializedRequestContext;
+    orderId: ID;
+}
+export type QlsProductJobData = FullProductsSyncJobData | ProductsSyncJobData;
+/**
+ * Job data required for pushing products to QLS (full sync)
+ */
+export interface FullProductsSyncJobData {
+    action: 'full-sync-products';
+    ctx: SerializedRequestContext;
+}
+/**
+ * Job data required for creating/updating fulfillment products in QLS (no full sync)
+ */
+export interface ProductsSyncJobData {
+    action: 'sync-products';
+    ctx: SerializedRequestContext;
+    productVariantIds: ID[];
+}
+export interface QlsClientConfig {
+    username: string;
+    password: string;
+    companyId: string;
+    brandId: string;
+    /**
+     * defaults to 'https://api.pakketdienstqls.nl'
+     */
+    url?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@pinelab/vendure-plugin-qls-fulfillment",
+  "version": "1.0.0-beta.1",
+  "description": "Vendure plugin to fulfill orders via QLS.",
+  "keywords": [
+    "fulfillment",
+    "fulfillment center",
+    "qls"
+  ],
+  "author": "Martijn van de Brug <martijn@pinelab.studio>",
+  "homepage": "https://plugins.pinelab.studio/",
+  "repository": "https://github.com/Pinelab-studio/pinelab-vendure-plugins",
+  "license": "MIT",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "rimraf dist && yarn generate && tsc",
+    "start": "nodemon --watch src --exec ts-node test/dev-server.ts",
+    "generate": "graphql-codegen",
+    "test": "vitest run --bail 1",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "catch-unknown": "^2.0.0"
+  }
+}