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

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 1.0.0 (2025-11-07) ## CHANGE THIS DATE AND VERSION
+
+- Initial release

package/README.md

@@ -0,0 +1,65 @@
+# Vendure plugin to fulfill orders via QLS
+
+Vendure plugin to fulfill orders via QLS. This uses QLS as fulfillment center and does not support shipments only via QLS.
+
+[Official documentation here](https://plugins.pinelab.studio/plugin/vendure-plugin-qls-fulfillment)
+
+This plugin contains:
+
+## Product Sync
+
+- Full product sync (via Admin UI):
+  - Fetches all products from QLS
+  - Ensures corresponding Vendure variants exist
+  - Updates Vendure stock levels from QLS
+- Partial product sync: Creates/updates products in QLS when products change in Vendure
+- Partial stock sync: Updates Vendure stock based on incoming QLS webhooks
+
+## Order Sync
+
+- Pushes orders to QLS automatically on order placement
+- Supports manual order push to QLS via Admin UI
+- Updates order status in Vendure based on QLS webhooks
+
+## Getting started
+
+// TODO
+
+This plugin requires the default order process to be configured with `checkFulfillmentStates: false`, so that orders can be transitioned to Shipped and Delivered without the need of fulfillment. Fulfillment is the responsibility of Picqer, so we won't handle that in Vendure when using this plugin.
+
+## Webhooks
+
+You should set up webhooks for the following events:
+
+- `fulfillment_order.cancelled`
+- `fulfillment_product.stock`
+- `fulfillment_order.status`
+- `fulfillment_order.completed`
+
+The URL for all these events should be `https://<YOUR_VENDURE_HOST>/qls/webhook/<CHANNEL_TOKEN>?secret=<PLUGIN_SECRET>`. E.g. `https://example.com/qls/webhook/your-channel-token?secret=121231`.
+
+- `<YOUR_VENDURE_HOST>` is the URL of your Vendure instance.
+- `<CHANNEL_TOKEN>` is the token of the channel you want to use.
+- `<PLUGIN_SECRET>` is the webhook secret you've passed into the plugin's `init()` function.
+
+### Stock location setup
+
+This plugin only uses Vendure's default stock location, that means you should either:
+
+1. Remove all but one stock location in Vendure
+2. Or, remove all stock from other stock locations than the default in Vendure
+
+Vendure assumes the first created stock location is the default stock location.
+
+## Monitoring
+
+Make sure to monitor failed jobs: A job that failed after its retries were exhausted, means:
+
+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.
+
+## Cancelling orders and manually pushing orders to QLS
+
+// TODO: Push will just create a new order in QLS, it will not cancel the existing order in QLS. Cancel existing order first via https://mijn.pakketdienstqls.nl/

package/dist/api/api-extensions.d.ts

@@ -0,0 +1 @@
+export declare const adminApiExtensions: import("graphql").DocumentNode;

package/dist/api/api-extensions.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminApiExtensions = void 0;
+const graphql_tag_1 = __importDefault(require("graphql-tag"));
+exports.adminApiExtensions = (0, graphql_tag_1.default) `
+  extend type Mutation {
+    """
+    Trigger a sync to create or update all products in Vendure to QLS, and pull in stock levels from QLS.
+    """
+    triggerQlsProductSync: Boolean!
+
+    """
+    Manually push an order to QLS (again)
+    """
+    pushOrderToQls(orderId: ID!): String!
+  }
+`;

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

@@ -0,0 +1,31 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: string | number;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+};
+export type Mutation = {
+    __typename?: 'Mutation';
+    /** Manually push an order to QLS (again) */
+    pushOrderToQls: Scalars['String'];
+    /** Trigger a sync to create or update all products in Vendure to QLS, and pull in stock levels from QLS. */
+    triggerQlsProductSync: Scalars['Boolean'];
+};
+export type MutationPushOrderToQlsArgs = {
+    orderId: Scalars['ID'];
+};

package/dist/api/generated/graphql.js

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

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

