@deenruv/core 1.0.0

package/dist/config/order/merge-orders-strategy.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MergeOrdersStrategy = void 0;
+const order_merge_strategy_1 = require("./order-merge-strategy");
+/**
+ * @description
+ * Merges both Orders. If the guest order contains items which are already in the
+ * existing Order, the guest Order quantity will replace that of the existing Order.
+ *
+ * @docsCategory orders
+ * @docsPage Merge Strategies
+ */
+class MergeOrdersStrategy {
+    merge(ctx, guestOrder, existingOrder) {
+        const mergedLines = existingOrder.lines.map(order_merge_strategy_1.toMergedOrderLine);
+        const guestLines = guestOrder.lines.slice();
+        for (const guestLine of guestLines.reverse()) {
+            const existingLine = this.findCorrespondingLine(existingOrder, guestLine);
+            if (!existingLine) {
+                mergedLines.unshift((0, order_merge_strategy_1.toMergedOrderLine)(guestLine));
+            }
+            else {
+                const matchingMergedLine = mergedLines.find((l) => l.orderLineId === existingLine.id);
+                if (matchingMergedLine) {
+                    matchingMergedLine.quantity = guestLine.quantity;
+                }
+            }
+        }
+        return mergedLines;
+    }
+    findCorrespondingLine(existingOrder, guestLine) {
+        return existingOrder.lines.find((line) => line.productVariant.id === guestLine.productVariant.id &&
+            JSON.stringify(line.customFields) ===
+                JSON.stringify(guestLine.customFields));
+    }
+}
+exports.MergeOrdersStrategy = MergeOrdersStrategy;
+//# sourceMappingURL=merge-orders-strategy.js.map

package/dist/config/order/merge-orders-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-orders-strategy.js","sourceRoot":"","sources":["../../../src/config/order/merge-orders-strategy.ts"],"names":[],"mappings":";;;AAIA,iEAIgC;AAEhC;;;;;;;GAOG;AACH,MAAa,mBAAmB;IAC9B,KAAK,CACH,GAAmB,EACnB,UAAiB,EACjB,aAAoB;QAEpB,MAAM,WAAW,GACf,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,wCAAiB,CAAC,CAAC;QAC7C,MAAM,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QAC5C,KAAK,MAAM,SAAS,IAAI,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC;YAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;YAC1E,IAAI,CAAC,YAAY,EAAE,CAAC;gBAClB,WAAW,CAAC,OAAO,CAAC,IAAA,wCAAiB,EAAC,SAAS,CAAC,CAAC,CAAC;YACpD,CAAC;iBAAM,CAAC;gBACN,MAAM,kBAAkB,GAAG,WAAW,CAAC,IAAI,CACzC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,KAAK,YAAY,CAAC,EAAE,CACzC,CAAC;gBACF,IAAI,kBAAkB,EAAE,CAAC;oBACvB,kBAAkB,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC;gBACnD,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEO,qBAAqB,CAC3B,aAAoB,EACpB,SAAoB;QAEpB,OAAO,aAAa,CAAC,KAAK,CAAC,IAAI,CAC7B,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,cAAc,CAAC,EAAE,KAAK,SAAS,CAAC,cAAc,CAAC,EAAE;YACtD,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,YAAY,CAAC;gBAC/B,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC,CAC3C,CAAC;IACJ,CAAC;CACF;AApCD,kDAoCC"}

package/dist/config/order/order-by-code-access-strategy.d.ts

