@devx-commerce/plugin-gati 0.0.34-beta.2 → 0.0.34-beta.21

package/.medusa/server/development/erp-order-payload-example.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const orderPayload = {
+    OrderId: 0,
+    BranchNo: "0004000711",
+    BranchName: "Timeless Jewels",
+    OrderPrefix: "",
+    OrderNo: "",
+    OrderDate: "2025-06-21T00:00:00",
+    CustomerId: "0001000056",
+    Customer: "",
+    PoNo: "ID1111",
+    PoDate: "2025-06-21T00:00:00",
+    SalesPerson: "",
+    WorkOrderNo: "",
+    Remarks: "",
+    PromocodeSeriesId: 0,
+    Promocode: "",
+    PromocodePercentage: 0,
+    PromocodeAmount: 0,
+    OrderDetail: [
+        {
+            OrderId: 0,
+            OrderItemId: 0,
+            SrNo: 1,
+            StyleId: 33067,
+            StyleCode: "DR00962",
+            PartyStyleId: 5445,
+            PartyStyleCode: "DR00260",
+            JewelId: 0,
+            JewelCode: "",
+            ItemSize: "5",
+            OrderQty: 1.0,
+            OrderItemPcs: 1,
+            Metal: "",
+            Tone: "",
+            ItemPoNo: "",
+            ItemRefNo: "",
+            Priority: "N",
+            StockType: "LG DIAMOND",
+            MakeType: "A",
+            CustomerProductionInstruction: "",
+            SpecialRemarks: "",
+            DesignProductionInstruction: "",
+            StampInstruction: "",
+            Expecteddeliverydate: "2025-06-25T00:00:00",
+            MRP: 36063.0,
+        },
+    ],
+    PaymentOption: [
+        {
+            OrderId: 0,
+            BookName: "UPI TimeLess - P",
+            Amount: 37144.89,
+        },
+    ],
+};
+console.log(JSON.stringify(orderPayload, null, 2));
+// You can use this payload with the ErpService.createOrder method.
+// Example:
+// import ErpService from './src/modules/erp/service';
+// const erpService = new ErpService(
+//   {},
+//   {
+//     authToken: "D7F0A5C3-E229-4BBF-AA62-5D8B858EB887",
+//     baseUrl: "http://103.98.6.30:90/api/Svaraa",
+//   }
+// );
+// erpService.createOrder(orderPayload)
+//   .then(result => {
+//     console.log('Order created successfully:', result);
+//   })
+//   .catch(error => {
+//     console.error('Error creating order:', error);
+//   });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJwLW9yZGVyLXBheWxvYWQtZXhhbXBsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL2RldmVsb3BtZW50L2VycC1vcmRlci1wYXlsb2FkLWV4YW1wbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQSxNQUFNLFlBQVksR0FBaUI7SUFDakMsT0FBTyxFQUFFLENBQUM7SUFDVixRQUFRLEVBQUUsWUFBWTtJQUN0QixVQUFVLEVBQUUsaUJBQWlCO0lBQzdCLFdBQVcsRUFBRSxFQUFFO0lBQ2YsT0FBTyxFQUFFLEVBQUU7SUFDWCxTQUFTLEVBQUUscUJBQXFCO0lBQ2hDLFVBQVUsRUFBRSxZQUFZO0lBQ3hCLFFBQVEsRUFBRSxFQUFFO0lBQ1osSUFBSSxFQUFFLFFBQVE7SUFDZCxNQUFNLEVBQUUscUJBQXFCO0lBQzdCLFdBQVcsRUFBRSxFQUFFO0lBQ2YsV0FBVyxFQUFFLEVBQUU7SUFDZixPQUFPLEVBQUUsRUFBRTtJQUNYLGlCQUFpQixFQUFFLENBQUM7SUFDcEIsU0FBUyxFQUFFLEVBQUU7SUFDYixtQkFBbUIsRUFBRSxDQUFDO0lBQ3RCLGVBQWUsRUFBRSxDQUFDO0lBQ2xCLFdBQVcsRUFBRTtRQUNYO1lBQ0UsT0FBTyxFQUFFLENBQUM7WUFDVixXQUFXLEVBQUUsQ0FBQztZQUNkLElBQUksRUFBRSxDQUFDO1lBQ1AsT0FBTyxFQUFFLEtBQUs7WUFDZCxTQUFTLEVBQUUsU0FBUztZQUNwQixZQUFZLEVBQUUsSUFBSTtZQUNsQixjQUFjLEVBQUUsU0FBUztZQUN6QixPQUFPLEVBQUUsQ0FBQztZQUNWLFNBQVMsRUFBRSxFQUFFO1lBQ2IsUUFBUSxFQUFFLEdBQUc7WUFDYixRQUFRLEVBQUUsR0FBRztZQUNiLFlBQVksRUFBRSxDQUFDO1lBQ2YsS0FBSyxFQUFFLEVBQUU7WUFDVCxJQUFJLEVBQUUsRUFBRTtZQUNSLFFBQVEsRUFBRSxFQUFFO1lBQ1osU0FBUyxFQUFFLEVBQUU7WUFDYixRQUFRLEVBQUUsR0FBRztZQUNiLFNBQVMsRUFBRSxZQUFZO1lBQ3ZCLFFBQVEsRUFBRSxHQUFHO1lBQ2IsNkJBQTZCLEVBQUUsRUFBRTtZQUNqQyxjQUFjLEVBQUUsRUFBRTtZQUNsQiwyQkFBMkIsRUFBRSxFQUFFO1lBQy9CLGdCQUFnQixFQUFFLEVBQUU7WUFDcEIsb0JBQW9CLEVBQUUscUJBQXFCO1lBQzNDLEdBQUcsRUFBRSxPQUFPO1NBQ2I7S0FDRjtJQUNELGFBQWEsRUFBRTtRQUNiO1lBQ0UsT0FBTyxFQUFFLENBQUM7WUFDVixRQUFRLEVBQUUsa0JBQWtCO1lBQzVCLE1BQU0sRUFBRSxRQUFRO1NBQ2pCO0tBQ0Y7Q0FDRixDQUFDO0FBRUYsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUVuRCxtRUFBbUU7QUFDbkUsV0FBVztBQUVYLHNEQUFzRDtBQUV0RCxxQ0FBcUM7QUFDckMsUUFBUTtBQUNSLE1BQU07QUFDTix5REFBeUQ7QUFDekQsbURBQW1EO0FBQ25ELE1BQU07QUFDTixLQUFLO0FBRUwsdUNBQXVDO0FBQ3ZDLHNCQUFzQjtBQUN0QiwwREFBMEQ7QUFDMUQsT0FBTztBQUNQLHNCQUFzQjtBQUN0QixxREFBcUQ7QUFDckQsUUFBUSJ9