@@ -0,0 +1,11 @@
+import { RequestContext } from '@vendure/core';
+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 qlsOrderService;
+    constructor(qlsService: QlsProductService, qlsOrderService: QlsOrderService);
+    triggerQlsProductSync(ctx: RequestContext): Promise<boolean>;
+    pushOrderToQls(ctx: RequestContext, input: MutationPushOrderToQlsArgs): Promise<string>;
+}

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

@@ -0,0 +1,59 @@
+"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.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");
+let QlsAdminResolver = class QlsAdminResolver {
+    constructor(qlsService, qlsOrderService) {
+        this.qlsService = qlsService;
+        this.qlsOrderService = qlsOrderService;
+    }
+    async triggerQlsProductSync(ctx) {
+        await this.qlsService.triggerFullSync(ctx);
+        return true;
+    }
+    async pushOrderToQls(ctx, input) {
+        return await this.qlsOrderService.pushOrderToQls(ctx, input.orderId);
+    }
+};
+exports.QlsAdminResolver = QlsAdminResolver;
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Transaction)(),
+    (0, core_1.Allow)(permissions_1.qlsFullSyncPermission.Permission),
+    __param(0, (0, core_1.Ctx)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext]),
+    __metadata("design:returntype", Promise)
+], QlsAdminResolver.prototype, "triggerQlsProductSync", null);
+__decorate([
+    (0, graphql_1.Mutation)(),
+    (0, core_1.Transaction)(),
+    (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.Args)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [core_1.RequestContext, Object]),
+    __metadata("design:returntype", Promise)
+], QlsAdminResolver.prototype, "pushOrderToQls", null);
+exports.QlsAdminResolver = QlsAdminResolver = __decorate([
+    (0, graphql_1.Resolver)(),
+    __metadata("design:paramtypes", [qls_product_service_1.QlsProductService,
+        qls_order_service_1.QlsOrderService])
+], QlsAdminResolver);

package/dist/api/qls-webhooks-controller.d.ts

@@ -0,0 +1,18 @@
+import { ChannelService } from '@vendure/core';
+import { Request } from 'express';
+import { QlsProductService } from '../services/qls-product.service';
+import { QlsPluginOptions } from '../types';
+import { QlsOrderService } from '../services/qls-order.service';
+import { IncomingOrderWebhook, IncomingStockWebhook } from '../lib/client-types';
+export declare class QlsWebhooksController {
+    private channelService;
+    private qlsProductService;
+    private qlsOrderService;
+    private options;
+    constructor(channelService: ChannelService, qlsProductService: QlsProductService, qlsOrderService: QlsOrderService, options: QlsPluginOptions);
+    /**
+     * Endpoint for all incoming webhooks
+     */
+    events(channelToken: string, webhookSecret: string, request: Request, body: IncomingStockWebhook | IncomingOrderWebhook): Promise<void>;
+    private getCtxForChannel;
+}

package/dist/api/qls-webhooks-controller.js