@@ -0,0 +1,57 @@
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Order } from "../../entity/order/order.entity";
+/**
+ * @description
+ * The OrderByCodeAccessStrategy determines how access to a placed Order via the
+ * orderByCode query is granted.
+ * With a custom strategy anonymous access could be made permanent or tied to specific
+ * conditions like IP range or an Order status.
+ *
+ * @example
+ * This example grants access to the requested Order to anyone – unless it's Monday.
+ * ```ts
+ * export class NotMondayOrderByCodeAccessStrategy implements OrderByCodeAccessStrategy {
+ *     canAccessOrder(ctx: RequestContext, order: Order): boolean {
+ *         const MONDAY = 1;
+ *         const today = (new Date()).getDay();
+ *
+ *         return today !== MONDAY;
+ *     }
+ * }
+ * ```
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.orderByCodeAccessStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @since 1.1.0
+ * @docsCategory orders
+ * @docsPage OrderByCodeAccessStrategy
+ */
+export interface OrderByCodeAccessStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Gives or denies permission to access the requested Order
+     */
+    canAccessOrder(ctx: RequestContext, order: Order): boolean | Promise<boolean>;
+}
+/**
+ * @description
+ * The default OrderByCodeAccessStrategy used by Deenruv. It permitts permanent access to
+ * the Customer owning the Order and anyone within a given time period after placing the Order
+ * (defaults to 2h).
+ *
+ * @param anonymousAccessDuration value for [ms](https://github.com/vercel/ms), e.g. `2h` for 2 hours or `5d` for 5 days
+ *
+ * @docsCategory orders
+ * @docsPage OrderByCodeAccessStrategy
+ */
+export declare class DefaultOrderByCodeAccessStrategy implements OrderByCodeAccessStrategy {
+    private anonymousAccessDuration;
+    constructor(anonymousAccessDuration: string);
+    canAccessOrder(ctx: RequestContext, order: Order): boolean;
+}

package/dist/config/order/order-by-code-access-strategy.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderByCodeAccessStrategy = void 0;
+const ms_1 = __importDefault(require("ms"));
+/**
+ * @description
+ * The default OrderByCodeAccessStrategy used by Deenruv. It permitts permanent access to
+ * the Customer owning the Order and anyone within a given time period after placing the Order
+ * (defaults to 2h).
+ *
+ * @param anonymousAccessDuration value for [ms](https://github.com/vercel/ms), e.g. `2h` for 2 hours or `5d` for 5 days
+ *
+ * @docsCategory orders
+ * @docsPage OrderByCodeAccessStrategy
+ */
+class DefaultOrderByCodeAccessStrategy {
+    constructor(anonymousAccessDuration) {
+        this.anonymousAccessDuration = anonymousAccessDuration;
+    }
+    canAccessOrder(ctx, order) {
+        var _a, _b;
+        // Order owned by active user
+        const activeUserMatches = ((_b = (_a = order === null || order === void 0 ? void 0 : order.customer) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.id) === ctx.activeUserId;
+        // For guest Customers, allow access to the Order for the following
+        // time period
+        const anonymousAccessPermitted = () => {
+            const anonymousAccessLimit = (0, ms_1.default)(this.anonymousAccessDuration);
+            const orderPlaced = order.orderPlacedAt ? +order.orderPlacedAt : 0;
+            const now = Date.now();
+            return now - orderPlaced < anonymousAccessLimit;
+        };
+        return ((ctx.activeUserId && activeUserMatches) ||
+            (!ctx.activeUserId && anonymousAccessPermitted()));
+    }
+}
+exports.DefaultOrderByCodeAccessStrategy = DefaultOrderByCodeAccessStrategy;
+//# sourceMappingURL=order-by-code-access-strategy.js.map

package/dist/config/order/order-by-code-access-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-by-code-access-strategy.js","sourceRoot":"","sources":["../../../src/config/order/order-by-code-access-strategy.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AA6CpB;;;;;;;;;;GAUG;AACH,MAAa,gCAAgC;IAG3C,YAAY,uBAA+B;QACzC,IAAI,CAAC,uBAAuB,GAAG,uBAAuB,CAAC;IACzD,CAAC;IAED,cAAc,CAAC,GAAmB,EAAE,KAAY;;QAC9C,6BAA6B;QAC7B,MAAM,iBAAiB,GAAG,CAAA,MAAA,MAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,QAAQ,0CAAE,IAAI,0CAAE,EAAE,MAAK,GAAG,CAAC,YAAY,CAAC;QAEzE,mEAAmE;QACnE,cAAc;QACd,MAAM,wBAAwB,GAAG,GAAG,EAAE;YACpC,MAAM,oBAAoB,GAAG,IAAA,YAAE,EAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;YAC9D,MAAM,WAAW,GAAG,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;YACnE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;YACvB,OAAO,GAAG,GAAG,WAAW,GAAG,oBAAoB,CAAC;QAClD,CAAC,CAAC;QAEF,OAAO,CACL,CAAC,GAAG,CAAC,YAAY,IAAI,iBAAiB,CAAC;YACvC,CAAC,CAAC,GAAG,CAAC,YAAY,IAAI,wBAAwB,EAAE,CAAC,CAClD,CAAC;IACJ,CAAC;CACF;AAzBD,4EAyBC"}

package/dist/config/order/order-code-strategy.d.ts

@@ -0,0 +1,54 @@
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+/**
+ * @description
+ * The OrderCodeStrategy determines how Order codes are generated.
+ * A custom strategy can be defined which e.g. integrates with an
+ * existing system to generate a code:
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.orderCodeStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @example
+ * ```ts
+ * class MyOrderCodeStrategy implements OrderCodeStrategy {
+ *   // Some imaginary service which calls out to an existing external
+ *   // order management system.
+ *   private mgmtService: ExternalOrderManagementService;
+ *
+ *   init(injector: Injector) {
+ *     this.mgmtService = injector.get(ExternalOrderManagementService);
+ *   }
+ *
+ *   async generate(ctx: RequestContext) {
+ *     const result = await this.mgmtService.getAvailableOrderParams();
+ *     return result.code;
+ *   }
+ * }
+ * ```
+ *
+ * @docsCategory orders
+ * @docsPage OrderCodeStrategy
+ */
+export interface OrderCodeStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Generates the order code.
+     */
+    generate(ctx: RequestContext): string | Promise<string>;
+}
+/**
+ * @description
+ * The default OrderCodeStrategy generates a random string consisting
+ * of 16 uppercase letters and numbers.
+ *
+ * @docsCategory orders
+ * @docsPage OrderCodeStrategy
+ */
+export declare class DefaultOrderCodeStrategy implements OrderCodeStrategy {
+    generate(ctx: RequestContext): string;
+}

