@reorderjs/reorder 1.0.1

package/.medusa/server/src/workflows/steps/start-dunning.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDunningStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const dunning_1 = require("../../modules/dunning");
+const types_1 = require("../../modules/dunning/types");
+const errors_1 = require("../../modules/dunning/utils/errors");
+const retry_schedule_1 = require("../../modules/dunning/utils/retry-schedule");
+const renewal_1 = require("../../modules/renewal");
+const types_2 = require("../../modules/renewal/types");
+const errors_2 = require("../../modules/renewal/utils/errors");
+const subscription_1 = require("../../modules/subscription");
+const types_3 = require("../../modules/subscription/types");
+const errors_3 = require("../../modules/subscription/utils/errors");
+const subscription_settings_1 = require("../utils/subscription-settings");
+const ACTIVE_DUNNING_CASE_STATUSES = new Set([
+    types_1.DunningCaseStatus.OPEN,
+    types_1.DunningCaseStatus.RETRY_SCHEDULED,
+    types_1.DunningCaseStatus.RETRYING,
+    types_1.DunningCaseStatus.AWAITING_MANUAL_RESOLUTION,
+]);
+const PAYMENT_FAILURE_SOURCES = new Set([
+    "payment_provider",
+    "payment_session",
+    "payment_capture",
+]);
+function isActiveDunningCase(status) {
+    return ACTIVE_DUNNING_CASE_STATUSES.has(status);
+}
+async function loadSubscription(container, id) {
+    const subscriptionModule = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    try {
+        return (await subscriptionModule.retrieveSubscription(id));
+    }
+    catch {
+        throw errors_3.subscriptionErrors.notFound("Subscription", id);
+    }
+}
+async function loadRenewalCycle(container, id) {
+    const renewalModule = container.resolve(renewal_1.RENEWAL_MODULE);
+    try {
+        return (await renewalModule.retrieveRenewalCycle(id));
+    }
+    catch {
+        throw errors_2.renewalErrors.notFound("RenewalCycle", id);
+    }
+}
+function normalizeFailureTime(failedAt) {
+    if (!failedAt) {
+        return new Date();
+    }
+    const normalized = failedAt instanceof Date ? failedAt : new Date(failedAt);
+    if (Number.isNaN(normalized.getTime())) {
+        throw errors_1.dunningErrors.invalidData("Dunning failed_at must be a valid date");
+    }
+    return normalized;
+}
+async function normalizeRetryPolicy(container, input) {
+    const settings = await (0, subscription_settings_1.getEffectiveSubscriptionSettings)(container);
+    const schedule = input.retry_schedule ?? {
+        strategy: "fixed_intervals",
+        intervals: [...settings.dunning_retry_intervals],
+        timezone: "UTC",
+        source: "default_policy",
+    };
+    const maxAttempts = input.max_attempts ?? settings.max_dunning_attempts;
+    try {
+        (0, retry_schedule_1.validateDunningRetrySchedule)(schedule, maxAttempts);
+    }
+    catch (error) {
+        throw errors_1.dunningErrors.invalidData(error instanceof Error ? error.message : "Invalid dunning retry schedule");
+    }
+    return { schedule, maxAttempts, settings };
+}
+function baseDunningMetadata(input) {
+    return {
+        ...(input.metadata ?? {}),
+        origin: "renewal_payment_failure",
+        payment_failure_source: input.payment_failure_source,
+        triggered_by: input.triggered_by ?? null,
+        reason: input.reason ?? null,
+    };
+}
+function createDunningMetadata(input, settings) {
+    return {
+        ...baseDunningMetadata(input),
+        settings_policy: {
+            dunning_retry_intervals: [...settings.dunning_retry_intervals],
+            max_dunning_attempts: settings.max_dunning_attempts,
+            settings_version: settings.version,
+            is_persisted: settings.is_persisted,
+        },
+    };
+}
+function mergeDunningMetadata(existingMetadata, input) {
+    return {
+        ...(existingMetadata ?? {}),
+        ...baseDunningMetadata(input),
+    };
+}
+exports.startDunningStep = (0, workflows_sdk_1.createStep)("start-dunning", async function (input, { container }) {
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    const subscriptionModule = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    if (!PAYMENT_FAILURE_SOURCES.has(input.payment_failure_source)) {
+        throw errors_1.dunningErrors.invalidData(`Unsupported payment failure source '${input.payment_failure_source}'`);
+    }
+    if (!input.payment_error_message?.trim()) {
+        throw errors_1.dunningErrors.invalidData("Dunning start requires a payment_error_message");
+    }
+    const subscription = await loadSubscription(container, input.subscription_id);
+    const cycle = await loadRenewalCycle(container, input.renewal_cycle_id);
+    if (cycle.subscription_id !== subscription.id) {
+        throw errors_1.dunningErrors.invalidData(`RenewalCycle '${cycle.id}' doesn't belong to Subscription '${subscription.id}'`);
+    }
+    if (cycle.status !== types_2.RenewalCycleStatus.FAILED) {
+        throw errors_1.dunningErrors.conflict(`Dunning can only start from failed renewal cycles. Renewal '${cycle.id}' is '${cycle.status}'`);
+    }
+    if (subscription.status !== types_3.SubscriptionStatus.ACTIVE &&
+        subscription.status !== types_3.SubscriptionStatus.PAST_DUE) {
+        throw errors_3.subscriptionErrors.invalidState(subscription.id, "enter dunning", subscription.status);
+    }
+    const sameCycleCases = (await dunningModule.listDunningCases({
+        renewal_cycle_id: cycle.id,
+    }));
+    if (sameCycleCases.length > 1) {
+        throw errors_1.dunningErrors.conflict(`RenewalCycle '${cycle.id}' already has multiple dunning cases`);
+    }
+    const existingCase = sameCycleCases[0] ?? null;
+    const subscriptionCases = (await dunningModule.listDunningCases({
+        subscription_id: subscription.id,
+    }));
+    const activeCaseForSubscription = subscriptionCases.find((dunningCase) => dunningCase.id !== existingCase?.id &&
+        isActiveDunningCase(dunningCase.status));
+    if (activeCaseForSubscription) {
+        throw errors_1.dunningErrors.duplicateActiveCaseBlocked(subscription.id, activeCaseForSubscription.id);
+    }
+    const { schedule, maxAttempts, settings } = await normalizeRetryPolicy(container, input);
+    const failureTime = normalizeFailureTime(input.failed_at);
+    const defaultNextRetryAt = (0, retry_schedule_1.calculateNextRetryAt)(schedule, 0, failureTime);
+    if (!defaultNextRetryAt) {
+        throw errors_1.dunningErrors.invalidData("Dunning retry policy didn't produce an initial next_retry_at");
+    }
+    const previousSubscription = subscription.status === types_3.SubscriptionStatus.PAST_DUE ? null : subscription;
+    if (!existingCase) {
+        const created = (await dunningModule.createDunningCases({
+            subscription_id: subscription.id,
+            renewal_cycle_id: cycle.id,
+            renewal_order_id: input.renewal_order_id ?? cycle.generated_order_id ?? null,
+            status: types_1.DunningCaseStatus.RETRY_SCHEDULED,
+            attempt_count: 0,
+            max_attempts: maxAttempts,
+            retry_schedule: schedule,
+            next_retry_at: defaultNextRetryAt,
+            last_payment_error_code: input.payment_error_code ?? null,
+            last_payment_error_message: input.payment_error_message,
+            last_attempt_at: null,
+            recovered_at: null,
+            closed_at: null,
+            recovery_reason: null,
+            metadata: createDunningMetadata(input, settings),
+        }));
+        if (previousSubscription) {
+            await subscriptionModule.updateSubscriptions({
+                id: subscription.id,
+                status: types_3.SubscriptionStatus.PAST_DUE,
+            });
+        }
+        return new workflows_sdk_1.StepResponse({
+            action: "created",
+            dunning_case_id: created.id,
+            subscription_id: subscription.id,
+            subscription_status: types_3.SubscriptionStatus.PAST_DUE,
+        }, {
+            action: "created",
+            created_dunning_case_id: created.id,
+            previous_subscription: previousSubscription,
+        });
+    }
+    if (!isActiveDunningCase(existingCase.status)) {
+        return new workflows_sdk_1.StepResponse({
+            action: "noop",
+            dunning_case_id: existingCase.id,
+            subscription_id: subscription.id,
+            subscription_status: subscription.status,
+        }, {
+            action: "noop",
+        });
+    }
+    const updated = (await dunningModule.updateDunningCases({
+        id: existingCase.id,
+        renewal_order_id: existingCase.renewal_order_id ??
+            input.renewal_order_id ??
+            cycle.generated_order_id ??
+            null,
+        status: existingCase.status === types_1.DunningCaseStatus.OPEN
+            ? types_1.DunningCaseStatus.RETRY_SCHEDULED
+            : existingCase.status,
+        max_attempts: existingCase.max_attempts || maxAttempts,
+        retry_schedule: existingCase.retry_schedule ?? schedule,
+        next_retry_at: existingCase.next_retry_at ?? defaultNextRetryAt,
+        last_payment_error_code: input.payment_error_code ?? existingCase.last_payment_error_code ?? null,
+        last_payment_error_message: input.payment_error_message,
+        metadata: mergeDunningMetadata(existingCase.metadata, input),
+    }));
+    if (previousSubscription) {
+        await subscriptionModule.updateSubscriptions({
+            id: subscription.id,
+            status: types_3.SubscriptionStatus.PAST_DUE,
+        });
+    }
+    return new workflows_sdk_1.StepResponse({
+        action: "updated",
+        dunning_case_id: updated.id,
+        subscription_id: subscription.id,
+        subscription_status: types_3.SubscriptionStatus.PAST_DUE,
+    }, {
+        action: "updated",
+        previous_dunning_case: existingCase,
+        previous_subscription: previousSubscription,
+    });
+}, async function (compensation, { container }) {
+    if (!compensation || compensation.action === "noop") {
+        return;
+    }
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    const subscriptionModule = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    if (compensation.action === "created") {
+        await dunningModule.deleteDunningCases(compensation.created_dunning_case_id);
+    }
+    else {
+        await dunningModule.updateDunningCases(compensation.previous_dunning_case);
+    }
+    if (compensation.previous_subscription) {
+        await subscriptionModule.updateSubscriptions(compensation.previous_subscription);
+    }
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-dunning.js","sourceRoot":"","sources":["../../../../../src/workflows/steps/start-dunning.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/workflows/steps/toggle-plan-offer.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.togglePlanOfferStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const plan_offer_1 = require("../../modules/plan-offer");
+const errors_1 = require("../../modules/plan-offer/utils/errors");
+const shared_plan_offer_1 = require("./shared-plan-offer");
+exports.togglePlanOfferStep = (0, workflows_sdk_1.createStep)("toggle-plan-offer", async function (input, { container }) {
+    const existing = await (0, shared_plan_offer_1.getPlanOfferRecordById)(container, input.id);
+    if (!existing) {
+        throw errors_1.planOfferErrors.notFound("PlanOffer", input.id);
+    }
+    const planOfferModuleService = container.resolve(plan_offer_1.PLAN_OFFER_MODULE);
+    const updated = await planOfferModuleService.updatePlanOffers({
+        id: input.id,
+        is_enabled: input.is_enabled,
+    });
+    const planOfferId = (0, shared_plan_offer_1.getPlanOfferId)(updated);
+    if (!planOfferId) {
+        throw new Error("Failed to resolve toggled plan offer id");
+    }
+    return new workflows_sdk_1.StepResponse(planOfferId, (0, shared_plan_offer_1.toUpdatePlanOfferServiceInput)(existing));
+}, async function (existing, { container }) {
+    if (!existing) {
+        return;
+    }
+    const planOfferModuleService = container.resolve(plan_offer_1.PLAN_OFFER_MODULE);
+    await planOfferModuleService.updatePlanOffers({
+        id: existing.id,
+        is_enabled: existing.is_enabled,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9nZ2xlLXBsYW4tb2ZmZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0ZXBzL3RvZ2dsZS1wbGFuLW9mZmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFFQUE0RTtBQUM1RSx5REFBNEQ7QUFFNUQsa0VBQXVFO0FBQ3ZFLDJEQUk0QjtBQU9mLFFBQUEsbUJBQW1CLEdBQUcsSUFBQSwwQkFBVSxFQUszQyxtQkFBbUIsRUFDbkIsS0FBSyxXQUFXLEtBQStCLEVBQUUsRUFBRSxTQUFTLEVBQUU7SUFDNUQsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFBLDBDQUFzQixFQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUE7SUFFbEUsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsTUFBTSx3QkFBZSxDQUFDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBQ3ZELENBQUM7SUFFRCxNQUFNLHNCQUFzQixHQUMxQixTQUFTLENBQUMsT0FBTyxDQUFDLDhCQUFpQixDQUFDLENBQUE7SUFFdEMsTUFBTSxPQUFPLEdBQUcsTUFBTSxzQkFBc0IsQ0FBQyxnQkFBZ0IsQ0FBQztRQUM1RCxFQUFFLEVBQUUsS0FBSyxDQUFDLEVBQUU7UUFDWixVQUFVLEVBQUUsS0FBSyxDQUFDLFVBQVU7S0FDN0IsQ0FBQyxDQUFBO0lBQ0YsTUFBTSxXQUFXLEdBQUcsSUFBQSxrQ0FBYyxFQUFDLE9BQU8sQ0FBQyxDQUFBO0lBRTNDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqQixNQUFNLElBQUksS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUE7SUFDNUQsQ0FBQztJQUVELE9BQU8sSUFBSSw0QkFBWSxDQUFDLFdBQVcsRUFBRSxJQUFBLGlEQUE2QixFQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUE7QUFDL0UsQ0FBQyxFQUNELEtBQUssV0FBVyxRQUFRLEVBQUUsRUFBRSxTQUFTLEVBQUU7SUFDckMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsT0FBTTtJQUNSLENBQUM7SUFFRCxNQUFNLHNCQUFzQixHQUMxQixTQUFTLENBQUMsT0FBTyxDQUFDLDhCQUFpQixDQUFDLENBQUE7SUFFdEMsTUFBTSxzQkFBc0IsQ0FBQyxnQkFBZ0IsQ0FBQztRQUM1QyxFQUFFLEVBQUUsUUFBUSxDQUFDLEVBQUU7UUFDZixVQUFVLEVBQUUsUUFBUSxDQUFDLFVBQVU7S0FDekIsQ0FBQyxDQUFBO0FBQ1gsQ0FBQyxDQUNGLENBQUEifQ==

package/.medusa/server/src/workflows/steps/update-cancellation-reason.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCancellationReasonStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const cancellation_1 = require("../../modules/cancellation");
+const types_1 = require("../../modules/cancellation/types");
+const audit_1 = require("../../modules/cancellation/utils/audit");
+const errors_1 = require("../../modules/cancellation/utils/errors");
+const subscription_1 = require("../../modules/subscription");
+const REASON_MUTABLE_CASE_STATUSES = new Set([
+    types_1.CancellationCaseStatus.REQUESTED,
+    types_1.CancellationCaseStatus.EVALUATING_RETENTION,
+    types_1.CancellationCaseStatus.RETENTION_OFFERED,
+]);
+async function loadCancellationCase(container, id) {
+    const cancellationModule = container.resolve(cancellation_1.CANCELLATION_MODULE);
+    try {
+        return (await cancellationModule.retrieveCancellationCase(id));
+    }
+    catch {
+        throw errors_1.cancellationErrors.notFound("CancellationCase", id);
+    }
+}
+async function loadSubscription(container, id) {
+    const subscriptionModule = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    return (await subscriptionModule.retrieveSubscription(id));
+}
+function validateCaseState(cancellationCase) {
+    if (cancellationCase.status === types_1.CancellationCaseStatus.RETAINED) {
+        throw errors_1.cancellationErrors.alreadyFinalized(cancellationCase.id, cancellationCase.status);
+    }
+    if (cancellationCase.status === types_1.CancellationCaseStatus.PAUSED) {
+        throw errors_1.cancellationErrors.alreadyFinalized(cancellationCase.id, cancellationCase.status);
+    }
+    if (cancellationCase.status === types_1.CancellationCaseStatus.CANCELED) {
+        throw errors_1.cancellationErrors.alreadyFinalized(cancellationCase.id, cancellationCase.status);
+    }
+    if (!REASON_MUTABLE_CASE_STATUSES.has(cancellationCase.status)) {
+        throw errors_1.cancellationErrors.invalidCaseState(cancellationCase.id, "update cancellation reason", cancellationCase.status);
+    }
+}
+exports.updateCancellationReasonStep = (0, workflows_sdk_1.createStep)("update-cancellation-reason", async function (input, { container }) {
+    const cancellationModule = container.resolve(cancellation_1.CANCELLATION_MODULE);
+    if (!input.reason?.trim()) {
+        throw errors_1.cancellationErrors.invalidData("Cancellation reason update requires a non-empty reason");
+    }
+    const cancellationCase = await loadCancellationCase(container, input.cancellation_case_id);
+    const subscription = await loadSubscription(container, cancellationCase.subscription_id);
+    validateCaseState(cancellationCase);
+    const changedAt = new Date().toISOString();
+    const updated = (await cancellationModule.updateCancellationCases({
+        id: cancellationCase.id,
+        reason: input.reason.trim(),
+        reason_category: input.reason_category ?? cancellationCase.reason_category ?? null,
+        notes: input.notes ?? cancellationCase.notes ?? null,
+        metadata: (0, audit_1.appendCancellationManualAction)({
+            ...(cancellationCase.metadata ?? {}),
+            ...(input.metadata ?? {}),
+            reason_update: {
+                reason: input.reason.trim(),
+                reason_category: input.reason_category ?? cancellationCase.reason_category ?? null,
+                notes: input.notes ?? cancellationCase.notes ?? null,
+                updated_by: input.updated_by ?? null,
+                updated_at: changedAt,
+            },
+        }, {
+            action: "update_reason",
+            who: input.updated_by ?? null,
+            when: changedAt,
+            why: input.update_reason ?? input.reason.trim(),
+            data: {
+                reason_category: input.reason_category ?? cancellationCase.reason_category ?? null,
+            },
+        }),
+    }));
+    return new workflows_sdk_1.StepResponse({
+        current: updated,
+        previous: cancellationCase,
+        subscription,
+        cancellation_case_id: updated.id,
+        subscription_id: updated.subscription_id,
+        status: updated.status,
+        reason: updated.reason ?? input.reason.trim(),
+        reason_category: updated.reason_category,
+    }, {
+        previous_case: cancellationCase,
+    });
+}, async function (compensation, { container }) {
+    if (!compensation) {
+        return;
+    }
+    const cancellationModule = container.resolve(cancellation_1.CANCELLATION_MODULE);
+    await cancellationModule.updateCancellationCases(compensation.previous_case);
+});
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDunningRetryScheduleStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const dunning_1 = require("../../modules/dunning");
+const types_1 = require("../../modules/dunning/types");
+const errors_1 = require("../../modules/dunning/utils/errors");
+const retry_schedule_1 = require("../../modules/dunning/utils/retry-schedule");
+function appendAuditMetadata(metadata, input, at) {
+    const existing = Array.isArray(metadata?.manual_actions)
+        ? [...metadata?.manual_actions]
+        : [];
+    existing.push({
+        action: "update_retry_schedule",
+        who: input.triggered_by ?? null,
+        when: at,
+        reason: input.reason ?? null,
+        schedule: {
+            intervals: input.intervals,
+            max_attempts: input.max_attempts,
+        },
+    });
+    return {
+        ...(metadata ?? {}),
+        manual_actions: existing,
+        last_manual_action: existing[existing.length - 1],
+    };
+}
+exports.updateDunningRetryScheduleStep = (0, workflows_sdk_1.createStep)("update-dunning-retry-schedule", async function (input, { container }) {
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    const dunningCase = (await dunningModule.retrieveDunningCase(input.dunning_case_id));
+    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.retryInFlightTransitionBlocked(dunningCase.id, "update retry schedule");
+    }
+    const retrySchedule = {
+        strategy: "fixed_intervals",
+        intervals: [...input.intervals],
+        timezone: "UTC",
+        source: "manual_override",
+    };
+    try {
+        (0, retry_schedule_1.validateDunningRetrySchedule)(retrySchedule, input.max_attempts);
+    }
+    catch (error) {
+        throw errors_1.dunningErrors.invalidData(error instanceof Error ? error.message : "Invalid retry schedule");
+    }
+    if (input.max_attempts < dunningCase.attempt_count) {
+        throw errors_1.dunningErrors.conflict(`DunningCase '${dunningCase.id}' already has ${dunningCase.attempt_count} attempts, which exceeds the requested max_attempts`);
+    }
+    const changedAt = new Date();
+    let nextRetryAt = dunningCase.next_retry_at;
+    let nextStatus = dunningCase.status;
+    if (dunningCase.status === types_1.DunningCaseStatus.OPEN) {
+        nextRetryAt = (0, retry_schedule_1.calculateNextRetryAt)(retrySchedule, 0, changedAt);
+        nextStatus = types_1.DunningCaseStatus.RETRY_SCHEDULED;
+    }
+    else if (dunningCase.status === types_1.DunningCaseStatus.RETRY_SCHEDULED) {
+        nextRetryAt = (0, retry_schedule_1.calculateNextRetryAt)(retrySchedule, dunningCase.attempt_count, changedAt);
+        nextStatus = types_1.DunningCaseStatus.RETRY_SCHEDULED;
+    }
+    else if (dunningCase.status === types_1.DunningCaseStatus.AWAITING_MANUAL_RESOLUTION) {
+        nextRetryAt = null;
+        nextStatus = types_1.DunningCaseStatus.AWAITING_MANUAL_RESOLUTION;
+    }
+    if (nextStatus === types_1.DunningCaseStatus.RETRY_SCHEDULED &&
+        !nextRetryAt) {
+        throw errors_1.dunningErrors.invalidRetryScheduleOverride(dunningCase.id);
+    }
+    const updated = await dunningModule.updateDunningCases({
+        id: dunningCase.id,
+        status: nextStatus,
+        retry_schedule: retrySchedule,
+        max_attempts: input.max_attempts,
+        next_retry_at: nextRetryAt,
+        metadata: appendAuditMetadata(dunningCase.metadata, input, changedAt.toISOString()),
+    });
+    return new workflows_sdk_1.StepResponse(updated, dunningCase);
+}, async function (previousCase, { container }) {
+    if (!previousCase) {
+        return;
+    }
+    const dunningModule = container.resolve(dunning_1.DUNNING_MODULE);
+    await dunningModule.updateDunningCases(previousCase);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/steps/update-plan-offer.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePlanOfferStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const plan_offer_1 = require("../../modules/plan-offer");
+const errors_1 = require("../../modules/plan-offer/utils/errors");
+const shared_plan_offer_1 = require("./shared-plan-offer");
+exports.updatePlanOfferStep = (0, workflows_sdk_1.createStep)("update-plan-offer", async function (input, { container }) {
+    const existing = await (0, shared_plan_offer_1.getPlanOfferRecordById)(container, input.id);
+    if (!existing) {
+        throw errors_1.planOfferErrors.notFound("PlanOffer", input.id);
+    }
+    const mergedInput = {
+        name: input.name ?? existing.name,
+        scope: existing.scope,
+        product_id: existing.product_id,
+        variant_id: existing.variant_id,
+        is_enabled: input.is_enabled ?? existing.is_enabled,
+        allowed_frequencies: input.allowed_frequencies ?? existing.allowed_frequencies,
+        discounts: input.discounts ??
+            (existing.discount_per_frequency ?? []).map((discount) => ({
+                interval: discount.interval,
+                frequency_value: discount.value,
+                type: discount.discount_type,
+                value: discount.discount_value,
+            })),
+        rules: input.rules === undefined
+            ? existing.rules
+            : input.rules,
+        metadata: input.metadata === undefined ? existing.metadata : input.metadata,
+    };
+    await (0, shared_plan_offer_1.assertPlanOfferTargetExists)(container, mergedInput);
+    const payload = (0, shared_plan_offer_1.normalizePlanOfferPayload)(mergedInput);
+    const planOfferModuleService = container.resolve(plan_offer_1.PLAN_OFFER_MODULE);
+    const updated = await planOfferModuleService.updatePlanOffers({
+        ...payload,
+        id: existing.id,
+    });
+    const planOfferId = (0, shared_plan_offer_1.getPlanOfferId)(updated);
+    if (!planOfferId) {
+        throw new Error("Failed to resolve updated plan offer id");
+    }
+    return new workflows_sdk_1.StepResponse(planOfferId, (0, shared_plan_offer_1.toUpdatePlanOfferServiceInput)(existing));
+}, async function (existing, { container }) {
+    if (!existing) {
+        return;
+    }
+    const planOfferModuleService = container.resolve(plan_offer_1.PLAN_OFFER_MODULE);
+    await planOfferModuleService.updatePlanOffers(existing);
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLXBsYW4tb2ZmZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0ZXBzL3VwZGF0ZS1wbGFuLW9mZmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFFQUE0RTtBQUM1RSx5REFBNEQ7QUFFNUQsa0VBQXVFO0FBQ3ZFLDJEQU80QjtBQVlmLFFBQUEsbUJBQW1CLEdBQUcsSUFBQSwwQkFBVSxFQUszQyxtQkFBbUIsRUFDbkIsS0FBSyxXQUFXLEtBQStCLEVBQUUsRUFBRSxTQUFTLEVBQUU7SUFDNUQsTUFBTSxRQUFRLEdBQUcsTUFBTSxJQUFBLDBDQUFzQixFQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsRUFBRSxDQUFDLENBQUE7SUFFbEUsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsTUFBTSx3QkFBZSxDQUFDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFBO0lBQ3ZELENBQUM7SUFFRCxNQUFNLFdBQVcsR0FBeUI7UUFDeEMsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLElBQUksUUFBUSxDQUFDLElBQUk7UUFDakMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxLQUFLO1FBQ3JCLFVBQVUsRUFBRSxRQUFRLENBQUMsVUFBVTtRQUMvQixVQUFVLEVBQUUsUUFBUSxDQUFDLFVBQVU7UUFDL0IsVUFBVSxFQUFFLEtBQUssQ0FBQyxVQUFVLElBQUksUUFBUSxDQUFDLFVBQVU7UUFDbkQsbUJBQW1CLEVBQ2pCLEtBQUssQ0FBQyxtQkFBbUIsSUFBSSxRQUFRLENBQUMsbUJBQW1CO1FBQzNELFNBQVMsRUFDUCxLQUFLLENBQUMsU0FBUztZQUNmLENBQUMsUUFBUSxDQUFDLHNCQUFzQixJQUFJLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQztnQkFDekQsUUFBUSxFQUFFLFFBQVEsQ0FBQyxRQUFRO2dCQUMzQixlQUFlLEVBQUUsUUFBUSxDQUFDLEtBQUs7Z0JBQy9CLElBQUksRUFBRSxRQUFRLENBQUMsYUFBYTtnQkFDNUIsS0FBSyxFQUFFLFFBQVEsQ0FBQyxjQUFjO2FBQy9CLENBQUMsQ0FBQztRQUNMLEtBQUssRUFDSCxLQUFLLENBQUMsS0FBSyxLQUFLLFNBQVM7WUFDdkIsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxLQUFLO1lBQ2hCLENBQUMsQ0FBQyxLQUFLLENBQUMsS0FBSztRQUNqQixRQUFRLEVBQ04sS0FBSyxDQUFDLFFBQVEsS0FBSyxTQUFTLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxRQUFRO0tBQ3BFLENBQUE7SUFFRCxNQUFNLElBQUEsK0NBQTJCLEVBQUMsU0FBUyxFQUFFLFdBQVcsQ0FBQyxDQUFBO0lBRXpELE1BQU0sT0FBTyxHQUFHLElBQUEsNkNBQXlCLEVBQUMsV0FBVyxDQUFDLENBQUE7SUFDdEQsTUFBTSxzQkFBc0IsR0FDMUIsU0FBUyxDQUFDLE9BQU8sQ0FBQyw4QkFBaUIsQ0FBQyxDQUFBO0lBRXRDLE1BQU0sT0FBTyxHQUFHLE1BQU0sc0JBQXNCLENBQUMsZ0JBQWdCLENBQUM7UUFDNUQsR0FBRyxPQUFPO1FBQ1YsRUFBRSxFQUFFLFFBQVEsQ0FBQyxFQUFFO0tBQ1QsQ0FBQyxDQUFBO0lBQ1QsTUFBTSxXQUFXLEdBQUcsSUFBQSxrQ0FBYyxFQUFDLE9BQU8sQ0FBQyxDQUFBO0lBRTNDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUNqQixNQUFNLElBQUksS0FBSyxDQUFDLHlDQUF5QyxDQUFDLENBQUE7SUFDNUQsQ0FBQztJQUVELE9BQU8sSUFBSSw0QkFBWSxDQUFDLFdBQVcsRUFBRSxJQUFBLGlEQUE2QixFQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUE7QUFDL0UsQ0FBQyxFQUNELEtBQUssV0FBVyxRQUFRLEVBQUUsRUFBRSxTQUFTLEVBQUU7SUFDckMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsT0FBTTtJQUNSLENBQUM7SUFFRCxNQUFNLHNCQUFzQixHQUMxQixTQUFTLENBQUMsT0FBTyxDQUFDLDhCQUFpQixDQUFDLENBQUE7SUFFdEMsTUFBTSxzQkFBc0IsQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFlLENBQUMsQ0FBQTtBQUNoRSxDQUFDLENBQ0YsQ0FBQSJ9

package/.medusa/server/src/workflows/steps/update-subscription-settings.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSubscriptionSettingsStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+const settings_1 = require("../../modules/settings");
+const types_1 = require("../../modules/settings/types");
+const audit_1 = require("../../modules/settings/utils/audit");
+function buildRestorationPayload(previous) {
+    return {
+        settings_key: types_1.GLOBAL_SUBSCRIPTION_SETTINGS_KEY,
+        default_trial_days: previous.default_trial_days,
+        dunning_retry_intervals: previous.dunning_retry_intervals,
+        max_dunning_attempts: previous.max_dunning_attempts,
+        default_renewal_behavior: previous.default_renewal_behavior,
+        default_cancellation_behavior: previous.default_cancellation_behavior,
+        version: previous.version,
+        updated_by: previous.updated_by,
+        metadata: previous.metadata,
+    };
+}
+exports.updateSubscriptionSettingsStep = (0, workflows_sdk_1.createStep)("update-subscription-settings", async function (input, { container }) {
+    const logger = container.resolve("logger");
+    const settingsModule = container.resolve(settings_1.SETTINGS_MODULE);
+    const previous = await settingsModule.getSettings();
+    if (input.expected_version !== previous.version) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, `SubscriptionSettings version conflict: expected ${input.expected_version}, current ${previous.version}`);
+    }
+    const changedAt = new Date().toISOString();
+    const settings = await settingsModule.updateSettings({
+        ...input,
+        metadata: previous.metadata,
+    });
+    const metadataWithAudit = (0, audit_1.appendSettingsAuditMetadata)(previous.metadata, {
+        previous,
+        next: settings,
+        updated_by: input.updated_by ?? null,
+        reason: input.reason ?? null,
+        changed_at: changedAt,
+    });
+    const [record] = (await settingsModule.listSubscriptionSettings({
+        settings_key: types_1.GLOBAL_SUBSCRIPTION_SETTINGS_KEY,
+    }));
+    if (record) {
+        await settingsModule.updateSubscriptionSettings({
+            id: record.id,
+            metadata: metadataWithAudit,
+        });
+    }
+    const persistedSettings = await settingsModule.getSettings();
+    const lastUpdate = metadataWithAudit.last_update ??
+        null;
+    logger.info(JSON.stringify({
+        domain: "settings",
+        event: "settings.update",
+        outcome: "completed",
+        settings_key: persistedSettings.settings_key,
+        previous_version: previous.version,
+        version: persistedSettings.version,
+        updated_by: persistedSettings.updated_by,
+        updated_at: persistedSettings.updated_at?.toISOString?.() ?? null,
+        reason: input.reason ?? null,
+        change_summary: lastUpdate?.change_summary ?? [],
+    }));
+    return new workflows_sdk_1.StepResponse({
+        settings: persistedSettings,
+    }, {
+        previous,
+        created_new_record: !previous.is_persisted,
+    });
+}, async function (compensation, { container }) {
+    if (!compensation) {
+        return;
+    }
+    const settingsModule = container.resolve(settings_1.SETTINGS_MODULE);
+    if (compensation.created_new_record) {
+        await settingsModule.resetSettings();
+        return;
+    }
+    const [record] = (await settingsModule.listSubscriptionSettings({
+        settings_key: types_1.GLOBAL_SUBSCRIPTION_SETTINGS_KEY,
+    }));
+    if (!record) {
+        return;
+    }
+    await settingsModule.updateSubscriptionSettings({
+        id: record.id,
+        ...buildRestorationPayload(compensation.previous),
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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