@@ -0,0 +1,93 @@
+"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.QlsWebhooksController = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@vendure/core");
+const catch_unknown_1 = require("catch-unknown");
+const qls_product_service_1 = require("../services/qls-product.service");
+const constants_1 = require("../constants");
+const qls_order_service_1 = require("../services/qls-order.service");
+let QlsWebhooksController = class QlsWebhooksController {
+    constructor(channelService, qlsProductService, qlsOrderService, options) {
+        this.channelService = channelService;
+        this.qlsProductService = qlsProductService;
+        this.qlsOrderService = qlsOrderService;
+        this.options = options;
+    }
+    /**
+     * Endpoint for all incoming webhooks
+     */
+    async events(channelToken, webhookSecret, request, body) {
+        if (webhookSecret !== this.options.webhookSecret) {
+            return core_1.Logger.warn(`Incoming webhook with invalid secret for channel '${channelToken}' to '${request.url}'`, constants_1.loggerCtx);
+        }
+        try {
+            const ctx = await this.getCtxForChannel(channelToken);
+            if (!ctx) {
+                return core_1.Logger.error(`Incoming webhook with invalid channel token for channel '${channelToken}' to '${request.url}'`, constants_1.loggerCtx, JSON.stringify(body));
+            }
+            if (isStockWebhook(body)) {
+                await this.qlsProductService.updateStockBySku(ctx, body.sku, body.amount_available);
+            }
+            else if (isOrderWebhook(body)) {
+                await this.qlsOrderService.handleOrderStatusUpdate(ctx, body);
+            }
+            else {
+                throw Error(`Invalid webhook body: ${JSON.stringify(body)}`);
+            }
+        }
+        catch (error) {
+            core_1.Logger.error(`QLS webhook error: ${(0, catch_unknown_1.asError)(error).message}`);
+            throw error;
+        }
+    }
+    async getCtxForChannel(token) {
+        const channel = await this.channelService.getChannelFromToken(token);
+        if (token !== channel.token) {
+            // This validation is needed. Vendure returns the default channel when a non-existing channel token is provided.
+            return undefined;
+        }
+        return new core_1.RequestContext({
+            apiType: 'admin',
+            authorizedAsOwnerOnly: false,
+            channel,
+            isAuthorized: true,
+        });
+    }
+};
+exports.QlsWebhooksController = QlsWebhooksController;
+__decorate([
+    (0, common_1.Post)('/webhook/:channelToken'),
+    __param(0, (0, common_1.Param)('channelToken')),
+    __param(1, (0, common_1.Query)('secret')),
+    __param(2, (0, common_1.Req)()),
+    __param(3, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], QlsWebhooksController.prototype, "events", null);
+exports.QlsWebhooksController = QlsWebhooksController = __decorate([
+    (0, common_1.Controller)('qls'),
+    __param(3, (0, common_1.Inject)(constants_1.PLUGIN_INIT_OPTIONS)),
+    __metadata("design:paramtypes", [core_1.ChannelService,
+        qls_product_service_1.QlsProductService,
+        qls_order_service_1.QlsOrderService, Object])
+], QlsWebhooksController);
+function isStockWebhook(body) {
+    return 'amount_available' in body;
+}
+function isOrderWebhook(body) {
+    return 'customer_reference' in body && 'status' in body;
+}

package/dist/config/full-product-sync-task.d.ts

@@ -0,0 +1,2 @@
+import { ScheduledTask } from '@vendure/core';
+export declare const fullProductSyncTask: ScheduledTask<{}>;

package/dist/config/full-product-sync-task.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fullProductSyncTask = void 0;
+const core_1 = require("@vendure/core");
+const qls_product_service_1 = require("../services/qls-product.service");
+const constants_1 = require("../constants");
+exports.fullProductSyncTask = new core_1.ScheduledTask({
+    id: 'full-sync-qls-products',
+    description: 'Trigger a full sync of products to QLS',
+    params: {},
+    schedule: (cron) => cron.everyDayAt(3, 0),
+    async execute({ injector }) {
+        const qlsProductService = injector.get(qls_product_service_1.QlsProductService);
+        // Verify for what channels we need to trigger QLS full sync
+        const ctx = await injector.get(core_1.RequestContextService).create({
+            apiType: 'admin',
+        });
+        const channels = await injector.get(core_1.ChannelService).findAll(ctx);
+        let triggeredFullSync = 0;
+        for (const channel of channels.items) {
+            // Create ctx for channel
+            const channelCtx = new core_1.RequestContext({
+                apiType: 'admin',
+                channel: channel,
+                isAuthorized: true,
+                authorizedAsOwnerOnly: false,
+            });
+            const options = injector
+                .get(constants_1.PLUGIN_INIT_OPTIONS)
+                .getConfig(channelCtx);
+            if (!options) {
+                core_1.Logger.info(`QLS not enabled for channel ${channel.token}`, constants_1.loggerCtx);
+                continue;
+            }
+            await qlsProductService.triggerFullSync(ctx);
+            triggeredFullSync += 1;
+        }
+        return {
+            message: `Triggered full sync for ${triggeredFullSync} channels`,
+        };
+    },
+});

package/dist/config/permissions.d.ts

@@ -0,0 +1,3 @@
+import { PermissionDefinition } from '@vendure/core';
+export declare const qlsFullSyncPermission: PermissionDefinition;
+export declare const qlsPushOrderPermission: PermissionDefinition;

package/dist/config/permissions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qlsPushOrderPermission = exports.qlsFullSyncPermission = void 0;
+const core_1 = require("@vendure/core");
+exports.qlsFullSyncPermission = new core_1.PermissionDefinition({
+    name: 'QLSFullSync',
+    description: 'Allows triggering QLS full sync',
+});
+exports.qlsPushOrderPermission = new core_1.PermissionDefinition({
+    name: 'QLSPushOrder',
+    description: 'Allows pushing orders to QLS',
+});

package/dist/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const loggerCtx = "QlsPlugin";
+export declare const PLUGIN_INIT_OPTIONS: unique symbol;

package/dist/constants.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_INIT_OPTIONS = exports.loggerCtx = void 0;
+exports.loggerCtx = 'QlsPlugin';
+exports.PLUGIN_INIT_OPTIONS = Symbol('PLUGIN_OPTIONS');

package/dist/custom-fields.d.ts

@@ -0,0 +1,7 @@
+import { CustomFieldConfig } from '@vendure/core';
+declare module '@vendure/core' {
+    interface CustomProductVariantFields {
+        qlsProductId?: string;
+    }
+}
+export declare const variantCustomFields: CustomFieldConfig[];

package/dist/custom-fields.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantCustomFields = void 0;
+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' },
+    },
+];

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './api/generated/graphql';
+export * from './config/full-product-sync-task';
+export * from './custom-fields';
+export * from './lib/client-types';
+export * from './lib/qls-client';
+export * from './qls-plugin';
+export * from './services/qls-order.service';
+export * from './services/qls-product.service';
+export * from './config/permissions';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api/generated/graphql"), exports);
+__exportStar(require("./config/full-product-sync-task"), exports);
+__exportStar(require("./custom-fields"), exports);
+__exportStar(require("./lib/client-types"), exports);
+__exportStar(require("./lib/qls-client"), exports);
+__exportStar(require("./qls-plugin"), exports);
+__exportStar(require("./services/qls-order.service"), exports);
+__exportStar(require("./services/qls-product.service"), exports);
+__exportStar(require("./config/permissions"), exports);
+__exportStar(require("./types"), exports);

