@webbers/pay-payments-medusa 2.2.50 → 2.2.52

package/.medusa/server/src/utils/directDebitSimulation.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEPA_TESTING_METADATA_KEY = exports.getPayProviderOptions = exports.isSimulatedExchangeKey = exports.SIMULATED_EXCHANGE_PRESETS = void 0;
+exports.isSepaTestingEnabled = isSepaTestingEnabled;
+exports.setSepaTestingEnabled = setSepaTestingEnabled;
+exports.getDirectDebitSimulationState = getDirectDebitSimulationState;
+exports.buildSimulatedExchangePayload = buildSimulatedExchangePayload;
+const utils_1 = require("@medusajs/framework/utils");
+const getPayPaymentSession_1 = __importDefault(require("./getPayPaymentSession"));
+const directDebitExchange_1 = require("./directDebitExchange");
+const types_1 = require("../providers/pay/types");
+const constants_1 = require("../providers/pay/core/constants");
+/**
+ * The exchanges a test server can simulate for a direct debit that only exists
+ * locally (see README "Testing direct debits locally"). Each preset is the body
+ * Pay. would send, minus the mandate and order reference that are filled in
+ * from the order.
+ */
+exports.SIMULATED_EXCHANGE_PRESETS = {
+    pending: {
+        label: "Pending",
+        description: "The debit is scheduled, the collection stays awaiting.",
+        payload: { action: "incassopending" },
+    },
+    sent: {
+        label: "Sent to bank",
+        description: "The debit was sent to the bank, the collection stays awaiting.",
+        payload: { action: "incassosend" },
+    },
+    collected: {
+        label: "Collected",
+        description: "The bank collected the money: the payment is captured.",
+        payload: { action: "incassocollected" },
+    },
+    storno: {
+        label: "Storno",
+        description: "The customer reversed the debit after collection: the payment is refunded in Medusa and the order becomes payable again.",
+        payload: { action: "incassostorno" },
+    },
+    failed: {
+        label: "Failed",
+        description: "The bank rejected the debit: the collection fails.",
+        payload: {
+            action: "incassosend",
+            status: { code: constants_1.PayDirectDebitStatusCode.FAILED },
+        },
+    },
+    declined: {
+        label: "Declined",
+        description: "The debit was declined: the collection fails.",
+        payload: { action: "incassosend", declined: true },
+    },
+};
+const isSimulatedExchangeKey = (value) => typeof value === "string" &&
+    Object.prototype.hasOwnProperty.call(exports.SIMULATED_EXCHANGE_PRESETS, value);
+exports.isSimulatedExchangeKey = isSimulatedExchangeKey;
+const getPayProviderOptions = (container) => {
+    const configModule = container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+    const payModuleConfig = configModule.modules?.payment?.options
+        ?.providers?.find((p) => p.id === "pay");
+    return payModuleConfig?.options ?? null;
+};
+exports.getPayProviderOptions = getPayProviderOptions;
+/**
+ * The "SEPA testing" switch on the Pay. settings page lives in the store's
+ * metadata, so it is shared by every admin user and needs no migration. Off by
+ * default: it is meant for staging servers only.
+ */
+exports.SEPA_TESTING_METADATA_KEY = "pay_sepa_testing";
+const getStore = async (container) => {
+    const storeModuleService = container.resolve(utils_1.Modules.STORE);
+    const [store] = await storeModuleService.listStores({}, { select: ["id", "metadata"], take: 1 });
+    return store ?? null;
+};
+async function isSepaTestingEnabled(container) {
+    const store = await getStore(container);
+    return store?.metadata?.[exports.SEPA_TESTING_METADATA_KEY] === true;
+}
+async function setSepaTestingEnabled(container, enabled) {
+    const store = await getStore(container);
+    if (!store) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "No store found");
+    }
+    const storeModuleService = container.resolve(utils_1.Modules.STORE);
+    await storeModuleService.updateStores(store.id, {
+        metadata: { ...(store.metadata ?? {}), [exports.SEPA_TESTING_METADATA_KEY]: enabled },
+    });
+    return enabled;
+}
+const presetSummaries = () => Object.fromEntries(Object.entries(exports.SIMULATED_EXCHANGE_PRESETS).map(([key, preset]) => [
+    key,
+    { label: preset.label, description: preset.description },
+]));
+async function getDirectDebitSimulationState(container, orderId) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const options = (0, exports.getPayProviderOptions)(container);
+    // Same default as the HTTP client: an unset testMode means test mode
+    const testMode = options?.testMode ?? true;
+    const sepaTesting = await isSepaTestingEnabled(container);
+    const { data: [order], } = await query.graph({
+        entity: "order",
+        fields: [
+            "id",
+            "display_id",
+            "payment_collections.id",
+            "payment_collections.status",
+            "payment_collections.payment_sessions.*",
+            "payment_collections.payment_sessions.payment.id",
+            "payment_collections.payment_sessions.payment.captured_at",
+        ],
+        filters: { id: orderId },
+    });
+    if (!order) {
+        return null;
+    }
+    const base = {
+        testMode,
+        sepaTesting,
+        orderId: order.id,
+        displayId: String(order.display_id),
+        presets: presetSummaries(),
+    };
+    const payPaymentSession = (0, getPayPaymentSession_1.default)(order);
+    if (!payPaymentSession?.provider_id.includes(types_1.PaymentProviderKeys.DIRECTDEBIT)) {
+        return {
+            ...base,
+            available: false,
+            reason: "no_direct_debit",
+            mandateCode: null,
+            paymentCollectionId: null,
+            paymentCollectionStatus: null,
+            captured: false,
+        };
+    }
+    const sessionData = (payPaymentSession.data ?? {});
+    const mandateCode = typeof sessionData.code === "string" ? sessionData.code : null;
+    const simulated = sessionData.testMode === true && (0, directDebitExchange_1.isSimulatedDirectDebitMandate)(mandateCode);
+    const collection = (order.payment_collections ?? []).find((pc) => pc?.id === payPaymentSession.payment_collection_id);
+    const reason = !sepaTesting
+        ? "sepa_testing_off"
+        : !testMode
+            ? "test_mode_off"
+            : !simulated
+                ? "not_simulated"
+                : undefined;
+    return {
+        ...base,
+        available: !reason,
+        reason,
+        mandateCode,
+        paymentCollectionId: payPaymentSession.payment_collection_id ?? null,
+        paymentCollectionStatus: collection?.status ?? null,
+        captured: !!payPaymentSession.payment?.captured_at,
+    };
+}
+/**
+ * Builds the exchange body for a preset, as Pay. would send it for the order's
+ * simulated mandate.
+ */
+function buildSimulatedExchangePayload(key, state) {
+    return {
+        ...exports.SIMULATED_EXCHANGE_PRESETS[key].payload,
+        mandateId: state.mandateCode,
+        reference: state.displayId,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./createPayOrder";
+export * from "./reverseCapturedPayment";
 //# sourceMappingURL=index.d.ts.map

package/.medusa/server/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,0BAA0B,CAAA"}

package/.medusa/server/src/utils/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./createPayOrder"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnQyJ9
+__exportStar(require("./reverseCapturedPayment"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnQztBQUNoQywyREFBd0MifQ==

package/.medusa/server/src/utils/reverseCapturedPayment.d.ts

@@ -0,0 +1,30 @@
+import { MedusaContainer } from "@medusajs/types";
+export type ReverseCapturedPaymentInput = {
+    orderId: string;
+    paymentId: string;
+    paymentCollectionId: string;
+    /** Stored as the refund note, e.g. "Pay. chargeback (status -71)" */
+    reason: string;
+};
+/**
+ * A chargeback or direct debit storno reverses a payment Medusa already
+ * captured. Reflect that on the order so it shows as unpaid and can be paid
+ * again:
+ *
+ * 1. record a refund for the still-captured amount on the payment. The Pay.
+ *    provider recognises a reversed payment and records it without asking Pay.
+ *    for a refund, the money is already back with the customer;
+ * 2. add the matching negative order transaction, so the order summary shows
+ *    the amount as outstanding again (refundPaymentWorkflow is not used
+ *    because it would also credit the order for the refund);
+ * 3. mark the payment collection failed;
+ * 4. create a fresh not_paid payment collection for the outstanding amount,
+ *    which is what the admin's "Copy payment link" / "Mark as paid" buttons and
+ *    the storefront payment-collection route work with.
+ *
+ * Safe to run more than once: a payment that is already fully reversed only
+ * gets whatever step is still missing.
+ */
+export declare function reverseCapturedPayment(container: MedusaContainer, input: ReverseCapturedPaymentInput): Promise<void>;
+export default reverseCapturedPayment;
+//# sourceMappingURL=reverseCapturedPayment.d.ts.map

package/.medusa/server/src/utils/reverseCapturedPayment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverseCapturedPayment.d.ts","sourceRoot":"","sources":["../../../../src/utils/reverseCapturedPayment.ts"],"names":[],"mappings":"AAQA,OAAO,EAKL,eAAe,EAChB,MAAM,iBAAiB,CAAA;AAExB,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAQD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,IAAI,CAAC,CA+Ef;AAED,eAAe,sBAAsB,CAAA"}

package/.medusa/server/src/utils/reverseCapturedPayment.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseCapturedPayment = reverseCapturedPayment;
+const core_flows_1 = require("@medusajs/core-flows");
+const utils_1 = require("@medusajs/framework/utils");
+const sumAmounts = (items) => (items ?? []).reduce((total, item) => utils_1.MathBN.add(total, item.amount), utils_1.MathBN.convert(0));
+/**
+ * A chargeback or direct debit storno reverses a payment Medusa already
+ * captured. Reflect that on the order so it shows as unpaid and can be paid
+ * again:
+ *
+ * 1. record a refund for the still-captured amount on the payment. The Pay.
+ *    provider recognises a reversed payment and records it without asking Pay.
+ *    for a refund, the money is already back with the customer;
+ * 2. add the matching negative order transaction, so the order summary shows
+ *    the amount as outstanding again (refundPaymentWorkflow is not used
+ *    because it would also credit the order for the refund);
+ * 3. mark the payment collection failed;
+ * 4. create a fresh not_paid payment collection for the outstanding amount,
+ *    which is what the admin's "Copy payment link" / "Mark as paid" buttons and
+ *    the storefront payment-collection route work with.
+ *
+ * Safe to run more than once: a payment that is already fully reversed only
+ * gets whatever step is still missing.
+ */
+async function reverseCapturedPayment(container, input) {
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const paymentModuleService = container.resolve(utils_1.Modules.PAYMENT);
+    const orderModuleService = container.resolve(utils_1.Modules.ORDER);
+    let payment = await paymentModuleService.retrievePayment(input.paymentId, {
+        relations: ["captures", "refunds"],
+    });
+    const outstanding = utils_1.MathBN.sub(sumAmounts(payment.captures), sumAmounts(payment.refunds));
+    if (utils_1.MathBN.gt(outstanding, 0)) {
+        const amount = new utils_1.BigNumber(outstanding).numeric;
+        payment = await paymentModuleService.refundPayment({
+            payment_id: payment.id,
+            amount,
+            note: input.reason,
+        });
+        logger.info(`Pay. - Recorded reversal of ${payment.currency_code} ${amount} on payment ${payment.id} for order ${input.orderId}: ${input.reason}`);
+    }
+    else {
+        logger.info(`Pay. - Payment ${payment.id} for order ${input.orderId} is already fully reversed`);
+    }
+    // Same bookkeeping as refundPaymentWorkflow: one negative transaction per
+    // refund. Refunds made earlier through the admin already have theirs.
+    const existingTransactions = await orderModuleService.listOrderTransactions({ order_id: input.orderId }, { select: ["reference", "reference_id"] });
+    const knownRefundIds = new Set(existingTransactions
+        .filter((transaction) => transaction.reference === "refund")
+        .map((transaction) => transaction.reference_id));
+    const missingTransactions = (payment.refunds ?? [])
+        .filter((refund) => !knownRefundIds.has(refund.id))
+        .map((refund) => ({
+        order_id: input.orderId,
+        amount: new utils_1.BigNumber(utils_1.MathBN.mult(refund.amount, -1)).numeric,
+        currency_code: payment.currency_code,
+        reference: "refund",
+        reference_id: refund.id,
+    }));
+    if (missingTransactions.length) {
+        await orderModuleService.addOrderTransactions(missingTransactions);
+    }
+    // Recording the refund recomputes the collection status from the captured
+    // amount (back to completed), so the failure is applied afterwards
+    await paymentModuleService.updatePaymentCollections(input.paymentCollectionId, { status: utils_1.PaymentCollectionStatus.FAILED });
+    const { result } = await (0, core_flows_1.createOrUpdateOrderPaymentCollectionWorkflow)(container).run({ input: { order_id: input.orderId } });
+    const collections = Array.isArray(result) ? result : result ? [result] : [];
+    logger.info(`Pay. - Order ${input.orderId} is payable again through payment collection ${collections.map((collection) => collection.id).join(", ") || "(none)"}`);
+}
+exports.default = reverseCapturedPayment;
+//# sourceMappingURL=data:application/json;base64,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

package/README.md

@@ -242,6 +242,49 @@ dropdown.
 
 Make sure that the selected payment methods are enabled in your Pay origanization settings as well.
 
+### Testing direct debits locally
+
+Pay.'s test environment does not process SEPA direct debits. With `testMode` enabled the plugin therefore does not
+create a mandate at Pay. when a direct debit order is placed. It stores a simulated mandate on the payment session
+instead (code `TEST-<payment session id>`, logged as `Pay. direct debit test mode: storing simulated mandate ...`), and
+the collection flow can be driven by posting the exchanges Pay. would normally send to the webhook route yourself.
+Exchanges for a simulated mandate are not re-fetched from Pay., the body is taken as the direct debit state. This only
+happens while `testMode` is on and only for mandates that were created in test mode.
+
+```bash
+# 1. Place an order with SEPA Direct Debit, the payment collection is now "awaiting".
+#    Copy the simulated mandate code from the server log.
+MANDATE="TEST-payses_01JXXXXXXXXXXXXXXXXXXXXXXX"
+
+# 2. The bank collected the money: the payment is captured and the order is paid.
+curl -X POST http://localhost:9000/hooks/pay/pay-direct-debit_pay \
+  -H "Content-Type: application/json" \
+  -d "{\"action\":\"incassocollected\",\"mandateId\":\"$MANDATE\"}"
+
+# 3. The customer reversed the debit (storno): the payment is refunded in Medusa only, the order
+#    shows the outstanding amount again and the admin offers "Copy payment link" / "Mark as paid".
+curl -X POST http://localhost:9000/hooks/pay/pay-direct-debit_pay \
+  -H "Content-Type: application/json" \
+  -d "{\"action\":\"incassostorno\",\"mandateId\":\"$MANDATE\"}"
+```
+
+Other legacy actions (`incassopending`, `incassosend`) and an explicit `status: {"code": 106}` (failed) or
+`declined: true` work the same way. Add `"reference": "<order display id>"` to the body when the order can not be
+resolved from the mandate code. The webhook route processes exchanges asynchronously (5 seconds by default), so give
+the server a moment before checking the order. The payment link opens the regular Pay. hosted checkout, so the
+outstanding amount can be paid with any test payment method.
+
+#### Simulator widget in the admin
+
+The same exchanges can be triggered from the order detail page. Switch on **SEPA testing** in Settings > Pay (off by
+default, meant for staging servers) and a "Pay. direct debit simulator" panel appears in the sidebar of orders that hold
+a simulated mandate, with a button per exchange (pending, sent, collected, storno, failed, declined). The exchanges are
+processed synchronously, so the order refreshes right away. The switch is stored in the store's metadata
+(`pay_sepa_testing`), so it applies to every admin user of that server. The panel is backed by
+`GET /admin/pay/orders/:id/direct-debit` and `POST /admin/pay/orders/:id/direct-debit/exchange` (`{"action": "storno"}`),
+which only work while the switch and `testMode` are on; the switch itself is read and written through
+`GET`/`POST /admin/pay/settings` (`{"sepaTesting": true}`).
+
 ## Supported Payment Methods
 
 The plugin currently supports the following Pay payment methods:

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webbers/pay-payments-medusa",
   "displayName": "Medusa v2 Pay. Plugin",
-  "version": "2.2.50",
+  "version": "2.2.52",
   "description": "The Pay.nl payment provider plugin for Medusa v2",
   "author": "Webbers B.V. <development@webbers.com>",
   "license": "MIT",