@deenruv/payments-plugin 1.0.0

package/package/mollie/mollie.plugin.d.ts

@@ -0,0 +1,176 @@
+import type { ListParameters } from "@mollie/api-client/dist/types/src/binders/methods/parameters";
+import { Injector, Order, RequestContext } from "@deenruv/core";
+export type AdditionalEnabledPaymentMethodsParams = Partial<Omit<ListParameters, "resource">>;
+/**
+ * @description
+ * Configuration options for the Mollie payments plugin.
+ *
+ * @docsCategory core plugins/PaymentsPlugin
+ * @docsPage MolliePlugin
+ */
+export interface MolliePluginOptions {
+    /**
+     * @description
+     * The host of your Deenruv server, e.g. `'https://my-deenruv.io'`.
+     * This is used by Mollie to send webhook events to the Deenruv server
+     */
+    deenruvHost: string;
+    /**
+     * @description
+     * Provide additional parameters to the Mollie enabled payment methods API call. By default,
+     * the plugin will already pass the `resource` parameter.
+     *
+     * For example, if you want to provide a `locale` and `billingCountry` for the API call, you can do so like this:
+     *
+     * **Note:** The `order` argument is possibly `null`, this could happen when you fetch the available payment methods
+     * before the order is created.
+     *
+     * @example
+     * ```ts
+     * import { DeenruvConfig } from '\@deenruv/core';
+     * import { MolliePlugin, getLocale } from '\@deenruv/payments-plugin/package/mollie';
+     *
+     * export const config: DeenruvConfig = {
+     *   // ...
+     *   plugins: [
+     *     MolliePlugin.init({
+     *       enabledPaymentMethodsParams: (injector, ctx, order) => {
+     *         const locale = order?.billingAddress?.countryCode
+     *             ? getLocale(order.billingAddress.countryCode, ctx.languageCode)
+     *             : undefined;
+     *
+     *         return {
+     *           locale,
+     *           billingCountry: order?.billingAddress?.countryCode,
+     *         },
+     *       }
+     *     }),
+     *   ],
+     * };
+     * ```
+     *
+     * @since 2.2.0
+     */
+    enabledPaymentMethodsParams?: (injector: Injector, ctx: RequestContext, order: Order | null) => AdditionalEnabledPaymentMethodsParams | Promise<AdditionalEnabledPaymentMethodsParams>;
+}
+/**
+ * @description
+ * Plugin to enable payments through the [Mollie platform](https://docs.mollie.com/).
+ * This plugin uses the Order API from Mollie, not the Payments API.
+ *
+ * ## Requirements
+ *
+ * 1. You will need to create a Mollie account and get your apiKey in the dashboard.
+ * 2. Install the Payments plugin and the Mollie client:
+ *
+ *     `yarn add \@deenruv/payments-plugin \@mollie/api-client`
+ *
+ *     or
+ *
+ *     `npm install \@deenruv/payments-plugin \@mollie/api-client`
+ *
+ * ## Setup
+ *
+ * 1. Add the plugin to your DeenruvConfig `plugins` array:
+ *     ```ts
+ *     import { MolliePlugin } from '\@deenruv/payments-plugin/package/mollie';
+ *
+ *     // ...
+ *
+ *     plugins: [
+ *       MolliePlugin.init({ deenruvHost: 'https://yourhost.io/' }),
+ *     ]
+ *     ```
+ * 2. Run a database migration to add the `mollieOrderId` custom field to the order entity.
+ * 3. Create a new PaymentMethod in the Admin UI, and select "Mollie payments" as the handler.
+ * 4. Set your Mollie apiKey in the `API Key` field.
+ * 5. Set the `Fallback redirectUrl` to the url that the customer should be redirected to after completing the payment.
+ * You can override this url by passing the `redirectUrl` as an argument to the `createMolliePaymentIntent` mutation.
+ *
+ * ## Storefront usage
+ *
+ * In your storefront you add a payment to an order using the `createMolliePaymentIntent` mutation. In this example, our Mollie
+ * PaymentMethod was given the code "mollie-payment-method". The `redirectUrl``is the url that is used to redirect the end-user
+ * back to your storefront after completing the payment.
+ *
+ * ```GraphQL
+ * mutation CreateMolliePaymentIntent {
+ *   createMolliePaymentIntent(input: {
+ *     redirectUrl: "https://storefront/order/1234XYZ"
+ *     paymentMethodCode: "mollie-payment-method"
+ *     molliePaymentMethodCode: "ideal"
+ *   }) {
+ *          ... on MolliePaymentIntent {
+ *               url
+ *           }
+ *          ... on MolliePaymentIntentError {
+ *               errorCode
+ *               message
+ *          }
+ *   }
+ * }
+ * ```
+ *
+ * The response will contain
+ * a redirectUrl, which can be used to redirect your customer to the Mollie
+ * platform.
+ *
+ * 'molliePaymentMethodCode' is an optional parameter that can be passed to skip Mollie's hosted payment method selection screen
+ * You can get available Mollie payment methods with the following query:
+ *
+ * ```GraphQL
+ * {
+ *  molliePaymentMethods(input: { paymentMethodCode: "mollie-payment-method" }) {
+ *    id
+ *    code
+ *    description
+ *    minimumAmount {
+ *      value
+ *      currency
+ *    }
+ *    maximumAmount {
+ *      value
+ *      currency
+ *    }
+ *    image {
+ *      size1x
+ *      size2x
+ *      svg
+ *    }
+ *  }
+ * }
+ * ```
+ * You can pass `creditcard` for example, to the `createMolliePaymentIntent` mutation to skip the method selection.
+ *
+ * After completing payment on the Mollie platform,
+ * the user is redirected to the given redirect url, e.g. `https://storefront/order/CH234X5`
+ *
+ * ## Pay later methods
+ * Mollie supports pay-later methods like 'Klarna Pay Later'. For pay-later methods, the status of an order is
+ * 'PaymentAuthorized' after the Mollie hosted checkout. You need to manually settle the payment via the admin ui to capture the payment!
+ * Make sure you capture a payment within 28 days, because this is the Klarna expiry time
+ *
+ * If you don't want this behaviour (Authorized first), you can set 'autoCapture=true' on the payment method. This option will immediately
+ * capture the payment after a customer authorizes the payment.
+ *
+ * ## ArrangingAdditionalPayment state
+ *
+ * In some rare cases, a customer can add items to the active order, while a Mollie payment is still open,
+ * for example by opening your storefront in another browser tab.
+ * This could result in an order being in `ArrangingAdditionalPayment` status after the customer finished payment.
+ * You should check if there is still an active order with status `ArrangingAdditionalPayment` on your order confirmation page,
+ * and if so, allow your customer to pay for the additional items by creating another Mollie payment.
+ *
+ * @docsCategory core plugins/PaymentsPlugin
+ * @docsPage MolliePlugin
+ * @docsWeight 0
+ */
+export declare class MolliePlugin {
+    static options: MolliePluginOptions;
+    /**
+     * @description
+     * Initialize the mollie payment plugin
+     * @param deenruvHost is needed to pass to mollie for callback
+     */
+    static init(options: MolliePluginOptions): typeof MolliePlugin;
+}

