@deenruv/core 1.0.0

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

@@ -0,0 +1,184 @@
+import { DocumentNode } from "graphql";
+import { RequestContext } from "../../api/common/request-context";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { Order } from "../../entity/order/order.entity";
+export declare const ACTIVE_ORDER_INPUT_FIELD_NAME = "activeOrderInput";
+/**
+ * @description
+ * This strategy is used to determine the active Order for all order-related operations in
+ * the Shop API. By default, all the Shop API operations that relate to the active Order (e.g.
+ * `activeOrder`, `addItemToOrder`, `applyCouponCode` etc.) will implicitly create a new Order
+ * and set it on the current Session, and then read the session to obtain the active Order.
+ * This behaviour is defined by the {@link DefaultActiveOrderStrategy}.
+ *
+ * The `InputType` generic argument should correspond to the input type defined by the
+ * `defineInputType()` method.
+ *
+ * When `defineInputType()` is used, then the following Shop API operations will receive an additional
+ * `activeOrderInput` argument allowing the active order input to be specified:
+ *
+ * - `activeOrder`
+ * - `eligibleShippingMethods`
+ * - `eligiblePaymentMethods`
+ * - `nextOrderStates`
+ * - `addItemToOrder`
+ * - `adjustOrderLine`
+ * - `removeOrderLine`
+ * - `removeAllOrderLines`
+ * - `applyCouponCode`
+ * - `removeCouponCode`
+ * - `addPaymentToOrder`
+ * - `setCustomerForOrder`
+ * - `setOrderShippingAddress`
+ * - `setOrderBillingAddress`
+ * - `setOrderShippingMethod`
+ * - `setOrderCustomFields`
+ * - `transitionOrderToState`
+ *
+ * @example
+ * ```GraphQL {hl_lines=[5]}
+ * mutation AddItemToOrder {
+ *   addItemToOrder(
+ *     productVariantId: 42,
+ *     quantity: 1,
+ *     activeOrderInput: { token: "123456" }
+ *   ) {
+ *     ...on Order {
+ *       id
+ *       # ...etc
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { ID } from '\@deenruv/common/lib/shared-types';
+ * import {
+ *   ActiveOrderStrategy,
+ *   CustomerService,
+ *   idsAreEqual,
+ *   Injector,
+ *   Order,
+ *   OrderService,
+ *   RequestContext,
+ *   TransactionalConnection,
+ * } from '\@deenruv/core';
+ * import gql from 'graphql-tag';
+ *
+ * // This strategy assumes a "orderToken" custom field is defined on the Order
+ * // entity, and uses that token to perform a lookup to determine the active Order.
+ * //
+ * // Additionally, it does _not_ define a `createActiveOrder()` method, which
+ * // means that a custom mutation would be required to create the initial Order in
+ * // the first place and set the "orderToken" custom field.
+ * class TokenActiveOrderStrategy implements ActiveOrderStrategy<{ token: string }> {
+ *   readonly name = 'orderToken';
+ *
+ *   private connection: TransactionalConnection;
+ *   private orderService: OrderService;
+ *
+ *   init(injector: Injector) {
+ *     this.connection = injector.get(TransactionalConnection);
+ *     this.orderService = injector.get(OrderService);
+ *   }
+ *
+ *   defineInputType = () => gql`
+ *     input OrderTokenActiveOrderInput {
+ *       token: String
+ *     }
+ *   `;
+ *
+ *   async determineActiveOrder(ctx: RequestContext, input: { token: string }) {
+ *     const qb = this.connection
+ *       .getRepository(ctx, Order)
+ *       .createQueryBuilder('order')
+ *       .leftJoinAndSelect('order.customer', 'customer')
+ *       .leftJoinAndSelect('customer.user', 'user')
+ *       .where('order.customFields.orderToken = :orderToken', { orderToken: input.token });
+ *
+ *     const order = await qb.getOne();
+ *     if (!order) {
+ *       return;
+ *     }
+ *     // Ensure the active user is the owner of this Order
+ *     const orderUserId = order.customer && order.customer.user && order.customer.user.id;
+ *     if (order.customer && idsAreEqual(orderUserId, ctx.activeUserId)) {
+ *       return order;
+ *     }
+ *   }
+ * }
+ *
+ * // in deenruv-config.ts
+ * export const config = {
+ *   // ...
+ *   orderOptions: {
+ *     activeOrderStrategy: new TokenActiveOrderStrategy(),
+ *   },
+ * }
+ * ```
+ *
+ * @since 1.9.0
+ * @docsCategory orders
+ */
+export interface ActiveOrderStrategy<InputType extends Record<string, any> | void = void> extends InjectableStrategy {
+    /**
+     * @description
+     * The name of the strategy, e.g. "orderByToken", which will also be used as the
+     * field name in the ActiveOrderInput type.
+     */
+    readonly name: string;
+    /**
+     * @description
+     * Defines the type of the GraphQL Input object expected by the `activeOrderInput`
+     * input argument.
+     *
+     * @example
+     * For example, given the following:
+     *
+     * ```ts
+     * defineInputType() {
+     *   return gql`
+     *      input OrderTokenInput {
+     *        token: String!
+     *      }
+     *   `;
+     * }
+     * ```
+     *
+     * assuming the strategy name is "orderByToken", then the resulting call to `activeOrder` (or any of the other
+     * affected Shop API operations) would look like:
+     *
+     * ```GraphQL
+     * activeOrder(activeOrderInput: {
+     *   orderByToken: {
+     *     token: "foo"
+     *   }
+     * }) {
+     *   # ...
+     * }
+     * ```
+     *
+     * **Note:** if more than one graphql `input` type is being defined (as in a nested input type), then
+     * the _first_ input will be assumed to be the top-level input.
+     */
+    defineInputType?: () => DocumentNode;
+    /**
+     * @description
+     * Certain mutations such as `addItemToOrder` can automatically create a new Order if one does not exist.
+     * In these cases, this method will be called to create the new Order.
+     *
+     * If automatic creation of an Order does not make sense in your strategy, then leave this method
+     * undefined. You'll then need to take care of creating an order manually by defining a custom mutation.
+     */
+    createActiveOrder?: (ctx: RequestContext, input: InputType) => Promise<Order>;
+    /**
+     * @description
+     * This method is used to determine the active Order based on the current RequestContext in addition to any
+     * input values provided, as defined by the `defineInputType` method of this strategy.
+     *
+     * Note that this method is invoked frequently, so you should aim to keep it efficient. The returned Order,
+     * for example, does not need to have its various relations joined.
+     */
+    determineActiveOrder(ctx: RequestContext, input: InputType): Promise<Order | undefined>;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"active-order-strategy.js","sourceRoot":"","sources":["../../../src/config/order/active-order-strategy.ts"],"names":[],"mappings":";;;AAMa,QAAA,6BAA6B,GAAG,kBAAkB,CAAC"}

