@hartl-services/medusa-affiliate 0.3.0

package/.medusa/server/src/workflows/affiliate/ensure-affiliate-coupon-promotion.js

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureAffiliateCouponPromotionWorkflow = exports.provisionAffiliateCouponPromotion = exports.isCurrentAffiliateCouponPromotion = exports.affiliateCouponProgramLockKeys = exports.affiliateCouponProvisioningLockKeys = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const affiliate_cart_operation_lock_1 = require("../../utils/affiliate-cart-operation-lock");
+const promotion_code_availability_1 = require("../../utils/promotion-code-availability");
+const resolve_services_1 = require("../../utils/resolve-services");
+const promotion_eligibility_1 = require("./promotion-eligibility");
+const AFFILIATE_CAMPAIGN_PROVISIONING_LOCK = "affiliate-campaign-provisioning";
+const couponCodeConflict = () => new utils_1.MedusaError(utils_1.MedusaError.Types.CONFLICT, "coupon_code_conflict");
+const provisioningErrorMessage = (error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return `Affiliate coupon promotion provisioning failed: ${message}`.slice(0, 2_000);
+};
+const assertAffiliateCampaign = (campaign) => {
+    const budget = campaign.budget;
+    if (campaign.campaign_identifier !== promotion_eligibility_1.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER ||
+        budget?.type !== "use_by_attribute" ||
+        budget.attribute !== "customer_email" ||
+        Number(budget.limit) !== 1) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "The Affiliate customer campaign does not have the required customer-email budget.");
+    }
+};
+const retrieveAffiliateCampaign = async (promotionService) => {
+    const campaigns = await promotionService.listCampaigns({
+        campaign_identifier: [promotion_eligibility_1.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER],
+    }, { relations: ["budget"], take: 2 });
+    if (campaigns.length > 1) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "Multiple Affiliate customer campaigns use the reserved identifier.");
+    }
+    if (campaigns[0]) {
+        assertAffiliateCampaign(campaigns[0]);
+    }
+    return campaigns[0] ?? null;
+};
+const ensureAffiliateCampaign = async (container, promotionService) => {
+    const existing = await retrieveAffiliateCampaign(promotionService);
+    if (existing) {
+        return existing;
+    }
+    return await (0, affiliate_cart_operation_lock_1.withAffiliateOperationLocks)(container, [AFFILIATE_CAMPAIGN_PROVISIONING_LOCK], async () => {
+        let campaign = await retrieveAffiliateCampaign(promotionService);
+        if (!campaign) {
+            await (0, core_flows_1.createCampaignsWorkflow)(container).run({
+                input: {
+                    campaignsData: [
+                        {
+                            name: "Affiliate customer codes",
+                            campaign_identifier: promotion_eligibility_1.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER,
+                            budget: {
+                                type: "use_by_attribute",
+                                attribute: "customer_email",
+                                limit: 1,
+                            },
+                        },
+                    ],
+                },
+            });
+            campaign = await retrieveAffiliateCampaign(promotionService);
+        }
+        if (!campaign) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "The Affiliate customer campaign could not be provisioned uniquely.");
+        }
+        return campaign;
+    });
+};
+const affiliateCouponProvisioningLockKeys = (affiliateId) => [
+    AFFILIATE_CAMPAIGN_PROVISIONING_LOCK,
+    (0, affiliate_cart_operation_lock_1.affiliateProgramSagaLockKey)(),
+    (0, affiliate_cart_operation_lock_1.affiliateSagaLockKey)(affiliateId),
+];
+exports.affiliateCouponProvisioningLockKeys = affiliateCouponProvisioningLockKeys;
+const affiliateCouponProgramLockKeys = () => [
+    AFFILIATE_CAMPAIGN_PROVISIONING_LOCK,
+    (0, affiliate_cart_operation_lock_1.affiliateProgramSagaLockKey)(),
+];
+exports.affiliateCouponProgramLockKeys = affiliateCouponProgramLockKeys;
+const promotionRelations = [
+    "campaign",
+    "rules",
+    "application_method",
+    "application_method.target_rules",
+    "application_method.target_rules.values",
+];
+const promotionHasExactIdentity = (promotion, coupon, campaign) => promotion.code === coupon.code &&
+    promotion.campaign_id === campaign.id &&
+    promotion.campaign?.id === campaign.id &&
+    promotion.campaign.campaign_identifier ===
+        promotion_eligibility_1.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER;
+const isCurrentAffiliateCouponPromotion = (input) => {
+    const { promotion, coupon, affiliate, campaign, discount_rate: discountRate, eligible_variant_ids: eligibleVariantIds, } = input;
+    const applicationMethod = promotion.application_method;
+    const targetRules = applicationMethod?.target_rules ?? [];
+    const targetRule = targetRules[0];
+    const currentValues = (targetRule?.values ?? [])
+        .map(({ value }) => value)
+        .sort();
+    const desiredValues = (0, promotion_eligibility_1.affiliateEligibleVariantRuleValues)(eligibleVariantIds);
+    const targetRulesCurrent = targetRules.length === 1 &&
+        targetRule?.attribute === "items.variant.id" &&
+        targetRule.operator === "eq" &&
+        currentValues.length === desiredValues.length &&
+        currentValues.every((value, index) => value === desiredValues[index]);
+    return (promotionHasExactIdentity(promotion, coupon, campaign) &&
+        promotion.type === "standard" &&
+        promotion.is_automatic === false &&
+        promotion.status ===
+            (coupon.lifecycle_status === "enabled" && affiliate.status === "active"
+                ? "active"
+                : "inactive") &&
+        (promotion.rules?.length ?? 0) === 0 &&
+        applicationMethod?.type === "percentage" &&
+        applicationMethod.target_type === "items" &&
+        applicationMethod.allocation === "across" &&
+        Number(applicationMethod.value) === discountRate &&
+        targetRulesCurrent);
+};
+exports.isCurrentAffiliateCouponPromotion = isCurrentAffiliateCouponPromotion;
+/**
+ * Conflicts and unexpected states are raised by this workflow's own checks
+ * (e.g. the bound promotion is missing or no longer the plugin's); anything
+ * else, such as a database error, may be transient.
+ */
+const isDetectedInconsistency = (error) => utils_1.MedusaError.isMedusaError(error) &&
+    (error.type === utils_1.MedusaError.Types.CONFLICT ||
+        error.type === utils_1.MedusaError.Types.UNEXPECTED_STATE);
+const deactivatePromotion = async (container, promotionId) => {
+    await (0, core_flows_1.updatePromotionsWorkflow)(container).run({
+        input: {
+            promotionsData: [{ id: promotionId, status: "inactive" }],
+        },
+    });
+};
+const persistProvisioningFailure = async (container, couponId, error, promotionId, mayDeactivatePromotion) => {
+    const affiliateService = (0, resolve_services_1.resolveAffiliateService)(container);
+    const failures = [error];
+    let latest = null;
+    try {
+        latest = await affiliateService.retrieveAffiliateCouponRecord(couponId);
+        if (latest.replaces_coupon_id &&
+            latest.lifecycle_status === "enabled" &&
+            latest.provisioning_status === "ready") {
+            const predecessor = await affiliateService.retrieveAffiliateCouponRecord(latest.replaces_coupon_id, latest.affiliate_id);
+            if (predecessor.lifecycle_status === "revoked") {
+                throw error;
+            }
+        }
+    }
+    catch (readError) {
+        if (readError === error) {
+            throw error;
+        }
+        failures.push(readError);
+    }
+    if (promotionId && mayDeactivatePromotion) {
+        try {
+            await deactivatePromotion(container, promotionId);
+        }
+        catch (deactivationError) {
+            failures.push(deactivationError);
+        }
+    }
+    try {
+        await affiliateService.setAffiliateCouponProvisioningState({
+            coupon_id: couponId,
+            ...(latest?.promotion_id ? { promotion_id: latest.promotion_id } : {}),
+            provisioning_status: "failed",
+            promotion_setup_error: provisioningErrorMessage(error),
+        });
+    }
+    catch (stateError) {
+        failures.push(stateError);
+    }
+    if (failures.length === 1) {
+        throw error;
+    }
+    throw new AggregateError(failures, "Affiliate coupon provisioning and fail-closed cleanup failed");
+};
+const loadPromotionByExactCode = async (promotionService, coupon, campaign) => {
+    const promotions = await promotionService.listPromotions({ code: [coupon.code] }, { relations: promotionRelations, take: 2 });
+    if (promotions.length > 1) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Multiple native promotions use Affiliate coupon code "${coupon.code}".`);
+    }
+    const promotion = promotions[0] ?? null;
+    if (promotion && !promotionHasExactIdentity(promotion, coupon, campaign)) {
+        throw couponCodeConflict();
+    }
+    return promotion;
+};
+const provisionAffiliateCouponPromotion = async (container, input) => {
+    const affiliateService = (0, resolve_services_1.resolveAffiliateService)(container);
+    const observed = await affiliateService.retrieveAffiliateCouponRecord(input.coupon_id);
+    const promotionService = container.resolve(utils_1.Modules.PROMOTION);
+    return await (0, affiliate_cart_operation_lock_1.withAffiliateOperationLocks)(container, observed.lifecycle_status === "revoked" && !observed.promotion_id
+        ? [
+            (0, affiliate_cart_operation_lock_1.affiliateProgramSagaLockKey)(),
+            (0, affiliate_cart_operation_lock_1.affiliateSagaLockKey)(observed.affiliate_id),
+        ]
+        : (0, exports.affiliateCouponProvisioningLockKeys)(observed.affiliate_id), async () => {
+        let coupon = await affiliateService.retrieveAffiliateCouponRecord(input.coupon_id, observed.affiliate_id);
+        const affiliate = await affiliateService.retrieveAffiliateRecord(coupon.affiliate_id);
+        if (coupon.lifecycle_status === "revoked" && !coupon.promotion_id) {
+            coupon = await affiliateService.setAffiliateCouponProvisioningState({
+                coupon_id: coupon.id,
+                provisioning_status: "ready",
+            });
+            return {
+                coupon,
+                outcome: "revoked_cleanup",
+                rotation_finalized: false,
+                revoked_coupon: null,
+            };
+        }
+        const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+        let promotionId = coupon.promotion_id;
+        let mayDeactivatePromotion = false;
+        // A ready coupon is redeemable, and every cart update that sees it in
+        // another state removes it from that cart. Until this run writes to its
+        // live promotion, a transient failure must therefore leave the coupon
+        // untouched; a detected inconsistency still fails closed.
+        let readyCouponUntouched = coupon.provisioning_status === "ready" &&
+            coupon.promotion_id !== null &&
+            !coupon.promotion_setup_error;
+        try {
+            const campaign = await ensureAffiliateCampaign(container, promotionService);
+            let promotion = await loadPromotionByExactCode(promotionService, coupon, campaign);
+            let outcome = "unchanged";
+            if (coupon.promotion_id) {
+                if (!promotion || promotion.id !== coupon.promotion_id) {
+                    throw couponCodeConflict();
+                }
+                mayDeactivatePromotion = true;
+            }
+            else if (promotion) {
+                const binding = await affiliateService.findAffiliateCouponByPromotionId(promotion.id);
+                if (binding && binding.id !== coupon.id) {
+                    throw couponCodeConflict();
+                }
+                promotionId = promotion.id;
+                mayDeactivatePromotion = true;
+                outcome = "adopted";
+            }
+            else {
+                // The exact-code lookup above cannot see a native promotion whose
+                // code differs only in case (Medusa's unique index is case
+                // sensitive); such a promotion is the same code for a customer.
+                const caseConflicts = await (0, promotion_code_availability_1.findPromotionsWithCodeIgnoringCase)(promotionService, coupon.code);
+                if (caseConflicts.length) {
+                    throw couponCodeConflict();
+                }
+                const created = await (0, core_flows_1.createPromotionsWorkflow)(container).run({
+                    input: {
+                        promotionsData: [
+                            {
+                                code: coupon.code,
+                                type: "standard",
+                                status: "inactive",
+                                is_automatic: false,
+                                campaign_id: campaign.id,
+                                application_method: {
+                                    type: "percentage",
+                                    target_type: "items",
+                                    allocation: "across",
+                                    value: affiliate.customer_discount_rate_override ??
+                                        (await affiliateService.retrieveProgramSettings())
+                                            .default_customer_discount_rate,
+                                    target_rules: promotion_eligibility_1.affiliateEligibleItemTargetRules,
+                                },
+                            },
+                        ],
+                    },
+                });
+                promotionId = created.result[0]?.id ?? null;
+                if (!promotionId) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "The Affiliate coupon promotion workflow returned no promotion.");
+                }
+                mayDeactivatePromotion = true;
+                outcome = "created";
+                promotion = await loadPromotionByExactCode(promotionService, coupon, campaign);
+                if (!promotion || promotion.id !== promotionId) {
+                    throw couponCodeConflict();
+                }
+            }
+            if (!promotion || !promotionId) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "The Affiliate coupon promotion could not be resolved.");
+            }
+            const wasReady = readyCouponUntouched;
+            const settings = await affiliateService.retrieveProgramSettings();
+            const discountRate = affiliate.customer_discount_rate_override ??
+                settings.default_customer_discount_rate;
+            const eligibleVariantIds = input.eligible_variant_ids ??
+                (await (0, promotion_eligibility_1.listAffiliateEligibleVariantIds)(query));
+            const wasCurrent = (0, exports.isCurrentAffiliateCouponPromotion)({
+                promotion,
+                coupon,
+                affiliate,
+                campaign,
+                discount_rate: discountRate,
+                eligible_variant_ids: eligibleVariantIds,
+            });
+            if (wasReady && wasCurrent) {
+                return {
+                    coupon,
+                    outcome: coupon.lifecycle_status === "revoked"
+                        ? "revoked_cleanup"
+                        : outcome,
+                    rotation_finalized: false,
+                    revoked_coupon: null,
+                };
+            }
+            // Only a coupon that is not redeemable yet (new, adopted, pending,
+            // failed or being rotated) goes through "pending". A ready coupon is
+            // updated in place and stays ready.
+            if (!wasReady) {
+                coupon = await affiliateService.setAffiliateCouponProvisioningState({
+                    coupon_id: coupon.id,
+                    promotion_id: promotionId,
+                    provisioning_status: "pending",
+                });
+            }
+            if (!wasCurrent) {
+                readyCouponUntouched = false;
+                await (0, core_flows_1.updatePromotionsWorkflow)(container).run({
+                    input: {
+                        promotionsData: [
+                            {
+                                id: promotionId,
+                                type: "standard",
+                                is_automatic: false,
+                                status: coupon.lifecycle_status === "enabled" &&
+                                    affiliate.status === "active"
+                                    ? "active"
+                                    : "inactive",
+                                application_method: {
+                                    type: "percentage",
+                                    target_type: "items",
+                                    allocation: "across",
+                                    value: discountRate,
+                                },
+                            },
+                        ],
+                    },
+                });
+                if (promotion.rules?.length) {
+                    await promotionService.removePromotionRules(promotionId, promotion.rules.map(({ id }) => id));
+                }
+                await (0, promotion_eligibility_1.ensureAffiliateEligibleItemTargetRules)(promotionService, query, promotionId, eligibleVariantIds);
+                if (outcome === "unchanged") {
+                    outcome = "repaired";
+                }
+            }
+            const currentPromotion = await loadPromotionByExactCode(promotionService, coupon, campaign);
+            if (!currentPromotion ||
+                currentPromotion.id !== promotionId ||
+                !(0, exports.isCurrentAffiliateCouponPromotion)({
+                    promotion: currentPromotion,
+                    coupon,
+                    affiliate,
+                    campaign,
+                    discount_rate: discountRate,
+                    eligible_variant_ids: eligibleVariantIds,
+                })) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, "The Affiliate coupon promotion remained inconsistent after reconciliation.");
+            }
+            if (coupon.lifecycle_status === "enabled" &&
+                coupon.replaces_coupon_id &&
+                coupon.provisioning_status !== "ready") {
+                const finalized = await affiliateService.finalizeAffiliateCouponRotation({
+                    affiliate_id: coupon.affiliate_id,
+                    predecessor_coupon_id: coupon.replaces_coupon_id,
+                    successor_coupon_id: coupon.id,
+                    promotion_id: promotionId,
+                    revoked_by_type: coupon.created_by_type,
+                    revoked_by_id: coupon.created_by_id,
+                });
+                return {
+                    coupon: finalized.coupon,
+                    outcome,
+                    rotation_finalized: true,
+                    revoked_coupon: finalized.revoked_coupon,
+                };
+            }
+            if (!wasReady) {
+                coupon = await affiliateService.setAffiliateCouponProvisioningState({
+                    coupon_id: coupon.id,
+                    promotion_id: promotionId,
+                    provisioning_status: "ready",
+                });
+            }
+            return {
+                coupon,
+                outcome: coupon.lifecycle_status === "revoked" ? "revoked_cleanup" : outcome,
+                rotation_finalized: false,
+                revoked_coupon: null,
+            };
+        }
+        catch (error) {
+            if (readyCouponUntouched && !isDetectedInconsistency(error)) {
+                throw error;
+            }
+            return await persistProvisioningFailure(container, coupon.id, error, promotionId, mayDeactivatePromotion);
+        }
+    });
+};
+exports.provisionAffiliateCouponPromotion = provisionAffiliateCouponPromotion;
+const ensureAffiliateCouponPromotionStep = (0, workflows_sdk_1.createStep)("ensure-affiliate-coupon-promotion", async (input, { container }) => new workflows_sdk_1.StepResponse(await (0, exports.provisionAffiliateCouponPromotion)(container, input)));
+exports.ensureAffiliateCouponPromotionWorkflow = (0, workflows_sdk_1.createWorkflow)("ensure-affiliate-coupon-promotion", (input) => new workflows_sdk_1.WorkflowResponse(ensureAffiliateCouponPromotionStep(input)));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ensure-affiliate-coupon-promotion.js","sourceRoot":"","sources":["../../../../../src/workflows/affiliate/ensure-affiliate-coupon-promotion.ts"],"names":[],"mappings":"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"}