@deenruv/core 1.0.0

package/dist/config/payment/payment-method-handler.d.ts

@@ -0,0 +1,389 @@
+import { ConfigArg, RefundOrderInput } from "@deenruv/common/lib/generated-types";
+import { RequestContext } from "../../api/common/request-context";
+import { ConfigArgs, ConfigArgValues, ConfigurableOperationDef, ConfigurableOperationDefOptions } from "../../common/configurable-operation";
+import { OnTransitionStartFn, StateMachineConfig } from "../../common/finite-state-machine/types";
+import { PaymentMetadata } from "../../common/types/common-types";
+import { Order, Payment, PaymentMethod } from "../../entity";
+import { PaymentState, PaymentTransitionData } from "../../service/helpers/payment-state-machine/payment-state";
+import { RefundState } from "../../service/helpers/refund-state-machine/refund-state";
+export type OnPaymentTransitionStartReturnType = ReturnType<Required<StateMachineConfig<any>>["onTransitionStart"]>;
+/**
+ * @description
+ * This object is the return value of the {@link CreatePaymentFn}.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface CreatePaymentResult {
+    /**
+     * @description
+     * The amount (as an integer - i.e. $10 = `1000`) that this payment is for.
+     * Typically this should equal the Order total, unless multiple payment methods
+     * are being used for the order.
+     */
+    amount: number;
+    /**
+     * @description
+     * The {@link PaymentState} of the resulting Payment.
+     *
+     * In a single-step payment flow, this should be set to `'Settled'`.
+     * In a two-step flow, this should be set to `'Authorized'`.
+     *
+     * If using a {@link PaymentProcess}, may be something else
+     * entirely according to your business logic.
+     */
+    state: Exclude<PaymentState, "Error">;
+    /**
+     * @description
+     * The unique payment reference code typically assigned by
+     * the payment provider.
+     */
+    transactionId?: string;
+    /**
+     * @description
+     * If the payment is declined or fails for ome other reason, pass the
+     * relevant error message here, and it gets returned with the
+     * ErrorResponse of the `addPaymentToOrder` mutation.
+     */
+    errorMessage?: string;
+    /**
+     * @description
+     * This field can be used to store other relevant data which is often
+     * provided by the payment provider, such as security data related to
+     * the payment method or data used in troubleshooting or debugging.
+     *
+     * Any data stored in the optional `public` property will be available
+     * via the Shop API. This is useful for certain checkout flows such as
+     * external gateways, where the payment provider returns a unique
+     * url which must then be passed to the storefront app.
+     */
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This object is the return value of the {@link CreatePaymentFn} when there has been an error.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface CreatePaymentErrorResult {
+    amount: number;
+    state: "Error";
+    transactionId?: string;
+    errorMessage: string;
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This object is the return value of the {@link CreateRefundFn}.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface CreateRefundResult {
+    state: RefundState;
+    transactionId?: string;
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This object is the return value of the {@link SettlePaymentFn} when the Payment
+ * has been successfully settled.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface SettlePaymentResult {
+    success: true;
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This object is the return value of the {@link SettlePaymentFn} when the Payment
+ * could not be settled.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface SettlePaymentErrorResult {
+    success: false;
+    /**
+     * @description
+     * The state to transition this Payment to upon unsuccessful settlement.
+     * Defaults to `Error`. Note that if using a different state, it must be
+     * legal to transition to that state from the `Authorized` state according
+     * to the PaymentState config (which can be customized using the
+     * {@link PaymentProcess}).
+     */
+    state?: Exclude<PaymentState, "Settled">;
+    /**
+     * @description
+     * The message that will be returned when attempting to settle the payment, and will
+     * also be persisted as `Payment.errorMessage`.
+     */
+    errorMessage?: string;
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This object is the return value of the {@link CancelPaymentFn} when the Payment
+ * has been successfully cancelled.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface CancelPaymentResult {
+    success: true;
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This object is the return value of the {@link CancelPaymentFn} when the Payment
+ * could not be cancelled.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export interface CancelPaymentErrorResult {
+    success: false;
+    /**
+     * @description
+     * The state to transition this Payment to upon unsuccessful cancellation.
+     * Defaults to `Error`. Note that if using a different state, it must be
+     * legal to transition to that state from the `Authorized` state according
+     * to the PaymentState config (which can be customized using the
+     * {@link PaymentProcess}).
+     */
+    state?: Exclude<PaymentState, "Cancelled">;
+    /**
+     * @description
+     * The message that will be returned when attempting to cancel the payment, and will
+     * also be persisted as `Payment.errorMessage`.
+     */
+    errorMessage?: string;
+    metadata?: PaymentMetadata;
+}
+/**
+ * @description
+ * This function contains the logic for creating a payment. See {@link PaymentMethodHandler} for an example.
+ *
+ * Returns a {@link CreatePaymentResult}.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export type CreatePaymentFn<T extends ConfigArgs> = (ctx: RequestContext, order: Order, amount: number, args: ConfigArgValues<T>, metadata: PaymentMetadata, method: PaymentMethod) => CreatePaymentResult | CreatePaymentErrorResult | Promise<CreatePaymentResult | CreatePaymentErrorResult>;
+/**
+ * @description
+ * This function contains the logic for settling a payment. See {@link PaymentMethodHandler} for an example.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export type SettlePaymentFn<T extends ConfigArgs> = (ctx: RequestContext, order: Order, payment: Payment, args: ConfigArgValues<T>, method: PaymentMethod) => SettlePaymentResult | SettlePaymentErrorResult | Promise<SettlePaymentResult | SettlePaymentErrorResult>;
+/**
+ * @description
+ * This function contains the logic for cancelling a payment. See {@link PaymentMethodHandler} for an example.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export type CancelPaymentFn<T extends ConfigArgs> = (ctx: RequestContext, order: Order, payment: Payment, args: ConfigArgValues<T>, method: PaymentMethod) => CancelPaymentResult | CancelPaymentErrorResult | Promise<CancelPaymentResult | CancelPaymentErrorResult>;
+/**
+ * @description
+ * This function contains the logic for creating a refund. See {@link PaymentMethodHandler} for an example.
+ *
+ * @docsCategory payment
+ * @docsPage Payment Method Types
+ */
+export type CreateRefundFn<T extends ConfigArgs> = (ctx: RequestContext, input: RefundOrderInput, amount: number, order: Order, payment: Payment, args: ConfigArgValues<T>, method: PaymentMethod) => CreateRefundResult | Promise<CreateRefundResult>;
+/**
+ * @description
+ * Defines the object which is used to construct the {@link PaymentMethodHandler}.
+ *
+ * @docsCategory payment
+ */
+export interface PaymentMethodConfigOptions<T extends ConfigArgs> extends ConfigurableOperationDefOptions<T> {
+    /**
+     * @description
+     * This function provides the logic for creating a payment. For example,
+     * it may call out to a third-party service with the data and should return a
+     * {@link CreatePaymentResult} object contains the details of the payment.
+     */
+    createPayment: CreatePaymentFn<T>;
+    /**
+     * @description
+     * This function provides the logic for settling a payment, also known as "capturing".
+     * For payment integrations that settle/capture the payment on creation (i.e. the
+     * `createPayment()` method returns with a state of `'Settled'`) this method
+     * need only return `{ success: true }`.
+     */
+    settlePayment: SettlePaymentFn<T>;
+    /**
+     * @description
+     * This function provides the logic for cancelling a payment, which would be invoked when a call is
+     * made to the `cancelPayment` mutation in the Admin API. Cancelling a payment can apply
+     * if, for example, you have created a "payment intent" with the payment provider but not yet
+     * completed the payment. It allows the incomplete payment to be cleaned up on the provider's end
+     * if it gets cancelled via Deenruv.
+     *
+     * @since 1.7.0
+     */
+    cancelPayment?: CancelPaymentFn<T>;
+    /**
+     * @description
+     * This function provides the logic for refunding a payment created with this
+     * payment method. Some payment providers may not provide the facility to
+     * programmatically create a refund. In such a case, this method should be
+     * omitted and any Refunds will have to be settled manually by an administrator.
+     */
+    createRefund?: CreateRefundFn<T>;
+    /**
+     * @description
+     * This function, when specified, will be invoked before any transition from one {@link PaymentState} to another.
+     * The return value (a sync / async `boolean`) is used to determine whether the transition is permitted.
+     */
+    onStateTransitionStart?: OnTransitionStartFn<PaymentState, PaymentTransitionData>;
+}
+/**
+ * @description
+ * A PaymentMethodHandler contains the code which is used to generate a Payment when a call to the
+ * `addPaymentToOrder` mutation is made. It contains any necessary steps of interfacing with a
+ * third-party payment gateway before the Payment is created and can also define actions to fire
+ * when the state of the payment is changed.
+ *
+ * PaymentMethodHandlers are instantiated using a {@link PaymentMethodConfigOptions} object, which
+ * configures the business logic used to create, settle and refund payments.
+ *
+ * @example
+ * ```ts
+ * import { PaymentMethodHandler, CreatePaymentResult, SettlePaymentResult, LanguageCode } from '\@deenruv/core';
+ * // A mock 3rd-party payment SDK
+ * import gripeSDK from 'gripe';
+ *
+ * export const examplePaymentHandler = new PaymentMethodHandler({
+ *   code: 'example-payment-provider',
+ *   description: [{
+ *     languageCode: LanguageCode.en,
+ *     value: 'Example Payment Provider',
+ *   }],
+ *   args: {
+ *     apiKey: { type: 'string' },
+ *   },
+ *   createPayment: async (ctx, order, amount, args, metadata): Promise<CreatePaymentResult> => {
+ *     try {
+ *       const result = await gripeSDK.charges.create({
+ *         amount,
+ *         apiKey: args.apiKey,
+ *         source: metadata.authToken,
+ *       });
+ *       return {
+ *         amount: order.total,
+ *         state: 'Settled' as const,
+ *         transactionId: result.id.toString(),
+ *         metadata: result.outcome,
+ *       };
+ *     } catch (err: any) {
+ *       return {
+ *         amount: order.total,
+ *         state: 'Declined' as const,
+ *         metadata: {
+ *           errorMessage: err.message,
+ *         },
+ *       };
+ *     }
+ *   },
+ *   settlePayment: async (ctx, order, payment, args): Promise<SettlePaymentResult> => {
+ *     return { success: true };
+ *   }
+ * });
+ * ```
+ *
+ * @docsCategory payment
+ */
+export declare class PaymentMethodHandler<T extends ConfigArgs = ConfigArgs> extends ConfigurableOperationDef<T> {
+    private readonly createPaymentFn;
+    private readonly settlePaymentFn;
+    private readonly cancelPaymentFn?;
+    private readonly createRefundFn?;
+    private readonly onTransitionStartFn?;
+    constructor(config: PaymentMethodConfigOptions<T>);
+    /**
+     * @description
+     * Called internally to create a new Payment
+     *
+     * @internal
+     */
+    createPayment(ctx: RequestContext, order: Order, amount: number, args: ConfigArg[], metadata: PaymentMetadata, method: PaymentMethod): Promise<{
+        /**
+         * @description
+         * The amount (as an integer - i.e. $10 = `1000`) that this payment is for.
+         * Typically this should equal the Order total, unless multiple payment methods
+         * are being used for the order.
+         */
+        amount: number;
+        /**
+         * @description
+         * The {@link PaymentState} of the resulting Payment.
+         *
+         * In a single-step payment flow, this should be set to `'Settled'`.
+         * In a two-step flow, this should be set to `'Authorized'`.
+         *
+         * If using a {@link PaymentProcess}, may be something else
+         * entirely according to your business logic.
+         */
+        state: "Created" | "Cancelled" | keyof import("../../service/helpers/payment-state-machine/payment-state").PaymentStates;
+        /**
+         * @description
+         * The unique payment reference code typically assigned by
+         * the payment provider.
+         */
+        transactionId?: string | undefined;
+        /**
+         * @description
+         * If the payment is declined or fails for ome other reason, pass the
+         * relevant error message here, and it gets returned with the
+         * ErrorResponse of the `addPaymentToOrder` mutation.
+         */
+        errorMessage?: string | undefined;
+        metadata: PaymentMetadata;
+        method: string;
+    } | {
+        amount: number;
+        state: "Error";
+        transactionId?: string | undefined;
+        errorMessage: string;
+        metadata: PaymentMetadata;
+        method: string;
+    }>;
+    /**
+     * @description
+     * Called internally to settle a payment
+     *
+     * @internal
+     */
+    settlePayment(ctx: RequestContext, order: Order, payment: Payment, args: ConfigArg[], method: PaymentMethod): Promise<SettlePaymentResult | SettlePaymentErrorResult>;
+    /**
+     * @description
+     * Called internally to cancel a payment
+     *
+     * @internal
+     */
+    cancelPayment(ctx: RequestContext, order: Order, payment: Payment, args: ConfigArg[], method: PaymentMethod): Promise<CancelPaymentResult | CancelPaymentErrorResult | undefined>;
+    /**
+     * @description
+     * Called internally to create a refund
+     *
+     * @internal
+     */
+    createRefund(ctx: RequestContext, input: RefundOrderInput, amount: number, order: Order, payment: Payment, args: ConfigArg[], method: PaymentMethod): Promise<false | CreateRefundResult>;
+    /**
+     * @description
+     * This function is called before the state of a Payment is transitioned. If the PaymentMethodHandler
+     * was instantiated with a `onStateTransitionStart` function, that function will be invoked and its
+     * return value used to determine whether the transition can occur.
+     *
+     * @internal
+     */
+    onStateTransitionStart(fromState: PaymentState, toState: PaymentState, data: PaymentTransitionData): OnPaymentTransitionStartReturnType;
+}

package/dist/config/payment/payment-method-handler.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentMethodHandler = void 0;
+const configurable_operation_1 = require("../../common/configurable-operation");
+/**
+ * @description
+ * A PaymentMethodHandler contains the code which is used to generate a Payment when a call to the
+ * `addPaymentToOrder` mutation is made. It contains any necessary steps of interfacing with a
+ * third-party payment gateway before the Payment is created and can also define actions to fire
+ * when the state of the payment is changed.
+ *
+ * PaymentMethodHandlers are instantiated using a {@link PaymentMethodConfigOptions} object, which
+ * configures the business logic used to create, settle and refund payments.
+ *
+ * @example
+ * ```ts
+ * import { PaymentMethodHandler, CreatePaymentResult, SettlePaymentResult, LanguageCode } from '\@deenruv/core';
+ * // A mock 3rd-party payment SDK
+ * import gripeSDK from 'gripe';
+ *
+ * export const examplePaymentHandler = new PaymentMethodHandler({
+ *   code: 'example-payment-provider',
+ *   description: [{
+ *     languageCode: LanguageCode.en,
+ *     value: 'Example Payment Provider',
+ *   }],
+ *   args: {
+ *     apiKey: { type: 'string' },
+ *   },
+ *   createPayment: async (ctx, order, amount, args, metadata): Promise<CreatePaymentResult> => {
+ *     try {
+ *       const result = await gripeSDK.charges.create({
+ *         amount,
+ *         apiKey: args.apiKey,
+ *         source: metadata.authToken,
+ *       });
+ *       return {
+ *         amount: order.total,
+ *         state: 'Settled' as const,
+ *         transactionId: result.id.toString(),
+ *         metadata: result.outcome,
+ *       };
+ *     } catch (err: any) {
+ *       return {
+ *         amount: order.total,
+ *         state: 'Declined' as const,
+ *         metadata: {
+ *           errorMessage: err.message,
+ *         },
+ *       };
+ *     }
+ *   },
+ *   settlePayment: async (ctx, order, payment, args): Promise<SettlePaymentResult> => {
+ *     return { success: true };
+ *   }
+ * });
+ * ```
+ *
+ * @docsCategory payment
+ */
+class PaymentMethodHandler extends configurable_operation_1.ConfigurableOperationDef {
+    constructor(config) {
+        super(config);
+        this.createPaymentFn = config.createPayment;
+        this.settlePaymentFn = config.settlePayment;
+        this.cancelPaymentFn = config.cancelPayment;
+        this.createRefundFn = config.createRefund;
+        this.onTransitionStartFn = config.onStateTransitionStart;
+    }
+    /**
+     * @description
+     * Called internally to create a new Payment
+     *
+     * @internal
+     */
+    async createPayment(ctx, order, amount, args, metadata, method) {
+        const paymentConfig = await this.createPaymentFn(ctx, order, amount, this.argsArrayToHash(args), metadata, method);
+        return Object.assign({ method: this.code, metadata: {} }, paymentConfig);
+    }
+    /**
+     * @description
+     * Called internally to settle a payment
+     *
+     * @internal
+     */
+    async settlePayment(ctx, order, payment, args, method) {
+        return this.settlePaymentFn(ctx, order, payment, this.argsArrayToHash(args), method);
+    }
+    /**
+     * @description
+     * Called internally to cancel a payment
+     *
+     * @internal
+     */
+    async cancelPayment(ctx, order, payment, args, method) {
+        var _a;
+        return (_a = this.cancelPaymentFn) === null || _a === void 0 ? void 0 : _a.call(this, ctx, order, payment, this.argsArrayToHash(args), method);
+    }
+    /**
+     * @description
+     * Called internally to create a refund
+     *
+     * @internal
+     */
+    async createRefund(ctx, input, amount, order, payment, args, method) {
+        return this.createRefundFn
+            ? this.createRefundFn(ctx, input, amount, order, payment, this.argsArrayToHash(args), method)
+            : false;
+    }
+    /**
+     * @description
+     * This function is called before the state of a Payment is transitioned. If the PaymentMethodHandler
+     * was instantiated with a `onStateTransitionStart` function, that function will be invoked and its
+     * return value used to determine whether the transition can occur.
+     *
+     * @internal
+     */
+    onStateTransitionStart(fromState, toState, data) {
+        if (typeof this.onTransitionStartFn === "function") {
+            return this.onTransitionStartFn(fromState, toState, data);
+        }
+        else {
+            return true;
+        }
+    }
+}
+exports.PaymentMethodHandler = PaymentMethodHandler;
+//# sourceMappingURL=payment-method-handler.js.map

package/dist/config/payment/payment-method-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-method-handler.js","sourceRoot":"","sources":["../../../src/config/payment/payment-method-handler.ts"],"names":[],"mappings":";;;AAMA,gFAK6C;AAkT7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,MAAa,oBAEX,SAAQ,iDAA2B;IAUnC,YAAY,MAAqC;QAC/C,KAAK,CAAC,MAAM,CAAC,CAAC;QACd,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC;QAC5C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC;QAC5C,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,aAAa,CAAC;QAC5C,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,YAAY,CAAC;QAC1C,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,sBAAsB,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CACjB,GAAmB,EACnB,KAAY,EACZ,MAAc,EACd,IAAiB,EACjB,QAAyB,EACzB,MAAqB;QAErB,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,eAAe,CAC9C,GAAG,EACH,KAAK,EACL,MAAM,EACN,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAC1B,QAAQ,EACR,MAAM,CACP,CAAC;QACF,uBACE,MAAM,EAAE,IAAI,CAAC,IAAI,EACjB,QAAQ,EAAE,EAAE,IACT,aAAa,EAChB;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CACjB,GAAmB,EACnB,KAAY,EACZ,OAAgB,EAChB,IAAiB,EACjB,MAAqB;QAErB,OAAO,IAAI,CAAC,eAAe,CACzB,GAAG,EACH,KAAK,EACL,OAAO,EACP,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAC1B,MAAM,CACP,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,aAAa,CACjB,GAAmB,EACnB,KAAY,EACZ,OAAgB,EAChB,IAAiB,EACjB,MAAqB;;QAErB,OAAO,MAAA,IAAI,CAAC,eAAe,qDACzB,GAAG,EACH,KAAK,EACL,OAAO,EACP,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAC1B,MAAM,CACP,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,YAAY,CAChB,GAAmB,EACnB,KAAuB,EACvB,MAAc,EACd,KAAY,EACZ,OAAgB,EAChB,IAAiB,EACjB,MAAqB;QAErB,OAAO,IAAI,CAAC,cAAc;YACxB,CAAC,CAAC,IAAI,CAAC,cAAc,CACjB,GAAG,EACH,KAAK,EACL,MAAM,EACN,KAAK,EACL,OAAO,EACP,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAC1B,MAAM,CACP;YACH,CAAC,CAAC,KAAK,CAAC;IACZ,CAAC;IAED;;;;;;;OAOG;IACH,sBAAsB,CACpB,SAAuB,EACvB,OAAqB,EACrB,IAA2B;QAE3B,IAAI,OAAO,IAAI,CAAC,mBAAmB,KAAK,UAAU,EAAE,CAAC;YACnD,OAAO,IAAI,CAAC,mBAAmB,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAC5D,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;CACF;AA7ID,oDA6IC"}

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

@@ -0,0 +1,38 @@
+import { OnTransitionEndFn, OnTransitionErrorFn, OnTransitionStartFn, Transitions } from "../../common/finite-state-machine/types";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+import { CustomPaymentStates, PaymentState, PaymentTransitionData } from "../../service/helpers/payment-state-machine/payment-state";
+/**
+ * @description
+ * A PaymentProcess is used to define the way the payment process works as in: what states a Payment can be
+ * in, and how it may transition from one state to another. Using the `onTransitionStart()` hook, a
+ * PaymentProcess 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 `paymentOptions.process` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @docsCategory payment
+ * @since 2.0.0
+ */
+export interface PaymentProcess<State extends keyof CustomPaymentStates | string> extends InjectableStrategy {
+    transitions?: Transitions<State, State | PaymentState> & Partial<Transitions<PaymentState | State>>;
+    onTransitionStart?: OnTransitionStartFn<State | PaymentState, PaymentTransitionData>;
+    onTransitionEnd?: OnTransitionEndFn<State | PaymentState, PaymentTransitionData>;
+    onTransitionError?: OnTransitionErrorFn<State | PaymentState>;
+}
+/**
+ * @description
+ * Used to define extensions to or modifications of the default payment process.
+ *
+ * For detailed description of the interface members, see the {@link StateMachineConfig} docs.
+ *
+ * @deprecated use PaymentProcess
+ */
+export interface CustomPaymentProcess<State extends keyof CustomPaymentStates | string> extends PaymentProcess<State> {
+}

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

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

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

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

package/dist/config/promotion/actions/buy-x-get-y-free-action.d.ts

@@ -0,0 +1,38 @@
+import { LanguageCode } from "@deenruv/common/lib/generated-types";
+import { PromotionItemAction } from "../promotion-action";
+export declare const buyXGetYFreeAction: PromotionItemAction<{}, import("..").PromotionCondition<{
+    amountX: {
+        type: "int";
+        defaultValue: number;
+    };
+    variantIdsX: {
+        type: "ID";
+        list: true;
+        ui: {
+            component: string;
+        };
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+    amountY: {
+        type: "int";
+        defaultValue: number;
+    };
+    variantIdsY: {
+        type: "ID";
+        list: true;
+        ui: {
+            component: string;
+        };
+        label: {
+            languageCode: LanguageCode.en;
+            value: string;
+        }[];
+    };
+}, "buy_x_get_y_free", false | {
+    freeItemsPerLine: {
+        [lineId: string]: number;
+    };
+}>[]>;

package/dist/config/promotion/actions/buy-x-get-y-free-action.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buyXGetYFreeAction = void 0;
+const generated_types_1 = require("@deenruv/common/lib/generated-types");
+const buy_x_get_y_free_condition_1 = require("../conditions/buy-x-get-y-free-condition");
+const promotion_action_1 = require("../promotion-action");
+exports.buyXGetYFreeAction = new promotion_action_1.PromotionItemAction({
+    code: "buy_x_get_y_free",
+    description: [
+        {
+            languageCode: generated_types_1.LanguageCode.en,
+            value: "Buy X products, get Y products free",
+        },
+    ],
+    args: {},
+    conditions: [buy_x_get_y_free_condition_1.buyXGetYFreeCondition],
+    execute(ctx, orderLine, args, state) {
+        const freeItemsPerLine = state.buy_x_get_y_free.freeItemsPerLine;
+        const freeQuantity = freeItemsPerLine[orderLine.id];
+        if (freeQuantity) {
+            const unitPrice = ctx.channel.pricesIncludeTax
+                ? orderLine.unitPriceWithTax
+                : orderLine.unitPrice;
+            return -unitPrice * (freeQuantity / orderLine.quantity);
+        }
+        return 0;
+    },
+});
+//# sourceMappingURL=buy-x-get-y-free-action.js.map

package/dist/config/promotion/actions/buy-x-get-y-free-action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buy-x-get-y-free-action.js","sourceRoot":"","sources":["../../../../src/config/promotion/actions/buy-x-get-y-free-action.ts"],"names":[],"mappings":";;;AAAA,yEAAmE;AAInE,yFAAiF;AACjF,0DAA0D;AAE7C,QAAA,kBAAkB,GAAG,IAAI,sCAAmB,CAAC;IACxD,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE;QACX;YACE,YAAY,EAAE,8BAAY,CAAC,EAAE;YAC7B,KAAK,EAAE,qCAAqC;SAC7C;KACF;IACD,IAAI,EAAE,EAAE;IACR,UAAU,EAAE,CAAC,kDAAqB,CAAC;IACnC,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK;QACjC,MAAM,gBAAgB,GAAG,KAAK,CAAC,gBAAgB,CAAC,gBAAgB,CAAC;QACjE,MAAM,YAAY,GAAG,gBAAgB,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACpD,IAAI,YAAY,EAAE,CAAC;YACjB,MAAM,SAAS,GAAG,GAAG,CAAC,OAAO,CAAC,gBAAgB;gBAC5C,CAAC,CAAC,SAAS,CAAC,gBAAgB;gBAC5B,CAAC,CAAC,SAAS,CAAC,SAAS,CAAC;YACxB,OAAO,CAAC,SAAS,GAAG,CAAC,YAAY,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;QAC1D,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC;CACF,CAAC,CAAC"}

package/dist/config/promotion/actions/facet-values-percentage-discount-action.d.ts

@@ -0,0 +1,17 @@
+import { PromotionItemAction } from "../promotion-action";
+export declare const discountOnItemWithFacets: PromotionItemAction<{
+    discount: {
+        type: "float";
+        ui: {
+            component: string;
+            suffix: string;
+        };
+    };
+    facets: {
+        type: "ID";
+        list: true;
+        ui: {
+            component: string;
+        };
+    };
+}, []>;