@hartl-services/medusa-affiliate 0.3.0

package/.medusa/server/src/workflows/affiliate/promotion-eligibility.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefiniteAffiliatePromotionRejection = exports.affiliatePromotionVariantAllowlist = exports.affiliateEligibleItemTargetRules = exports.affiliateEligibleVariantRuleValues = exports.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER = void 0;
+exports.assertAuthenticAffiliateCouponPromotion = assertAuthenticAffiliateCouponPromotion;
+exports.listAffiliateEligibleVariantIds = listAffiliateEligibleVariantIds;
+exports.ensureAffiliateEligibleItemTargetRules = ensureAffiliateEligibleItemTargetRules;
+const utils_1 = require("@medusajs/framework/utils");
+exports.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER = "affiliate-customer-codes";
+const NO_ELIGIBLE_VARIANT_ID = "variant_affiliate_no_eligible_physical_product";
+const affiliateEligibleVariantRuleValues = (eligibleVariantIds) => eligibleVariantIds.length
+    ? [...new Set(eligibleVariantIds)].sort()
+    : [NO_ELIGIBLE_VARIANT_ID];
+exports.affiliateEligibleVariantRuleValues = affiliateEligibleVariantRuleValues;
+exports.affiliateEligibleItemTargetRules = [
+    {
+        attribute: "items.variant.id",
+        operator: "eq",
+        values: NO_ELIGIBLE_VARIANT_ID,
+    },
+];
+const isVariantAllowlistRule = (rule) => rule.attribute === "items.variant.id" &&
+    rule.operator === "eq" &&
+    (rule.values ?? []).some(({ value }) => Boolean(value));
+/**
+ * The variant ids a promotion's target rules actually let through. Medusa
+ * requires every target rule to match, so while an allowlist is being
+ * replaced (new rule added before the old one is removed) the effective list
+ * is the intersection - never wider than either list.
+ */
+const affiliatePromotionVariantAllowlist = (targetRules) => {
+    const [first, ...rest] = (targetRules ?? []).map((rule) => new Set((rule.values ?? [])
+        .map(({ value }) => value)
+        .filter((value) => Boolean(value))));
+    if (!first) {
+        return new Set();
+    }
+    return new Set([...first].filter((value) => rest.every((values) => values.has(value))));
+};
+exports.affiliatePromotionVariantAllowlist = affiliatePromotionVariantAllowlist;
+/**
+ * True only for the definite outcomes of `assertAuthenticAffiliateCouponPromotion`
+ * (rejected, or the promotion no longer exists). Anything else, such as a
+ * database error, may be transient and must not be treated as invalidity.
+ */
+const isDefiniteAffiliatePromotionRejection = (error) => utils_1.MedusaError.isMedusaError(error) &&
+    (error.type === utils_1.MedusaError.Types.NOT_ALLOWED ||
+        error.type === utils_1.MedusaError.Types.NOT_FOUND);
+exports.isDefiniteAffiliatePromotionRejection = isDefiniteAffiliatePromotionRejection;
+/**
+ * Cart and checkout gate for an Affiliate coupon promotion: it must be the
+ * plugin's own, active, correctly shaped promotion for this coupon. Whether its
+ * rate and variant allowlist are up to date is deliberately not checked here:
+ * after a rate or catalogue change every promotion lags until provisioning
+ * (admin actions, the product-eligibility subscriber and the periodic
+ * affiliate-promotion-freshness job) catches up, and failing carts in that
+ * window would strip customers of their coupon.
+ */
+async function assertAuthenticAffiliateCouponPromotion(promotionService, input) {
+    if (input.coupon.affiliate_id !== input.affiliate.id ||
+        input.coupon.lifecycle_status !== "enabled" ||
+        input.coupon.provisioning_status !== "ready" ||
+        !input.coupon.promotion_id ||
+        input.affiliate.status !== "active") {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "The Affiliate coupon is inactive or not prepared.");
+    }
+    const promotion = await promotionService.retrievePromotion(input.coupon.promotion_id, {
+        relations: [
+            "campaign",
+            "rules",
+            "application_method",
+            "application_method.target_rules",
+            "application_method.target_rules.values",
+        ],
+    });
+    const campaign = promotion.campaign_id
+        ? await promotionService.retrieveCampaign(promotion.campaign_id, {
+            relations: ["budget"],
+        })
+        : null;
+    const campaignBudget = campaign?.budget;
+    const targetRules = promotion.application_method?.target_rules ?? [];
+    const rate = Number(promotion.application_method?.value);
+    const valid = promotion.id === input.coupon.promotion_id &&
+        promotion.code === input.coupon.code &&
+        promotion.type === "standard" &&
+        promotion.status === "active" &&
+        promotion.is_automatic === false &&
+        campaign !== null &&
+        promotion.campaign_id === campaign?.id &&
+        promotion.campaign?.id === campaign.id &&
+        campaign.campaign_identifier ===
+            exports.AFFILIATE_CUSTOMER_CAMPAIGN_IDENTIFIER &&
+        campaignBudget?.type === "use_by_attribute" &&
+        campaignBudget.attribute === "customer_email" &&
+        Number(campaignBudget.limit) === 1 &&
+        (promotion.rules?.length ?? 0) === 0 &&
+        promotion.application_method?.type === "percentage" &&
+        promotion.application_method.target_type === "items" &&
+        promotion.application_method.allocation === "across" &&
+        Number.isFinite(rate) &&
+        rate > 0 &&
+        rate <= 100 &&
+        targetRules.length > 0 &&
+        targetRules.every(isVariantAllowlistRule);
+    if (!valid) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "The Affiliate coupon promotion is inactive or no longer belongs to this coupon.");
+    }
+    return promotion;
+}
+async function listAffiliateEligibleVariantIds(query) {
+    const eligibleVariantIds = [];
+    const pageSize = 200;
+    let skip = 0;
+    while (true) {
+        const { data } = await query.graph({
+            entity: "product",
+            fields: [
+                "id",
+                "is_giftcard",
+                "metadata",
+                "variants.id",
+                "variants.inventory_items.inventory.requires_shipping",
+            ],
+            pagination: { skip, take: pageSize },
+        });
+        const products = data;
+        for (const product of products) {
+            if (product.is_giftcard ||
+                product.metadata?.affiliate_commission_excluded === true) {
+                continue;
+            }
+            for (const variant of product.variants ?? []) {
+                const requiresShipping = variant.inventory_items?.some((item) => item.inventory?.requires_shipping === true);
+                if (requiresShipping) {
+                    eligibleVariantIds.push(variant.id);
+                }
+            }
+        }
+        if (products.length < pageSize) {
+            break;
+        }
+        skip += pageSize;
+    }
+    return [...new Set(eligibleVariantIds)].sort();
+}
+async function ensureAffiliateEligibleItemTargetRules(promotionService, query, promotionId, prefetchedEligibleVariantIds) {
+    const eligibleVariantIds = prefetchedEligibleVariantIds ??
+        (await listAffiliateEligibleVariantIds(query));
+    const desiredValues = (0, exports.affiliateEligibleVariantRuleValues)(eligibleVariantIds);
+    const promotion = await promotionService.retrievePromotion(promotionId, {
+        relations: [
+            "application_method",
+            "application_method.target_rules",
+            "application_method.target_rules.values",
+        ],
+    });
+    const existingRules = promotion.application_method?.target_rules ?? [];
+    const currentRule = existingRules.find((rule) => rule.attribute === "items.variant.id" &&
+        rule.operator === "eq");
+    const currentValues = (currentRule?.values ?? [])
+        .map((value) => value.value)
+        .sort();
+    const alreadyCurrent = currentValues.length === desiredValues.length &&
+        currentValues.every((value, index) => value === desiredValues[index]);
+    if (alreadyCurrent && existingRules.length === 1) {
+        return;
+    }
+    await promotionService.addPromotionTargetRules(promotionId, [
+        {
+            attribute: "items.variant.id",
+            operator: "eq",
+            values: desiredValues,
+        },
+    ]);
+    if (existingRules.length) {
+        await promotionService.removePromotionTargetRules(promotionId, existingRules.map((rule) => rule.id));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/affiliate/reconcile-affiliate-cart-referral.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcileAffiliateCartReferralWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_1 = require("@medusajs/framework/utils");
+const resolve_services_1 = require("../../utils/resolve-services");
+const cart_promotions_1 = require("../../utils/cart-promotions");
+const affiliate_cart_operation_lock_1 = require("../../utils/affiliate-cart-operation-lock");
+const affiliate_coupon_cart_1 = require("./affiliate-coupon-cart");
+const apply_affiliate_coupon_1 = require("./apply-affiliate-coupon");
+const payment_authorization_1 = require("./payment-authorization");
+const promotion_eligibility_1 = require("./promotion-eligibility");
+const emptyCompensation = (cartId) => ({
+    cart_id: cartId,
+    created_referral_ids: [],
+    previous_referrals: []
+});
+const restoreReconciliation = async (container, compensation) => {
+    const affiliateService = (0, resolve_services_1.resolveAffiliateService)(container);
+    const restored = await affiliateService.compensateAffiliateCouponReferralMutation(compensation.referral, container.resolve(utils_1.ContainerRegistrationKeys.QUERY));
+    let target = null;
+    try {
+        target = await (0, apply_affiliate_coupon_1.resolveAppliedAffiliateCouponForCart)(container, compensation.cart_id, new Set(restored.restorable_affiliate_coupon_ids));
+    }
+    catch {
+        target = null;
+    }
+    const settings = await affiliateService.retrieveProgramSettings();
+    await (0, affiliate_coupon_cart_1.syncAffiliateCouponCartPromotion)({
+        container,
+        affiliate_service: affiliateService,
+        cart_id: compensation.cart_id,
+        target_coupon: target,
+        promotion_stacking: settings.promotion_stacking,
+        base_promotions: compensation.previous_promotions,
+        force_replace: true
+    });
+};
+const reconcileAffiliateCartReferralStep = (0, workflows_sdk_1.createStep)("reconcile-affiliate-cart-referral", async (input, { container }) => {
+    const affiliateService = (0, resolve_services_1.resolveAffiliateService)(container);
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const { data } = await query.graph({
+        entity: "cart",
+        fields: [
+            "id",
+            "email",
+            "customer_id",
+            "promotions.id",
+            "promotions.code",
+            "payment_collection.status",
+            "payment_collection.payment_sessions.status"
+        ],
+        filters: { id: input.cart_id }
+    });
+    const cart = data[0];
+    if (!cart) {
+        return new workflows_sdk_1.StepResponse({ reconciled: false }, {
+            cart_id: input.cart_id,
+            previous_promotions: [],
+            referral: emptyCompensation(input.cart_id)
+        });
+    }
+    if ((0, payment_authorization_1.hasPaymentAuthorizationStarted)(cart.payment_collection)) {
+        return new workflows_sdk_1.StepResponse({ reconciled: false }, {
+            cart_id: cart.id,
+            previous_promotions: (0, cart_promotions_1.readCartPromotions)(cart.promotions),
+            referral: emptyCompensation(cart.id)
+        });
+    }
+    const previousPromotions = (0, cart_promotions_1.readCartPromotions)(cart.promotions);
+    const bindings = await (0, affiliate_coupon_cart_1.loadAffiliateCouponCartBindings)(affiliateService, previousPromotions);
+    const [pendingReferrals, activeReferrals, expiredReferrals] = await Promise.all([
+        affiliateService.listAffiliateCartReferrals({
+            cart_id: cart.id,
+            source: "coupon",
+            status: "pending_email_validation"
+        }, { take: 1, order: { captured_at: "DESC" } }),
+        affiliateService.listAffiliateCartReferrals({ cart_id: cart.id, status: "active" }, { take: 1, order: { captured_at: "DESC" } }),
+        affiliateService.listAffiliateCartReferrals({
+            cart_id: cart.id,
+            status: "expired",
+            applied_promotion_id: { $ne: null }
+        }, { order: { captured_at: "DESC", id: "DESC" } })
+    ]);
+    const pending = pendingReferrals[0] ?? null;
+    const active = activeReferrals[0] ?? null;
+    let referralCompensation = emptyCompensation(cart.id);
+    const compensation = () => ({
+        cart_id: cart.id,
+        previous_promotions: previousPromotions,
+        referral: referralCompensation
+    });
+    const finish = async (reconciled) => {
+        const cleanup = expiredReferrals.flatMap((referral) => referral.applied_promotion_id
+            ? [
+                {
+                    referral_id: referral.id,
+                    applied_promotion_id: referral.applied_promotion_id
+                }
+            ]
+            : []);
+        if (cleanup.length) {
+            await affiliateService.completeExpiredCartReferralPromotionCleanup({
+                referrals: cleanup
+            });
+        }
+        return new workflows_sdk_1.StepResponse({ reconciled }, compensation());
+    };
+    const removeCouponState = async (reason) => {
+        referralCompensation =
+            await affiliateService.invalidateAffiliateCouponReferrals({ cart_id: cart.id, reason }, query);
+        const settings = await affiliateService.retrieveProgramSettings();
+        await (0, affiliate_coupon_cart_1.syncAffiliateCouponCartPromotion)({
+            container,
+            affiliate_service: affiliateService,
+            cart_id: cart.id,
+            target_coupon: null,
+            promotion_stacking: settings.promotion_stacking
+        });
+    };
+    try {
+        if (cart.customer_id &&
+            (await affiliateService.isCustomerAffiliate(cart.customer_id))) {
+            referralCompensation =
+                await affiliateService.invalidateAffiliateCartReferrals({ cart_id: cart.id, reason: "affiliate_customer" }, query);
+            const settings = await affiliateService.retrieveProgramSettings();
+            await (0, affiliate_coupon_cart_1.syncAffiliateCouponCartPromotion)({
+                container,
+                affiliate_service: affiliateService,
+                cart_id: cart.id,
+                target_coupon: null,
+                promotion_stacking: settings.promotion_stacking
+            });
+            return await finish(true);
+        }
+        if (bindings.length > 1 || bindings.some(({ exact }) => !exact)) {
+            await removeCouponState("multiple_or_mismatched_affiliate_promotions");
+            return await finish(true);
+        }
+        const candidateCouponId = pending?.source_affiliate_coupon_id ??
+            active?.applied_affiliate_coupon_id ??
+            (active?.source === "coupon"
+                ? active.source_affiliate_coupon_id
+                : null) ??
+            (active ? null : bindings[0]?.coupon.id) ??
+            null;
+        if (!candidateCouponId) {
+            if (bindings.length ||
+                active?.source === "coupon" ||
+                active?.applied_affiliate_coupon_id) {
+                await removeCouponState("affiliate_coupon_binding_missing");
+                return await finish(true);
+            }
+            return await finish(false);
+        }
+        const coupon = await affiliateService.retrieveAffiliateCouponRecord(candidateCouponId);
+        const affiliate = await affiliateService.retrieveAffiliateRecord(coupon.affiliate_id);
+        if (coupon.lifecycle_status !== "enabled" ||
+            coupon.provisioning_status !== "ready" ||
+            !coupon.promotion_id ||
+            affiliate.status !== "active") {
+            await removeCouponState("affiliate_coupon_inactive");
+            return await finish(true);
+        }
+        const settings = await affiliateService.retrieveProgramSettings();
+        try {
+            await (0, promotion_eligibility_1.assertAuthenticAffiliateCouponPromotion)(container.resolve(utils_1.Modules.PROMOTION), { coupon, affiliate });
+        }
+        catch (error) {
+            // Removing the coupon is permanent for this cart, so only a definite
+            // rejection may do it. A transient failure is rethrown and the event
+            // retried, leaving the customer's coupon in place.
+            if (!(0, promotion_eligibility_1.isDefiniteAffiliatePromotionRejection)(error)) {
+                throw error;
+            }
+            await removeCouponState("affiliate_coupon_promotion_invalid");
+            return await finish(true);
+        }
+        const result = await affiliateService.applyAffiliateCouponReferral({
+            cart_id: cart.id,
+            email: cart.email ?? null,
+            customer_id: cart.customer_id ?? null,
+            affiliate,
+            coupon
+        }, query);
+        referralCompensation = result.compensation;
+        const target = [
+            "pending_email_validation",
+            "coupon_already_redeemed",
+            "ignored_existing_assignment"
+        ].includes(result.status)
+            ? null
+            : await (0, apply_affiliate_coupon_1.resolveAppliedAffiliateCouponForCart)(container, cart.id);
+        await (0, affiliate_coupon_cart_1.syncAffiliateCouponCartPromotion)({
+            container,
+            affiliate_service: affiliateService,
+            cart_id: cart.id,
+            target_coupon: target,
+            promotion_stacking: settings.promotion_stacking
+        });
+        return await finish(true);
+    }
+    catch (error) {
+        await restoreReconciliation(container, compensation());
+        throw error;
+    }
+}, async (compensation, { container }) => {
+    if (compensation)
+        await restoreReconciliation(container, compensation);
+});
+const reconcileAffiliateCartReferralWorkflowInternal = (0, workflows_sdk_1.createWorkflow)("reconcile-affiliate-cart-referral", (input) => new workflows_sdk_1.WorkflowResponse(reconcileAffiliateCartReferralStep(input)));
+const reconcileAffiliateCartReferralWorkflow = (container) => {
+    const workflow = reconcileAffiliateCartReferralWorkflowInternal(container);
+    return {
+        run: async (options) => await (0, affiliate_cart_operation_lock_1.withAffiliateCartOperationLock)(container, options.input.cart_id, async () => await workflow.run(options))
+    };
+};
+exports.reconcileAffiliateCartReferralWorkflow = reconcileAffiliateCartReferralWorkflow;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reconcile-affiliate-cart-referral.js","sourceRoot":"","sources":["../../../../../src/workflows/affiliate/reconcile-affiliate-cart-referral.ts"],"names":[],"mappings":"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"}