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

package/dist/lib/qls-client.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QlsClient = void 0;
+exports.getQlsClient = getQlsClient;
+const core_1 = require("@vendure/core");
+const constants_1 = require("../constants");
+async function getQlsClient(ctx, pluginOptions) {
+    const config = await pluginOptions.getConfig(ctx);
+    if (!config) {
+        core_1.Logger.info(`QLS not enabled for channel ${ctx.channel.token}`, constants_1.loggerCtx);
+        return undefined;
+    }
+    return new QlsClient(config);
+}
+/**
+ * Wrapper around the QLS Rest API.
+ */
+class QlsClient {
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = config.url || 'https://api.pakketdienstqls.nl';
+    }
+    /**
+     * Find a product by SKU.
+     * Returns the first product found, or undefined if no product is found.
+     */
+    async getFulfillmentProductBySku(sku) {
+        const result = await this.rawRequest('GET', `fulfillment/products?filter%5Bsku%5D=${encodeURIComponent(sku)}`);
+        if (result.data.length === 0) {
+            return undefined;
+        }
+        if (result.data.length > 1) {
+            core_1.Logger.error(`Multiple products found for SKU: ${sku}`, constants_1.loggerCtx, JSON.stringify(result.data));
+        }
+        return result.data[0];
+    }
+    /**
+     * Get stock for all fulfillment products.
+     * Might require multiple requests if the result is paginated.
+     */
+    async getAllFulfillmentProducts() {
+        let page = 1;
+        const allProducts = [];
+        let hasNextPage = true;
+        while (hasNextPage) {
+            const result = await this.rawRequest('GET', `fulfillment/products?page=${page}`);
+            if (!result.data || result.data.length === 0) {
+                break;
+            }
+            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
+        }
+        return allProducts;
+    }
+    async createFulfillmentProduct(data) {
+        const response = await this.rawRequest('POST', 'fulfillment/products', data);
+        return response.data;
+    }
+    async updateFulfillmentProduct(fulfillmentProductId, data) {
+        const response = await this.rawRequest('PUT', `fulfillment/products/${fulfillmentProductId}`, data);
+        return response.data;
+    }
+    async createFulfillmentOrder(data) {
+        const response = await this.rawRequest('POST', 'fulfillment/orders', {
+            ...data,
+            brand_id: this.config.brandId,
+        });
+        return response.data;
+    }
+    async rawRequest(method, action, data) {
+        // Set headers
+        const headers = {
+            Authorization: `Basic ${Buffer.from(`${this.config.username}:${this.config.password}`).toString('base64')}`,
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+        };
+        const body = data ? JSON.stringify(data) : undefined;
+        const url = `${this.baseUrl}/companies/${this.config.companyId}/${action}`;
+        const response = await fetch(url, {
+            method,
+            headers,
+            body,
+        });
+        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);
+            throw new Error(errorText);
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            return response.json();
+        }
+        throw new Error(`Unexpected content type: ${contentType}`);
+    }
+}
+exports.QlsClient = QlsClient;

package/dist/qls-plugin.d.ts

@@ -0,0 +1,8 @@
+import { Type } from '@vendure/core';
+import { AdminUiExtension } from '@vendure/ui-devkit/compiler';
+import { QlsPluginOptions } from './types';
+export declare class QlsPlugin {
+    static options: QlsPluginOptions;
+    static init(options: QlsPluginOptions): Type<QlsPlugin>;
+    static ui: AdminUiExtension;
+}

package/dist/qls-plugin.js

@@ -0,0 +1,60 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var QlsPlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QlsPlugin = void 0;
+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_webhooks_controller_1 = require("./api/qls-webhooks-controller");
+const permissions_1 = require("./config/permissions");
+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");
+let QlsPlugin = QlsPlugin_1 = class QlsPlugin {
+    static init(options) {
+        this.options = options;
+        return QlsPlugin_1;
+    }
+};
+exports.QlsPlugin = QlsPlugin;
+QlsPlugin.ui = {
+    extensionPath: path_1.default.join(__dirname, 'ui'),
+    id: 'qls-fulfillment-ui',
+    providers: ['providers.ts'],
+};
+exports.QlsPlugin = QlsPlugin = QlsPlugin_1 = __decorate([
+    (0, core_1.VendurePlugin)({
+        imports: [core_1.PluginCommonModule],
+        providers: [
+            {
+                provide: constants_1.PLUGIN_INIT_OPTIONS,
+                useFactory: () => QlsPlugin.options,
+            },
+            qls_product_service_1.QlsProductService,
+            qls_order_service_1.QlsOrderService,
+        ],
+        controllers: [qls_webhooks_controller_1.QlsWebhooksController],
+        configuration: (config) => {
+            config.authOptions.customPermissions.push(permissions_1.qlsFullSyncPermission);
+            config.authOptions.customPermissions.push(permissions_1.qlsPushOrderPermission);
+            config.customFields.ProductVariant.push(...custom_fields_1.variantCustomFields);
+            return config;
+        },
+        compatibility: '>=3.2.0',
+        adminApiExtensions: {
+            schema: api_extensions_1.adminApiExtensions,
+            resolvers: [qls_admin_resolver_1.QlsAdminResolver],
+        },
+    })
+], QlsPlugin);

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