package/dist/config/order/order-code-strategy.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderCodeStrategy = void 0;
+const generate_public_id_1 = require("../../common/generate-public-id");
+/**
+ * @description
+ * The default OrderCodeStrategy generates a random string consisting
+ * of 16 uppercase letters and numbers.
+ *
+ * @docsCategory orders
+ * @docsPage OrderCodeStrategy
+ */
+class DefaultOrderCodeStrategy {
+    generate(ctx) {
+        return (0, generate_public_id_1.generatePublicId)();
+    }
+}
+exports.DefaultOrderCodeStrategy = DefaultOrderCodeStrategy;
+//# sourceMappingURL=order-code-strategy.js.map

package/dist/config/order/order-code-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-code-strategy.js","sourceRoot":"","sources":["../../../src/config/order/order-code-strategy.ts"],"names":[],"mappings":";;;AACA,wEAAmE;AA6CnE;;;;;;;GAOG;AACH,MAAa,wBAAwB;IACnC,QAAQ,CAAC,GAAmB;QAC1B,OAAO,IAAA,qCAAgB,GAAE,CAAC;IAC5B,CAAC;CACF;AAJD,4DAIC"}

package/dist/config/order/order-item-price-calculation-strategy.d.ts

@@ -0,0 +1,74 @@
+import { RequestContext } from "../../api/common/request-context";
+import { PriceCalculationResult } from "../../common/types/common-types";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Order } from "../../entity/order/order.entity";
+import { ProductVariant } from "../../entity/product-variant/product-variant.entity";
+/**
+ * @description
+ * The OrderItemPriceCalculationStrategy defines the listPrice of an OrderLine when adding an item to an Order. By default the
+ * {@link DefaultOrderItemPriceCalculationStrategy} is used.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.orderItemPriceCalculationStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * ### When is the strategy invoked ?
+ * * addItemToOrder (only on the new order line)
+ * * adjustOrderLine  (only on the adjusted order line)
+ * * setOrderShippingAddress (on all order lines)
+ * * setOrderBillingAddress (on all order lines)
+ *
+ * ### OrderItemPriceCalculationStrategy vs Promotions
+ * Both the OrderItemPriceCalculationStrategy and Promotions can be used to alter the price paid for a product.
+ *
+ * The main difference is when a Promotion is applied, it adds a `discount` line to the Order, and the regular
+ * price is used for the value of `OrderLine.listPrice` property, whereas
+ * the OrderItemPriceCalculationStrategy actually alters the value of `OrderLine.listPrice` itself, and does not
+ * add any discounts to the Order.
+ *
+ * Use OrderItemPriceCalculationStrategy if:
+ *
+ * * The price calculation is based on the properties of the ProductVariant and any CustomFields
+ *   specified on the OrderLine, for example via a product configurator.
+ * * The logic is a permanent part of your business requirements.
+ *
+ * Use Promotions if:
+ *
+ * * You want to implement "discounts" and "special offers"
+ * * The calculation is not a permanent part of your business requirements.
+ * * The price depends on dynamic aspects such as quantities and which other
+ *   ProductVariants are in the Order.
+ * * The configuration of the logic needs to be manipulated via the Admin UI.
+ *
+ * ### Example use-cases
+ *
+ * A custom OrderItemPriceCalculationStrategy can be used to implement things like:
+ *
+ * * A gift-wrapping service, where a boolean custom field is defined on the OrderLine. If `true`,
+ *   a gift-wrapping surcharge would be added to the price.
+ * * A product-configurator where e.g. various finishes, colors, and materials can be selected and stored
+ *   as OrderLine custom fields (see [the Custom Fields guide](/guides/developer-guide/custom-fields/).
+ * * Price lists or bulk pricing, where different price bands are stored e.g. in a customField on the ProductVariant, and this
+ *   is used to calculate the price based on the current quantity.
+ *
+ * @docsCategory Orders
+ */
+export interface OrderItemPriceCalculationStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Receives the ProductVariant to be added to the Order as well as any OrderLine custom fields and returns
+     * the price for a single unit.
+     *
+     * Note: if you have any `relation` type custom fields defined on the OrderLine entity, they will only be
+     * passed in to this method if they are set to `eager: true`. Otherwise, you can use the {@link EntityHydrator}
+     * to join the missing relations.
+     *
+     * Note: the `quantity` argument was added in v2.0.0
+     */
+    calculateUnitPrice(ctx: RequestContext, productVariant: ProductVariant, orderLineCustomFields: {
+        [key: string]: any;
+    }, order: Order, quantity: number): PriceCalculationResult | Promise<PriceCalculationResult>;
+}