package/dist/config/order/changed-price-handling-strategy.d.ts

@@ -0,0 +1,32 @@
+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 { OrderLine } from "../../entity/order-line/order-line.entity";
+/**
+ * @description
+ * This strategy defines how we handle the situation where an item exists in an Order, and
+ * then later on another is added but in the meantime the price of the ProductVariant has changed.
+ *
+ * By default, the latest price will be used. Any price changes resulting from using a newer price
+ * will be reflected in the GraphQL `OrderLine.unitPrice[WithTax]ChangeSinceAdded` field.
+ *
+ * :::info
+ *
+ * This is configured via the `orderOptions.changedPriceHandlingStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory orders
+ */
+export interface ChangedPriceHandlingStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * This method is called when adding to or adjusting OrderLines, if the latest price
+     * (as determined by the ProductVariant price, potentially modified by the configured
+     * {@link OrderItemPriceCalculationStrategy}) differs from the initial price at the time
+     * that the OrderLine was created.
+     */
+    handlePriceChange(ctx: RequestContext, current: PriceCalculationResult, orderLine: OrderLine, order: Order): PriceCalculationResult | Promise<PriceCalculationResult>;
+}

package/dist/config/order/changed-price-handling-strategy.js

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

package/dist/config/order/changed-price-handling-strategy.js.map

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