package/.medusa/server/src/api/admin/variant-options/recalculate/route.js

@@ -0,0 +1,446 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const api_response_1 = require("../../../../lib/api-response");
+const update_variant_option_metadata_1 = require("../../../../workflows/helpers/update-variant-option-metadata");
+const BATCH_SIZE = 10; // Process 10 products at a time
+/**
+ * POST /admin/variant-options/recalculate
+ *
+ * Recalculate product options for one or more products and all their variants.
+ * This is useful when:
+ * - Options got out of sync
+ * - After bulk updates
+ * - To fix option mismatch errors
+ *
+ * Body:
+ *   { style_id: string } - Single style
+ *   { style_ids: string[] } - Multiple styles (processed in batches)
+ *   { product_id: string } - Single product
+ *   { product_ids: string[] } - Multiple products (processed in batches)
+ */
+const POST = async (req, res) => {
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const { style_id, style_ids, product_id, product_ids } = (req.body || {});
+    // Normalize inputs to arrays
+    const styleIdList = style_ids || (style_id ? [style_id] : []);
+    const productIdList = product_ids || (product_id ? [product_id] : []);
+    if (styleIdList.length === 0 && productIdList.length === 0) {
+        return (0, api_response_1.sendApiResponse)(res, (0, api_response_1.createErrorResponse)("Provide style_id, style_ids, product_id, or product_ids", api_response_1.HttpStatus.BAD_REQUEST, api_response_1.ErrorCode.VALIDATION_ERROR));
+    }
+    try {
+        const totalItems = styleIdList.length + productIdList.length;
+        logger.info(`[recalculate-options] Starting for ${totalItems} item(s)`);
+        // Load master maps once - shared across all products
+        const masterMaps = await loadMasterMaps(query);
+        // Collect all products to process
+        const productsToProcess = [];
+        // Fetch products by style_ids
+        if (styleIdList.length > 0) {
+            const { data: productsByStyle } = await query.graph({
+                entity: "product",
+                fields: ["id", "external_id", "options.*"],
+                filters: {
+                    external_id: styleIdList,
+                },
+            });
+            productsToProcess.push(...(productsByStyle || []));
+        }
+        // Fetch products by product_ids
+        if (productIdList.length > 0) {
+            const { data: productsById } = await query.graph({
+                entity: "product",
+                fields: ["id", "external_id", "options.*"],
+                filters: {
+                    id: productIdList,
+                },
+            });
+            productsToProcess.push(...(productsById || []));
+        }
+        // Deduplicate by product id
+        const uniqueProducts = Array.from(new Map(productsToProcess.map(p => [p.id, p])).values());
+        if (uniqueProducts.length === 0) {
+            return (0, api_response_1.sendApiResponse)(res, (0, api_response_1.createErrorResponse)("No products found for the provided identifiers", api_response_1.HttpStatus.NOT_FOUND, api_response_1.ErrorCode.NOT_FOUND));
+        }
+        logger.info(`[recalculate-options] Found ${uniqueProducts.length} unique products to process`);
+        // Process in batches
+        const results = [];
+        const batches = chunkArray(uniqueProducts, BATCH_SIZE);
+        for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+            const batch = batches[batchIdx];
+            logger.info(`[recalculate-options] Processing batch ${batchIdx + 1}/${batches.length} (${batch.length} products)`);
+            // Process each product in the batch independently
+            const batchResults = await Promise.all(batch.map(product => processProductOptions(req.scope, query, logger, product, masterMaps)));
+            results.push(...batchResults);
+        }
+        // Summary
+        const summary = {
+            total: results.length,
+            success: results.filter(r => r.status === "success").length,
+            errors: results.filter(r => r.status === "error").length,
+            skipped: results.filter(r => r.status === "skipped").length,
+        };
+        logger.info(`[recalculate-options] Completed: ${summary.success} success, ${summary.errors} errors, ${summary.skipped} skipped`);
+        return (0, api_response_1.sendApiResponse)(res, (0, api_response_1.createSuccessResponse)({
+            summary,
+            results,
+        }, `Processed ${results.length} products: ${summary.success} success, ${summary.errors} errors, ${summary.skipped} skipped`));
+    }
+    catch (error) {
+        logger.error("[recalculate-options] Error:", error);
+        const errorMessage = error instanceof Error ? error.message : "Internal server error";
+        return (0, api_response_1.sendApiResponse)(res, (0, api_response_1.createErrorResponse)(errorMessage, api_response_1.HttpStatus.INTERNAL_SERVER_ERROR, api_response_1.ErrorCode.INTERNAL_ERROR));
+    }
+};
+exports.POST = POST;
+/**
+ * Load all master maps once for reuse
+ */
+async function loadMasterMaps(query) {
+    const [{ data: rawMasterArr }, { data: qualityMasterArr }, { data: toneMasterArr }, { data: itemSizeMasterArr }, { data: shapeMasterArr },] = await Promise.all([
+        query.graph({ entity: "raw_master", fields: ["id", "title", "raw_code"] }),
+        query.graph({ entity: "quality_master", fields: ["id", "title", "qly_code"] }),
+        query.graph({ entity: "tone_master", fields: ["id", "title", "tone_code"] }),
+        query.graph({ entity: "item_size_master", fields: ["id", "title", "item_size_code"] }),
+        query.graph({ entity: "shape_master", fields: ["id", "title", "shape_code"] }),
+    ]);
+    const rawMasterMap = new Map();
+    rawMasterArr?.forEach((x) => rawMasterMap.set(x.raw_code, x.title));
+    const qualityMasterMap = new Map();
+    qualityMasterArr?.forEach((x) => qualityMasterMap.set(x.qly_code, x.title));
+    const toneMasterMap = new Map();
+    toneMasterArr?.forEach((x) => toneMasterMap.set(x.tone_code, x.title));
+    const itemSizeMasterMap = new Map();
+    itemSizeMasterArr?.forEach((x) => itemSizeMasterMap.set(x.item_size_code, x.title));
+    const shapeMasterMap = new Map();
+    shapeMasterArr?.forEach((x) => shapeMasterMap.set(x.shape_code, x.title));
+    return {
+        rawMasterMap,
+        qualityMasterMap,
+        toneMasterMap,
+        itemSizeMasterMap,
+        shapeMasterMap,
+    };
+}
+/**
+ * Process a single product's options
+ */
+async function processProductOptions(scope, query, logger, product, masterMaps) {
+    const result = {
+        product_id: product.id,
+        style_id: product.external_id,
+        status: "success",
+        updated_variants: 0,
+        skipped_variants: [],
+    };
+    try {
+        // Capture old product options
+        const oldProductOptions = (product.options || []).map((opt) => ({
+            title: opt.title,
+            values: opt.values?.map((v) => v.value || v) || [],
+        })).filter((opt) => opt.title !== "Default");
+        // Get all variants for this product with their current options
+        const { data: variants } = await query.graph({
+            entity: "product_variant",
+            fields: [
+                "id",
+                "product_id",
+                "options.*",
+                "extended_variant.id",
+                "extended_variant.item_size",
+                "extended_variant.stock_type",
+                "extended_variant.party_style_details.*",
+            ],
+            filters: {
+                product_id: product.id,
+            },
+        });
+        if (!variants || variants.length === 0) {
+            result.status = "skipped";
+            result.error = "No variants found";
+            // Include old product options even when skipped
+            result.product_options = {
+                old: oldProductOptions,
+                new: oldProductOptions, // No change when skipped
+            };
+            result.variant_options = [];
+            return result;
+        }
+        // Get extended variant IDs
+        const extendedVariantIds = variants
+            .map((v) => v.extended_variant?.id)
+            .filter(Boolean);
+        // Get extended variants with party_style_details
+        const { data: extendedVariants } = await query.graph({
+            entity: "extended_variant",
+            fields: ["id", "item_size", "stock_type", "party_style_details.*"],
+            filters: {
+                id: extendedVariantIds,
+            },
+        });
+        // Capture old variant options
+        const oldVariantOptionsMap = new Map();
+        for (const variant of variants) {
+            const oldOptions = {};
+            if (variant.options) {
+                for (const opt of variant.options) {
+                    if (opt.value) {
+                        oldOptions[opt.title] = opt.value;
+                    }
+                }
+            }
+            oldVariantOptionsMap.set(variant.id, oldOptions);
+        }
+        // Calculate options for each variant
+        const productOptionsMap = new Map();
+        const variantsToUpdate = [];
+        const rawValueMappings = [];
+        const newVariantOptionsMap = new Map();
+        for (const variant of variants) {
+            const extendedVariant = extendedVariants?.find((ev) => ev.id === variant.extended_variant?.id);
+            if (!extendedVariant) {
+                result.skipped_variants.push({
+                    id: variant.id,
+                    reason: "No extended_variant found",
+                });
+                continue;
+            }
+            const variantOptions = {};
+            // Detect solitaire styles based on stock_type
+            const stockType = extendedVariant?.stock_type;
+            const isSolitaire = stockType === "LG SOLITAIRE" || stockType === "SOLITAIRE";
+            // Size
+            if (extendedVariant.item_size) {
+                const sizeTitle = (masterMaps.itemSizeMasterMap.get(extendedVariant.item_size) ||
+                    String(extendedVariant.item_size)).trim();
+                variantOptions["Size"] = sizeTitle;
+                if (!productOptionsMap.has("Size")) {
+                    productOptionsMap.set("Size", new Set());
+                }
+                productOptionsMap.get("Size").add(sizeTitle);
+                rawValueMappings.push({
+                    variantId: variant.id,
+                    optionTitle: "Size",
+                    optionValue: sizeTitle,
+                    rawValue: extendedVariant.item_size,
+                });
+            }
+            // Process party_style_details
+            if (extendedVariant.party_style_details) {
+                for (const detail of extendedVariant.party_style_details) {
+                    // Metal options
+                    if (detail.raw_type === "Metal" && detail.is_base) {
+                        const qualityTitle = (masterMaps.qualityMasterMap.get(detail.qly_code) || detail.qly_code).trim();
+                        const rawTitle = (masterMaps.rawMasterMap.get(detail.raw_code) || detail.raw_code).trim();
+                        const metalValue = `${qualityTitle} ${rawTitle}`.trim();
+                        variantOptions["Metal"] = metalValue;
+                        if (!productOptionsMap.has("Metal")) {
+                            productOptionsMap.set("Metal", new Set());
+                        }
+                        productOptionsMap.get("Metal").add(metalValue);
+                        rawValueMappings.push({
+                            variantId: variant.id,
+                            optionTitle: "Metal",
+                            optionValue: metalValue,
+                            rawValue: `${detail.qly_code || ""}:${detail.raw_code || ""}`.trim(),
+                        });
+                        // Metal Color
+                        if (detail.tone_code) {
+                            let colorTitle = masterMaps.toneMasterMap.get(detail.tone_code) || detail.tone_code;
+                            // Fallback to static mappings
+                            if (!masterMaps.toneMasterMap.has(detail.tone_code)) {
+                                if (detail.tone_code === "R")
+                                    colorTitle = "Rose";
+                                else if (detail.tone_code === "Y")
+                                    colorTitle = "Yellow";
+                                else if (detail.tone_code === "W")
+                                    colorTitle = "White";
+                                else if (detail.tone_code === "YRW")
+                                    colorTitle = "YELLOW/ROSE/WHITE";
+                                else if (detail.tone_code === "YW")
+                                    colorTitle = "YELLOW/WHITE";
+                                else if (detail.tone_code === "RW")
+                                    colorTitle = "ROSE/WHITE";
+                                else if (detail.tone_code === "BU")
+                                    colorTitle = "BLUE";
+                                else if (detail.tone_code === "BL")
+                                    colorTitle = "BLACK";
+                            }
+                            colorTitle = colorTitle.trim();
+                            variantOptions["Metal Color"] = colorTitle;
+                            if (!productOptionsMap.has("Metal Color")) {
+                                productOptionsMap.set("Metal Color", new Set());
+                            }
+                            productOptionsMap.get("Metal Color").add(colorTitle);
+                            rawValueMappings.push({
+                                variantId: variant.id,
+                                optionTitle: "Metal Color",
+                                optionValue: colorTitle,
+                                rawValue: detail.tone_code || "",
+                            });
+                        }
+                    }
+                    // Diamond Quality
+                    if (detail.raw_type === "Diamond" &&
+                        detail.tone_code &&
+                        detail.qly_code &&
+                        detail.is_base) {
+                        const toneTitle = (masterMaps.toneMasterMap.get(detail.tone_code) || detail.tone_code).trim();
+                        const qualityTitle = (masterMaps.qualityMasterMap.get(detail.qly_code) || detail.qly_code).trim();
+                        const diamondValue = `${toneTitle} ${qualityTitle}`.trim();
+                        variantOptions["Diamond Quality"] = diamondValue;
+                        if (!productOptionsMap.has("Diamond Quality")) {
+                            productOptionsMap.set("Diamond Quality", new Set());
+                        }
+                        productOptionsMap.get("Diamond Quality").add(diamondValue);
+                        rawValueMappings.push({
+                            variantId: variant.id,
+                            optionTitle: "Diamond Quality",
+                            optionValue: diamondValue,
+                            rawValue: `${detail.tone_code || ""}:${detail.qly_code || ""}`.trim(),
+                        });
+                    }
+                    // Shape and Carat for solitaire
+                    if (isSolitaire &&
+                        detail.raw_type === "Diamond" &&
+                        detail.raw_code === "LGS" &&
+                        detail.is_base) {
+                        const shapeTitle = (masterMaps.shapeMasterMap.get(detail.shape_code) ||
+                            String(detail.shape_code || "")).trim();
+                        if (shapeTitle) {
+                            variantOptions["Shape"] = shapeTitle;
+                            if (!productOptionsMap.has("Shape")) {
+                                productOptionsMap.set("Shape", new Set());
+                            }
+                            productOptionsMap.get("Shape").add(shapeTitle);
+                            rawValueMappings.push({
+                                variantId: variant.id,
+                                optionTitle: "Shape",
+                                optionValue: shapeTitle,
+                                rawValue: detail.shape_code || "",
+                            });
+                        }
+                        const weightStr = String(detail?.weight || "").trim();
+                        if (weightStr) {
+                            variantOptions["Carat"] = weightStr;
+                            if (!productOptionsMap.has("Carat")) {
+                                productOptionsMap.set("Carat", new Set());
+                            }
+                            productOptionsMap.get("Carat").add(weightStr);
+                            rawValueMappings.push({
+                                variantId: variant.id,
+                                optionTitle: "Carat",
+                                optionValue: weightStr,
+                                rawValue: weightStr,
+                            });
+                        }
+                    }
+                }
+            }
+            // Check if we have all required options
+            const productOptionTitles = product.options?.map((opt) => opt.title) || [];
+            const hasAllOptions = productOptionTitles.every((title) => variantOptions[title] !== undefined);
+            if (!hasAllOptions) {
+                const missingOptions = productOptionTitles.filter((title) => variantOptions[title] === undefined);
+                result.skipped_variants.push({
+                    id: variant.id,
+                    reason: `Missing options: [${missingOptions.join(", ")}]`,
+                });
+                continue;
+            }
+            // Sort options alphabetically
+            const sortedOptions = {};
+            Object.keys(variantOptions)
+                .sort((a, b) => a.localeCompare(b))
+                .forEach((key) => {
+                sortedOptions[key] = variantOptions[key];
+            });
+            variantsToUpdate.push({
+                id: variant.id,
+                options: sortedOptions,
+            });
+            // Store new variant options
+            newVariantOptionsMap.set(variant.id, sortedOptions);
+        }
+        // STEP 1: Update product options to include all values
+        const productOptions = Array.from(productOptionsMap.entries())
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([title, values]) => ({
+            title,
+            values: Array.from(values).sort((a, b) => a.localeCompare(b)),
+        }));
+        if (productOptions.length > 0) {
+            await (0, core_flows_1.updateProductsWorkflow)(scope).run({
+                input: {
+                    products: [{ id: product.id, options: productOptions }],
+                },
+            });
+        }
+        // STEP 2: Update variant options
+        if (variantsToUpdate.length > 0) {
+            await (0, core_flows_1.updateProductVariantsWorkflow)(scope).run({
+                input: {
+                    product_variants: variantsToUpdate,
+                },
+            });
+            // Update variant option metadata with raw values
+            if (rawValueMappings.length > 0) {
+                await (0, update_variant_option_metadata_1.updateVariantOptionMetadata)(scope, rawValueMappings);
+            }
+        }
+        // Fetch new product options after update
+        const { data: updatedProduct } = await query.graph({
+            entity: "product",
+            fields: ["id", "options.*"],
+            filters: {
+                id: product.id,
+            },
+        });
+        const newProductOptions = (updatedProduct?.[0]?.options || []).map((opt) => ({
+            title: opt.title,
+            values: opt.values?.map((v) => v.value || v) || [],
+        })).filter((opt) => opt.title !== "Default");
+        // Build variant options comparison
+        const variantOptionsComparison = [];
+        for (const variant of variants) {
+            const oldOptions = oldVariantOptionsMap.get(variant.id) || {};
+            const newOptions = newVariantOptionsMap.get(variant.id) || {};
+            // Only include variants that were updated
+            if (variantsToUpdate.some(v => v.id === variant.id)) {
+                variantOptionsComparison.push({
+                    variant_id: variant.id,
+                    old: oldOptions,
+                    new: newOptions,
+                });
+            }
+        }
+        // Include old and new options in result
+        result.product_options = {
+            old: oldProductOptions,
+            new: newProductOptions,
+        };
+        result.variant_options = variantOptionsComparison;
+        result.updated_variants = variantsToUpdate.length;
+        logger.info(`[recalculate-options] Product ${product.external_id || product.id}: ${variantsToUpdate.length} updated, ${result.skipped_variants.length} skipped`);
+    }
+    catch (error) {
+        result.status = "error";
+        result.error = error instanceof Error ? error.message : "Unknown error";
+        logger.error(`[recalculate-options] Error processing product ${product.external_id || product.id}:`, error);
+    }
+    return result;
+}
+/**
+ * Split array into chunks
+ */
+function chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../../../../../src/api/admin/variant-options/recalculate/route.ts"],"names":[],"mappings":"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"}