package/package/mollie/mollie.plugin.js

@@ -0,0 +1,167 @@
+"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 MolliePlugin_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MolliePlugin = void 0;
+const core_1 = require("@deenruv/core");
+const api_extensions_1 = require("./api-extensions");
+const constants_1 = require("./constants");
+const custom_fields_1 = require("./custom-fields");
+const mollie_common_resolver_1 = require("./mollie.common-resolver");
+const mollie_controller_1 = require("./mollie.controller");
+const mollie_handler_1 = require("./mollie.handler");
+const mollie_service_1 = require("./mollie.service");
+const mollie_shop_resolver_1 = require("./mollie.shop-resolver");
+/**
+ * @description
+ * Plugin to enable payments through the [Mollie platform](https://docs.mollie.com/).
+ * This plugin uses the Order API from Mollie, not the Payments API.
+ *
+ * ## Requirements
+ *
+ * 1. You will need to create a Mollie account and get your apiKey in the dashboard.
+ * 2. Install the Payments plugin and the Mollie client:
+ *
+ *     `yarn add \@deenruv/payments-plugin \@mollie/api-client`
+ *
+ *     or
+ *
+ *     `npm install \@deenruv/payments-plugin \@mollie/api-client`
+ *
+ * ## Setup
+ *
+ * 1. Add the plugin to your DeenruvConfig `plugins` array:
+ *     ```ts
+ *     import { MolliePlugin } from '\@deenruv/payments-plugin/package/mollie';
+ *
+ *     // ...
+ *
+ *     plugins: [
+ *       MolliePlugin.init({ deenruvHost: 'https://yourhost.io/' }),
+ *     ]
+ *     ```
+ * 2. Run a database migration to add the `mollieOrderId` custom field to the order entity.
+ * 3. Create a new PaymentMethod in the Admin UI, and select "Mollie payments" as the handler.
+ * 4. Set your Mollie apiKey in the `API Key` field.
+ * 5. Set the `Fallback redirectUrl` to the url that the customer should be redirected to after completing the payment.
+ * You can override this url by passing the `redirectUrl` as an argument to the `createMolliePaymentIntent` mutation.
+ *
+ * ## Storefront usage
+ *
+ * In your storefront you add a payment to an order using the `createMolliePaymentIntent` mutation. In this example, our Mollie
+ * PaymentMethod was given the code "mollie-payment-method". The `redirectUrl``is the url that is used to redirect the end-user
+ * back to your storefront after completing the payment.
+ *
+ * ```GraphQL
+ * mutation CreateMolliePaymentIntent {
+ *   createMolliePaymentIntent(input: {
+ *     redirectUrl: "https://storefront/order/1234XYZ"
+ *     paymentMethodCode: "mollie-payment-method"
+ *     molliePaymentMethodCode: "ideal"
+ *   }) {
+ *          ... on MolliePaymentIntent {
+ *               url
+ *           }
+ *          ... on MolliePaymentIntentError {
+ *               errorCode
+ *               message
+ *          }
+ *   }
+ * }
+ * ```
+ *
+ * The response will contain
+ * a redirectUrl, which can be used to redirect your customer to the Mollie
+ * platform.
+ *
+ * 'molliePaymentMethodCode' is an optional parameter that can be passed to skip Mollie's hosted payment method selection screen
+ * You can get available Mollie payment methods with the following query:
+ *
+ * ```GraphQL
+ * {
+ *  molliePaymentMethods(input: { paymentMethodCode: "mollie-payment-method" }) {
+ *    id
+ *    code
+ *    description
+ *    minimumAmount {
+ *      value
+ *      currency
+ *    }
+ *    maximumAmount {
+ *      value
+ *      currency
+ *    }
+ *    image {
+ *      size1x
+ *      size2x
+ *      svg
+ *    }
+ *  }
+ * }
+ * ```
+ * You can pass `creditcard` for example, to the `createMolliePaymentIntent` mutation to skip the method selection.
+ *
+ * After completing payment on the Mollie platform,
+ * the user is redirected to the given redirect url, e.g. `https://storefront/order/CH234X5`
+ *
+ * ## Pay later methods
+ * Mollie supports pay-later methods like 'Klarna Pay Later'. For pay-later methods, the status of an order is
+ * 'PaymentAuthorized' after the Mollie hosted checkout. You need to manually settle the payment via the admin ui to capture the payment!
+ * Make sure you capture a payment within 28 days, because this is the Klarna expiry time
+ *
+ * If you don't want this behaviour (Authorized first), you can set 'autoCapture=true' on the payment method. This option will immediately
+ * capture the payment after a customer authorizes the payment.
+ *
+ * ## ArrangingAdditionalPayment state
+ *
+ * In some rare cases, a customer can add items to the active order, while a Mollie payment is still open,
+ * for example by opening your storefront in another browser tab.
+ * This could result in an order being in `ArrangingAdditionalPayment` status after the customer finished payment.
+ * You should check if there is still an active order with status `ArrangingAdditionalPayment` on your order confirmation page,
+ * and if so, allow your customer to pay for the additional items by creating another Mollie payment.
+ *
+ * @docsCategory core plugins/PaymentsPlugin
+ * @docsPage MolliePlugin
+ * @docsWeight 0
+ */
+let MolliePlugin = exports.MolliePlugin = MolliePlugin_1 = class MolliePlugin {
+    /**
+     * @description
+     * Initialize the mollie payment plugin
+     * @param deenruvHost is needed to pass to mollie for callback
+     */
+    static init(options) {
+        this.options = options;
+        return MolliePlugin_1;
+    }
+};
+exports.MolliePlugin = MolliePlugin = MolliePlugin_1 = __decorate([
+    (0, core_1.DeenruvPlugin)({
+        imports: [core_1.PluginCommonModule],
+        controllers: [mollie_controller_1.MollieController],
+        providers: [
+            mollie_service_1.MollieService,
+            { provide: constants_1.PLUGIN_INIT_OPTIONS, useFactory: () => MolliePlugin_1.options },
+        ],
+        configuration: (config) => {
+            config.paymentOptions.paymentMethodHandlers.push(mollie_handler_1.molliePaymentHandler);
+            config.customFields.Order.push(...custom_fields_1.orderCustomFields);
+            return config;
+        },
+        shopApiExtensions: {
+            schema: api_extensions_1.shopApiExtensions,
+            resolvers: [mollie_common_resolver_1.MollieCommonResolver, mollie_shop_resolver_1.MollieShopResolver],
+        },
+        adminApiExtensions: {
+            schema: api_extensions_1.adminApiExtensions,
+            resolvers: [mollie_common_resolver_1.MollieCommonResolver],
+        },
+        compatibility: "^0.0.1",
+    })
+], MolliePlugin);
+//# sourceMappingURL=mollie.plugin.js.map

