medusa-payment-sumup 0.1.0

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

@@ -0,0 +1,22 @@
+"use strict";
+const widgetModule = { widgets: [] };
+const routeModule = {
+  routes: []
+};
+const menuItemModule = {
+  menuItems: []
+};
+const formModule = { customFields: {} };
+const displayModule = {
+  displays: {}
+};
+const i18nModule = { resources: {} };
+const plugin = {
+  widgetModule,
+  routeModule,
+  menuItemModule,
+  formModule,
+  displayModule,
+  i18nModule
+};
+module.exports = plugin;

package/.medusa/server/src/admin/index.mjs

@@ -0,0 +1,23 @@
+const widgetModule = { widgets: [] };
+const routeModule = {
+  routes: []
+};
+const menuItemModule = {
+  menuItems: []
+};
+const formModule = { customFields: {} };
+const displayModule = {
+  displays: {}
+};
+const i18nModule = { resources: {} };
+const plugin = {
+  widgetModule,
+  routeModule,
+  menuItemModule,
+  formModule,
+  displayModule,
+  i18nModule
+};
+export {
+  plugin as default
+};

package/.medusa/server/src/providers/sumup/core/sumup-client.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SumUpClient = void 0;
+const types_1 = require("../types");
+const SUMUP_API_BASE = "https://api.sumup.com";
+const REQUEST_TIMEOUT_MS = 10_000;
+const MAX_RETRIES = 3;
+// Use zero-delay backoff in tests so the suite stays fast.
+const BASE_BACKOFF_MS = process.env.NODE_ENV === "test" ? 0 : 300;
+// Fields that must never appear in logged/thrown error messages.
+const SENSITIVE_FIELDS = new Set([
+    "card",
+    "cvv",
+    "pan",
+    "pan_fingerprint",
+    "token",
+    "number",
+    "secret",
+]);
+/** Strips sensitive keys from a JSON error body before it appears in error messages. */
+function redactErrorBody(text) {
+    try {
+        const obj = JSON.parse(text);
+        for (const key of SENSITIVE_FIELDS) {
+            delete obj[key];
+        }
+        return JSON.stringify(obj);
+    }
+    catch {
+        // Non-JSON body (e.g. HTML gateway error) — truncate to avoid noise.
+        return text.length > 500 ? `${text.slice(0, 500)}…` : text;
+    }
+}
+/** Classify an HTTP status code into a SumUpErrorType. */
+function classifyStatus(status) {
+    if (status === 400 || status === 422)
+        return "validation";
+    if (status === 401 || status === 403)
+        return "auth";
+    if (status === 404)
+        return "not_found";
+    if (status === 409)
+        return "conflict";
+    if (status === 429)
+        return "rate_limit";
+    return "server"; // 5xx and any other non-OK code
+}
+/** Async sleep.  Resolves immediately when ms ≤ 0. */
+function sleep(ms) {
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Compute how long to wait before the next retry.
+ * Respects the `Retry-After` header (seconds) when provided by the server,
+ * otherwise uses bounded exponential back-off with ±30 % jitter.
+ */
+function backoffMs(attempt, retryAfterSec) {
+    if (retryAfterSec !== undefined && !Number.isNaN(retryAfterSec)) {
+        return Math.min(retryAfterSec * 1_000, 60_000);
+    }
+    const base = BASE_BACKOFF_MS * 2 ** attempt;
+    const jitter = Math.random() * base * 0.3;
+    return Math.min(base + jitter, 10_000);
+}
+class SumUpClient {
+    constructor(options) {
+        this.headers = {
+            Authorization: `Bearer ${options.apiKey}`,
+            "Content-Type": "application/json",
+        };
+    }
+    /**
+     * Central request dispatcher.  Handles timeouts, error classification,
+     * and retries (with back-off) for transient failures (5xx, rate-limit,
+     * network errors, and timeouts).
+     */
+    async request(url, init, attempt = 0) {
+        let res;
+        // ── Network / timeout ──────────────────────────────────────────
+        try {
+            res = await fetch(url, {
+                ...init,
+                headers: this.headers,
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+        }
+        catch (err) {
+            const isTimeout = err?.name === "TimeoutError" || err?.name === "AbortError";
+            const type = isTimeout ? "timeout" : "network";
+            if (attempt < MAX_RETRIES) {
+                await sleep(backoffMs(attempt));
+                return this.request(url, init, attempt + 1);
+            }
+            throw new types_1.SumUpClientError(isTimeout
+                ? `SumUp request timed out after ${REQUEST_TIMEOUT_MS}ms`
+                : `SumUp network error: ${err?.message ?? "unknown"}`, type);
+        }
+        // ── Success ────────────────────────────────────────────────────
+        if (res.ok) {
+            if (res.status === 204)
+                return undefined;
+            return (await res.json());
+        }
+        // ── Error response ─────────────────────────────────────────────
+        const bodyText = await res.text().catch(() => "");
+        const type = classifyStatus(res.status);
+        const isRetryable = type === "rate_limit" || type === "server";
+        if (isRetryable && attempt < MAX_RETRIES) {
+            const retryAfterHeader = res.headers.get("Retry-After");
+            const retryAfterSec = retryAfterHeader != null
+                ? parseInt(retryAfterHeader, 10)
+                : undefined;
+            await sleep(backoffMs(attempt, retryAfterSec));
+            return this.request(url, init, attempt + 1);
+        }
+        throw new types_1.SumUpClientError(`SumUp API error (${res.status}): ${redactErrorBody(bodyText)}`, type, res.status);
+    }
+    async createCheckout(params) {
+        return this.request(`${SUMUP_API_BASE}/v0.1/checkouts`, {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
+    async getCheckout(checkoutId) {
+        return this.request(`${SUMUP_API_BASE}/v0.1/checkouts/${encodeURIComponent(checkoutId)}`, { method: "GET" });
+    }
+    async deactivateCheckout(checkoutId) {
+        try {
+            await this.request(`${SUMUP_API_BASE}/v0.1/checkouts/${encodeURIComponent(checkoutId)}`, { method: "DELETE" });
+        }
+        catch (err) {
+            // A 404 means the checkout is already gone — treat as success.
+            if (err instanceof types_1.SumUpClientError && err.type === "not_found")
+                return;
+            throw err;
+        }
+    }
+    async refundTransaction(transactionId, amount) {
+        const body = {};
+        if (amount !== undefined)
+            body.amount = amount;
+        return this.request(`${SUMUP_API_BASE}/v0.1/me/refund/${encodeURIComponent(transactionId)}`, { method: "POST", body: JSON.stringify(body) });
+    }
+}
+exports.SumUpClient = SumUpClient;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/providers/sumup/core/sumup-provider.js

@@ -0,0 +1,489 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const sumup_client_1 = require("./sumup-client");
+const types_1 = require("../types");
+// ISO-4217: 3 uppercase alpha characters.
+const CURRENCY_RE = /^[A-Z]{3}$/;
+const SUMUP_STATUS_MAP = {
+    PENDING: utils_1.PaymentSessionStatus.PENDING,
+    PAID: utils_1.PaymentSessionStatus.CAPTURED,
+    FAILED: utils_1.PaymentSessionStatus.ERROR,
+    EXPIRED: utils_1.PaymentSessionStatus.CANCELED,
+};
+class SumUpProviderService extends utils_1.AbstractPaymentProvider {
+    static validateOptions(options) {
+        if (!options.apiKey || typeof options.apiKey !== "string") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "SumUp API key (apiKey) is required.");
+        }
+        if (!options.merchantCode || typeof options.merchantCode !== "string") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "SumUp merchant code (merchantCode) is required.");
+        }
+        if (!options.medusaUrl || typeof options.medusaUrl !== "string") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Medusa backend URL (medusaUrl) is required.");
+        }
+        if (!options.redirectUrl || typeof options.redirectUrl !== "string") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Redirect URL (redirectUrl) is required.");
+        }
+    }
+    constructor(container, options) {
+        super(container, options);
+        this.logger_ = container.logger;
+        this.options_ = options;
+        this.debug_ =
+            options.debug ||
+                process.env.NODE_ENV === "development" ||
+                process.env.NODE_ENV === "test" ||
+                false;
+        this.client_ = new sumup_client_1.SumUpClient(options);
+    }
+    // ── Input validators ──────────────────────────────────────────────────────
+    /**
+     * Asserts that `amount` is a positive finite number and returns it as a
+     * parsed float.  Throws INVALID_DATA otherwise.
+     */
+    static assertAmount(amount, ctx) {
+        const n = parseFloat(String(amount));
+        if (!Number.isFinite(n) || n <= 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `${ctx}: amount must be a positive finite number, got "${amount}"`);
+        }
+        return n;
+    }
+    /**
+     * Asserts that `code` is a valid ISO-4217 format (3 alpha chars), normalises
+     * to uppercase, and returns it.  Throws INVALID_DATA otherwise.
+     */
+    static assertCurrency(code, ctx) {
+        const upper = typeof code === "string" ? code.toUpperCase().trim() : "";
+        if (!CURRENCY_RE.test(upper)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `${ctx}: currency_code must be a 3-letter ISO-4217 code, got "${code}"`);
+        }
+        return upper;
+    }
+    /**
+     * Asserts that `id` is a non-empty string and returns it trimmed.
+     * Throws INVALID_DATA otherwise.
+     */
+    static assertExternalId(id, ctx) {
+        if (typeof id !== "string" || id.trim() === "") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `${ctx}: checkout ID is required`);
+        }
+        return id.trim();
+    }
+    /**
+     * Translates a SumUpClientError into the most appropriate MedusaError type
+     * so callers receive structured, actionable errors rather than raw HTTP
+     * status text.  Always throws.
+     */
+    rethrowAsMedusaError(error, ctx) {
+        if (error instanceof types_1.SumUpClientError) {
+            switch (error.type) {
+                case "auth":
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNAUTHORIZED, `SumUp authentication failed in ${ctx}. Verify your API key.`);
+                case "not_found":
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `SumUp resource not found in ${ctx}.`);
+                case "validation":
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `SumUp rejected the request in ${ctx}: ${error.message}`);
+                case "conflict":
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, `SumUp conflict in ${ctx}: ${error.message}`);
+                case "rate_limit":
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `SumUp rate limit exceeded in ${ctx}. Please retry later.`);
+                // network / timeout / server: re-throw as-is with a clear prefix
+                default: {
+                    const wrapped = new Error(`SumUp ${error.type} error in ${ctx}: ${error.message}`);
+                    throw wrapped;
+                }
+            }
+        }
+        throw error;
+    }
+    /**
+     * Creates a new SumUp checkout for the payment session.
+     */
+    async initiatePayment(input) {
+        const ctx = "initiatePayment";
+        // ── Input validation ────────────────────────────────────────────
+        const amount = SumUpProviderService.assertAmount(input.amount, ctx);
+        const currency = SumUpProviderService.assertCurrency(input.currency_code, ctx);
+        const { context } = input;
+        try {
+            const checkoutReference = input.data?.session_id ?? crypto.randomUUID();
+            if (!input.data?.session_id) {
+                this.logger_.warn("SumUp: data.session_id is missing — using random UUID as checkout_reference. " +
+                    "Webhook-based status updates may not work correctly.");
+            }
+            const webhookUrl = this.options_.medusaUrl + "/hooks/payment/sumup_sumup";
+            const customer = context?.customer;
+            // Merge guest data (from cart shipping address) with logged-in customer
+            // context; context.customer takes precedence when present.
+            const pdFirst = customer?.first_name ?? input.data?.first_name;
+            const pdLast = customer?.last_name ?? input.data?.last_name;
+            const pdEmail = customer?.email ?? input.data?.email;
+            const personalDetails = pdFirst || pdLast || pdEmail
+                ? {
+                    ...(pdFirst && { first_name: pdFirst }),
+                    ...(pdLast && { last_name: pdLast }),
+                    ...(pdEmail && { email: pdEmail }),
+                }
+                : undefined;
+            const checkout = await this.client_.createCheckout({
+                checkout_reference: checkoutReference,
+                amount,
+                currency,
+                merchant_code: this.options_.merchantCode,
+                description: input.data?.description || "SumUp payment via Medusa",
+                return_url: webhookUrl,
+                redirect_url: this.options_.redirectUrl,
+                ...(personalDetails && { personal_details: personalDetails }),
+            });
+            this.debug_ &&
+                this.logger_.info(`SumUp checkout ${checkout.id} created with amount ${amount} ${currency}`);
+            return {
+                id: checkout.id,
+                data: {
+                    id: checkout.id,
+                    checkout_reference: checkoutReference,
+                    idempotency_key: context?.idempotency_key,
+                },
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * Checks the SumUp checkout status to authorize the payment.
+     * SumUp auto-captures — when the checkout is PAID we return AUTHORIZED
+     * so that Medusa can proceed to capture (which is a no-op verification).
+     */
+    async authorizePayment(input) {
+        const ctx = "authorizePayment";
+        const externalId = SumUpProviderService.assertExternalId(input.data?.id, ctx);
+        try {
+            const checkout = await this.client_.getCheckout(externalId);
+            const sumupStatus = checkout.status;
+            const transaction = checkout.transactions?.[0];
+            switch (sumupStatus) {
+                case "PAID":
+                    // SumUp auto-captures. Return AUTHORIZED so Medusa's
+                    // authorize → capture flow proceeds naturally.
+                    this.debug_ &&
+                        this.logger_.info(`SumUp payment ${externalId} is PAID — returning AUTHORIZED`);
+                    return {
+                        data: {
+                            ...input.data,
+                            transaction_id: transaction?.id,
+                            transaction_code: transaction?.transaction_code,
+                        },
+                        status: utils_1.PaymentSessionStatus.AUTHORIZED,
+                    };
+                case "PENDING":
+                    this.debug_ &&
+                        this.logger_.info(`SumUp payment ${externalId} is still PENDING`);
+                    return {
+                        data: input.data,
+                        status: utils_1.PaymentSessionStatus.PENDING,
+                    };
+                case "FAILED":
+                    return {
+                        data: input.data,
+                        status: utils_1.PaymentSessionStatus.ERROR,
+                    };
+                case "EXPIRED":
+                    return {
+                        data: input.data,
+                        status: utils_1.PaymentSessionStatus.CANCELED,
+                    };
+                default:
+                    this.logger_.warn(`SumUp payment ${externalId} returned unknown status "${sumupStatus}" — treating as PENDING`);
+                    return {
+                        data: input.data,
+                        status: utils_1.PaymentSessionStatus.PENDING,
+                    };
+            }
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for ${externalId}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * SumUp auto-captures payments. This verifies the checkout is PAID.
+     */
+    async capturePayment(input) {
+        const ctx = "capturePayment";
+        const externalId = SumUpProviderService.assertExternalId(input.data?.id, ctx);
+        try {
+            const checkout = await this.client_.getCheckout(externalId);
+            if (checkout.status !== "PAID") {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.PAYMENT_AUTHORIZATION_ERROR, `Cannot capture: SumUp checkout status is ${checkout.status}, not PAID.`);
+            }
+            const transactions = checkout.transactions ?? [];
+            if (transactions.length === 0) {
+                // PAID but no transactions array — log a warning and proceed;
+                // SumUp sometimes omits this on freshly completed checkouts.
+                this.logger_.warn(`SumUp checkout ${externalId} is PAID but has no transactions array. ` +
+                    "transaction_id will not be available.");
+                return { data: { ...input.data } };
+            }
+            const transaction = transactions[0];
+            this.debug_ &&
+                this.logger_.info(`SumUp payment ${externalId} capture confirmed`);
+            return {
+                data: {
+                    ...input.data,
+                    transaction_id: transaction.id,
+                    transaction_code: transaction.transaction_code,
+                },
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for ${externalId}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * Refunds a captured SumUp payment.
+     */
+    async refundPayment(input) {
+        const ctx = "refundPayment";
+        // Validate refund amount first — before any API call.
+        const refundAmount = SumUpProviderService.assertAmount(input.amount, ctx);
+        const transactionId = input.data?.transaction_id;
+        if (!transactionId) {
+            // If we don't have transaction_id yet, try to get it from the checkout
+            const externalId = input.data?.id;
+            if (externalId) {
+                let checkout;
+                try {
+                    checkout = await this.client_.getCheckout(externalId);
+                }
+                catch (error) {
+                    this.logger_.error(`Error in ${ctx} looking up checkout ${externalId}: ${error.message}`);
+                    this.rethrowAsMedusaError(error, ctx);
+                }
+                const transactions = checkout.transactions ?? [];
+                if (transactions.length === 0) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot refund: checkout ${externalId} has no completed transactions.`);
+                }
+                const txn = transactions[0];
+                // Guard against refunding more than was originally captured.
+                if (typeof txn.amount === "number" &&
+                    refundAmount > txn.amount) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot refund ${refundAmount}: exceeds captured transaction amount of ${txn.amount}.`);
+                }
+                try {
+                    await this.client_.refundTransaction(txn.id, refundAmount);
+                }
+                catch (error) {
+                    this.logger_.error(`Error in ${ctx} refunding transaction ${txn.id}: ${error.message}`);
+                    this.rethrowAsMedusaError(error, ctx);
+                }
+                this.debug_ &&
+                    this.logger_.info(`SumUp refund for payment ${externalId} created with amount ${refundAmount}`);
+                return {
+                    data: {
+                        ...input.data,
+                        transaction_id: txn.id,
+                    },
+                };
+            }
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Cannot refund: no transaction_id found in payment data.");
+        }
+        try {
+            await this.client_.refundTransaction(transactionId, refundAmount);
+            this.debug_ &&
+                this.logger_.info(`SumUp refund for transaction ${transactionId} created with amount ${refundAmount}`);
+            return {
+                data: input.data,
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for transaction ${transactionId}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * Cancels a pending SumUp checkout by deactivating it.
+     */
+    async cancelPayment(input) {
+        const externalId = input.data?.id;
+        try {
+            if (externalId) {
+                const checkout = await this.client_.getCheckout(externalId);
+                if (checkout.status === "EXPIRED") {
+                    this.debug_ &&
+                        this.logger_.info(`SumUp checkout ${externalId} is already expired, no need to cancel`);
+                    return { data: input.data };
+                }
+                await this.client_.deactivateCheckout(externalId);
+            }
+            this.debug_ &&
+                this.logger_.info(`SumUp payment ${externalId} cancelled`);
+            return {
+                data: input.data,
+            };
+        }
+        catch (error) {
+            this.logger_.warn(`Could not cancel SumUp checkout ${externalId}: ${error.message}`);
+            return { data: input.data };
+        }
+    }
+    /**
+     * Deletes a payment session. Equivalent to cancellation for SumUp.
+     */
+    async deletePayment(input) {
+        return this.cancelPayment(input);
+    }
+    /**
+     * Retrieves the full checkout data from SumUp.
+     */
+    async retrievePayment(input) {
+        const ctx = "retrievePayment";
+        const externalId = SumUpProviderService.assertExternalId(input.data?.id, ctx);
+        try {
+            const data = await this.client_.getCheckout(externalId);
+            return { data: data };
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for ${externalId}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * Maps SumUp checkout status to Medusa PaymentSessionStatus.
+     */
+    async getPaymentStatus(input) {
+        const ctx = "getPaymentStatus";
+        const externalId = SumUpProviderService.assertExternalId(input.data?.id, ctx);
+        try {
+            const checkout = await this.client_.getCheckout(externalId);
+            const status = checkout.status;
+            const mappedStatus = SUMUP_STATUS_MAP[status] ?? utils_1.PaymentSessionStatus.PENDING;
+            if (!SUMUP_STATUS_MAP[status]) {
+                this.logger_.warn(`SumUp checkout ${externalId} returned unknown status "${status}" — defaulting to PENDING`);
+            }
+            this.debug_ &&
+                this.logger_.debug(`SumUp checkout ${externalId} status: ${status} (mapped to: ${mappedStatus})`);
+            return { status: mappedStatus };
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for ${externalId}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * SumUp does not support modifying a checkout after creation.
+     * We cancel the old checkout and create a new one with the updated amount.
+     */
+    async updatePayment(input) {
+        const ctx = "updatePayment";
+        // ── Input validation ────────────────────────────────────────────
+        const amount = SumUpProviderService.assertAmount(input.amount, ctx);
+        const currency = SumUpProviderService.assertCurrency(input.currency_code, ctx);
+        const externalId = input.data?.id;
+        try {
+            // Cancel the existing checkout (best-effort; may already be expired)
+            if (externalId) {
+                try {
+                    await this.client_.deactivateCheckout(externalId);
+                }
+                catch {
+                    // Ignore — checkout may already be in a terminal state
+                }
+            }
+            // Create a new checkout with the updated amount
+            const checkoutReference = input.data?.session_id ??
+                input.data?.checkout_reference ??
+                crypto.randomUUID();
+            const webhookUrl = this.options_.medusaUrl + "/hooks/payment/sumup_sumup";
+            const checkout = await this.client_.createCheckout({
+                checkout_reference: checkoutReference,
+                amount,
+                currency,
+                merchant_code: this.options_.merchantCode,
+                description: input.data?.description ||
+                    "SumUp payment via Medusa",
+                return_url: webhookUrl,
+                redirect_url: this.options_.redirectUrl,
+            });
+            this.debug_ &&
+                this.logger_.info(`SumUp checkout updated: old=${externalId} → new=${checkout.id} (amount: ${amount} ${currency})`);
+            return {
+                data: {
+                    id: checkout.id,
+                    checkout_reference: checkoutReference,
+                    idempotency_key: input.context?.idempotency_key,
+                },
+            };
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for ${externalId}: ${error.message}`);
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+    /**
+     * Processes SumUp webhook events.
+     * SumUp does NOT sign webhooks — we always verify by calling the API.
+     */
+    async getWebhookActionAndData(payload) {
+        const ctx = "getWebhookActionAndData";
+        const { data } = payload;
+        // Validate that the payload carries a checkout ID before hitting the API.
+        const checkoutId = data?.id;
+        if (!checkoutId || typeof checkoutId !== "string") {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "SumUp webhook payload is missing a checkout ID.");
+        }
+        try {
+            // Always re-verify via the SumUp API — never trust the webhook body alone.
+            const checkout = await this.client_.getCheckout(checkoutId);
+            const session_id = checkout.checkout_reference;
+            const amount = new utils_1.BigNumber(checkout.amount);
+            const transaction = checkout.transactions?.[0];
+            const baseData = {
+                session_id,
+                amount,
+                transaction_id: transaction?.id,
+                transaction_code: transaction?.transaction_code,
+            };
+            switch (checkout.status) {
+                case "PAID":
+                    return {
+                        action: utils_1.PaymentActions.SUCCESSFUL,
+                        data: baseData,
+                    };
+                case "FAILED":
+                    return {
+                        action: utils_1.PaymentActions.FAILED,
+                        data: baseData,
+                    };
+                case "EXPIRED":
+                    return {
+                        action: utils_1.PaymentActions.CANCELED,
+                        data: baseData,
+                    };
+                case "PENDING":
+                    return {
+                        action: utils_1.PaymentActions.PENDING,
+                        data: baseData,
+                    };
+                default:
+                    this.logger_.warn(`SumUp webhook: checkout ${checkoutId} has unknown status "${checkout.status}"`);
+                    return {
+                        action: utils_1.PaymentActions.NOT_SUPPORTED,
+                        data: baseData,
+                    };
+            }
+        }
+        catch (error) {
+            this.logger_.error(`Error in ${ctx} for checkout ${checkoutId}: ${error.message}`);
+            // Attempt graceful degradation: if we can classify the error (e.g. auth
+            // failure), surface it.  Otherwise re-throw so Medusa can retry.
+            this.rethrowAsMedusaError(error, ctx);
+        }
+    }
+}
+SumUpProviderService.identifier = "sumup";
+exports.default = SumUpProviderService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sumup-provider.js","sourceRoot":"","sources":["../../../../../../src/providers/sumup/core/sumup-provider.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/providers/sumup/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const services_1 = require("./services");
+const services = [services_1.SumUpProviderService];
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.PAYMENT, {
+    services,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N1bXVwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBQUEscURBQW9FO0FBQ3BFLHlDQUFrRDtBQUVsRCxNQUFNLFFBQVEsR0FBRyxDQUFDLCtCQUFvQixDQUFDLENBQUM7QUFFeEMsa0JBQWUsSUFBQSxzQkFBYyxFQUFDLGVBQU8sQ0FBQyxPQUFPLEVBQUU7SUFDN0MsUUFBUTtDQUNULENBQUMsQ0FBQyJ9

package/.medusa/server/src/providers/sumup/services/index.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SumUpProviderService = void 0;
+var sumup_provider_1 = require("../core/sumup-provider");
+Object.defineProperty(exports, "SumUpProviderService", { enumerable: true, get: function () { return __importDefault(sumup_provider_1).default; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N1bXVwL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLHlEQUF5RTtBQUFoRSx1SUFBQSxPQUFPLE9BQXdCIn0=

package/.medusa/server/src/providers/sumup/types/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SumUpClientError = void 0;
+/**
+ * Typed error thrown by SumUpClient for all non-OK HTTP responses and
+ * network-level failures.  Callers can inspect `.type` to decide how to
+ * handle (surface to user, retry, fall through, etc.).
+ */
+class SumUpClientError extends Error {
+    constructor(message, type, statusCode) {
+        super(message);
+        this.name = "SumUpClientError";
+        this.type = type;
+        this.statusCode = statusCode;
+    }
+}
+exports.SumUpClientError = SumUpClientError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvcHJvdmlkZXJzL3N1bXVwL3R5cGVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQTJHQTs7OztHQUlHO0FBQ0gsTUFBYSxnQkFBaUIsU0FBUSxLQUFLO0lBSXpDLFlBQ0UsT0FBZSxFQUNmLElBQW9CLEVBQ3BCLFVBQW1CO1FBRW5CLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNmLElBQUksQ0FBQyxJQUFJLEdBQUcsa0JBQWtCLENBQUM7UUFDL0IsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLFVBQVUsR0FBRyxVQUFVLENBQUM7SUFDL0IsQ0FBQztDQUNGO0FBZEQsNENBY0MifQ==

package/README.md

@@ -0,0 +1,142 @@
+# SumUp Payments for Medusa
+
+A SumUp payment provider plugin for [Medusa](https://medusajs.com/) V2.
+Inspired by https://github.com/VariableVic/mollie-payments-medusa and mostly implemented by Claude.
+
+> [!WARNING]
+> This plugin has not been tested on a live store. Please conduct thorough testing before using it in a production environment. I am not responsible for any missed or failed payments resulting from the use of this plugin. If you encounter any issues, please report them [here](https://github.com/meister-eder/medusa-payment-sumup/issues).
+
+## Table of Contents
+
+- [Features](#features)
+- [Prerequisites](#prerequisites)
+- [Installation](#installation)
+- [Configuration](#configuration)
+  - [Configuration Options](#configuration-options)
+  - [Environment Variables](#environment-variables)
+- [Usage](#usage)
+- [Client-Side Integration](#client-side-integration)
+- [License](#license)
+
+## Features
+
+- **SumUp Checkout**: Creates a hosted SumUp checkout session that customers complete via the SumUp Card Widget or a custom card form.
+- **Webhook Support**: Receives real-time checkout status updates via SumUp webhooks.
+- **Refunds**: Supports full and partial refunds via the SumUp Transactions API.
+- **No extra dependencies**: Uses the native Node.js `fetch` API — no additional HTTP client needed.
+
+## Prerequisites
+
+- Medusa server v2.3.0 or later
+- Node.js v20 or later
+- A [SumUp](https://sumup.com/) merchant account with a valid API key and merchant code
+
+> [!NOTE]
+> You can find your API key and merchant code in your SumUp Dashboard under **Settings → Developer → API Keys**.
+
+## Installation
+
+```bash
+npm install medusa-payment-sumup
+# or
+yarn add medusa-payment-sumup
+```
+
+## Configuration
+
+Add the provider to the `@medusajs/payment` module in your `medusa-config.ts` file:
+
+```ts
+modules: [
+  // ... other modules
+  {
+    resolve: "@medusajs/payment",
+    options: {
+      providers: [
+        // ... other providers
+        {
+          resolve: "medusa-payment-sumup/providers/sumup",
+          id: "sumup",
+          options: {
+            apiKey: process.env.SUMUP_API_KEY,
+            merchantCode: process.env.SUMUP_MERCHANT_CODE,
+            medusaUrl: process.env.MEDUSA_BACKEND_URL,
+            redirectUrl: process.env.SUMUP_REDIRECT_URL,
+          },
+        },
+      ],
+    },
+  },
+]
+```
+
+### Configuration Options
+
+| Option | Description | Required | Default |
+|---|---|---|---|
+| `apiKey` | Your SumUp API key (e.g. `sup_sk_...`) | ✅ | — |
+| `merchantCode` | Your SumUp merchant code (e.g. `MH4H92C7`) | ✅ | — |
+| `medusaUrl` | The public URL of your Medusa backend | ✅ | — |
+| `redirectUrl` | The storefront URL to redirect the customer to after payment | ✅ | — |
+| `debug` | Enable verbose debug logging | ❌ | `false` |
+
+### Environment Variables
+
+Add the following to your `.env` file:
+
+```env
+SUMUP_API_KEY=sup_sk_your_api_key
+SUMUP_MERCHANT_CODE=MH4H92C7
+MEDUSA_BACKEND_URL=https://your-medusa-server.com
+SUMUP_REDIRECT_URL=https://your-store.com/checkout/payment
+```
+
+## Usage
+
+Once installed and configured, the SumUp payment method will be available in your Medusa Admin. To enable it:
+
+1. Log in to your Medusa Admin
+2. Go to **Settings → Regions**
+3. Add or edit a region and select **SumUp** from the payment providers dropdown
+
+The provider ID for the SumUp checkout is:
+
+```
+pp_sumup_sumup
+```
+
+## Client-Side Integration
+
+SumUp checkouts are created server-side by Medusa. After a payment session is initiated, the session data will contain a SumUp checkout `id` that you pass to the [SumUp Card Widget](https://developer.sumup.com/online-payments/tools/card-widget/) on your storefront to render the payment form.
+
+Basic flow:
+
+1. Customer reaches the payment step — Medusa creates a SumUp checkout via `initiatePayment`
+2. Your storefront receives the checkout `id` from the payment session data
+3. Render the SumUp Card Widget with the checkout ID
+4. SumUp processes the payment and calls the Medusa webhook (`/hooks/payment/sumup_sumup`)
+5. Medusa authorizes and captures the payment automatically
+
+Example Card Widget integration:
+
+```html
+<script src="https://gateway.sumup.com/gateway/ecom/card/v2/sdk.js"></script>
+<div id="sumup-card"></div>
+
+<script>
+  SumUpCard.mount({
+    checkoutId: "<checkout-id-from-session-data>",
+    onResponse: function (type, body) {
+      if (type === "success") {
+        // Redirect or poll for order completion
+      }
+    },
+  });
+</script>
+```
+
+For APMs (iDEAL, Bancontact, etc.), the `redirectUrl` option handles the post-payment redirect automatically.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "medusa-payment-sumup",
+    "version": "0.1.0",
+    "description": "SumUp payment provider for Medusa v2",
+    "author": "Tim Eder <timeder92@gmail.com>",
+    "license": "MIT",
+    "files": [
+        ".medusa/server"
+    ],
+    "exports": {
+        "./package.json": "./package.json",
+        "./providers/*": "./.medusa/server/src/providers/*/index.js",
+        "./*": "./.medusa/server/src/*.js"
+    },
+    "engines": {
+        "node": ">=20"
+    },
+    "keywords": [
+        "medusa-plugin-integration",
+        "medusa-v2",
+        "medusa-plugin-payment",
+        "sumup",
+        "payment",
+        "payment-provider",
+        "ecommerce"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/meister-eder/medusa-payment-sumup.git"
+    },
+    "scripts": {
+        "build": "medusa plugin:build",
+        "dev": "medusa plugin:develop",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "prepublishOnly": "medusa plugin:build"
+    },
+    "dependencies": {},
+    "devDependencies": {
+        "@medusajs/cli": "^2.5.0",
+        "@medusajs/framework": "^2.5.0",
+        "@medusajs/medusa": "^2.5.0",
+        "@types/node": "^22.0.0",
+        "typescript": "^5.6.0",
+        "vitest": "^3.0.0"
+    },
+    "peerDependencies": {
+        "@medusajs/framework": "^2.5.0",
+        "@medusajs/medusa": "^2.5.0"
+    }
+}