@hartl-services/medusa-base 3.0.0 → 5.0.0

package/.medusa/server/src/workflows/free-shipping/sync-free-shipping-promotions.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncFreeShippingPromotions = exports.FREE_SHIPPING_PROMOTION_SYNC_LOCK_KEY = exports.AFFILIATE_FREE_SHIPPING_PROMOTION_CODE = exports.STANDARD_FREE_SHIPPING_PROMOTION_CODE = exports.AFFILIATE_QUALIFICATION_ATTRIBUTE = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const public_1 = require("../../public");
+const plugin_features_1 = require("../../free-shipping/plugin-features");
+const free_shipping_settings_1 = require("../../free-shipping/free-shipping-settings");
+/**
+ * Context attribute the `set-free-shipping-promotion-context` hook injects
+ * into every cart-promotion computation. Both promotions below key off it so
+ * a cart between the two thresholds can't get free shipping through the
+ * standard promotion just because it also satisfies `item_total >= X`.
+ */
+exports.AFFILIATE_QUALIFICATION_ATTRIBUTE = "qualifies_for_affiliate_shipping_threshold";
+exports.STANDARD_FREE_SHIPPING_PROMOTION_CODE = "AUTO-FREE-SHIPPING-STANDARD";
+exports.AFFILIATE_FREE_SHIPPING_PROMOTION_CODE = "AUTO-FREE-SHIPPING-AFFILIATE";
+/** Serializes every sync run (job and both subscribers) across processes. */
+exports.FREE_SHIPPING_PROMOTION_SYNC_LOCK_KEY = "free-shipping-promotion-sync";
+/** Seconds to wait for the lock; the in-memory provider also expires it then. */
+const SYNC_LOCK_TIMEOUT_SECONDS = 60;
+const buildRules = (threshold, qualifiesValue) => [
+    { attribute: "item_total", operator: "gte", values: [String(threshold)] },
+    {
+        attribute: exports.AFFILIATE_QUALIFICATION_ATTRIBUTE,
+        operator: "eq",
+        values: [qualifiesValue],
+    },
+];
+const ruleKey = (rule) => JSON.stringify([rule.attribute, rule.operator, [...rule.values].sort()]);
+const ensurePromotion = async (container, promotionService, code, status, threshold, qualifiesValue) => {
+    const rules = buildRules(threshold, qualifiesValue);
+    const existing = await promotionService.listPromotions({ code: [code] }, { relations: ["rules"] });
+    if (!existing[0]) {
+        try {
+            await (0, core_flows_1.createPromotionsWorkflow)(container).run({
+                input: {
+                    promotionsData: [
+                        {
+                            code,
+                            type: "standard",
+                            status,
+                            is_automatic: true,
+                            application_method: {
+                                type: "percentage",
+                                value: 100,
+                                target_type: "shipping_methods",
+                                allocation: "across",
+                            },
+                            rules,
+                        },
+                    ],
+                },
+            });
+            return;
+        }
+        catch (error) {
+            // Concurrent boot across server/worker processes can race on the
+            // unique promotion code. Whoever loses the race falls through to the
+            // update path below, which is idempotent either way.
+            const createdByAnotherProcess = await promotionService.listPromotions({ code: [code] }, { relations: ["rules"] });
+            if (!createdByAnotherProcess[0]) {
+                throw error;
+            }
+        }
+    }
+    const current = (await promotionService.listPromotions({ code: [code] }, { relations: ["application_method", "rules", "rules.values"] }))[0];
+    if (!current) {
+        return;
+    }
+    const desiredKeys = new Set(rules.map(ruleKey));
+    const currentRules = (current.rules ?? []).map((rule) => ({
+        id: rule.id,
+        key: ruleKey({
+            attribute: rule.attribute,
+            operator: rule.operator,
+            values: (rule.values ?? []).map(({ value }) => String(value)),
+        }),
+    }));
+    const currentKeys = new Set(currentRules.map(({ key }) => key));
+    const rulesToCreate = rules.filter((rule) => !currentKeys.has(ruleKey(rule)));
+    const ruleIdsToDelete = currentRules
+        .filter(({ key }) => !desiredKeys.has(key))
+        .map(({ id }) => id);
+    // Create before delete: meanwhile the old and new rules apply together,
+    // which can only narrow which carts qualify. Deleting first would briefly
+    // leave an automatic promotion without rules - free shipping for every cart.
+    if (rulesToCreate.length) {
+        await (0, core_flows_1.batchPromotionRulesWorkflow)(container).run({
+            input: { id: current.id, rule_type: utils_1.RuleType.RULES, create: rulesToCreate },
+        });
+    }
+    if (ruleIdsToDelete.length) {
+        await (0, core_flows_1.batchPromotionRulesWorkflow)(container).run({
+            input: {
+                id: current.id,
+                rule_type: utils_1.RuleType.RULES,
+                delete: ruleIdsToDelete,
+            },
+        });
+    }
+    if (current.status !== status ||
+        Number(current.application_method?.value) !== 100) {
+        await (0, core_flows_1.updatePromotionsWorkflow)(container).run({
+            input: {
+                promotionsData: [
+                    {
+                        id: current.id,
+                        status,
+                        application_method: { value: 100 },
+                    },
+                ],
+            },
+        });
+    }
+};
+/**
+ * Keeps the two automatic free-shipping promotions in sync with the plugin's
+ * settings (thresholds) and the base plugin toggle `free_shipping` (status:
+ * active while the plugin is on, inactive while it is off). Called by the
+ * `free-shipping-promotion-sync` job and by the `plugin-features-updated`
+ * and `plugin-settings-updated` subscribers.
+ *
+ * The whole run (toggle and settings read, both reconciliations) holds one
+ * Locking-module lock. Unlocked runs could interleave their rule diffs, e.g.
+ * one run deleting the threshold rule another run just created, and leave an
+ * automatic promotion without its `item_total` rule. Reading inside the lock
+ * also means the last run always writes the latest values. A read failure
+ * propagates; nothing is written then.
+ */
+const syncFreeShippingPromotions = async (container) => {
+    const locking = container.resolve(utils_1.Modules.LOCKING);
+    await locking.execute(exports.FREE_SHIPPING_PROMOTION_SYNC_LOCK_KEY, async () => {
+        const promotionService = container.resolve(utils_1.Modules.PROMOTION);
+        const enabled = await (0, public_1.isPluginFeatureEnabled)(container, plugin_features_1.freeShippingPluginFeatures);
+        const settings = await (0, free_shipping_settings_1.resolveFreeShippingSettings)(container);
+        const status = enabled ? "active" : "inactive";
+        await ensurePromotion(container, promotionService, exports.STANDARD_FREE_SHIPPING_PROMOTION_CODE, status, settings.default_threshold, "false");
+        await ensurePromotion(container, promotionService, exports.AFFILIATE_FREE_SHIPPING_PROMOTION_CODE, status, settings.affiliate_threshold, "true");
+    }, { timeout: SYNC_LOCK_TIMEOUT_SECONDS });
+};
+exports.syncFreeShippingPromotions = syncFreeShippingPromotions;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/hooks/set-free-shipping-promotion-context.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFreeShippingPromotionContext = 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 lib_1 = require("../../shared/lib");
+const plugin_features_1 = require("../../free-shipping/plugin-features");
+const free_shipping_settings_1 = require("../../free-shipping/free-shipping-settings");
+const sync_free_shipping_promotions_1 = require("../free-shipping/sync-free-shipping-promotions");
+const declaredBooleanDefault = (key) => plugin_features_1.freeShippingPluginFeatures.settings?.find((setting) => setting.key === key)
+    ?.default === true;
+/** The descriptor's defaults: account holders on, referred customers off. */
+const DECLARED_DEFAULT_AFFILIATE_RULES = {
+    affiliate_applies_to_account_holders: declaredBooleanDefault("affiliate_applies_to_account_holders"),
+    affiliate_applies_to_referred_customers: declaredBooleanDefault("affiliate_applies_to_referred_customers"),
+};
+/** Last successfully read rules of this process (null until the first read). */
+let lastKnownAffiliateRules = null;
+/**
+ * This hook runs in every cart-promotion computation, so a failing settings
+ * read must not fail the cart. It is reported (`logger.error`, which the base
+ * plugin's logger wrapper forwards to Sentry) and the cart is computed with
+ * the last rules this process read successfully, or with the declared
+ * defaults when there are none yet. That keeps affiliate carts on the
+ * affiliate threshold instead of silently moving them to the standard one.
+ */
+const readAffiliateRules = async (container, cartId) => {
+    try {
+        const settings = await (0, free_shipping_settings_1.resolveFreeShippingSettings)(container);
+        lastKnownAffiliateRules = {
+            affiliate_applies_to_account_holders: settings.affiliate_applies_to_account_holders,
+            affiliate_applies_to_referred_customers: settings.affiliate_applies_to_referred_customers,
+        };
+        return settings;
+    }
+    catch (error) {
+        const fallback = lastKnownAffiliateRules;
+        try {
+            container
+                .resolve(utils_1.ContainerRegistrationKeys.LOGGER)
+                .error(`Free-shipping settings could not be read for cart ${cartId}; computing the promotion context with the ${fallback ? "last known" : "default"} affiliate rules.`, error instanceof Error ? error : new Error(String(error)));
+        }
+        catch {
+            // A missing logger must not turn the fail-safe itself into a failure.
+        }
+        return fallback ?? DECLARED_DEFAULT_AFFILIATE_RULES;
+    }
+};
+/**
+ * Computes whether the cart qualifies for the affiliate free-shipping
+ * threshold, so the two automatic promotions (whose rules are static, see
+ * `sync-free-shipping-promotions.ts`) can tell them apart at evaluation
+ * time. Which criteria count as "affiliate" is controlled entirely by the
+ * two boolean settings - no promotion resync is needed when they change,
+ * only this computation.
+ */
+const setFreeShippingPromotionContext = async ({ cart }, { container }) => {
+    const typedCart = cart;
+    let qualifies = false;
+    if (typedCart.customer_id) {
+        // The Affiliate plugin is optional: without it no cart qualifies.
+        const affiliateService = (0, lib_1.tryResolveOptional)(container, "affiliate");
+        if (affiliateService) {
+            const settings = await readAffiliateRules(container, typedCart.id);
+            if (settings.affiliate_applies_to_account_holders) {
+                qualifies = await affiliateService.isCustomerAffiliate(typedCart.customer_id);
+            }
+            if (!qualifies && settings.affiliate_applies_to_referred_customers) {
+                const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+                const state = await affiliateService.inspectAffiliateCartReferralForCheckout({
+                    cart_id: typedCart.id,
+                    customer_id: typedCart.customer_id,
+                    normalized_email: (0, lib_1.normalizeEmail)(typedCart.email),
+                }, query);
+                qualifies = state.assignment !== null;
+            }
+        }
+    }
+    return new workflows_sdk_1.StepResponse({
+        [sync_free_shipping_promotions_1.AFFILIATE_QUALIFICATION_ATTRIBUTE]: qualifies ? "true" : "false",
+    });
+};
+exports.setFreeShippingPromotionContext = setFreeShippingPromotionContext;
+core_flows_1.updateCartPromotionsWorkflow.hooks.setPromotionContext(exports.setFreeShippingPromotionContext);
+//# sourceMappingURL=data:application/json;base64,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