package/dist/lib/client-types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * QLS API types only
+ */
+export interface QlsApiResponse<T> {
+    meta: {
+        code: number;
+    };
+    data: T;
+    pagination?: {
+        page: number;
+        limit: number;
+        count: number;
+        pageCount: number;
+        nextPage: boolean;
+        prevPage: boolean;
+    };
+}
+export type FulfillmentProductInput = {
+    name: string;
+    ean?: string;
+    sku: string;
+    image_url?: string;
+    price_cost?: number;
+    price_store?: number;
+    order_unit?: number;
+};
+export type FulfillmentProduct = {
+    id: string;
+    company_id: string;
+    collection_id: string | null;
+    dimensions: unknown;
+    article_number: string | null;
+    ean: string;
+    name: string;
+    sku: string;
+    image_url: string | null;
+    country_code_of_origin: string | null;
+    hs_code: string | null;
+    need_barcode_picking: boolean;
+    need_best_before_stock: boolean;
+    need_serial_number: boolean;
+    amount_available: number;
+    amount_reserved: number;
+    amount_total: number;
+    price_cost: number | null;
+    price_store: number | null;
+    weight: number;
+    created: string;
+    modified: string;
+    foldable: boolean;
+    fulfillment_product_brand_id: string | null;
+    description: string | null;
+    amount_blocked: number;
+    status: string | null;
+    suppliers: unknown[];
+    barcodes: string[];
+    image_url_handheld: string | null;
+    barcodes_and_ean: string[];
+};
+export interface FulfillmentOrderInput {
+    brand_id: string;
+    customer_reference: string;
+    processable: string;
+    servicepoint_code?: string;
+    total_price: number;
+    receiver_contact: FulfillmentOrderReceiverContactInput;
+    custom_values?: CustomValue[];
+    products: FulfillmentOrderLineInput[];
+    delivery_options: string[];
+}
+export interface FulfillmentOrderReceiverContactInput {
+    name: string;
+    companyname?: string;
+    street: string;
+    housenumber: string;
+    address2?: string | null;
+    postalcode: string;
+    locality: string;
+    country: string;
+    email?: string | null;
+    phone?: string | null;
+    vat?: string | null;
+    eori?: string | null;
+    oss?: string | null;
+}
+export interface CustomValue {
+    key: string;
+    value: string;
+}
+export interface FulfillmentOrderLineInput {
+    amount_ordered: number;
+    product_id: string;
+    name: string;
+    custom_values?: CustomValue[];
+}
+export type QlsOrderStatus = 'concept' | 'error_validation' | 'received' | 'pending' | 'partically_sent' | 'sent';
+export interface FulfillmentOrder {
+    id: string;
+    customer_reference: string;
+    amount_delivered: number | null;
+    amount_reserved: number | null;
+    amount_total: number;
+    status: QlsOrderStatus;
+    created: string;
+    modified: string;
+    cancelled: boolean | null;
+    hold: boolean | null;
+    processable: string;
+    shop_integration_id: string | null;
+    shop_integration_reference: string | null;
+    need_customs_information: boolean | null;
+    brand: string | null;
+    receiver_contact: {
+        companyName: string | null;
+        name: string;
+        phone: string | null;
+        email: string | null;
+        street: string;
+        houseNumber: string | null;
+        address2: string | null;
+        postalCode: string | null;
+        locality: string;
+        country: string;
+    };
+    delivery_options: string[];
+    products: Array<{
+        id: string;
+        order_id: string;
+        product_id: string;
+        name: string;
+        shop_integration_reference: string | null;
+        status: string | null;
+        amount_open: number | null;
+        amount_ordered: number;
+        amount_reserved: number | null;
+        amount_delivered: number | null;
+        amount_original: number | null;
+        country_code_of_origin: string | null;
+        hs_code: string | null;
+        price_per_unit: number | null;
+        custom1: string | null;
+        special_handling: string | null;
+        weight_per_unit: number | null;
+        company_id: string;
+        created: string;
+        modified: string;
+        product: unknown;
+    }>;
+}
+export type IncomingStockWebhook = Pick<FulfillmentProduct, 'sku' | 'amount_available'>;
+export type IncomingOrderWebhook = Pick<FulfillmentOrder, 'customer_reference' | 'status' | 'cancelled' | 'amount_delivered' | 'amount_total'>;