package/dist/config/order/default-active-order-strategy.d.ts

@@ -0,0 +1,22 @@
+import { RequestContext } from "../../api/common/request-context";
+import { Injector } from "../../common/injector";
+import { Order } from "../../entity/order/order.entity";
+import { ActiveOrderStrategy } from "./active-order-strategy";
+/**
+ * @description
+ * The default {@link ActiveOrderStrategy}, which uses the current {@link Session} to determine
+ * the active Order, and requires no additional input in the Shop API since it is based on the
+ * session which is part of the RequestContext.
+ *
+ * @since 1.9.0
+ * @docsCategory orders
+ */
+export declare class DefaultActiveOrderStrategy implements ActiveOrderStrategy {
+    private connection;
+    private orderService;
+    private sessionService;
+    name: "default-active-order-strategy";
+    init(injector: Injector): Promise<void>;
+    createActiveOrder(ctx: RequestContext): Promise<Order>;
+    determineActiveOrder(ctx: RequestContext): Promise<Order | undefined>;
+}

package/dist/config/order/default-active-order-strategy.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultActiveOrderStrategy = void 0;
+const errors_1 = require("../../common/error/errors");
+const transactional_connection_1 = require("../../connection/transactional-connection");
+const order_entity_1 = require("../../entity/order/order.entity");
+/**
+ * @description
+ * The default {@link ActiveOrderStrategy}, which uses the current {@link Session} to determine
+ * the active Order, and requires no additional input in the Shop API since it is based on the
+ * session which is part of the RequestContext.
+ *
+ * @since 1.9.0
+ * @docsCategory orders
+ */
+class DefaultActiveOrderStrategy {
+    async init(injector) {
+        this.connection = injector.get(transactional_connection_1.TransactionalConnection);
+        // Lazy import these dependencies to avoid a circular dependency issue in NestJS.
+        const { OrderService } = await import("../../service/services/order.service.js");
+        const { SessionService } = await import("../../service/services/session.service.js");
+        this.orderService = injector.get(OrderService);
+        this.sessionService = injector.get(SessionService);
+    }
+    createActiveOrder(ctx) {
+        return this.orderService.create(ctx, ctx.activeUserId);
+    }
+    async determineActiveOrder(ctx) {
+        if (!ctx.session) {
+            throw new errors_1.InternalServerError("error.no-active-session");
+        }
+        let order = ctx.session.activeOrderId
+            ? await this.connection
+                .getRepository(ctx, order_entity_1.Order)
+                .createQueryBuilder("order")
+                .leftJoin("order.channels", "channel")
+                .where("order.id = :orderId", { orderId: ctx.session.activeOrderId })
+                .andWhere("channel.id = :channelId", { channelId: ctx.channelId })
+                .getOne()
+            : undefined;
+        if (order && order.active === false) {
+            // edge case where an inactive order may not have been
+            // removed from the session, i.e. the regular process was interrupted
+            await this.sessionService.unsetActiveOrder(ctx, ctx.session);
+            order = undefined;
+        }
+        if (!order) {
+            if (ctx.activeUserId) {
+                order = await this.orderService.getActiveOrderForUser(ctx, ctx.activeUserId);
+            }
+        }
+        return order || undefined;
+    }
+}
+exports.DefaultActiveOrderStrategy = DefaultActiveOrderStrategy;
+//# sourceMappingURL=default-active-order-strategy.js.map