@@ -0,0 +1,29 @@
+import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { EventBus, ID, Job, JobQueueService, OrderService, RequestContext, TransactionalConnection } from '@vendure/core';
+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);
+    onApplicationBootstrap(): void;
+    onModuleInit(): Promise<void>;
+    /**
+     * Decide what kind of job it is and handle accordingly.
+     * Returns the result of the job, which will be stored in the job record.
+     */
+    handleOrderJob(job: Job<QlsOrderJobData>): Promise<unknown>;
+    pushOrderToQls(ctx: RequestContext, orderId: ID): Promise<string>;
+    /**
+     * Update the status of an order in QLS based on the given order code and status
+     */
+    handleOrderStatusUpdate(ctx: RequestContext, body: IncomingOrderWebhook): Promise<void>;
+    triggerPushOrder(ctx: RequestContext, orderId: ID, orderCode?: string): Promise<Job<QlsOrderJobData> | undefined>;
+    private getVendureOrderState;
+}

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

@@ -0,0 +1,210 @@
+"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.QlsOrderService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const core_2 = 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 QlsOrderService = class QlsOrderService {
+    constructor(connection, options, jobQueueService, eventBus, orderService, moduleRef) {
+        this.connection = connection;
+        this.options = options;
+        this.jobQueueService = jobQueueService;
+        this.eventBus = eventBus;
+        this.orderService = orderService;
+        this.moduleRef = moduleRef;
+    }
+    onApplicationBootstrap() {
+        // Listen for OrderPlacedEvent and add a job to the queue
+        this.eventBus.ofType(core_2.OrderPlacedEvent).subscribe((event) => {
+            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);
+            });
+        });
+    }
+    async onModuleInit() {
+        this.orderJobQueue = await this.jobQueueService.createQueue({
+            name: 'qls-order-jobs',
+            process: (job) => {
+                return this.handleOrderJob(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 handleOrderJob(job) {
+        try {
+            const ctx = core_2.RequestContext.deserialize(job.data.ctx);
+            if (job.data.action === 'push-order') {
+                return await this.pushOrderToQls(ctx, job.data.orderId);
+            }
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- According to TS this cant happen, in reality an old job with different action could be in the queue
+            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_2.Logger.error(`Error handling job ${job.data.action}: ${error}`, constants_1.loggerCtx, util_1.default.inspect(dataWithoutCtx, false, 5));
+            throw error;
+        }
+    }
+    async pushOrderToQls(ctx, orderId) {
+        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
+            throw new Error(`QLS not enabled for channel ${ctx.channel.token}`);
+        }
+        const order = await this.orderService.findOne(ctx, orderId);
+        if (!order) {
+            throw new Error(`No order with id ${orderId} not found`);
+        }
+        try {
+            // Check if all products are available in QLS
+            const qlsProducts = order.lines.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.`);
+                }
+                return {
+                    amount_ordered: line.quantity,
+                    product_id: line.productVariant.customFields.qlsProductId,
+                    name: line.productVariant.name,
+                };
+            });
+            const additionalOrderFields = await this.options.getAdditionalOrderFields?.(ctx, new core_2.Injector(this.moduleRef), order);
+            const customerName = [order.customer?.firstName, order.customer?.lastName]
+                .filter(Boolean)
+                .join(' ');
+            // Validate customer and shipping address
+            if (!order.customer) {
+                throw new Error(`Order '${order.code}' has no customer! Can not push order to QLS.`);
+            }
+            if (!order.shippingAddress) {
+                throw new Error(`Order '${order.code}' has no shipping address! Can not push order to QLS.`);
+            }
+            if (!order.shippingAddress.streetLine1 ||
+                !order.shippingAddress.postalCode ||
+                !order.shippingAddress.city ||
+                !order.shippingAddress.streetLine2 ||
+                !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 qlsOrder = {
+                customer_reference: order.code,
+                processable: new Date().toISOString(), // Processable starting now
+                servicepoint_code: additionalOrderFields?.servicepoint_code,
+                delivery_options: additionalOrderFields?.delivery_options ?? [],
+                total_price: order.totalWithTax,
+                receiver_contact: {
+                    name: order.shippingAddress.fullName || customerName,
+                    companyname: order.shippingAddress.company,
+                    street: order.shippingAddress.streetLine1,
+                    housenumber: order.shippingAddress.streetLine2,
+                    postalcode: order.shippingAddress.postalCode,
+                    locality: order.shippingAddress.city,
+                    country: order.shippingAddress.countryCode.toUpperCase(),
+                    email: order.customer.emailAddress,
+                    phone: order.customer.phoneNumber,
+                },
+                products: qlsProducts,
+                ...(additionalOrderFields ?? {}),
+            };
+            const result = await client.createFulfillmentOrder(qlsOrder);
+            await this.orderService.addNoteToOrder(ctx, {
+                id: orderId,
+                isPublic: false,
+                note: `Created order '${result.id}' in QLS`,
+            });
+            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, {
+                id: orderId,
+                isPublic: false,
+                note: `Failed to create order '${order.code}' in QLS: ${error.message}`,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Update the status of an order in QLS based on the given order code and status
+     */
+    async handleOrderStatusUpdate(ctx, body) {
+        const orderCode = body.customer_reference;
+        const order = await this.orderService.findOneByCode(ctx, orderCode, []);
+        if (!order) {
+            throw new Error(`Order with code '${orderCode}' not found`);
+        }
+        const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
+        if (!client) {
+            throw new Error(`QLS not enabled for channel ${ctx.channel.token}`);
+        }
+        const vendureOrderState = this.getVendureOrderState(body);
+        if (!vendureOrderState) {
+            core_2.Logger.info(`Not handling QLS order status '${body.status}' for order '${orderCode}', because no Vendure order state found for this status`, constants_1.loggerCtx);
+            return;
+        }
+        await this.orderService.transitionToState(ctx, order.id, vendureOrderState);
+        core_2.Logger.info(`Successfully updated order '${orderCode}' to '${vendureOrderState}'`, constants_1.loggerCtx);
+    }
+    async triggerPushOrder(ctx, orderId, orderCode) {
+        const client = await (0, qls_client_1.getQlsClient)(ctx, this.options);
+        if (!client) {
+            // QLS not enabled for channel, so don't add a job to the queue
+            core_2.Logger.info(`QLS not enabled for channel ${ctx.channel.token}, not adding order '${orderCode ?? orderId}' job to queue`, constants_1.loggerCtx);
+            return;
+        }
+        return await this.orderJobQueue.add({
+            action: 'push-order',
+            ctx: ctx.serialize(),
+            orderId,
+        }, { retries: 5 });
+    }
+    getVendureOrderState(body) {
+        if (body.cancelled) {
+            return 'Cancelled';
+        }
+        if (body.amount_delivered === body.amount_total) {
+            return 'Delivered';
+        }
+        switch (body.status) {
+            case 'sent':
+                return 'Shipped';
+            case 'partically_sent':
+                return 'PartiallyShipped';
+        }
+    }
+};
+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,
+        core_2.EventBus,
+        core_2.OrderService,
+        core_1.ModuleRef])
+], QlsOrderService);

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

@@ -0,0 +1,69 @@
+import { OnApplicationBootstrap, OnModuleInit } from '@nestjs/common';
+import { EventBus, ID, Job, JobQueueService, ProductVariant, ProductVariantService, RequestContext, StockLevelService, StockLocationService, TransactionalConnection } from '@vendure/core';
+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;
+};
+export declare class QlsProductService implements OnModuleInit, OnApplicationBootstrap {
+    private connection;
+    private options;
+    private jobQueueService;
+    private stockLevelService;
+    private readonly variantService;
+    private readonly stockLocationService;
+    private readonly eventBus;
+    private productJobQueue;
+    constructor(connection: TransactionalConnection, options: QlsPluginOptions, jobQueueService: JobQueueService, stockLevelService: StockLevelService, variantService: ProductVariantService, stockLocationService: StockLocationService, eventBus: EventBus);
+    onApplicationBootstrap(): void;
+    onModuleInit(): Promise<void>;
+    /**
+     * Decide what kind of job it is and handle accordingly.
+     * Returns the result of the job, which will be stored in the job record.
+     */
+    handleProductJob(job: Job<QlsProductJobData>): Promise<unknown>;
+    /**
+     * 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
+     */
+    runFullSync(ctx: RequestContext): Promise<SyncProductsJobResult>;
+    /**
+     * Creates or updates the fulfillment products in QLS for the given product variants.
+     */
+    syncVariants(ctx: RequestContext, productVariantIds: ID[]): Promise<SyncProductsJobResult>;
+    /**
+     * Trigger a full product sync job
+     */
+    triggerFullSync(ctx: RequestContext): Promise<import("@vendure/core/dist/job-queue/subscribable-job").SubscribableJob<QlsProductJobData>>;
+    /**
+     * Trigger a product sync job for particular product variants
+     */
+    triggerSyncVariants(ctx: RequestContext, productVariantIds: ID[]): Promise<import("@vendure/core/dist/job-queue/subscribable-job").SubscribableJob<QlsProductJobData> | undefined>;
+    /**
+     * Update the stock level for a variant based on the given available stock
+     */
+    updateStockBySku(ctx: RequestContext, sku: string, availableStock: number): Promise<void>;
+    /**
+     * 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'>;
+    /**
+     * Determine if a product needs to be updated in QLS based on the given variant and QLS product.
+     */
+    private shouldUpdateProductInQls;
+    /**
+     * Get all variants for the current channel in batches
+     */
+    private getAllVariants;
+    /**
+     * Update stock level for a variant based on the given available stock
+     */
+    private updateStock;
+}
+export {};