@webbers/pay-payments-medusa 2.2.51 → 2.2.53

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,4 @@
 export * from "./createPayOrder";
+export * from "./reverseCapturedPayment";
+export * from "./paymentReversal";
 //# 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;AACxC,cAAc,mBAAmB,CAAA"}

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

@@ -15,4 +15,6 @@ 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);
+__exportStar(require("./paymentReversal"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLG1EQUFnQztBQUNoQywyREFBd0M7QUFDeEMsb0RBQWlDIn0=

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

@@ -0,0 +1,24 @@
+import { MedusaContainer } from "@medusajs/types";
+import { PaymentReversalKind } from "./reverseCapturedPayment";
+export type PaymentReversal = {
+    /** Whether a Pay. chargeback / storno reversed a captured payment */
+    reversed: boolean;
+    kind: PaymentReversalKind | null;
+    statusCode: number | null;
+    /** When the (latest) reversal was recorded */
+    at: string | null;
+    /** Total amount that went back to the customer */
+    amount: number;
+    currency_code: string | null;
+    /** What the customer still owes on the order */
+    outstanding: number;
+    /** Whether a not_paid payment collection exists to collect it with */
+    payable: boolean;
+};
+/**
+ * Finds the reversal reverseCapturedPayment recorded on an order, recognised
+ * by the note on the refund. Used by the "payment reversed" order banner,
+ * since Medusa's own payment status can only say "refunded" for it.
+ */
+export declare function getPaymentReversal(container: MedusaContainer, orderId: string): Promise<PaymentReversal | null>;
+//# sourceMappingURL=paymentReversal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paymentReversal.d.ts","sourceRoot":"","sources":["../../../../src/utils/paymentReversal.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,eAAe,EAAC,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAEL,mBAAmB,EACpB,MAAM,0BAA0B,CAAA;AAEjC,MAAM,MAAM,eAAe,GAAG;IAC5B,qEAAqE;IACrE,QAAQ,EAAE,OAAO,CAAA;IACjB,IAAI,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAChC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,8CAA8C;IAC9C,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IACjB,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,gDAAgD;IAChD,WAAW,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAYD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,eAAe,EAC1B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAkFjC"}

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPaymentReversal = getPaymentReversal;
+const utils_1 = require("@medusajs/framework/utils");
+const reverseCapturedPayment_1 = require("./reverseCapturedPayment");
+const toNumber = (value) => {
+    if (value === null || value === undefined || value === "") {
+        return 0;
+    }
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : 0;
+};
+/**
+ * Finds the reversal reverseCapturedPayment recorded on an order, recognised
+ * by the note on the refund. Used by the "payment reversed" order banner,
+ * since Medusa's own payment status can only say "refunded" for it.
+ */
+async function getPaymentReversal(container, orderId) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: [order], } = await query.graph({
+        entity: "order",
+        fields: [
+            "id",
+            "currency_code",
+            "summary",
+            "payment_collections.id",
+            "payment_collections.status",
+            "payment_collections.payments.id",
+            "payment_collections.payments.refunds.id",
+            "payment_collections.payments.refunds.amount",
+            "payment_collections.payments.refunds.note",
+            "payment_collections.payments.refunds.created_at",
+        ],
+        filters: { id: orderId },
+    });
+    if (!order) {
+        return null;
+    }
+    const collections = (order.payment_collections ?? []);
+    const reversals = collections
+        .flatMap((collection) => collection?.payments ?? [])
+        .flatMap((payment) => payment?.refunds ?? [])
+        .map((refund) => ({
+        refund,
+        parsed: (0, reverseCapturedPayment_1.parsePayReversalNote)(refund?.note),
+    }))
+        .filter((entry) => entry.parsed !== null)
+        .sort((a, b) => new Date(b.refund.created_at ?? 0).getTime() -
+        new Date(a.refund.created_at ?? 0).getTime());
+    const summary = (order.summary ?? {});
+    const outstanding = toNumber(summary.pending_difference);
+    const payable = collections.some((collection) => collection?.status === "not_paid");
+    if (!reversals.length) {
+        return {
+            reversed: false,
+            kind: null,
+            statusCode: null,
+            at: null,
+            amount: 0,
+            currency_code: order.currency_code ?? null,
+            outstanding,
+            payable,
+        };
+    }
+    const latest = reversals[0];
+    const amount = reversals.reduce((total, entry) => utils_1.MathBN.add(total, entry.refund.amount ?? 0), utils_1.MathBN.convert(0));
+    return {
+        reversed: true,
+        kind: latest.parsed.kind,
+        statusCode: latest.parsed.statusCode,
+        at: latest.refund.created_at
+            ? new Date(latest.refund.created_at).toISOString()
+            : null,
+        amount: toNumber(amount.toString()),
+        currency_code: order.currency_code ?? null,
+        outstanding,
+        payable,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,43 @@
+import { MedusaContainer } from "@medusajs/types";
+export type PaymentReversalKind = "chargeback" | "storno" | "failure";
+export type ReverseCapturedPaymentInput = {
+    orderId: string;
+    paymentId: string;
+    paymentCollectionId: string;
+    /** What reversed the payment, becomes the refund note */
+    kind: PaymentReversalKind;
+    /** The Pay. status code that reported it, when known */
+    statusCode?: number | string;
+};
+/**
+ * The refund note that marks a reversal, e.g. "Pay. chargeback (status -71)"
+ * or "Pay. direct debit storno (status 127)". Medusa 2.11 refunds carry no
+ * metadata, so the note is what the admin banner recognises a reversal by.
+ */
+export declare function formatPayReversalNote(kind: PaymentReversalKind, statusCode?: number | string): string;
+export declare function parsePayReversalNote(note: unknown): {
+    kind: PaymentReversalKind;
+    statusCode: number | null;
+} | null;
+/**
+ * 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,mBAAmB,GAAG,YAAY,GAAG,QAAQ,GAAG,SAAS,CAAA;AAErE,MAAM,MAAM,2BAA2B,GAAG;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,SAAS,EAAE,MAAM,CAAA;IACjB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,yDAAyD;IACzD,IAAI,EAAE,mBAAmB,CAAA;IACzB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;CAC7B,CAAA;AAKD;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,mBAAmB,EACzB,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAC3B,MAAM,CAQR;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,GACZ;IAAC,IAAI,EAAE,mBAAmB,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAC,GAAG,IAAI,CAe/D;AAQD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,eAAe,EAC1B,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,IAAI,CAAC,CAiFf;AAED,eAAe,sBAAsB,CAAA"}

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

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPayReversalNote = formatPayReversalNote;
+exports.parsePayReversalNote = parsePayReversalNote;
+exports.reverseCapturedPayment = reverseCapturedPayment;
+const core_flows_1 = require("@medusajs/core-flows");
+const utils_1 = require("@medusajs/framework/utils");
+const REVERSAL_NOTE_PATTERN = /^Pay\. (chargeback|direct debit (?:storno|failure)) \(status (-?\d+|unknown)\)$/;
+/**
+ * The refund note that marks a reversal, e.g. "Pay. chargeback (status -71)"
+ * or "Pay. direct debit storno (status 127)". Medusa 2.11 refunds carry no
+ * metadata, so the note is what the admin banner recognises a reversal by.
+ */
+function formatPayReversalNote(kind, statusCode) {
+    const what = kind === "chargeback" ? "chargeback" : `direct debit ${kind}`;
+    const status = statusCode === undefined || statusCode === null || statusCode === ""
+        ? "unknown"
+        : String(statusCode);
+    return `Pay. ${what} (status ${status})`;
+}
+function parsePayReversalNote(note) {
+    if (typeof note !== "string") {
+        return null;
+    }
+    const match = note.trim().match(REVERSAL_NOTE_PATTERN);
+    if (!match) {
+        return null;
+    }
+    const kind = match[1].replace("direct debit ", "");
+    const statusCode = match[2] === "unknown" ? null : Number(match[2]);
+    return { kind, statusCode };
+}
+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));
+    const note = formatPayReversalNote(input.kind, input.statusCode);
+    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,
+        });
+        logger.info(`Pay. - Recorded reversal of ${payment.currency_code} ${amount} on payment ${payment.id} for order ${input.orderId}: ${note}`);
+    }
+    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,57 @@ 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.
+
+#### Reversed payments in the admin
+
+When a chargeback or storno reverses a captured payment, the plugin refunds the payment in Medusa (without contacting
+Pay.), books the amount as outstanding again and opens a new payment collection, so the order offers "Copy payment
+link" and "Mark as paid". Medusa's own payment status can only call that "Refunded", so the plugin adds a
+"Payment reversed, action required" banner on top of the order page that names the cause (chargeback, storno, failed
+collection), the amount that went back to the customer and what is still outstanding.
+
+#### 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.51",
+  "version": "2.2.53",
   "description": "The Pay.nl payment provider plugin for Medusa v2",
   "author": "Webbers B.V. <development@webbers.com>",
   "license": "MIT",