package/dist/config/order/default-active-order-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-active-order-strategy.js","sourceRoot":"","sources":["../../../src/config/order/default-active-order-strategy.ts"],"names":[],"mappings":";;;AACA,sDAAgE;AAEhE,wFAAoF;AACpF,kEAAwD;AAIxD;;;;;;;;GAQG;AACH,MAAa,0BAA0B;IAOrC,KAAK,CAAC,IAAI,CAAC,QAAkB;QAC3B,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC,GAAG,CAAC,kDAAuB,CAAC,CAAC;QACxD,iFAAiF;QACjF,MAAM,EAAE,YAAY,EAAE,GACpB,MAAM,MAAM,CAAC,yCAAyC,CAAC,CAAC;QAC1D,MAAM,EAAE,cAAc,EAAE,GACtB,MAAM,MAAM,CAAC,2CAA2C,CAAC,CAAC;QAC5D,IAAI,CAAC,YAAY,GAAG,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QAC/C,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC;IACrD,CAAC;IAED,iBAAiB,CAAC,GAAmB;QACnC,OAAO,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC;IACzD,CAAC;IAED,KAAK,CAAC,oBAAoB,CAAC,GAAmB;QAC5C,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,IAAI,4BAAmB,CAAC,yBAAyB,CAAC,CAAC;QAC3D,CAAC;QACD,IAAI,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,aAAa;YACnC,CAAC,CAAC,MAAM,IAAI,CAAC,UAAU;iBAClB,aAAa,CAAC,GAAG,EAAE,oBAAK,CAAC;iBACzB,kBAAkB,CAAC,OAAO,CAAC;iBAC3B,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC;iBACrC,KAAK,CAAC,qBAAqB,EAAE,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;iBACpE,QAAQ,CAAC,yBAAyB,EAAE,EAAE,SAAS,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;iBACjE,MAAM,EAAE;YACb,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;YACpC,sDAAsD;YACtD,qEAAqE;YACrE,MAAM,IAAI,CAAC,cAAc,CAAC,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;YAC7D,KAAK,GAAG,SAAS,CAAC;QACpB,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,IAAI,GAAG,CAAC,YAAY,EAAE,CAAC;gBACrB,KAAK,GAAG,MAAM,IAAI,CAAC,YAAY,CAAC,qBAAqB,CACnD,GAAG,EACH,GAAG,CAAC,YAAY,CACjB,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,KAAK,IAAI,SAAS,CAAC;IAC5B,CAAC;CACF;AAnDD,gEAmDC"}

package/dist/config/order/default-changed-price-handling-strategy.d.ts

@@ -0,0 +1,11 @@
+import { RequestContext } from "../../api/common/request-context";
+import { PriceCalculationResult } from "../../common/types/common-types";
+import { ChangedPriceHandlingStrategy } from "./changed-price-handling-strategy";
+/**
+ * @description
+ * The default {@link ChangedPriceHandlingStrategy} will always use the latest price when
+ * updating existing OrderLines.
+ */
+export declare class DefaultChangedPriceHandlingStrategy implements ChangedPriceHandlingStrategy {
+    handlePriceChange(ctx: RequestContext, current: PriceCalculationResult): PriceCalculationResult;
+}

package/dist/config/order/default-changed-price-handling-strategy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultChangedPriceHandlingStrategy = void 0;
+/**
+ * @description
+ * The default {@link ChangedPriceHandlingStrategy} will always use the latest price when
+ * updating existing OrderLines.
+ */
+class DefaultChangedPriceHandlingStrategy {
+    handlePriceChange(ctx, current) {
+        return current;
+    }
+}
+exports.DefaultChangedPriceHandlingStrategy = DefaultChangedPriceHandlingStrategy;
+//# sourceMappingURL=default-changed-price-handling-strategy.js.map