package/dist/config/order/order-item-price-calculation-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=order-item-price-calculation-strategy.js.map

package/dist/config/order/order-item-price-calculation-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-item-price-calculation-strategy.js","sourceRoot":"","sources":["../../../src/config/order/order-item-price-calculation-strategy.ts"],"names":[],"mappings":""}

package/dist/config/order/order-merge-strategy.d.ts

@@ -0,0 +1,45 @@
+import { ID } from "@deenruv/common/lib/shared-types";
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Order } from "../../entity/order/order.entity";
+import { OrderLine } from "../../entity/order-line/order-line.entity";
+/**
+ * @description
+ * The result of the {@link OrderMergeStrategy} `merge` method.
+ *
+ * @docsCategory orders
+ * @docsPage OrderMergeStrategy
+ */
+export interface MergedOrderLine {
+    orderLineId: ID;
+    quantity: number;
+    customFields?: any;
+}
+export declare function toMergedOrderLine(line: OrderLine): MergedOrderLine;
+/**
+ * @description
+ * An OrderMergeStrategy defines what happens when a Customer with an existing Order
+ * signs in with a guest Order, where both Orders may contain differing OrderLines.
+ *
+ * Somehow these differing OrderLines need to be reconciled into a single collection
+ * of OrderLines. The OrderMergeStrategy defines the rules governing this reconciliation.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.mergeStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory orders
+ * @docsPage OrderMergeStrategy
+ * @docsWeight 0
+ */
+export interface OrderMergeStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Merges the lines of the guest Order with those of the existing Order which is associated
+     * with the active customer.
+     */
+    merge(ctx: RequestContext, guestOrder: Order, existingOrder: Order): MergedOrderLine[];
+}