package/dist/lib/client-types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * QLS API types only
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/qls-client.d.ts

@@ -0,0 +1,26 @@
+import { RequestContext } from '@vendure/core';
+import { QlsClientConfig, QlsPluginOptions } from '../types';
+import type { FulfillmentOrder, FulfillmentOrderInput, FulfillmentProduct, FulfillmentProductInput, QlsApiResponse } from './client-types';
+export declare function getQlsClient(ctx: RequestContext, pluginOptions: QlsPluginOptions): Promise<QlsClient | undefined>;
+/**
+ * Wrapper around the QLS Rest API.
+ */
+export declare class QlsClient {
+    private readonly config;
+    private baseUrl;
+    constructor(config: QlsClientConfig);
+    /**
+     * Find a product by SKU.
+     * Returns the first product found, or undefined if no product is found.
+     */
+    getFulfillmentProductBySku(sku: string): Promise<FulfillmentProduct | undefined>;
+    /**
+     * Get stock for all fulfillment products.
+     * Might require multiple requests if the result is paginated.
+     */
+    getAllFulfillmentProducts(): Promise<FulfillmentProduct[]>;
+    createFulfillmentProduct(data: FulfillmentProductInput): Promise<FulfillmentProduct>;
+    updateFulfillmentProduct(fulfillmentProductId: string, data: FulfillmentProductInput): Promise<FulfillmentProduct>;
+    createFulfillmentOrder(data: Omit<FulfillmentOrderInput, 'brand_id'>): Promise<FulfillmentOrder>;
+    rawRequest<T>(method: 'POST' | 'GET' | 'PUT' | 'DELETE', action: string, data?: unknown): Promise<QlsApiResponse<T>>;
+}