package/dist/config/order/default-changed-price-handling-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-changed-price-handling-strategy.js","sourceRoot":"","sources":["../../../src/config/order/default-changed-price-handling-strategy.ts"],"names":[],"mappings":";;;AAKA;;;;GAIG;AACH,MAAa,mCAAmC;IAC9C,iBAAiB,CACf,GAAmB,EACnB,OAA+B;QAE/B,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AAPD,kFAOC"}

package/dist/config/order/default-guest-checkout-strategy.d.ts

@@ -0,0 +1,64 @@
+import { CreateCustomerInput, SetCustomerForOrderResult } from "@deenruv/common/lib/generated-shop-types";
+import { RequestContext } from "../../api/common/request-context";
+import { ErrorResultUnion } from "../../common/error/error-result";
+import { Injector } from "../../common/injector";
+import { Customer, Order } from "../../entity/index";
+import { GuestCheckoutStrategy } from "./guest-checkout-strategy";
+/**
+ * @description
+ * Options available for the {@link DefaultGuestCheckoutStrategy}.
+ *
+ * @docsCategory orders
+ * @docsPage DefaultGuestCheckoutStrategy
+ * @since 2.0.0
+ */
+export interface DefaultGuestCheckoutStrategyOptions {
+    /**
+     * @description
+     * Whether to allow guest checkouts.
+     *
+     * @default true
+     */
+    allowGuestCheckouts?: boolean;
+    /**
+     * @description
+     * Whether to allow guest checkouts for customers who already have an account.
+     * Note that when this is enabled, the details provided in the `CreateCustomerInput`
+     * will overwrite the existing customer details of the registered customer.
+     *
+     * @default false
+     */
+    allowGuestCheckoutForRegisteredCustomers?: boolean;
+}
+/**
+ * @description
+ * The default implementation of the {@link GuestCheckoutStrategy}. This strategy allows
+ * guest checkouts by default, but can be configured to disallow them.
+ *
+ * @example
+ * ```ts
+ * import { DefaultGuestCheckoutStrategy, DeenruvConfig } from '\@deenruv/core';
+ *
+ * export const config: DeenruvConfig = {
+ *   orderOptions: {
+ *     guestCheckoutStrategy: new DefaultGuestCheckoutStrategy({
+ *       allowGuestCheckouts: false,
+ *       allowGuestCheckoutForRegisteredCustomers: false,
+ *     }),
+ *   },
+ *   // ...
+ * };
+ * ```
+ *
+ * @docsCategory orders
+ * @docsPage DefaultGuestCheckoutStrategy
+ * @docsWeight 0
+ * @since 2.0.0
+ */
+export declare class DefaultGuestCheckoutStrategy implements GuestCheckoutStrategy {
+    private customerService;
+    private readonly options;
+    init(injector: Injector): void;
+    constructor(options?: DefaultGuestCheckoutStrategyOptions);
+    setCustomerForOrder(ctx: RequestContext, order: Order, input: CreateCustomerInput): Promise<ErrorResultUnion<SetCustomerForOrderResult, Customer>>;
+}