package/package/mollie/mollie.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mollie.plugin.js","sourceRoot":"","sources":["../../src/mollie/mollie.plugin.ts"],"names":[],"mappings":";;;;;;;;;;AACA,wCAOuB;AAEvB,qDAAyE;AACzE,2CAAkD;AAClD,mDAAoD;AACpD,qEAAgE;AAChE,2DAAuD;AACvD,qDAAwD;AACxD,qDAAiD;AACjD,iEAA4D;AAkE5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+GG;AAuBI,IAAM,YAAY,2CAAlB,MAAM,YAAY;IAGvB;;;;OAIG;IACH,MAAM,CAAC,IAAI,CAAC,OAA4B;QACtC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,OAAO,cAAY,CAAC;IACtB,CAAC;CACF,CAAA;uBAZY,YAAY;IAtBxB,IAAA,oBAAa,EAAC;QACb,OAAO,EAAE,CAAC,yBAAkB,CAAC;QAC7B,WAAW,EAAE,CAAC,oCAAgB,CAAC;QAC/B,SAAS,EAAE;YACT,8BAAa;YACb,EAAE,OAAO,EAAE,+BAAmB,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC,cAAY,CAAC,OAAO,EAAE;SACzE;QACD,aAAa,EAAE,CAAC,MAA4B,EAAE,EAAE;YAC9C,MAAM,CAAC,cAAc,CAAC,qBAAqB,CAAC,IAAI,CAAC,qCAAoB,CAAC,CAAC;YACvE,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,iCAAiB,CAAC,CAAC;YACrD,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,iBAAiB,EAAE;YACjB,MAAM,EAAE,kCAAiB;YACzB,SAAS,EAAE,CAAC,6CAAoB,EAAE,yCAAkB,CAAC;SACtD;QACD,kBAAkB,EAAE;YAClB,MAAM,EAAE,mCAAkB;YAC1B,SAAS,EAAE,CAAC,6CAAoB,CAAC;SAClC;QACD,aAAa,EAAE,QAAQ;KACxB,CAAC;GACW,YAAY,CAYxB"}