package/dist/config/order/order-merge-strategy.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMergedOrderLine = void 0;
+function toMergedOrderLine(line) {
+    return {
+        orderLineId: line.id,
+        quantity: line.quantity,
+        customFields: line.customFields,
+    };
+}
+exports.toMergedOrderLine = toMergedOrderLine;
+//# sourceMappingURL=order-merge-strategy.js.map

package/dist/config/order/order-merge-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-merge-strategy.js","sourceRoot":"","sources":["../../../src/config/order/order-merge-strategy.ts"],"names":[],"mappings":";;;AAoBA,SAAgB,iBAAiB,CAAC,IAAe;IAC/C,OAAO;QACL,WAAW,EAAE,IAAI,CAAC,EAAE;QACpB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,YAAY,EAAE,IAAI,CAAC,YAAY;KAChC,CAAC;AACJ,CAAC;AAND,8CAMC"}

package/dist/config/order/order-middleware.d.ts

@@ -0,0 +1,20 @@
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { CustomOrderLineFields, Order, OrderLine, ProductVariant } from "../../entity/index";
+export interface ShouldAddItemToOrderInput {
+    productVariant: ProductVariant;
+    quantity: number;
+    customFields?: CustomOrderLineFields;
+}
+export interface ShouldAdjustOrderLineInput {
+    orderLine: OrderLine;
+    quantity: number;
+    customFields?: CustomOrderLineFields;
+}
+export interface OrderMiddleware extends InjectableStrategy {
+    shouldAddItemToOrder?(ctx: RequestContext, order: Order, input: ShouldAddItemToOrderInput): Promise<void | string>;
+    shouldAdjustOrderLine?(ctx: RequestContext, order: Order, input: ShouldAdjustOrderLineInput): Promise<void | string>;
+    shouldRemoveItemFromOrder?(ctx: RequestContext, order: Order, orderLine: OrderLine): Promise<void | string>;
+    shouldAddCouponCode?(ctx: RequestContext, order: Order, couponCode: string): Promise<void | string>;
+    shouldRemoveCouponCode?(ctx: RequestContext, order: Order, couponCode: string): Promise<void | string>;
+}

package/dist/config/order/order-middleware.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=order-middleware.js.map

package/dist/config/order/order-middleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-middleware.js","sourceRoot":"","sources":["../../../src/config/order/order-middleware.ts"],"names":[],"mappings":""}

package/dist/config/order/order-placed-strategy.d.ts

@@ -0,0 +1,34 @@
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Order } from "../../entity/order/order.entity";
+import { OrderState } from "../../service/helpers/order-state-machine/order-state";
+/**
+ * @description
+ * This strategy is responsible for deciding at which stage in the order process
+ * the Order will be set as "placed" (i.e. the Customer has checked out, and
+ * next it must be processed by an Administrator).
+ *
+ * By default, the order is set as "placed" when it transitions from
+ * 'ArrangingPayment' to either 'PaymentAuthorized' or 'PaymentSettled'.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.orderPlacedStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory orders
+ */
+export interface OrderPlacedStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * This method is called whenever an _active_ Order transitions from one state to another.
+     * If it resolves to `true`, then the Order will be set as "placed", which means:
+     *
+     * * Order.active = false
+     * * Order.placedAt = new Date()
+     * * Any active Promotions are linked to the Order
+     */
+    shouldSetAsPlaced(ctx: RequestContext, fromState: OrderState, toState: OrderState, order: Order): boolean | Promise<boolean>;
+}