package/dist/config/order/default-guest-checkout-strategy.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultGuestCheckoutStrategy = void 0;
+const generated_graphql_shop_errors_1 = require("../../common/error/generated-graphql-shop-errors");
+const customer_service_1 = require("../../service/services/customer.service");
+/**
+ * @description
+ * The default implementation of the {@link GuestCheckoutStrategy}. This strategy allows
+ * guest checkouts by default, but can be configured to disallow them.
+ *
+ * @example
+ * ```ts
+ * import { DefaultGuestCheckoutStrategy, DeenruvConfig } from '\@deenruv/core';
+ *
+ * export const config: DeenruvConfig = {
+ *   orderOptions: {
+ *     guestCheckoutStrategy: new DefaultGuestCheckoutStrategy({
+ *       allowGuestCheckouts: false,
+ *       allowGuestCheckoutForRegisteredCustomers: false,
+ *     }),
+ *   },
+ *   // ...
+ * };
+ * ```
+ *
+ * @docsCategory orders
+ * @docsPage DefaultGuestCheckoutStrategy
+ * @docsWeight 0
+ * @since 2.0.0
+ */
+class DefaultGuestCheckoutStrategy {
+    init(injector) {
+        this.customerService = injector.get(customer_service_1.CustomerService);
+    }
+    constructor(options) {
+        this.options = {
+            allowGuestCheckouts: true,
+            allowGuestCheckoutForRegisteredCustomers: false,
+        };
+        this.options = Object.assign(Object.assign({}, this.options), (options !== null && options !== void 0 ? options : {}));
+    }
+    async setCustomerForOrder(ctx, order, input) {
+        if (!this.options.allowGuestCheckouts) {
+            return new generated_graphql_shop_errors_1.GuestCheckoutError({
+                errorDetail: "Guest checkouts are disabled",
+            });
+        }
+        if (ctx.activeUserId) {
+            return new generated_graphql_shop_errors_1.AlreadyLoggedInError();
+        }
+        const errorOnExistingUser = !this.options.allowGuestCheckoutForRegisteredCustomers;
+        const customer = await this.customerService.createOrUpdate(ctx, input, errorOnExistingUser);
+        return customer;
+    }
+}
+exports.DefaultGuestCheckoutStrategy = DefaultGuestCheckoutStrategy;
+//# sourceMappingURL=default-guest-checkout-strategy.js.map

package/dist/config/order/default-guest-checkout-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-guest-checkout-strategy.js","sourceRoot":"","sources":["../../../src/config/order/default-guest-checkout-strategy.ts"],"names":[],"mappings":";;;AAOA,oGAG0D;AAG1D,8EAA0E;AA+B1E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAa,4BAA4B;IAMvC,IAAI,CAAC,QAAkB;QACrB,IAAI,CAAC,eAAe,GAAG,QAAQ,CAAC,GAAG,CAAC,kCAAe,CAAC,CAAC;IACvD,CAAC;IAED,YAAY,OAA6C;QARxC,YAAO,GAAkD;YACxE,mBAAmB,EAAE,IAAI;YACzB,wCAAwC,EAAE,KAAK;SAChD,CAAC;QAMA,IAAI,CAAC,OAAO,mCACP,IAAI,CAAC,OAAO,GACZ,CAAC,OAAO,aAAP,OAAO,cAAP,OAAO,GAAI,EAAE,CAAC,CACnB,CAAC;IACJ,CAAC;IACD,KAAK,CAAC,mBAAmB,CACvB,GAAmB,EACnB,KAAY,EACZ,KAA0B;QAE1B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,mBAAmB,EAAE,CAAC;YACtC,OAAO,IAAI,kDAAkB,CAAC;gBAC5B,WAAW,EAAE,8BAA8B;aAC5C,CAAC,CAAC;QACL,CAAC;QACD,IAAI,GAAG,CAAC,YAAY,EAAE,CAAC;YACrB,OAAO,IAAI,oDAAoB,EAAE,CAAC;QACpC,CAAC;QACD,MAAM,mBAAmB,GACvB,CAAC,IAAI,CAAC,OAAO,CAAC,wCAAwC,CAAC;QACzD,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CACxD,GAAG,EACH,KAAK,EACL,mBAAmB,CACpB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF;AAtCD,oEAsCC"}

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