package/package/mollie/mollie.service.d.ts

@@ -0,0 +1,64 @@
+import { Order as MollieOrder } from "@mollie/api-client";
+import { CreateParameters } from "@mollie/api-client/dist/types/src/binders/orders/parameters";
+import { ModuleRef } from "@nestjs/core";
+import { ActiveOrderService, EntityHydrator, Order, OrderService, PaymentMethodService, ProductVariant, ProductVariantService, RequestContext } from "@deenruv/core";
+import { ExtendedMollieClient } from "./extended-mollie-client";
+import { MolliePaymentIntentInput, MolliePaymentIntentResult, MolliePaymentMethod } from "./graphql/generated-shop-types";
+import { MolliePluginOptions } from "./mollie.plugin";
+interface OrderStatusInput {
+    paymentMethodId: string;
+    orderId: string;
+}
+export declare class MollieService {
+    private paymentMethodService;
+    private options;
+    private activeOrderService;
+    private orderService;
+    private entityHydrator;
+    private variantService;
+    private moduleRef;
+    private readonly injector;
+    constructor(paymentMethodService: PaymentMethodService, options: MolliePluginOptions, activeOrderService: ActiveOrderService, orderService: OrderService, entityHydrator: EntityHydrator, variantService: ProductVariantService, moduleRef: ModuleRef);
+    /**
+     * Creates a redirectUrl to Mollie for the given paymentMethod and current activeOrder
+     */
+    createPaymentIntent(ctx: RequestContext, input: MolliePaymentIntentInput): Promise<MolliePaymentIntentResult>;
+    /**
+     * Update Deenruv payments and order status based on the incoming Mollie order
+     */
+    handleMollieStatusUpdate(ctx: RequestContext, { paymentMethodId, orderId }: OrderStatusInput): Promise<void>;
+    /**
+     * Add payment to order. Can be settled or authorized depending on the payment method.
+     */
+    addPayment(ctx: RequestContext, order: Order, amount: number, mollieMetadata: Partial<MollieOrder>, paymentMethodCode: string, status: "Authorized" | "Settled"): Promise<Order>;
+    /**
+     * Settle an existing payment based on the given mollieOrder
+     */
+    settleExistingPayment(ctx: RequestContext, order: Order, mollieOrderId: string): Promise<void>;
+    getEnabledPaymentMethods(ctx: RequestContext, paymentMethodCode: string): Promise<MolliePaymentMethod[]>;
+    getVariantsWithInsufficientStock(ctx: RequestContext, order: Order): Promise<ProductVariant[]>;
+    /**
+     * Update an existing Mollie order based on the given Deenruv order.
+     */
+    updateMollieOrder(mollieClient: ExtendedMollieClient, newMollieOrderInput: CreateParameters, mollieOrderId: string): Promise<MollieOrder>;
+    /**
+     * Update the Mollie Order data itself, excluding the order lines.
+     * So, addresses, redirect url etc
+     */
+    private updateMollieOrderData;
+    /**
+     * Delete all order lines of current Mollie order, and create new ones based on the new Deenruv order lines
+     */
+    private updateMollieOrderLines;
+    /**
+     * Dry run a transition to a given state.
+     * As long as we don't call 'finalize', the transition never completes.
+     */
+    private canTransitionTo;
+    private getPaymentMethod;
+    /**
+     * Get order by id, or active order if no orderId is given
+     */
+    private getOrder;
+}
+export {};