@devx-commerce/plugin-discounts-svaraa 0.0.1-beta.2

package/.medusa/server/src/modules/discounts/service.js

@@ -0,0 +1,98 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const discount_code_1 = __importDefault(require("./models/discount-code"));
+const freebie_rule_1 = __importDefault(require("./models/freebie-rule"));
+const price_rule_1 = __importDefault(require("./models/price-rule"));
+class DiscountService extends (0, utils_1.MedusaService)({
+    DiscountPriceRule: price_rule_1.default,
+    DiscountCode: discount_code_1.default,
+    FreebieRule: freebie_rule_1.default,
+}) {
+    /**
+     * Increments the code_count field of a price rule by the specified count
+     * @param priceRuleId - The ID of the price rule to update
+     * @param count - The number to increment the code_count by
+     */
+    async incrementCodeCount(priceRuleId, count, context = {}) {
+        if (!context?.manager) {
+            throw new Error("Transaction manager is required");
+        }
+        const em = context.manager;
+        // Use raw SQL to increment the code_count field
+        await em.getConnection().execute(`
+      UPDATE discount_price_rule
+      SET code_count = code_count + ?
+      WHERE id = ?
+      `, [count, priceRuleId]);
+    }
+    // @ts-ignore
+    async listDiscountPriceRules(filters, config, sharedContext) {
+        delete filters.context;
+        const priceRules = await super.listDiscountPriceRules(filters, config, sharedContext);
+        return await Promise.all(priceRules.map(async (priceRule) => {
+            if (priceRule.prefix)
+                return priceRule;
+            const [{ code }] = await this.listDiscountCodes({
+                price_rule_id: priceRule.id,
+            });
+            return {
+                ...priceRule,
+                discount_code: code,
+            };
+        }));
+    }
+    // @ts-ignore
+    async listAndCountDiscountPriceRules(filters, config, sharedContext) {
+        delete filters.context;
+        const [priceRules, metadata] = await super.listAndCountDiscountPriceRules(filters, config, sharedContext);
+        const updatedPriceRules = await Promise.all(priceRules.map(async (priceRule) => {
+            if (priceRule.prefix)
+                return priceRule;
+            const [{ code }] = await this.listDiscountCodes({
+                price_rule_id: priceRule.id,
+            });
+            return {
+                ...priceRule,
+                discount_code: code,
+            };
+        }));
+        return [updatedPriceRules, metadata];
+    }
+}
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number, Object]),
+    __metadata("design:returntype", Promise)
+], DiscountService.prototype, "incrementCodeCount", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], DiscountService.prototype, "listDiscountPriceRules", null);
+__decorate([
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], DiscountService.prototype, "listAndCountDiscountPriceRules", null);
+exports.default = DiscountService;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/discount/add-more-code-in-price-rule/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMoreCodesToPriceRuleWorkflow = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const throw_error_step_1 = require("../../steps/throw-error-step");
+const add_bulk_codes_to_rule_1 = require("../create-bulk-discount/steps/add-bulk-codes-to-rule");
+exports.addMoreCodesToPriceRuleWorkflow = (0, workflows_sdk_1.createWorkflow)("add-more-codes-to-price-rule", (input) => {
+    const validate = (0, workflows_sdk_1.createHook)("validate", { input });
+    const { data: priceRules } = (0, core_flows_1.useQueryGraphStep)({
+        entity: "discount_price_rule",
+        fields: ["prefix", "id"],
+        filters: { id: input.price_rule_id },
+        options: { throwIfKeyNotFound: true },
+    });
+    (0, workflows_sdk_1.when)("throw-error-if-prefix-rule-does-not-exists", priceRules, (priceRules) => !(0, utils_1.isDefined)(priceRules?.[0]?.prefix)).then(() => {
+        (0, throw_error_step_1.throwErrorStep)({
+            errorMessage: priceRules[0].id,
+        });
+    });
+    (0, add_bulk_codes_to_rule_1.addBulkCodesToRuleStep)({
+        priceRuleId: priceRules[0].id,
+        codeCountToAdd: input.count,
+    });
+    return new workflows_sdk_1.WorkflowResponse({ message: "Codes addition to price rule started" }, { hooks: [validate] });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL2Rpc2NvdW50L2FkZC1tb3JlLWNvZGUtaW4tcHJpY2UtcnVsZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxxREFBc0Q7QUFDdEQscUVBSzJDO0FBQzNDLDREQUFnRTtBQUdoRSxtRUFBOEQ7QUFDOUQsaUdBQThGO0FBRWpGLFFBQUEsK0JBQStCLEdBQUcsSUFBQSw4QkFBYyxFQUMzRCw4QkFBOEIsRUFDOUIsQ0FDRSxLQUVDLEVBQ0QsRUFBRTtJQUNGLE1BQU0sUUFBUSxHQUFHLElBQUEsMEJBQVUsRUFBQyxVQUFVLEVBQUUsRUFBRSxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBRW5ELE1BQU0sRUFBRSxJQUFJLEVBQUUsVUFBVSxFQUFFLEdBQUcsSUFBQSw4QkFBaUIsRUFBQztRQUM3QyxNQUFNLEVBQUUscUJBQXFCO1FBQzdCLE1BQU0sRUFBRSxDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUM7UUFDeEIsT0FBTyxFQUFFLEVBQUUsRUFBRSxFQUFFLEtBQUssQ0FBQyxhQUFhLEVBQUU7UUFDcEMsT0FBTyxFQUFFLEVBQUUsa0JBQWtCLEVBQUUsSUFBSSxFQUFFO0tBQ3RDLENBQUMsQ0FBQztJQUVILElBQUEsb0JBQUksRUFDRiw0Q0FBNEMsRUFDNUMsVUFBVSxFQUNWLENBQUMsVUFBVSxFQUFFLEVBQUUsQ0FBQyxDQUFDLElBQUEsaUJBQVMsRUFBQyxVQUFVLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxNQUFNLENBQUMsQ0FDcEQsQ0FBQyxJQUFJLENBQUMsR0FBRyxFQUFFO1FBQ1YsSUFBQSxpQ0FBYyxFQUFDO1lBQ2IsWUFBWSxFQUFFLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFO1NBQy9CLENBQUMsQ0FBQztJQUNMLENBQUMsQ0FBQyxDQUFDO0lBRUgsSUFBQSwrQ0FBc0IsRUFBQztRQUNyQixXQUFXLEVBQUUsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUU7UUFDN0IsY0FBYyxFQUFFLEtBQUssQ0FBQyxLQUFLO0tBQzVCLENBQUMsQ0FBQztJQUVILE9BQU8sSUFBSSxnQ0FBZ0IsQ0FDekIsRUFBRSxPQUFPLEVBQUUsc0NBQXNDLEVBQUUsRUFDbkQsRUFBRSxLQUFLLEVBQUUsQ0FBQyxRQUFRLENBQVUsRUFBRSxDQUMvQixDQUFDO0FBQ0osQ0FBQyxDQUNGLENBQUMifQ==

package/.medusa/server/src/workflows/discount/apply-coupon/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCouponWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const calculate_coupon_discount_1 = require("../calculate-coupon-discount");
+const remove_coupon_step_1 = require("../remove-coupon/step/remove-coupon-step");
+const generate_adjustment_line_item_1 = __importDefault(require("./steps/generate-adjustment-line-item"));
+exports.applyCouponWorkflow = (0, workflows_sdk_1.createWorkflow)("apply-coupon", (input) => {
+    const response = calculate_coupon_discount_1.calculateCouponDiscountWorkflow.runAsStep({
+        input: {
+            code: input.code,
+            cart_id: input.cart_id,
+            customerId: input.customerId,
+        },
+    });
+    const { data: carts } = (0, core_flows_1.useQueryGraphStep)({
+        entity: "cart",
+        fields: [
+            "*",
+            "items.*",
+            "items.variant.*",
+            "items.variant.prices.*",
+            "items.variant.extended_product_variants.compare_at_price",
+        ],
+        filters: { id: input.cart_id },
+        options: { throwIfKeyNotFound: true },
+    }).config({ name: "get-cart" });
+    const cart = (0, workflows_sdk_1.transform)({ carts }, ({ carts }) => carts[0]);
+    (0, remove_coupon_step_1.removeCouponStep)({ cart });
+    (0, generate_adjustment_line_item_1.default)(response.adjustmentLineItems);
+    return new workflows_sdk_1.WorkflowResponse({
+        discount: response.discount,
+        isApplied: response.isApplied,
+        message: response.message,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL2Rpc2NvdW50L2FwcGx5LWNvdXBvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxxRUFJMkM7QUFDM0MsNERBQWdFO0FBR2hFLDRFQUErRTtBQUMvRSxpRkFBNEU7QUFDNUUsMEdBQStFO0FBRWxFLFFBQUEsbUJBQW1CLEdBQUcsSUFBQSw4QkFBYyxFQUMvQyxjQUFjLEVBQ2QsQ0FBQyxLQUE2QixFQUFFLEVBQUU7SUFDaEMsTUFBTSxRQUFRLEdBQUcsMkRBQStCLENBQUMsU0FBUyxDQUFDO1FBQ3pELEtBQUssRUFBRTtZQUNMLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtZQUNoQixPQUFPLEVBQUUsS0FBSyxDQUFDLE9BQU87WUFDdEIsVUFBVSxFQUFFLEtBQUssQ0FBQyxVQUFVO1NBQzdCO0tBQ0YsQ0FBQyxDQUFDO0lBRUgsTUFBTSxFQUFFLElBQUksRUFBRSxLQUFLLEVBQUUsR0FBRyxJQUFBLDhCQUFpQixFQUFDO1FBQ3hDLE1BQU0sRUFBRSxNQUFNO1FBQ2QsTUFBTSxFQUFFO1lBQ04sR0FBRztZQUNILFNBQVM7WUFDVCxpQkFBaUI7WUFDakIsd0JBQXdCO1lBQ3hCLDBEQUEwRDtTQUMzRDtRQUNELE9BQU8sRUFBRSxFQUFFLEVBQUUsRUFBRSxLQUFLLENBQUMsT0FBTyxFQUFFO1FBQzlCLE9BQU8sRUFBRSxFQUFFLGtCQUFrQixFQUFFLElBQUksRUFBRTtLQUN0QyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsSUFBSSxFQUFFLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFFaEMsTUFBTSxJQUFJLEdBQUcsSUFBQSx5QkFBUyxFQUFDLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztJQUUzRCxJQUFBLHFDQUFnQixFQUFDLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQztJQUUzQixJQUFBLHVDQUEwQixFQUFDLFFBQVEsQ0FBQyxtQkFBbUIsQ0FBQyxDQUFDO0lBRXpELE9BQU8sSUFBSSxnQ0FBZ0IsQ0FBQztRQUMxQixRQUFRLEVBQUUsUUFBUSxDQUFDLFFBQVE7UUFDM0IsU0FBUyxFQUFFLFFBQVEsQ0FBQyxTQUFTO1FBQzdCLE9BQU8sRUFBRSxRQUFRLENBQUMsT0FBTztLQUMxQixDQUFDLENBQUM7QUFDTCxDQUFDLENBQ0YsQ0FBQyJ9

package/.medusa/server/src/workflows/discount/apply-coupon/steps/apply-coupon-step-backup.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyCouponStep = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const validators_1 = require("../../../../api/admin/discounts/validators");
+exports.applyCouponStep = (0, workflows_sdk_1.createStep)("apply-coupon", async ({ priceRule, code, cart }, { container }) => {
+    const logger = container.resolve("logger");
+    logger.setLogLevel(process.env.LOG_LEVEL);
+    const { product_variants, product_categories } = priceRule;
+    let applicableCartLineItems = [...cart.items];
+    if (product_variants?.length) {
+        applicableCartLineItems = applicableCartLineItems.filter((item) => product_variants?.some((v) => v.id === item.variant_id));
+    }
+    if (product_categories?.length) {
+        applicableCartLineItems = applicableCartLineItems.filter((item) => product_categories?.some((v) => v.products?.some((p) => p.id === item.product_id)));
+    }
+    if (!priceRule.applicable_on_bundle) {
+        applicableCartLineItems = applicableCartLineItems.filter((item) => !item.metadata?.bundle_type);
+    }
+    const totalApplicableProductsQty = applicableCartLineItems.reduce((acc, item) => {
+        return acc + Number(item.quantity || 0);
+    }, 0);
+    let number_of_time_coupon_should_apply = Math.min(totalApplicableProductsQty, priceRule.usage_limit_per_cart_type ==
+        validators_1.DiscountUsageLimitPerCartType.Values.ONLY_ONCE
+        ? 1
+        : priceRule.usage_limit_per_cart_specific || Infinity);
+    const isMrp = priceRule.applies_on == validators_1.DiscountAppliesOn.Values.MRP;
+    const cartMrpTotal = applicableCartLineItems?.reduce((acc, item) => {
+        let variantListingPrice = item?.variant?.extended_product_variants?.compare_at_price;
+        const isBundle = !!item.metadata?.bundle_type;
+        return (acc +
+            Number(isBundle ? item.compare_at_unit_price : variantListingPrice) *
+                Number(item.quantity || 1));
+    }, 0);
+    const cartPriceTotal = applicableCartLineItems?.reduce((acc, item) => {
+        return acc + Number(item.unit_price) * Number(item.quantity || 1);
+    }, 0);
+    const cartTotal = isMrp ? cartMrpTotal : cartPriceTotal;
+    let totalDiscount = 0;
+    const cartService = container.resolve("cart");
+    switch (priceRule.type) {
+        case validators_1.DiscountType.Values.FIXED:
+            totalDiscount = Math.min(priceRule.get_flat_discount * number_of_time_coupon_should_apply, cartTotal);
+            await Promise.all(applicableCartLineItems?.map(async (item) => {
+                let variantListingPrice = item?.variant?.extended_product_variants?.compare_at_price;
+                const isBundle = !!item.metadata?.bundle_type;
+                let mrp = isBundle
+                    ? item.compare_at_unit_price
+                    : variantListingPrice;
+                const ratio = isMrp
+                    ? Number((Number(mrp) / Number(cartMrpTotal)).toFixed(2))
+                    : Number((Number(item.unit_price) / Number(cartPriceTotal)).toFixed(2));
+                const discount = ratio * totalDiscount;
+                await cartService.addLineItemAdjustments({
+                    amount: discount,
+                    code: code,
+                    description: priceRule.title || priceRule.description || "Discount",
+                    item_id: item.id,
+                    promotion_id: priceRule.id,
+                });
+            }));
+            break;
+        case validators_1.DiscountType.Values.PERCENTAGE:
+            totalDiscount = Math.min((priceRule.get_percent * cartTotal) / 100, priceRule.max_discount || Infinity);
+            await Promise.all(applicableCartLineItems?.map(async (item) => {
+                let variantListingPrice = item?.variant?.extended_product_variants?.compare_at_price;
+                const isBundle = !!item.metadata?.bundle_type;
+                let mrp = isBundle
+                    ? item.compare_at_unit_price
+                    : variantListingPrice;
+                const ratio = isMrp
+                    ? Number((Number(mrp) / Number(cartMrpTotal)).toFixed(2))
+                    : Number((Number(item.unit_price) / Number(cartPriceTotal)).toFixed(2));
+                const discount = ratio * totalDiscount;
+                await cartService.addLineItemAdjustments({
+                    amount: discount,
+                    code: code,
+                    description: priceRule.title || priceRule.description || "Discount",
+                    item_id: item.id,
+                    promotion_id: priceRule.id,
+                });
+            }));
+            break;
+        case validators_1.DiscountType.Values.BXGY:
+            // This is a “Buy X, Get Y Free” coupon.
+            // We first count how many items the customer has.
+            // For every (X + Y) items, they get Y items free.
+            // We always give the free items starting from the cheapest ones.
+            // Example 1: Buy 2, Get 1 free (B2G1), used once
+            // If the cart has 3 to 6 items, the customer gets 1 free item (the cheapest).
+            // Example 2: B2G1, used twice
+            // If the cart has 6 or 7 items, the customer gets 2 free items (the cheapest ones).
+            // Example 3: Buy 3, Get 2 free (B3G2), used once
+            // If the cart has 5 items, the customer gets 2 free items (the cheapest).
+            const totalEligibleQty = applicableCartLineItems.reduce((acc, item) => acc + Number(item.quantity || 0), 0);
+            const maxTimesCouponCanApply = Math.floor(totalEligibleQty / (priceRule.buy_x + priceRule.get_y));
+            const sortedByUnitPrice = applicableCartLineItems.sort((a, b) => {
+                const aPrice = isMrp
+                    ? a.metadata?.bundle_type
+                        ? Number(a.compare_at_unit_price)
+                        : Number(a.variant.extended_product_variants.compare_at_price)
+                    : Number(a.unit_price);
+                const bPrice = isMrp
+                    ? b.metadata?.bundle_type
+                        ? Number(b.compare_at_unit_price)
+                        : Number(b.variant.extended_product_variants.compare_at_price)
+                    : Number(b.unit_price);
+                return aPrice - bPrice;
+            });
+            const numberOfFreeItems = Math.min(priceRule.get_y * maxTimesCouponCanApply, totalEligibleQty);
+            let iterator = 0;
+            for (const item of sortedByUnitPrice) {
+                const t = Math.min(Number(item.quantity), numberOfFreeItems - iterator);
+                iterator += t;
+                totalDiscount += t * Number(item.unit_price);
+                await cartService.addLineItemAdjustments({
+                    amount: t * Number(item.unit_price),
+                    code,
+                    description: priceRule.title || priceRule.description || "Discount",
+                    item_id: item.id,
+                    promotion_id: priceRule.id,
+                });
+            }
+            break;
+        case validators_1.DiscountType.Values.BXAY:
+            /* ────────────────────────────────────────────────────────────────────────────────────|
+             * Apply a “Buy X At Y” (BXAY) discount, which may fire multiple times per cart.       |
+             * ────────────────────────────────────────────────────────────────────────────────────|
+             * Example A: limit = 1 (“only once”)
+             *
+             *   Cart:
+             *     - A: qty=1 @200  → units [200]
+             *     - B: qty=4 @300  → units [300,300,300,300]
+             *
+             *   buy_x = 2, at_y = 400, limit = 1
+             *   totalQty = 5 → maxPossibleBundles = 2
+             *   times = min(2,1) = 1
+             *   unitsNeeded = 1 * 2 = 2
+             *
+             *   Flatten & sort: [200,300,300,300,300] → select [200,300]
+             *   sumPrices = 200 + 300 = 500
+             *   bundleTotalPrice = 1 * 400 = 400
+             *   totalBundleDiscount = 500 − 400 = 100
+             *
+             *   Shares:
+             *     - A: 200/500 = 0.4 → 0.4 * 100 = 40
+             *     - B: 300/500 = 0.6 → 0.6 * 100 = 60
+             *
+             *
+             * Example B: limit = 2 (“twice”)
+             *
+             *   Same cart & rule, but limit = 2
+             *   totalQty = 5 → maxPossibleBundles = 2
+             *   times = min(2,2) = 2
+             *   unitsNeeded = 2 * 2 = 4
+             *
+             *   Flatten & sort: [200,300,300,300,300] → select [200,300,300,300]
+             *   sumPrices = 200 + 3*300 = 1100
+             *   bundleTotalPrice = 2 * 400 = 800
+             *   totalBundleDiscount = 1100 − 800 = 300
+             *
+             *   Shares:
+             *     - A: 200/1100 ≈ 0.1818 → ~300 * 0.1818 ≈ 54.55
+             *     - B: 900/1100 ≈ 0.8182 → ~300 * 0.8182 ≈ 245.45
+             *
+             * You can extend this to any n by adjusting `limit`. The algorithm
+             * automatically picks the cheapest `n * buy_x` units and splits the
+             * discount proportionally.
+             */
+            // 1) Total times the bundle applies, and units per bundle
+            const unitsNeeded = number_of_time_coupon_should_apply;
+            logger.info("unitsNeeded: " + unitsNeeded);
+            const bxayTimes = Math.floor(number_of_time_coupon_should_apply / (priceRule.buy_x || 1));
+            logger.info("times: " + bxayTimes);
+            const units = [];
+            for (const item of applicableCartLineItems) {
+                const unitPrice = isMrp
+                    ? item.metadata?.bundle_type
+                        ? item.compare_at_unit_price
+                        : item.variant.extended_product_variants.compare_at_price
+                    : item.unit_price;
+                for (let i = 0; i < (Number(item.quantity) || 1); i++) {
+                    units.push({ item, unitPrice: Number(unitPrice) });
+                }
+            }
+            // 3) Sort ascending by unitPrice
+            units.sort((a, b) => a.unitPrice - b.unitPrice);
+            // 4) Pick the cheapest `unitsNeeded` units
+            const selected = units.slice(0, unitsNeeded);
+            logger.info("selected: " + JSON.stringify(selected, null, 2));
+            // 5) Sum their original prices
+            const sumPrices = selected.reduce((sum, u) => sum + u.unitPrice, 0);
+            logger.info("sumPrices: " + sumPrices);
+            // 6) Compute total bundle price (you pay at_y per bundle)
+            const totalOfItemsAfterDiscount = priceRule.at_y * bxayTimes;
+            logger.info("totalOfItemsAfterDiscount: " + totalOfItemsAfterDiscount);
+            // 7) Total discount to allocate
+            const totalBundleDiscount = sumPrices - totalOfItemsAfterDiscount;
+            logger.info("totalBundleDiscount: " + totalBundleDiscount);
+            // 8) Group back by line-item to allocate proportionally
+            const lineBuckets = {};
+            for (const { item, unitPrice } of selected) {
+                if (!lineBuckets[item.id]) {
+                    lineBuckets[item.id] = { sumPrices: 0 };
+                }
+                lineBuckets[item.id].sumPrices += unitPrice;
+            }
+            logger.info("lineBuckets: " + JSON.stringify(lineBuckets, null, 2));
+            // 9) For each line, compute its share and create one adjustment
+            let allocated = 0;
+            for (const [itemId, { sumPrices: lineSum }] of Object.entries(lineBuckets)) {
+                const share = lineSum / sumPrices;
+                const lineDiscount = Math.round(totalBundleDiscount * share * 100) / 100;
+                allocated += lineDiscount;
+                logger.info("line items: " +
+                    {
+                        amount: lineDiscount,
+                        code,
+                        description: priceRule.title || priceRule.description || "Discount",
+                        item_id: itemId,
+                        promotion_id: priceRule.id,
+                    });
+                await cartService.addLineItemAdjustments({
+                    amount: lineDiscount,
+                    code,
+                    description: priceRule.title || priceRule.description || "Discount",
+                    item_id: itemId,
+                    promotion_id: priceRule.id,
+                });
+            }
+            // 10) Track overall discount
+            totalDiscount += allocated;
+            break;
+        default:
+            logger.error("Discount type not supported", priceRule.type);
+            break;
+    }
+    return new workflows_sdk_1.StepResponse({
+        hasError: false,
+        isApplied: true,
+        discount: totalDiscount,
+        message: "Coupon Applied Successfully",
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"apply-coupon-step-backup.js","sourceRoot":"","sources":["../../../../../../../src/workflows/discount/apply-coupon/steps/apply-coupon-step-backup.ts"],"names":[],"mappings":"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"}