package/dist/config/order/order-placed-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=order-placed-strategy.js.map

package/dist/config/order/order-placed-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-placed-strategy.js","sourceRoot":"","sources":["../../../src/config/order/order-placed-strategy.ts"],"names":[],"mappings":""}

package/dist/config/order/order-process.d.ts

@@ -0,0 +1,37 @@
+import { OnTransitionEndFn, OnTransitionErrorFn, OnTransitionStartFn, Transitions } from "../../common/finite-state-machine/types";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { CustomOrderStates, OrderState, OrderTransitionData } from "../../service/helpers/order-state-machine/order-state";
+/**
+ * @description
+ * An OrderProcess is used to define the way the order process works as in: what states an Order can be
+ * in, and how it may transition from one state to another. Using the `onTransitionStart()` hook, an
+ * OrderProcess can perform checks before allowing a state transition to occur, and the `onTransitionEnd()`
+ * hook allows logic to be executed after a state change.
+ *
+ * For detailed description of the interface members, see the {@link StateMachineConfig} docs.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.process` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory orders
+ * @docsPage OrderProcess
+ * @docsWeight 0
+ */
+export interface OrderProcess<State extends keyof CustomOrderStates | string> extends InjectableStrategy {
+    transitions?: Transitions<State, State | OrderState> & Partial<Transitions<OrderState | State>>;
+    onTransitionStart?: OnTransitionStartFn<State | OrderState, OrderTransitionData>;
+    onTransitionEnd?: OnTransitionEndFn<State | OrderState, OrderTransitionData>;
+    onTransitionError?: OnTransitionErrorFn<State | OrderState>;
+}
+/**
+ * @description
+ * Used to define extensions to or modifications of the default order process.
+ *
+ * @deprecated Use OrderProcess
+ */
+export interface CustomOrderProcess<State extends keyof CustomOrderStates | string> extends OrderProcess<State> {
+}

package/dist/config/order/order-process.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=order-process.js.map

package/dist/config/order/order-process.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-process.js","sourceRoot":"","sources":["../../../src/config/order/order-process.ts"],"names":[],"mappings":""}

package/dist/config/order/order-seller-strategy.d.ts

@@ -0,0 +1,63 @@
+import { ID } from "@deenruv/common/lib/shared-types";
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Channel } from "../../entity/channel/channel.entity";
+import { Order } from "../../entity/order/order.entity";
+import { OrderLine } from "../../entity/order-line/order-line.entity";
+import { ShippingLine } from "../../entity/shipping-line/shipping-line.entity";
+import { OrderState } from "../../service/helpers/order-state-machine/order-state";
+/**
+ * @description
+ * The contents of the aggregate Order which make up a single seller Order.
+ *
+ * @since 2.0.0
+ * @docsCategory orders
+ * @docsPage OrderSellerStrategy
+ */
+export interface SplitOrderContents {
+    channelId: ID;
+    state: OrderState;
+    lines: OrderLine[];
+    shippingLines: ShippingLine[];
+}
+/**
+ * @description
+ * This strategy defines how an Order can be split into multiple sub-orders for the use-case of
+ * a multivendor application.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.orderSellerStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @since 2.0.0
+ * @docsCategory orders
+ * @docsPage OrderSellerStrategy
+ * @docsWeight 0
+ */
+export interface OrderSellerStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * This method is called whenever a new OrderLine is added to the Order via the `addItemToOrder` mutation or the
+     * underlying `addItemToOrder()` method of the {@link OrderService}.
+     *
+     * It should return the ID of the Channel to which this OrderLine will be assigned, which will be used to set the
+     * {@link OrderLine} `sellerChannel` property.
+     */
+    setOrderLineSellerChannel?(ctx: RequestContext, orderLine: OrderLine): Channel | undefined | Promise<Channel | undefined>;
+    /**
+     * @description
+     * Upon checkout (by default, when the Order moves from "active" to "inactive" according to the {@link OrderPlacedStrategy}),
+     * this method will be called in order to split the Order into multiple Orders, one for each Seller.
+     */
+    splitOrder?(ctx: RequestContext, order: Order): SplitOrderContents[] | Promise<SplitOrderContents[]>;
+    /**
+     * @description
+     * This method is called after splitting the orders, including calculating the totals for each of the seller Orders.
+     * This method can be used to set platform fee surcharges on the seller Orders as well as perform any payment processing
+     * needed.
+     */
+    afterSellerOrdersCreated?(ctx: RequestContext, aggregateOrder: Order, sellerOrders: Order[]): void | Promise<void>;
+}

