@reorderjs/reorder 1.0.1

package/.medusa/server/src/workflows/steps/schedule-subscription-plan-change.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleSubscriptionPlanChangeStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const effective_config_1 = require("../../modules/plan-offer/utils/effective-config");
+const subscription_1 = require("../../modules/subscription");
+const types_1 = require("../../modules/subscription/types");
+const errors_1 = require("../../modules/subscription/utils/errors");
+const pause_subscription_1 = require("./pause-subscription");
+exports.scheduleSubscriptionPlanChangeStep = (0, workflows_sdk_1.createStep)("schedule-subscription-plan-change", async function (input, { container }) {
+    const subscriptionModuleService = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    const subscription = await subscriptionModuleService.retrieveSubscription(input.id);
+    if (subscription.status !== types_1.SubscriptionStatus.ACTIVE &&
+        subscription.status !== types_1.SubscriptionStatus.PAUSED &&
+        subscription.status !== types_1.SubscriptionStatus.PAST_DUE) {
+        throw errors_1.subscriptionErrors.invalidState(input.id, "schedule a plan change", subscription.status);
+    }
+    if (input.frequency_value <= 0) {
+        throw errors_1.subscriptionErrors.invalidData("frequency_value must be greater than 0");
+    }
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data: variants } = await query.graph({
+        entity: "variant",
+        fields: ["id", "title", "sku", "product.id", "product.title"],
+        filters: {
+            id: [input.variant_id],
+        },
+    });
+    const variant = variants[0];
+    if (!variant) {
+        throw errors_1.subscriptionErrors.notFound("Variant", input.variant_id);
+    }
+    if (variant.product?.id !== subscription.product_id) {
+        throw errors_1.subscriptionErrors.planChangeVariantMismatch(input.variant_id, subscription.product_id);
+    }
+    const effectiveConfig = await (0, effective_config_1.resolveProductSubscriptionConfig)(container, {
+        product_id: subscription.product_id,
+        variant_id: variant.id,
+    });
+    if (!effectiveConfig.is_enabled) {
+        throw errors_1.subscriptionErrors.planChangeNotAllowed(subscription.product_id, variant.id);
+    }
+    const isAllowedFrequency = effectiveConfig.allowed_frequencies.some((frequency) => String(frequency.interval) === input.frequency_interval &&
+        frequency.value === input.frequency_value);
+    if (!isAllowedFrequency) {
+        throw errors_1.subscriptionErrors.planChangeFrequencyNotAllowed(input.frequency_interval, input.frequency_value);
+    }
+    const requestedAt = new Date().toISOString();
+    const updated = await subscriptionModuleService.updateSubscriptions({
+        id: input.id,
+        pending_update_data: {
+            variant_id: variant.id,
+            variant_title: variant.title,
+            sku: variant.sku ?? null,
+            frequency_interval: input.frequency_interval,
+            frequency_value: input.frequency_value,
+            effective_at: input.effective_at ?? null,
+            requested_at: requestedAt,
+            requested_by: input.requested_by ?? null,
+        },
+        metadata: {
+            ...(subscription.metadata ?? {}),
+            scheduled_plan_change_context: {
+                requested_at: requestedAt,
+                requested_by: input.requested_by ?? null,
+            },
+        },
+    });
+    return new workflows_sdk_1.StepResponse({
+        current: (0, pause_subscription_1.asSubscriptionWorkflowRecord)(updated),
+        previous: (0, pause_subscription_1.asSubscriptionWorkflowRecord)(subscription),
+    }, (0, pause_subscription_1.asSubscriptionWorkflowRecord)(subscription));
+}, async function (subscription, { container }) {
+    if (!subscription) {
+        return;
+    }
+    const subscriptionModuleService = container.resolve(subscription_1.SUBSCRIPTION_MODULE);
+    await subscriptionModuleService.updateSubscriptions((0, pause_subscription_1.asSubscriptionUpdateInput)(subscription));
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/steps/shared-cancellation-log.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLWNhbmNlbGxhdGlvbi1sb2cuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0ZXBzL3NoYXJlZC1jYW5jZWxsYXRpb24tbG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

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

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPlanOfferTargetExists = assertPlanOfferTargetExists;
+exports.findPlanOfferByTarget = findPlanOfferByTarget;
+exports.getPlanOfferRecordById = getPlanOfferRecordById;
+exports.normalizePlanOfferPayload = normalizePlanOfferPayload;
+exports.getPlanOfferId = getPlanOfferId;
+exports.toUpdatePlanOfferServiceInput = toUpdatePlanOfferServiceInput;
+const utils_1 = require("@medusajs/framework/utils");
+const types_1 = require("../../modules/plan-offer/types");
+const errors_1 = require("../../modules/plan-offer/utils/errors");
+const planOfferFields = [
+    "id",
+    "name",
+    "scope",
+    "product_id",
+    "variant_id",
+    "is_enabled",
+    "allowed_frequencies",
+    "frequency_intervals",
+    "discount_per_frequency",
+    "rules",
+    "metadata",
+];
+function assertPositiveInteger(value, field) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw errors_1.planOfferErrors.invalidFrequencyMix(`'${field}' must be a positive integer`);
+    }
+}
+function validateTarget(input) {
+    if (normalizeScope(input.scope) === types_1.PlanOfferScope.PRODUCT) {
+        if (input.variant_id) {
+            throw errors_1.planOfferErrors.productScopeDisallowsVariantId();
+        }
+        return;
+    }
+    if (!input.variant_id) {
+        throw errors_1.planOfferErrors.variantScopeRequiresVariantId();
+    }
+}
+function normalizeScope(scope) {
+    switch (scope) {
+        case "variant":
+        case types_1.PlanOfferScope.VARIANT:
+            return types_1.PlanOfferScope.VARIANT;
+        case "product":
+        case types_1.PlanOfferScope.PRODUCT:
+            return types_1.PlanOfferScope.PRODUCT;
+    }
+}
+function normalizeFrequencyInterval(interval) {
+    switch (interval) {
+        case "week":
+        case types_1.PlanOfferFrequencyInterval.WEEK:
+            return types_1.PlanOfferFrequencyInterval.WEEK;
+        case "month":
+        case types_1.PlanOfferFrequencyInterval.MONTH:
+            return types_1.PlanOfferFrequencyInterval.MONTH;
+        case "year":
+        case types_1.PlanOfferFrequencyInterval.YEAR:
+            return types_1.PlanOfferFrequencyInterval.YEAR;
+    }
+}
+function normalizeDiscountType(type) {
+    switch (type) {
+        case "fixed":
+        case types_1.PlanOfferDiscountType.FIXED:
+            return types_1.PlanOfferDiscountType.FIXED;
+        case "percentage":
+        case types_1.PlanOfferDiscountType.PERCENTAGE:
+            return types_1.PlanOfferDiscountType.PERCENTAGE;
+    }
+}
+function normalizeStackingPolicy(stackingPolicy) {
+    switch (stackingPolicy) {
+        case "allowed":
+        case types_1.PlanOfferStackingPolicy.ALLOWED:
+            return types_1.PlanOfferStackingPolicy.ALLOWED;
+        case "disallow_all":
+        case types_1.PlanOfferStackingPolicy.DISALLOW_ALL:
+            return types_1.PlanOfferStackingPolicy.DISALLOW_ALL;
+        case "disallow_subscription_discounts":
+        case types_1.PlanOfferStackingPolicy.DISALLOW_SUBSCRIPTION_DISCOUNTS:
+            return types_1.PlanOfferStackingPolicy.DISALLOW_SUBSCRIPTION_DISCOUNTS;
+    }
+}
+function normalizeAllowedFrequencies(allowedFrequencies) {
+    if (!allowedFrequencies.length) {
+        throw errors_1.planOfferErrors.allowedFrequenciesRequired();
+    }
+    const seen = new Set();
+    return allowedFrequencies.map((frequency) => {
+        assertPositiveInteger(frequency.value, `allowed_frequencies.${frequency.interval}.value`);
+        const key = `${frequency.interval}:${frequency.value}`;
+        if (seen.has(key)) {
+            throw errors_1.planOfferErrors.duplicateFrequency(String(frequency.interval), frequency.value);
+        }
+        seen.add(key);
+        return {
+            interval: normalizeFrequencyInterval(frequency.interval),
+            value: frequency.value,
+        };
+    });
+}
+function normalizeDiscounts(discounts, allowedFrequencies) {
+    if (!discounts?.length) {
+        return [];
+    }
+    const allowedFrequencyKeys = new Set(allowedFrequencies.map((frequency) => `${frequency.interval}:${frequency.value}`));
+    const seen = new Set();
+    return discounts.map((discount) => {
+        assertPositiveInteger(discount.frequency_value, `discounts.${discount.interval}.frequency_value`);
+        const frequencyKey = `${discount.interval}:${discount.frequency_value}`;
+        if (!allowedFrequencyKeys.has(frequencyKey)) {
+            throw errors_1.planOfferErrors.discountFrequencyNotAllowed(String(discount.interval), discount.frequency_value);
+        }
+        if (seen.has(frequencyKey)) {
+            throw errors_1.planOfferErrors.duplicateDiscountForFrequency(String(discount.interval), discount.frequency_value);
+        }
+        seen.add(frequencyKey);
+        if (normalizeDiscountType(discount.type) === types_1.PlanOfferDiscountType.PERCENTAGE) {
+            if (discount.value <= 0 || discount.value > 100) {
+                throw errors_1.planOfferErrors.discountOutOfRange("Percentage discounts must be greater than 0 and at most 100");
+            }
+        }
+        else if (discount.value <= 0) {
+            throw errors_1.planOfferErrors.discountOutOfRange("Fixed discounts must be greater than 0");
+        }
+        return {
+            interval: normalizeFrequencyInterval(discount.interval),
+            value: discount.frequency_value,
+            discount_type: normalizeDiscountType(discount.type),
+            discount_value: discount.value,
+        };
+    });
+}
+function normalizeRules(rules) {
+    if (rules === undefined || rules === null) {
+        return null;
+    }
+    if (rules.minimum_cycles !== null && rules.minimum_cycles !== undefined) {
+        assertPositiveInteger(rules.minimum_cycles, "rules.minimum_cycles");
+    }
+    if (!rules.trial_enabled) {
+        if (rules.trial_days !== null && rules.trial_days !== undefined) {
+            throw errors_1.planOfferErrors.invalidTrialConfiguration("'rules.trial_days' must be null when trial is disabled");
+        }
+    }
+    else {
+        if (rules.trial_days === null || rules.trial_days === undefined) {
+            throw errors_1.planOfferErrors.invalidTrialConfiguration("'rules.trial_days' is required when trial is enabled");
+        }
+        assertPositiveInteger(rules.trial_days, "rules.trial_days");
+    }
+    return {
+        minimum_cycles: rules.minimum_cycles ?? null,
+        trial_enabled: rules.trial_enabled,
+        trial_days: rules.trial_days ?? null,
+        stacking_policy: normalizeStackingPolicy(rules.stacking_policy),
+    };
+}
+async function assertPlanOfferTargetExists(container, input) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data } = await query.graph({
+        entity: "product",
+        fields: ["id", "variants.id"],
+        filters: {
+            id: [input.product_id],
+        },
+    });
+    const product = data[0];
+    if (!product) {
+        throw errors_1.planOfferErrors.productNotFound(input.product_id);
+    }
+    if (normalizeScope(input.scope) === types_1.PlanOfferScope.VARIANT) {
+        const variantId = input.variant_id;
+        if (!product.variants?.some((variant) => variant.id === variantId)) {
+            throw errors_1.planOfferErrors.variantDoesNotBelongToProduct(variantId, input.product_id);
+        }
+    }
+}
+async function findPlanOfferByTarget(container, input) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const filters = normalizeScope(input.scope) === types_1.PlanOfferScope.PRODUCT
+        ? {
+            scope: types_1.PlanOfferScope.PRODUCT,
+            product_id: input.product_id,
+        }
+        : {
+            scope: types_1.PlanOfferScope.VARIANT,
+            variant_id: input.variant_id,
+        };
+    const { data } = await query.graph({
+        entity: "plan_offer",
+        fields: [...planOfferFields],
+        filters,
+    });
+    const records = data;
+    if (!records.length) {
+        return null;
+    }
+    if (records.length > 1) {
+        throw errors_1.planOfferErrors.conflictingOverrideConfiguration(normalizeScope(input.scope) === types_1.PlanOfferScope.PRODUCT
+            ? `Multiple plan offers were found for product '${input.product_id}'`
+            : `Multiple plan offers were found for variant '${input.variant_id}'`);
+    }
+    const record = records[0];
+    return {
+        ...record,
+        scope: record.scope === "product"
+            ? types_1.PlanOfferScope.PRODUCT
+            : types_1.PlanOfferScope.VARIANT,
+    };
+}
+async function getPlanOfferRecordById(container, id) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data } = await query.graph({
+        entity: "plan_offer",
+        fields: [...planOfferFields],
+        filters: {
+            id: [id],
+        },
+        pagination: {
+            take: 1,
+        },
+    });
+    const record = data[0];
+    if (!record) {
+        return null;
+    }
+    return {
+        ...record,
+        scope: record.scope === "product"
+            ? types_1.PlanOfferScope.PRODUCT
+            : types_1.PlanOfferScope.VARIANT,
+    };
+}
+function normalizePlanOfferPayload(input) {
+    validateTarget(input);
+    const normalizedScope = normalizeScope(input.scope);
+    const allowed_frequencies = normalizeAllowedFrequencies(input.allowed_frequencies);
+    const discount_per_frequency = normalizeDiscounts(input.discounts, allowed_frequencies);
+    const rules = normalizeRules(input.rules);
+    return {
+        name: input.name.trim(),
+        scope: normalizedScope,
+        product_id: input.product_id,
+        variant_id: normalizedScope === types_1.PlanOfferScope.PRODUCT ? null : input.variant_id,
+        is_enabled: input.is_enabled,
+        allowed_frequencies,
+        frequency_intervals: [
+            ...new Set(allowed_frequencies.map((frequency) => String(frequency.interval))),
+        ],
+        discount_per_frequency,
+        rules,
+        metadata: input.metadata ?? null,
+    };
+}
+function getPlanOfferId(result) {
+    if (Array.isArray(result)) {
+        return result[0]?.id;
+    }
+    return result?.id;
+}
+function toUpdatePlanOfferServiceInput(record) {
+    return {
+        id: record.id,
+        name: record.name,
+        scope: record.scope,
+        product_id: record.product_id,
+        variant_id: record.variant_id,
+        is_enabled: record.is_enabled,
+        allowed_frequencies: record.allowed_frequencies,
+        frequency_intervals: record.frequency_intervals,
+        discount_per_frequency: record.discount_per_frequency ?? [],
+        rules: record.rules,
+        metadata: record.metadata,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shared-plan-offer.js","sourceRoot":"","sources":["../../../../../src/workflows/steps/shared-plan-offer.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/workflows/steps/shared-renewal-approval.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRenewalCycleApprovalRecord = getRenewalCycleApprovalRecord;
+exports.validateRenewalApprovalTransition = validateRenewalApprovalTransition;
+const renewal_1 = require("../../modules/renewal");
+const types_1 = require("../../modules/renewal/types");
+const errors_1 = require("../../modules/renewal/utils/errors");
+async function getRenewalCycleApprovalRecord(container, id) {
+    const renewalModule = container.resolve(renewal_1.RENEWAL_MODULE);
+    try {
+        return (await renewalModule.retrieveRenewalCycle(id));
+    }
+    catch {
+        throw errors_1.renewalErrors.notFound("RenewalCycle", id);
+    }
+}
+function validateRenewalApprovalTransition(cycle, targetStatus) {
+    if (!cycle.approval_required) {
+        throw errors_1.renewalErrors.approvalNotRequired(cycle.id);
+    }
+    if (cycle.status === types_1.RenewalCycleStatus.PROCESSING) {
+        throw errors_1.renewalErrors.invalidTransition(cycle.id, `Renewal '${cycle.id}' can't change approval state while processing`);
+    }
+    if (cycle.status === types_1.RenewalCycleStatus.SUCCEEDED) {
+        throw errors_1.renewalErrors.invalidTransition(cycle.id, `Renewal '${cycle.id}' can't change approval state after success`);
+    }
+    if (cycle.approval_status !== types_1.RenewalApprovalStatus.PENDING) {
+        throw errors_1.renewalErrors.approvalAlreadyDecided(cycle.id);
+    }
+    if (targetStatus !== types_1.RenewalApprovalStatus.APPROVED && targetStatus !== types_1.RenewalApprovalStatus.REJECTED) {
+        throw errors_1.renewalErrors.invalidData(`Unsupported approval transition '${targetStatus}'`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLXJlbmV3YWwtYXBwcm92YWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL3N0ZXBzL3NoYXJlZC1yZW5ld2FsLWFwcHJvdmFsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBb0JBLHNFQWFDO0FBRUQsOEVBK0JDO0FBakVELG1EQUFzRDtBQUV0RCx1REFHb0M7QUFDcEMsK0RBQWtFO0FBYTNELEtBQUssVUFBVSw2QkFBNkIsQ0FDakQsU0FBMEIsRUFDMUIsRUFBVTtJQUVWLE1BQU0sYUFBYSxHQUFHLFNBQVMsQ0FBQyxPQUFPLENBQXVCLHdCQUFjLENBQUMsQ0FBQTtJQUU3RSxJQUFJLENBQUM7UUFDSCxPQUFPLENBQUMsTUFBTSxhQUFhLENBQUMsb0JBQW9CLENBQzlDLEVBQUUsQ0FDSCxDQUEwQyxDQUFBO0lBQzdDLENBQUM7SUFBQyxNQUFNLENBQUM7UUFDUCxNQUFNLHNCQUFhLENBQUMsUUFBUSxDQUFDLGNBQWMsRUFBRSxFQUFFLENBQUMsQ0FBQTtJQUNsRCxDQUFDO0FBQ0gsQ0FBQztBQUVELFNBQWdCLGlDQUFpQyxDQUMvQyxLQUFpQyxFQUNqQyxZQUFtQztJQUVuQyxJQUFJLENBQUMsS0FBSyxDQUFDLGlCQUFpQixFQUFFLENBQUM7UUFDN0IsTUFBTSxzQkFBYSxDQUFDLG1CQUFtQixDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUNuRCxDQUFDO0lBRUQsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLDBCQUFrQixDQUFDLFVBQVUsRUFBRSxDQUFDO1FBQ25ELE1BQU0sc0JBQWEsQ0FBQyxpQkFBaUIsQ0FDbkMsS0FBSyxDQUFDLEVBQUUsRUFDUixZQUFZLEtBQUssQ0FBQyxFQUFFLGdEQUFnRCxDQUNyRSxDQUFBO0lBQ0gsQ0FBQztJQUVELElBQUksS0FBSyxDQUFDLE1BQU0sS0FBSywwQkFBa0IsQ0FBQyxTQUFTLEVBQUUsQ0FBQztRQUNsRCxNQUFNLHNCQUFhLENBQUMsaUJBQWlCLENBQ25DLEtBQUssQ0FBQyxFQUFFLEVBQ1IsWUFBWSxLQUFLLENBQUMsRUFBRSw2Q0FBNkMsQ0FDbEUsQ0FBQTtJQUNILENBQUM7SUFFRCxJQUFJLEtBQUssQ0FBQyxlQUFlLEtBQUssNkJBQXFCLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDNUQsTUFBTSxzQkFBYSxDQUFDLHNCQUFzQixDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsQ0FBQTtJQUN0RCxDQUFDO0lBRUQsSUFBSSxZQUFZLEtBQUssNkJBQXFCLENBQUMsUUFBUSxJQUFJLFlBQVksS0FBSyw2QkFBcUIsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN2RyxNQUFNLHNCQUFhLENBQUMsV0FBVyxDQUM3QixvQ0FBb0MsWUFBWSxHQUFHLENBQ3BELENBQUE7SUFDSCxDQUFDO0FBQ0gsQ0FBQyJ9

package/.medusa/server/src/workflows/steps/start-cancellation-case.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCancellationCaseStep = 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 types_2 = require("../../modules/subscription/types");
+const errors_2 = require("../../modules/subscription/utils/errors");
+const subscription_settings_1 = require("../utils/subscription-settings");
+const ACTIVE_CANCELLATION_CASE_STATUSES = new Set([
+    types_1.CancellationCaseStatus.REQUESTED,
+    types_1.CancellationCaseStatus.EVALUATING_RETENTION,
+    types_1.CancellationCaseStatus.RETENTION_OFFERED,
+]);
+function isActiveCancellationCase(status) {
+    return ACTIVE_CANCELLATION_CASE_STATUSES.has(status);
+}
+function normalizeEntryContext(input) {
+    const rawTriggeredAt = input.entry_context?.triggered_at;
+    const triggeredAt = rawTriggeredAt
+        ? rawTriggeredAt instanceof Date
+            ? rawTriggeredAt
+            : new Date(rawTriggeredAt)
+        : new Date();
+    if (Number.isNaN(triggeredAt.getTime())) {
+        throw errors_1.cancellationErrors.invalidData("Cancellation entry_context.triggered_at must be a valid date");
+    }
+    return {
+        source: input.entry_context?.source ?? "admin_manual",
+        triggered_by: input.entry_context?.triggered_by ?? null,
+        triggered_at: triggeredAt.toISOString(),
+        reason: input.entry_context?.reason ?? input.reason ?? null,
+    };
+}
+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);
+    }
+}
+function validateSubscriptionEntryState(subscription) {
+    if (subscription.status !== types_2.SubscriptionStatus.ACTIVE &&
+        subscription.status !== types_2.SubscriptionStatus.PAUSED &&
+        subscription.status !== types_2.SubscriptionStatus.PAST_DUE) {
+        throw errors_2.subscriptionErrors.invalidState(subscription.id, "enter cancellation handling", subscription.status);
+    }
+}
+function mergeCaseMetadata(existingMetadata, input, entryContext, settings) {
+    const base = {
+        ...(existingMetadata ?? {}),
+        ...(input.metadata ?? {}),
+        origin: "admin_cancel_intent",
+        entry_context: entryContext,
+        ...(settings
+            ? {
+                settings_policy: {
+                    default_cancellation_behavior: settings.default_cancellation_behavior,
+                    settings_version: settings.version,
+                    is_persisted: settings.is_persisted,
+                },
+            }
+            : {}),
+    };
+    return (0, audit_1.appendCancellationManualAction)(base, {
+        action: "start_case",
+        who: entryContext.triggered_by,
+        when: entryContext.triggered_at,
+        why: entryContext.reason,
+        data: {
+            entry_source: entryContext.source,
+        },
+    });
+}
+exports.startCancellationCaseStep = (0, workflows_sdk_1.createStep)("start-cancellation-case", async function (input, { container }) {
+    const cancellationModule = container.resolve(cancellation_1.CANCELLATION_MODULE);
+    if (!input.subscription_id?.trim()) {
+        throw errors_1.cancellationErrors.invalidData("Cancellation start requires a subscription_id");
+    }
+    const subscription = await loadSubscription(container, input.subscription_id);
+    validateSubscriptionEntryState(subscription);
+    const entryContext = normalizeEntryContext(input);
+    const settings = await (0, subscription_settings_1.getEffectiveSubscriptionSettings)(container);
+    const subscriptionCases = (await cancellationModule.listCancellationCases({
+        subscription_id: subscription.id,
+    }));
+    const activeCases = subscriptionCases.filter((cancellationCase) => isActiveCancellationCase(cancellationCase.status));
+    if (activeCases.length > 1) {
+        throw errors_1.cancellationErrors.multipleActiveCases(subscription.id);
+    }
+    const activeCase = activeCases[0] ?? null;
+    if (activeCase) {
+        const updated = (await cancellationModule.updateCancellationCases({
+            id: activeCase.id,
+            reason: activeCase.reason ?? input.reason ?? null,
+            reason_category: activeCase.reason_category ?? input.reason_category ?? null,
+            notes: activeCase.notes ?? input.notes ?? null,
+            metadata: mergeCaseMetadata(activeCase.metadata, input, entryContext),
+        }));
+        return new workflows_sdk_1.StepResponse({
+            action: "updated",
+            current: updated,
+            previous: activeCase,
+            subscription: subscription,
+        }, {
+            action: "updated",
+            previous_case: activeCase,
+        });
+    }
+    const created = (await cancellationModule.createCancellationCases({
+        subscription_id: subscription.id,
+        status: types_1.CancellationCaseStatus.REQUESTED,
+        reason: input.reason ?? null,
+        reason_category: input.reason_category ?? null,
+        notes: input.notes ?? null,
+        final_outcome: null,
+        finalized_at: null,
+        finalized_by: null,
+        cancellation_effective_at: null,
+        metadata: mergeCaseMetadata(null, input, entryContext, settings),
+    }));
+    return new workflows_sdk_1.StepResponse({
+        action: "created",
+        current: created,
+        previous: null,
+        subscription: subscription,
+    }, {
+        action: "created",
+        created_case_id: created.id,
+    });
+}, async function (compensation, { container }) {
+    if (!compensation) {
+        return;
+    }
+    const cancellationModule = container.resolve(cancellation_1.CANCELLATION_MODULE);
+    if (compensation.action === "created") {
+        await cancellationModule.deleteCancellationCases(compensation.created_case_id);
+        return;
+    }
+    await cancellationModule.updateCancellationCases(compensation.previous_case);
+});
+//# sourceMappingURL=data:application/json;base64,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