@@ -0,0 +1,14 @@
+import { RequestContext } from "../../api/common/request-context";
+import { PriceCalculationResult } from "../../common/types/common-types";
+import { ProductVariant } from "../../entity/product-variant/product-variant.entity";
+import { OrderItemPriceCalculationStrategy } from "./order-item-price-calculation-strategy";
+/**
+ * @description
+ * The default {@link OrderItemPriceCalculationStrategy}, which simply passes through the price of
+ * the ProductVariant without performing any calculations
+ *
+ * @docsCategory orders
+ */
+export declare class DefaultOrderItemPriceCalculationStrategy implements OrderItemPriceCalculationStrategy {
+    calculateUnitPrice(ctx: RequestContext, productVariant: ProductVariant): PriceCalculationResult | Promise<PriceCalculationResult>;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderItemPriceCalculationStrategy = void 0;
+/**
+ * @description
+ * The default {@link OrderItemPriceCalculationStrategy}, which simply passes through the price of
+ * the ProductVariant without performing any calculations
+ *
+ * @docsCategory orders
+ */
+class DefaultOrderItemPriceCalculationStrategy {
+    calculateUnitPrice(ctx, productVariant) {
+        return {
+            price: productVariant.listPrice,
+            priceIncludesTax: productVariant.listPriceIncludesTax,
+        };
+    }
+}
+exports.DefaultOrderItemPriceCalculationStrategy = DefaultOrderItemPriceCalculationStrategy;
+//# sourceMappingURL=default-order-item-price-calculation-strategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default-order-item-price-calculation-strategy.js","sourceRoot":"","sources":["../../../src/config/order/default-order-item-price-calculation-strategy.ts"],"names":[],"mappings":";;;AAMA;;;;;;GAMG;AACH,MAAa,wCAAwC;IACnD,kBAAkB,CAChB,GAAmB,EACnB,cAA8B;QAE9B,OAAO;YACL,KAAK,EAAE,cAAc,CAAC,SAAS;YAC/B,gBAAgB,EAAE,cAAc,CAAC,oBAAoB;SACtD,CAAC;IACJ,CAAC;CACF;AAVD,4FAUC"}

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

@@ -0,0 +1,14 @@
+import { RequestContext } from "../../api/common/request-context";
+import { Order } from "../../entity/order/order.entity";
+import { OrderState } from "../../service/helpers/order-state-machine/order-state";
+import { OrderPlacedStrategy } from "./order-placed-strategy";
+/**
+ * @description
+ * The default {@link OrderPlacedStrategy}. The order is set as "placed" when it transitions from
+ * 'ArrangingPayment' to either 'PaymentAuthorized' or 'PaymentSettled'.
+ *
+ * @docsCategory orders
+ */
+export declare class DefaultOrderPlacedStrategy implements OrderPlacedStrategy {
+    shouldSetAsPlaced(ctx: RequestContext, fromState: OrderState, toState: OrderState, order: Order): boolean;
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultOrderPlacedStrategy = void 0;
+/**
+ * @description
+ * The default {@link OrderPlacedStrategy}. The order is set as "placed" when it transitions from
+ * 'ArrangingPayment' to either 'PaymentAuthorized' or 'PaymentSettled'.
+ *
+ * @docsCategory orders
+ */
+class DefaultOrderPlacedStrategy {
+    shouldSetAsPlaced(ctx, fromState, toState, order) {
+        return fromState === "ArrangingPayment" &&
+            (toState === "PaymentAuthorized" || toState === "PaymentSettled")
+            ? true
+            : false;
+    }
+}
+exports.DefaultOrderPlacedStrategy = DefaultOrderPlacedStrategy;
+//# sourceMappingURL=default-order-placed-strategy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"default-order-placed-strategy.js","sourceRoot":"","sources":["../../../src/config/order/default-order-placed-strategy.ts"],"names":[],"mappings":";;;AAMA;;;;;;GAMG;AACH,MAAa,0BAA0B;IACrC,iBAAiB,CACf,GAAmB,EACnB,SAAqB,EACrB,OAAmB,EACnB,KAAY;QAEZ,OAAO,SAAS,KAAK,kBAAkB;YACrC,CAAC,OAAO,KAAK,mBAAmB,IAAI,OAAO,KAAK,gBAAgB,CAAC;YACjE,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,KAAK,CAAC;IACZ,CAAC;CACF;AAZD,gEAYC"}