package/dist/config/order/order-seller-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=order-seller-strategy.js.map

package/dist/config/order/order-seller-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"order-seller-strategy.js","sourceRoot":"","sources":["../../../src/config/order/order-seller-strategy.ts"],"names":[],"mappings":""}

package/dist/config/order/stock-allocation-strategy.d.ts

@@ -0,0 +1,26 @@
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Order } from "../../entity/order/order.entity";
+import { OrderState } from "../../service/helpers/order-state-machine/order-state";
+/**
+ * @description
+ * This strategy is responsible for deciding at which stage in the order process
+ * stock will be allocated.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.stockAllocationStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory orders
+ */
+export interface StockAllocationStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * This method is called whenever an Order transitions from one state to another.
+     * If it resolves to `true`, then stock will be allocated for this order.
+     */
+    shouldAllocateStock(ctx: RequestContext, fromState: OrderState, toState: OrderState, order: Order): boolean | Promise<boolean>;
+}

package/dist/config/order/stock-allocation-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=stock-allocation-strategy.js.map

package/dist/config/order/stock-allocation-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stock-allocation-strategy.js","sourceRoot":"","sources":["../../../src/config/order/stock-allocation-strategy.ts"],"names":[],"mappings":""}

package/dist/config/order/use-existing-strategy.d.ts

@@ -0,0 +1,13 @@
+import { RequestContext } from "../../api/common/request-context";
+import { Order } from "../../entity/order/order.entity";
+import { MergedOrderLine, OrderMergeStrategy } from "./order-merge-strategy";
+/**
+ * @description
+ * The guest order is discarded and the existing order is used as the active order.
+ *
+ * @docsCategory orders
+ * @docsPage Merge Strategies
+ */
+export declare class UseExistingStrategy implements OrderMergeStrategy {
+    merge(ctx: RequestContext, guestOrder: Order, existingOrder: Order): MergedOrderLine[];
+}

package/dist/config/order/use-existing-strategy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseExistingStrategy = void 0;
+const order_merge_strategy_1 = require("./order-merge-strategy");
+/**
+ * @description
+ * The guest order is discarded and the existing order is used as the active order.
+ *
+ * @docsCategory orders
+ * @docsPage Merge Strategies
+ */
+class UseExistingStrategy {
+    merge(ctx, guestOrder, existingOrder) {
+        return existingOrder.lines.map(order_merge_strategy_1.toMergedOrderLine);
+    }
+}
+exports.UseExistingStrategy = UseExistingStrategy;
+//# sourceMappingURL=use-existing-strategy.js.map

package/dist/config/order/use-existing-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-existing-strategy.js","sourceRoot":"","sources":["../../../src/config/order/use-existing-strategy.ts"],"names":[],"mappings":";;;AAGA,iEAIgC;AAEhC;;;;;;GAMG;AACH,MAAa,mBAAmB;IAC9B,KAAK,CACH,GAAmB,EACnB,UAAiB,EACjB,aAAoB;QAEpB,OAAO,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,wCAAiB,CAAC,CAAC;IACpD,CAAC;CACF;AARD,kDAQC"}