@reorderjs/reorder 1.0.1

package/.medusa/server/src/workflows/steps/run-dunning-retry.js

@@ -0,0 +1,592 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDunningRetryStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const dunning_1 = require("../../modules/dunning");
+const types_1 = require("../../modules/dunning/types");
+const errors_1 = require("../../modules/dunning/utils/errors");
+const observability_1 = require("../../modules/dunning/utils/observability");
+const retry_schedule_1 = require("../../modules/dunning/utils/retry-schedule");
+const subscription_1 = require("../../modules/subscription");
+const types_2 = require("../../modules/subscription/types");
+const errors_2 = require("../../modules/subscription/utils/errors");
+function appendRetryAuditMetadata(metadata, input, at) {
+    const nextMetadata = {
+        ...(metadata ?? {}),
+        last_retry_triggered_by: input.triggered_by ?? null,
+        last_retry_reason: input.reason ?? null,
+    };
+    if (!input.ignore_schedule) {
+        return nextMetadata;
+    }
+    const existing = Array.isArray(metadata?.manual_actions)
+        ? [...metadata?.manual_actions]
+        : [];
+    existing.push({
+        action: "retry_now",
+        who: input.triggered_by ?? null,
+        when: at,
+        reason: input.reason ?? null,
+    });
+    return {
+        ...nextMetadata,
+        manual_actions: existing,
+        last_manual_action: existing[existing.length - 1],
+    };
+}
+function normalizeNow(now) {
+    if (!now) {
+        return new Date();
+    }
+    const normalized = now instanceof Date ? now : new Date(now);
+    if (Number.isNaN(normalized.getTime())) {
+        throw errors_1.dunningErrors.invalidData("Dunning retry 'now' must be a valid date");
+    }
+    return normalized;
+}
+async function loadDunningCase(container, id) {
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    try {
+        return (await dunningModule.retrieveDunningCase(id));
+    }
+    catch {
+        throw errors_1.dunningErrors.notFound("DunningCase", id);
+    }
+}
+async function loadSubscription(container, id) {
+    const subscriptionModule = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    try {
+        return (await subscriptionModule.retrieveSubscription(id));
+    }
+    catch {
+        throw errors_2.subscriptionErrors.notFound("Subscription", id);
+    }
+}
+async function getNextAttemptNo(container, dunningCase) {
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    const attempts = (await dunningModule.listDunningAttempts({
+        dunning_case_id: dunningCase.id,
+    }));
+    const highestAttemptNo = attempts.reduce((max, attempt) => {
+        return Math.max(max, attempt.attempt_no ?? 0);
+    }, 0);
+    return Math.max(dunningCase.attempt_count, highestAttemptNo) + 1;
+}
+async function loadOrderTotal(container, id) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data } = await query.graph({
+        entity: "order",
+        fields: ["id", "total"],
+        filters: {
+            id: [id],
+        },
+    });
+    const order = data[0];
+    if (!order) {
+        throw errors_1.dunningErrors.notFound("Order", id);
+    }
+    return Number(order.total ?? 0);
+}
+function validateRetryableCase(dunningCase, now, ignoreSchedule) {
+    if (dunningCase.status === types_1.DunningCaseStatus.RECOVERED) {
+        throw errors_1.dunningErrors.alreadyRecovered(dunningCase.id);
+    }
+    if (dunningCase.status === types_1.DunningCaseStatus.UNRECOVERED) {
+        throw errors_1.dunningErrors.alreadyUnrecovered(dunningCase.id);
+    }
+    if (dunningCase.status === types_1.DunningCaseStatus.RETRYING) {
+        throw errors_1.dunningErrors.retryAlreadyProcessing(dunningCase.id);
+    }
+    if (!dunningCase.renewal_order_id) {
+        throw errors_1.dunningErrors.invalidData(`DunningCase '${dunningCase.id}' is missing renewal_order_id`);
+    }
+    if (!dunningCase.retry_schedule) {
+        throw errors_1.dunningErrors.invalidData(`DunningCase '${dunningCase.id}' is missing retry_schedule`);
+    }
+    if (!ignoreSchedule && !dunningCase.next_retry_at) {
+        throw errors_1.dunningErrors.retryNotDue(dunningCase.id);
+    }
+    if (!ignoreSchedule && dunningCase.next_retry_at && dunningCase.next_retry_at > now) {
+        throw errors_1.dunningErrors.retryNotDue(dunningCase.id);
+    }
+    if (dunningCase.attempt_count >= dunningCase.max_attempts) {
+        throw errors_1.dunningErrors.maxAttemptsExceeded(dunningCase.id);
+    }
+}
+function classifyPaymentRetryFailure(error, paymentSessionStatus) {
+    const message = error instanceof Error ? error.message : "Dunning payment retry failed";
+    const normalizedMessage = message.toLowerCase();
+    const normalizedStatus = String(paymentSessionStatus ?? "").toLowerCase();
+    const normalizedErrorCode = readPaymentErrorCode(error);
+    if (normalizedStatus === "requires_more" ||
+        normalizedStatus === "canceled" ||
+        normalizedStatus === "cancelled") {
+        return {
+            kind: "permanent_failure",
+            payment_reference: null,
+            error_code: normalizedStatus || "payment_requires_manual_action",
+            error_message: message,
+        };
+    }
+    if (normalizedErrorCode === "insufficient_funds" ||
+        normalizedErrorCode === "generic_decline" ||
+        normalizedErrorCode === "do_not_honor") {
+        return {
+            kind: "temporary_failure",
+            payment_reference: null,
+            error_code: normalizedErrorCode,
+            error_message: message,
+        };
+    }
+    if (normalizedMessage.includes("missing payment retry context") ||
+        normalizedMessage.includes("doesn't have a collectible total") ||
+        normalizedMessage.includes("no payment collection is available") ||
+        normalizedMessage.includes("expired") ||
+        normalizedMessage.includes("declined") ||
+        normalizedMessage.includes("requires payment method") ||
+        normalizedMessage.includes("requires more")) {
+        return {
+            kind: "permanent_failure",
+            payment_reference: null,
+            error_code: normalizedStatus || "payment_declined",
+            error_message: message,
+        };
+    }
+    if (normalizedStatus === "pending" ||
+        normalizedStatus === "error" ||
+        normalizedMessage.includes("insufficient") ||
+        normalizedMessage.includes("generic_decline") ||
+        normalizedMessage.includes("do_not_honor") ||
+        normalizedMessage.includes("timeout") ||
+        normalizedMessage.includes("temporar") ||
+        normalizedMessage.includes("network") ||
+        normalizedMessage.includes("unavailable")) {
+        return {
+            kind: "temporary_failure",
+            payment_reference: null,
+            error_code: normalizedStatus || "payment_retryable_error",
+            error_message: message,
+        };
+    }
+    return {
+        kind: "temporary_failure",
+        payment_reference: null,
+        error_code: normalizedErrorCode || normalizedStatus || "payment_retry_failed",
+        error_message: message,
+    };
+}
+function readPaymentErrorCode(error) {
+    if (!error || typeof error !== "object") {
+        return null;
+    }
+    const record = error;
+    const candidates = [
+        record.code,
+        record.decline_code,
+        record.cause?.code,
+        record.cause?.decline_code,
+        record.payment_intent?.last_payment_error,
+        record.raw?.code,
+        record.raw?.decline_code,
+    ];
+    for (const candidate of candidates) {
+        const value = readNestedErrorCode(candidate);
+        if (value) {
+            return value;
+        }
+    }
+    return null;
+}
+function readNestedErrorCode(value) {
+    if (!value) {
+        return null;
+    }
+    if (typeof value === "string" && value.trim()) {
+        return value.trim().toLowerCase();
+    }
+    if (typeof value === "object") {
+        const record = value;
+        const candidates = [record.code, record.decline_code];
+        for (const candidate of candidates) {
+            if (typeof candidate === "string" && candidate.trim()) {
+                return candidate.trim().toLowerCase();
+            }
+        }
+    }
+    return null;
+}
+async function executePaymentRetry(container, subscription, renewalOrderId) {
+    let paymentSession = null;
+    try {
+        const paymentContext = subscription.payment_context;
+        if (!paymentContext?.payment_provider_id ||
+            !paymentContext.payment_method_reference) {
+            throw errors_1.dunningErrors.invalidData(`Subscription '${subscription.id}' is missing payment retry context`);
+        }
+        const total = await loadOrderTotal(container, renewalOrderId);
+        if (total <= 0) {
+            throw errors_1.dunningErrors.invalidData(`Renewal order '${renewalOrderId}' doesn't have a collectible total`);
+        }
+        const paymentCollections = await (0, core_flows_1.createOrUpdateOrderPaymentCollectionWorkflow)(container).run({
+            input: {
+                order_id: renewalOrderId,
+                amount: total,
+            },
+        });
+        const paymentCollection = paymentCollections.result[0];
+        if (!paymentCollection) {
+            throw errors_1.dunningErrors.invalidData(`No payment collection is available for renewal order '${renewalOrderId}'`);
+        }
+        const paymentSessionResult = await (0, core_flows_1.createPaymentSessionsWorkflow)(container).run({
+            input: {
+                payment_collection_id: paymentCollection.id,
+                provider_id: paymentContext.payment_provider_id,
+                customer_id: subscription.customer_id,
+                data: {
+                    payment_method: paymentContext.payment_method_reference,
+                    off_session: true,
+                    confirm: true,
+                    capture_method: "automatic",
+                },
+            },
+        });
+        paymentSession = paymentSessionResult.result;
+        const paymentModule = container.resolve(utils_1.Modules.PAYMENT);
+        const payment = (await paymentModule.authorizePaymentSession(paymentSession.id, paymentSession.context ?? {}));
+        if (!payment?.id) {
+            return {
+                kind: "temporary_failure",
+                payment_reference: paymentSession.id,
+                error_code: "payment_authorization_missing",
+                error_message: "Payment authorization did not return a payment reference",
+            };
+        }
+        await paymentModule.capturePayment({
+            payment_id: payment.id,
+            amount: payment.amount,
+        });
+        return {
+            kind: "recovery",
+            payment_reference: payment.id,
+            error_code: null,
+            error_message: null,
+        };
+    }
+    catch (error) {
+        let paymentSessionStatus = paymentSession?.status ?? null;
+        if (paymentSession?.id) {
+            const paymentModule = container.resolve(utils_1.Modules.PAYMENT);
+            const sessions = (await paymentModule.listPaymentSessions({
+                id: [paymentSession.id],
+            }));
+            paymentSessionStatus = sessions[0]?.status ?? paymentSessionStatus;
+        }
+        const outcome = classifyPaymentRetryFailure(error, paymentSessionStatus);
+        return {
+            ...outcome,
+            payment_reference: paymentSession?.id ?? outcome.payment_reference,
+        };
+    }
+}
+exports.runDunningRetryStep = (0, workflows_sdk_1.createStep)("run-dunning-retry", async function (input, { container }) {
+    const logger = container.resolve("logger");
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    const subscriptionModule = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    const now = normalizeNow(input.now);
+    const startedAtMs = Date.now();
+    const correlationId = input.correlation_id ??
+        (0, observability_1.createDunningCorrelationId)(`dunning-retry-${input.ignore_schedule ? "manual" : "scheduled"}`);
+    const dunningCase = await loadDunningCase(container, input.dunning_case_id);
+    const attemptNo = await getNextAttemptNo(container, dunningCase);
+    const transitionSnapshot = {
+        status: dunningCase.status,
+        attempt_count: dunningCase.attempt_count,
+        next_retry_at: dunningCase.next_retry_at,
+        last_attempt_at: dunningCase.last_attempt_at,
+        metadata: dunningCase.metadata ?? null,
+    };
+    let transitionedToRetrying = false;
+    (0, observability_1.logDunningEvent)(logger, "info", {
+        event: "dunning.retry",
+        outcome: "started",
+        correlation_id: correlationId,
+        dunning_case_id: dunningCase.id,
+        subscription_id: dunningCase.subscription_id,
+        renewal_cycle_id: dunningCase.renewal_cycle_id,
+        attempt_no: attemptNo,
+        metadata: {
+            triggered_by: input.triggered_by ?? null,
+            reason: input.reason ?? null,
+            ignore_schedule: Boolean(input.ignore_schedule),
+        },
+    });
+    try {
+        validateRetryableCase(dunningCase, now, input.ignore_schedule);
+        const subscription = await loadSubscription(container, dunningCase.subscription_id);
+        if (subscription.status !== types_2.SubscriptionStatus.PAST_DUE &&
+            subscription.status !== types_2.SubscriptionStatus.ACTIVE) {
+            throw errors_2.subscriptionErrors.invalidState(subscription.id, "run dunning retry", subscription.status);
+        }
+        const startedAt = now;
+        await dunningModule.updateDunningCases({
+            id: dunningCase.id,
+            status: types_1.DunningCaseStatus.RETRYING,
+            attempt_count: attemptNo,
+            next_retry_at: null,
+            last_attempt_at: startedAt,
+            metadata: appendRetryAuditMetadata(dunningCase.metadata, input, startedAt.toISOString()),
+        });
+        transitionedToRetrying = true;
+        const attempt = (await dunningModule.createDunningAttempts({
+            dunning_case_id: dunningCase.id,
+            attempt_no: attemptNo,
+            started_at: startedAt,
+            finished_at: null,
+            status: types_1.DunningAttemptStatus.PROCESSING,
+            error_code: null,
+            error_message: null,
+            payment_reference: null,
+            metadata: {
+                triggered_by: input.triggered_by ?? null,
+                reason: input.reason ?? null,
+                correlation_id: correlationId,
+            },
+        }));
+        const outcome = await executePaymentRetry(container, subscription, dunningCase.renewal_order_id);
+        const finishedAt = new Date();
+        if (outcome.kind === "recovery") {
+            await dunningModule.updateDunningAttempts({
+                id: attempt.id,
+                finished_at: finishedAt,
+                status: types_1.DunningAttemptStatus.SUCCEEDED,
+                error_code: null,
+                error_message: null,
+                payment_reference: outcome.payment_reference,
+            });
+            const updatedCase = await dunningModule.updateDunningCases({
+                id: dunningCase.id,
+                status: types_1.DunningCaseStatus.RECOVERED,
+                next_retry_at: null,
+                last_attempt_at: finishedAt,
+                last_payment_error_code: null,
+                last_payment_error_message: null,
+                recovered_at: finishedAt,
+                closed_at: finishedAt,
+                recovery_reason: "payment_recovered",
+            });
+            if (subscription.status === types_2.SubscriptionStatus.PAST_DUE) {
+                await subscriptionModule.updateSubscriptions({
+                    id: subscription.id,
+                    status: types_2.SubscriptionStatus.ACTIVE,
+                });
+            }
+            const createdAt = updatedCase.created_at
+                ? new Date(updatedCase.created_at)
+                : dunningCase.created_at
+                    ? new Date(dunningCase.created_at)
+                    : null;
+            const timeToRecoverMs = createdAt
+                ? finishedAt.getTime() - createdAt.getTime()
+                : null;
+            (0, observability_1.logDunningEvent)(logger, "info", {
+                event: "dunning.retry",
+                outcome: "succeeded",
+                correlation_id: correlationId,
+                dunning_case_id: updatedCase.id,
+                subscription_id: updatedCase.subscription_id,
+                renewal_cycle_id: updatedCase.renewal_cycle_id,
+                attempt_no: attemptNo,
+                duration_ms: Date.now() - startedAtMs,
+                success_count: 1,
+                recovered_count: 1,
+                avg_attempts: attemptNo,
+                avg_time_to_recover_ms: timeToRecoverMs ?? undefined,
+                metadata: {
+                    retry_outcome: "recovered",
+                    payment_reference: outcome.payment_reference,
+                },
+            });
+            return new workflows_sdk_1.StepResponse({
+                dunning_case_id: updatedCase.id,
+                dunning_attempt_id: attempt.id,
+                outcome: "recovered",
+                subscription_status: types_2.SubscriptionStatus.ACTIVE,
+                correlation_id: correlationId,
+                attempt_no: attemptNo,
+                time_to_recover_ms: timeToRecoverMs,
+            });
+        }
+        await dunningModule.updateDunningAttempts({
+            id: attempt.id,
+            finished_at: finishedAt,
+            status: types_1.DunningAttemptStatus.FAILED,
+            error_code: outcome.error_code,
+            error_message: outcome.error_message,
+            payment_reference: outcome.payment_reference,
+        });
+        const shouldCloseAsUnrecovered = outcome.kind === "permanent_failure" ||
+            attemptNo >= dunningCase.max_attempts;
+        if (shouldCloseAsUnrecovered) {
+            const updatedCase = await dunningModule.updateDunningCases({
+                id: dunningCase.id,
+                status: types_1.DunningCaseStatus.UNRECOVERED,
+                next_retry_at: null,
+                last_attempt_at: finishedAt,
+                last_payment_error_code: outcome.error_code,
+                last_payment_error_message: outcome.error_message,
+                closed_at: finishedAt,
+                recovery_reason: outcome.kind === "permanent_failure"
+                    ? "permanent_payment_failure"
+                    : "retry_limit_exhausted",
+            });
+            (0, observability_1.logDunningEvent)(logger, "warn", {
+                event: "dunning.retry",
+                outcome: "failed",
+                correlation_id: correlationId,
+                dunning_case_id: updatedCase.id,
+                subscription_id: updatedCase.subscription_id,
+                renewal_cycle_id: updatedCase.renewal_cycle_id,
+                attempt_no: attemptNo,
+                duration_ms: Date.now() - startedAtMs,
+                failure_count: 1,
+                unrecovered_count: 1,
+                avg_attempts: attemptNo,
+                failure_kind: "retry_exhausted",
+                alertable: outcome.kind === "permanent_failure",
+                message: outcome.error_message,
+                metadata: {
+                    retry_outcome: "unrecovered",
+                    error_code: outcome.error_code,
+                    payment_reference: outcome.payment_reference,
+                },
+            });
+            return new workflows_sdk_1.StepResponse({
+                dunning_case_id: updatedCase.id,
+                dunning_attempt_id: attempt.id,
+                outcome: "unrecovered",
+                subscription_status: subscription.status,
+                correlation_id: correlationId,
+                attempt_no: attemptNo,
+            });
+        }
+        const nextRetryAt = (0, retry_schedule_1.calculateNextRetryAt)(dunningCase.retry_schedule, attemptNo, finishedAt);
+        if (!nextRetryAt) {
+            const updatedCase = await dunningModule.updateDunningCases({
+                id: dunningCase.id,
+                status: types_1.DunningCaseStatus.UNRECOVERED,
+                next_retry_at: null,
+                last_attempt_at: finishedAt,
+                last_payment_error_code: outcome.error_code,
+                last_payment_error_message: outcome.error_message,
+                closed_at: finishedAt,
+                recovery_reason: "retry_schedule_exhausted",
+            });
+            (0, observability_1.logDunningEvent)(logger, "warn", {
+                event: "dunning.retry",
+                outcome: "failed",
+                correlation_id: correlationId,
+                dunning_case_id: updatedCase.id,
+                subscription_id: updatedCase.subscription_id,
+                renewal_cycle_id: updatedCase.renewal_cycle_id,
+                attempt_no: attemptNo,
+                duration_ms: Date.now() - startedAtMs,
+                failure_count: 1,
+                unrecovered_count: 1,
+                avg_attempts: attemptNo,
+                failure_kind: "retry_exhausted",
+                alertable: false,
+                message: outcome.error_message,
+                metadata: {
+                    retry_outcome: "unrecovered",
+                    error_code: outcome.error_code,
+                    payment_reference: outcome.payment_reference,
+                },
+            });
+            return new workflows_sdk_1.StepResponse({
+                dunning_case_id: updatedCase.id,
+                dunning_attempt_id: attempt.id,
+                outcome: "unrecovered",
+                subscription_status: subscription.status,
+                correlation_id: correlationId,
+                attempt_no: attemptNo,
+            });
+        }
+        const updatedCase = await dunningModule.updateDunningCases({
+            id: dunningCase.id,
+            status: types_1.DunningCaseStatus.RETRY_SCHEDULED,
+            next_retry_at: nextRetryAt,
+            last_attempt_at: finishedAt,
+            last_payment_error_code: outcome.error_code,
+            last_payment_error_message: outcome.error_message,
+            recovered_at: null,
+            closed_at: null,
+            recovery_reason: null,
+        });
+        (0, observability_1.logDunningEvent)(logger, "warn", {
+            event: "dunning.retry",
+            outcome: "failed",
+            correlation_id: correlationId,
+            dunning_case_id: updatedCase.id,
+            subscription_id: updatedCase.subscription_id,
+            renewal_cycle_id: updatedCase.renewal_cycle_id,
+            attempt_no: attemptNo,
+            duration_ms: Date.now() - startedAtMs,
+            failure_count: 1,
+            rescheduled_count: 1,
+            avg_attempts: attemptNo,
+            failure_kind: "unexpected_error",
+            alertable: outcome.kind === "temporary_failure",
+            message: outcome.error_message,
+            metadata: {
+                retry_outcome: "retry_scheduled",
+                error_code: outcome.error_code,
+                payment_reference: outcome.payment_reference,
+                next_retry_at: nextRetryAt.toISOString(),
+            },
+        });
+        return new workflows_sdk_1.StepResponse({
+            dunning_case_id: updatedCase.id,
+            dunning_attempt_id: attempt.id,
+            outcome: "retry_scheduled",
+            subscription_status: subscription.status,
+            correlation_id: correlationId,
+            attempt_no: attemptNo,
+        });
+    }
+    catch (error) {
+        const failureKind = (0, observability_1.classifyDunningFailure)(error);
+        (0, observability_1.logDunningEvent)(logger, (0, observability_1.isAlertableDunningFailure)(failureKind) ? "error" : "warn", {
+            event: "dunning.retry",
+            outcome: (0, observability_1.isAlertableDunningFailure)(failureKind) ? "failed" : "blocked",
+            correlation_id: correlationId,
+            dunning_case_id: dunningCase.id,
+            subscription_id: dunningCase.subscription_id,
+            renewal_cycle_id: dunningCase.renewal_cycle_id,
+            attempt_no: attemptNo,
+            duration_ms: Date.now() - startedAtMs,
+            failure_count: 1,
+            failure_kind: failureKind,
+            alertable: (0, observability_1.isAlertableDunningFailure)(failureKind),
+            message: (0, observability_1.getDunningErrorMessage)(error),
+            metadata: {
+                triggered_by: input.triggered_by ?? null,
+                reason: input.reason ?? null,
+                ignore_schedule: Boolean(input.ignore_schedule),
+            },
+        });
+        if (transitionedToRetrying) {
+            await dunningModule.updateDunningCases({
+                id: dunningCase.id,
+                status: transitionSnapshot.status,
+                attempt_count: transitionSnapshot.attempt_count,
+                next_retry_at: transitionSnapshot.next_retry_at,
+                last_attempt_at: transitionSnapshot.last_attempt_at,
+                metadata: transitionSnapshot.metadata,
+            });
+        }
+        throw error;
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"run-dunning-retry.js","sourceRoot":"","sources":["../../../../../src/workflows/steps/run-dunning-retry.ts"],"names":[],"mappings":"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"}