@devx-commerce/plugin-gati 0.0.30 → 0.0.31-beta.1

package/.medusa/server/src/api/store/gold-rate/middleware.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = require("@medusajs/framework/http");
+const validators_1 = require("./validators");
+exports.default = (0, http_1.defineMiddlewares)({
+    routes: [
+        {
+            matcher: "/store/gold-rate/current",
+            method: "POST",
+            middlewares: [(0, http_1.validateAndTransformBody)(validators_1.GetCurrentGoldRateBody)],
+        },
+        {
+            matcher: "/store/gold-rate/historical",
+            method: "POST",
+            middlewares: [(0, http_1.validateAndTransformBody)(validators_1.GetHistoricalGoldRateBody)],
+        },
+    ],
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcGkvc3RvcmUvZ29sZC1yYXRlL21pZGRsZXdhcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxtREFHa0M7QUFDbEMsNkNBR3NCO0FBRXRCLGtCQUFlLElBQUEsd0JBQWlCLEVBQUM7SUFDL0IsTUFBTSxFQUFFO1FBQ047WUFDRSxPQUFPLEVBQUUsMEJBQTBCO1lBQ25DLE1BQU0sRUFBRSxNQUFNO1lBQ2QsV0FBVyxFQUFFLENBQUMsSUFBQSwrQkFBd0IsRUFBQyxtQ0FBc0IsQ0FBQyxDQUFDO1NBQ2hFO1FBQ0Q7WUFDRSxPQUFPLEVBQUUsNkJBQTZCO1lBQ3RDLE1BQU0sRUFBRSxNQUFNO1lBQ2QsV0FBVyxFQUFFLENBQUMsSUFBQSwrQkFBd0IsRUFBQyxzQ0FBeUIsQ0FBQyxDQUFDO1NBQ25FO0tBQ0Y7Q0FDRixDQUFDLENBQUMifQ==

package/.medusa/server/src/api/store/gold-rate/validators.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHistoricalGoldRateBody = exports.GetCurrentGoldRateBody = void 0;
+const zod_1 = require("zod");
+exports.GetCurrentGoldRateBody = zod_1.z
+    .object({
+    grams: zod_1.z
+        .number({
+        required_error: "Grams is required",
+        invalid_type_error: "Grams must be a number",
+    })
+        .positive({
+        message: "Grams must be a positive number",
+    }),
+    purity: zod_1.z
+        .number({
+        required_error: "Purity is required",
+        invalid_type_error: "Purity must be a number",
+    })
+        .positive({
+        message: "Purity must be a positive number",
+    }),
+})
+    .strict();
+exports.GetHistoricalGoldRateBody = zod_1.z
+    .object({
+    grams: zod_1.z
+        .number({
+        required_error: "Grams is required",
+        invalid_type_error: "Grams must be a number",
+    })
+        .positive({
+        message: "Grams must be a positive number",
+    }),
+})
+    .strict();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hcGkvc3RvcmUvZ29sZC1yYXRlL3ZhbGlkYXRvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkJBQXdCO0FBRVgsUUFBQSxzQkFBc0IsR0FBRyxPQUFDO0tBQ3BDLE1BQU0sQ0FBQztJQUNOLEtBQUssRUFBRSxPQUFDO1NBQ0wsTUFBTSxDQUFDO1FBQ04sY0FBYyxFQUFFLG1CQUFtQjtRQUNuQyxrQkFBa0IsRUFBRSx3QkFBd0I7S0FDN0MsQ0FBQztTQUNELFFBQVEsQ0FBQztRQUNSLE9BQU8sRUFBRSxpQ0FBaUM7S0FDM0MsQ0FBQztJQUNKLE1BQU0sRUFBRSxPQUFDO1NBQ04sTUFBTSxDQUFDO1FBQ04sY0FBYyxFQUFFLG9CQUFvQjtRQUNwQyxrQkFBa0IsRUFBRSx5QkFBeUI7S0FDOUMsQ0FBQztTQUNELFFBQVEsQ0FBQztRQUNSLE9BQU8sRUFBRSxrQ0FBa0M7S0FDNUMsQ0FBQztDQUNMLENBQUM7S0FDRCxNQUFNLEVBQUUsQ0FBQztBQUlDLFFBQUEseUJBQXlCLEdBQUcsT0FBQztLQUN2QyxNQUFNLENBQUM7SUFDTixLQUFLLEVBQUUsT0FBQztTQUNMLE1BQU0sQ0FBQztRQUNOLGNBQWMsRUFBRSxtQkFBbUI7UUFDbkMsa0JBQWtCLEVBQUUsd0JBQXdCO0tBQzdDLENBQUM7U0FDRCxRQUFRLENBQUM7UUFDUixPQUFPLEVBQUUsaUNBQWlDO0tBQzNDLENBQUM7Q0FDTCxDQUFDO0tBQ0QsTUFBTSxFQUFFLENBQUMifQ==

package/.medusa/server/src/api/store/middleware.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const framework_1 = require("@medusajs/framework");
 const middleware_1 = __importDefault(require("./carts/middleware"));
 const middleware_2 = __importDefault(require("./custom-price/middleware"));
+const middleware_3 = __importDefault(require("./gold-rate/middleware"));
 exports.default = (0, framework_1.defineMiddlewares)({
     routes: [
         ...(middleware_1.default.routes || []),
         ...(middleware_2.default.routes || []),
+        ...(middleware_3.default.routes || []),
     ],
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcGkvc3RvcmUvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG1EQUF3RDtBQUV4RCxvRUFBdUQ7QUFDdkQsMkVBQW9FO0FBRXBFLGtCQUFlLElBQUEsNkJBQWlCLEVBQUM7SUFDL0IsTUFBTSxFQUFFO1FBQ04sR0FBRyxDQUFDLG9CQUFxQixDQUFDLE1BQU0sSUFBSSxFQUFFLENBQUM7UUFDdkMsR0FBRyxDQUFDLG9CQUEyQixDQUFDLE1BQU0sSUFBSSxFQUFFLENBQUM7S0FDOUM7Q0FDRixDQUFDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlkZGxld2FyZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9hcGkvc3RvcmUvbWlkZGxld2FyZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLG1EQUF3RDtBQUV4RCxvRUFBdUQ7QUFDdkQsMkVBQW9FO0FBQ3BFLHdFQUE4RDtBQUU5RCxrQkFBZSxJQUFBLDZCQUFpQixFQUFDO0lBQy9CLE1BQU0sRUFBRTtRQUNOLEdBQUcsQ0FBQyxvQkFBcUIsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDO1FBQ3ZDLEdBQUcsQ0FBQyxvQkFBMkIsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDO1FBQzdDLEdBQUcsQ0FBQyxvQkFBd0IsQ0FBQyxNQUFNLElBQUksRUFBRSxDQUFDO0tBQzNDO0NBQ0YsQ0FBQyxDQUFDIn0=

package/.medusa/server/src/jobs/process-variant-option-sync.js

@@ -0,0 +1,428 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = processVariantOptionSync;
+const utils_1 = require("@medusajs/framework/utils");
+const core_flows_1 = require("@medusajs/medusa/core-flows");
+const variant_option_sync_queue_1 = require("../modules/variant-option-sync-queue");
+const variant_helper_1 = require("../workflows/helpers/variant-helper");
+/**
+ /**
+  * This function processes queued variant/product option sync records
+  * (triggered by changes to master tables like Raw, Quality, Tone, Size).
+  *
+  * - It fetches all pending queue records,
+  * - Determines all affected variants and their products,
+  * - Regenerates option values for each variant based on master data,
+  * - Updates products to ensure their option lists include all required values,
+  * - Updates the product variants with the correct options,
+  * - Marks each queue record as complete or failed.
+  */
+async function processVariantOptionSync(container) {
+    const query = container.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const logger = container.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const syncQueueService = container.resolve(variant_option_sync_queue_1.VARIANT_OPTION_SYNC_QUEUE_MODULE);
+    logger.info("------Starting variant option sync job------");
+    try {
+        // Query all pending tracking records
+        const { data: pendingRecords } = await query.graph({
+            entity: "variant_option_sync_queue",
+            fields: [
+                "id",
+                "master_type",
+                "master_code",
+                "master_id",
+                "old_title",
+                "new_title",
+            ],
+            filters: {
+                status: "pending",
+            },
+            pagination: {
+                take: 50, // Process 50 records at a time
+            },
+        });
+        if (!pendingRecords || pendingRecords.length === 0) {
+            logger.info("------No pending variant option sync records found------");
+            return;
+        }
+        logger.info(`------Found ${pendingRecords.length} pending records to process------`);
+        // Build master maps once for all records
+        const { data: rawMasterArr } = await query.graph({
+            entity: "raw_master",
+            fields: ["id", "title", "raw_code"],
+        });
+        const { data: qualityMasterArr } = await query.graph({
+            entity: "quality_master",
+            fields: ["id", "title", "qly_code"],
+        });
+        const { data: toneMasterArr } = await query.graph({
+            entity: "tone_master",
+            fields: ["id", "title", "tone_code"],
+        });
+        const { data: itemSizeMasterArr } = await query.graph({
+            entity: "item_size_master",
+            fields: ["id", "title", "item_size_code"],
+        });
+        const { data: shapeMasterArr } = await 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));
+        const masterMaps = {
+            rawMasterMap,
+            qualityMasterMap,
+            toneMasterMap,
+            itemSizeMasterMap,
+            shapeMasterMap,
+        };
+        // Process each tracking record
+        for (const record of pendingRecords) {
+            try {
+                // Update status to processing
+                await syncQueueService.updateVariantOptionSyncQueues([
+                    {
+                        id: record.id,
+                        status: "processing",
+                    },
+                ]);
+                logger.info(`------Processing record ${record.id}: ${record.master_type} - ${record.master_code}------`);
+                // Find affected variants
+                const affectedVariants = await (0, variant_helper_1.findVariantsAffectedByMasterUpdate)(query, record.master_type, record.master_code);
+                if (affectedVariants.length === 0) {
+                    logger.info(`------No affected variants found for ${record.master_type} - ${record.master_code}------ (record id: ${record.id})`);
+                    // Mark as completed with 0 affected variants
+                    await syncQueueService.updateVariantOptionSyncQueues([
+                        {
+                            id: record.id,
+                            status: "completed",
+                            affected_variant_count: 0,
+                            processed_at: new Date(),
+                        },
+                    ]);
+                    continue;
+                }
+                logger.info(`------Found ${affectedVariants.length} affected variants for record ${record.id}------`);
+                // Group variants by product_id
+                const variantsByProduct = new Map();
+                for (const variant of affectedVariants) {
+                    if (!variantsByProduct.has(variant.productId)) {
+                        variantsByProduct.set(variant.productId, []);
+                    }
+                    variantsByProduct.get(variant.productId).push(variant);
+                }
+                // Get all affected products with their options
+                const productIds = Array.from(variantsByProduct.keys());
+                const { data: products } = await query.graph({
+                    entity: "product",
+                    fields: ["id", "external_id", "options.*"],
+                    filters: {
+                        id: productIds,
+                    },
+                });
+                // Process variants in batches
+                const BATCH_SIZE = 25;
+                const variantBatches = [];
+                for (let i = 0; i < affectedVariants.length; i += BATCH_SIZE) {
+                    variantBatches.push(affectedVariants.slice(i, i + BATCH_SIZE));
+                }
+                const variantsToUpdate = [];
+                // Collect all new option values that will be used across all affected variants
+                // This is needed to update product options BEFORE updating variants
+                const newOptionValuesByProduct = new Map();
+                // For each batch of variants
+                let batchIndex = 0;
+                for (const batch of variantBatches) {
+                    batchIndex++;
+                    // Get extended variants data for this batch
+                    const extendedVariantIds = batch.map((v) => v.extendedVariantId);
+                    const { data: extendedVariants } = await query.graph({
+                        entity: "extended_variant",
+                        fields: [
+                            "id",
+                            "mapping_id",
+                            "party_style_id",
+                            "style_id",
+                            "item_size",
+                            "party_style_details.*",
+                        ],
+                        filters: {
+                            id: extendedVariantIds,
+                        },
+                    });
+                    logger.info(`------Found ${extendedVariants?.length} extended variants for batch : ${batchIndex}------`);
+                    // For each variant, regenerate options
+                    for (const variant of batch) {
+                        const extendedVariant = extendedVariants?.find((ev) => ev.id === variant.extendedVariantId);
+                        const product = products?.find((p) => p.id === variant.productId);
+                        if (!extendedVariant || !product) {
+                            logger.warn(`------Extended variant or product not found for variant ${variant.variantId} (product id: ${variant.productId}) batch: ${batchIndex}------`);
+                            continue;
+                        }
+                        // Initialize product's option map if not exists
+                        if (!newOptionValuesByProduct.has(variant.productId)) {
+                            newOptionValuesByProduct.set(variant.productId, new Map());
+                        }
+                        const productOptionMap = newOptionValuesByProduct.get(variant.productId);
+                        // Generate options directly from extended_variant data
+                        const variantOptions = {};
+                        // Size
+                        if (extendedVariant.item_size) {
+                            const sizeTitle = (masterMaps.itemSizeMasterMap.get(extendedVariant.item_size) ||
+                                String(extendedVariant.item_size)).trim();
+                            // Always set on variant and track for product options update
+                            variantOptions["Size"] = sizeTitle;
+                            if (!productOptionMap.has("Size")) {
+                                productOptionMap.set("Size", new Set());
+                            }
+                            productOptionMap.get("Size").add(sizeTitle);
+                        }
+                        // Process party_style_details for metals, metal colors, diamond qualities, and shapes
+                        let hasMetalOption = false;
+                        let hasDiamondOption = false;
+                        if (extendedVariant.party_style_details) {
+                            for (const detail of extendedVariant.party_style_details) {
+                                // Metal options
+                                if (detail.raw_type === "Metal" && detail.is_base) {
+                                    hasMetalOption = true;
+                                    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();
+                                    const metalOption = product.options?.find((opt) => opt.title === "Metal");
+                                    if (metalOption) {
+                                        variantOptions["Metal"] = metalValue;
+                                        // Track this value for product options update
+                                        if (!productOptionMap.has("Metal")) {
+                                            productOptionMap.set("Metal", new Set());
+                                        }
+                                        productOptionMap.get("Metal").add(metalValue);
+                                    }
+                                    // Metal Color
+                                    if (detail.tone_code) {
+                                        let colorTitle = masterMaps.toneMasterMap.get(detail.tone_code) ||
+                                            detail.tone_code;
+                                        // Fallback to static mappings if not in master
+                                        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();
+                                        const metalColorOption = product.options?.find((opt) => opt.title === "Metal Color");
+                                        if (metalColorOption) {
+                                            variantOptions["Metal Color"] = colorTitle;
+                                            // Track this value for product options update
+                                            if (!productOptionMap.has("Metal Color")) {
+                                                productOptionMap.set("Metal Color", new Set());
+                                            }
+                                            productOptionMap.get("Metal Color").add(colorTitle);
+                                        }
+                                    }
+                                }
+                                // Diamond Quality
+                                if (detail.raw_type === "Diamond" &&
+                                    detail.tone_code &&
+                                    detail.qly_code &&
+                                    detail.is_base) {
+                                    hasDiamondOption = true;
+                                    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();
+                                    const diamondOption = product.options?.find((opt) => opt.title === "Diamond Quality");
+                                    if (diamondOption) {
+                                        variantOptions["Diamond Quality"] = diamondValue;
+                                        // Track this value for product options update
+                                        if (!productOptionMap.has("Diamond Quality")) {
+                                            productOptionMap.set("Diamond Quality", new Set());
+                                        }
+                                        productOptionMap.get("Diamond Quality").add(diamondValue);
+                                    }
+                                }
+                                if (detail.raw_type === "Diamond" &&
+                                    detail.is_base) {
+                                    const shapeTitle = (masterMaps.shapeMasterMap.get(detail.shape_code) ||
+                                        String(detail.shape_code || "")).trim();
+                                    if (shapeTitle) {
+                                        const shapeOption = product.options?.find((opt) => opt.title === "Shape");
+                                        if (shapeOption) {
+                                            variantOptions["Shape"] = shapeTitle;
+                                            if (!productOptionMap.has("Shape")) {
+                                                productOptionMap.set("Shape", new Set());
+                                            }
+                                            productOptionMap.get("Shape").add(shapeTitle);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        variantsToUpdate.push({
+                            variant: {
+                                id: variant.variantId,
+                                options: variantOptions,
+                            },
+                        });
+                    }
+                }
+                // STEP 1: Update product options FIRST to include all new values
+                // This ensures option values exist before assigning them to variants
+                const productsToUpdate = [];
+                for (const productId of productIds) {
+                    const product = products?.find((p) => p.id === productId);
+                    if (!product)
+                        continue;
+                    // Get all existing variants for this product to preserve existing option values
+                    const { data: allVariants } = await query.graph({
+                        entity: "product_variant",
+                        fields: ["id", "options.*"],
+                        filters: {
+                            product_id: productId,
+                        },
+                    });
+                    // Collect unique option values from existing variants
+                    const productOptionsMap = new Map();
+                    // Map option_id -> canonical product option title
+                    const optionIdToTitle = new Map();
+                    const canonicalTitleByLower = new Map();
+                    for (const po of product.options || []) {
+                        if (po?.id && po?.title) {
+                            const t = String(po.title).trim();
+                            optionIdToTitle.set(po.id, t);
+                            canonicalTitleByLower.set(t.toLowerCase(), t);
+                        }
+                    }
+                    // First, collect from existing variants
+                    for (const variant of allVariants || []) {
+                        if (variant.options) {
+                            for (const opt of variant.options) {
+                                // Resolve canonical title: prefer option_id mapping, then normalize provided title
+                                let resolvedTitle = undefined;
+                                if (opt.option_id) {
+                                    resolvedTitle = optionIdToTitle.get(opt.option_id);
+                                }
+                                if (!resolvedTitle && opt.title) {
+                                    const t = String(opt.title).trim();
+                                    resolvedTitle = canonicalTitleByLower.get(t.toLowerCase()) || t;
+                                }
+                                const value = opt.value ? String(opt.value).trim() : "";
+                                if (resolvedTitle && value) {
+                                    if (!productOptionsMap.has(resolvedTitle)) {
+                                        productOptionsMap.set(resolvedTitle, new Set());
+                                    }
+                                    productOptionsMap.get(resolvedTitle).add(value);
+                                }
+                            }
+                        }
+                    }
+                    // Then, merge in the new option values we'll be using
+                    const newValuesForProduct = newOptionValuesByProduct.get(productId);
+                    if (newValuesForProduct) {
+                        for (const [optionTitle, newValues,] of newValuesForProduct.entries()) {
+                            if (!productOptionsMap.has(optionTitle)) {
+                                productOptionsMap.set(optionTitle, new Set());
+                            }
+                            // Merge new values into existing set
+                            for (const value of newValues) {
+                                productOptionsMap.get(optionTitle).add(value.trim());
+                            }
+                        }
+                    }
+                    // Convert to options format, filtering out empty strings
+                    const productOptions = Array.from(productOptionsMap.entries())
+                        .map(([title, values]) => ({
+                        title,
+                        values: Array.from(values).filter((v) => v.length > 0),
+                    }))
+                        .filter((opt) => opt.values.length > 0); // Only include options with values
+                    productsToUpdate.push({
+                        product: {
+                            id: productId,
+                            options: productOptions,
+                        },
+                    });
+                }
+                // Update products FIRST
+                if (productsToUpdate.length > 0) {
+                    logger.info(`------Updating ${productsToUpdate.length} products with new option values before variant update------`);
+                    await (0, core_flows_1.updateProductsWorkflow)(container).run({
+                        input: {
+                            products: productsToUpdate.map((p) => p.product),
+                        },
+                    });
+                    logger.info(`------Updated ${productsToUpdate.length} products for record ${record.id}------`);
+                }
+                // STEP 2: Now update variants with the new option values
+                // The option values now exist in the products, so this will succeed
+                if (variantsToUpdate.length > 0) {
+                    logger.info(`------Updating ${variantsToUpdate.length} variants with new option values------`);
+                    await (0, core_flows_1.updateProductVariantsWorkflow)(container).run({
+                        input: {
+                            product_variants: variantsToUpdate.map((v) => v.variant),
+                        },
+                    });
+                    logger.info(`------Updated ${variantsToUpdate.length} variants for record ${record.id}------`);
+                }
+                // Mark record as completed
+                await syncQueueService.updateVariantOptionSyncQueues([
+                    {
+                        id: record.id,
+                        status: "completed",
+                        affected_variant_count: affectedVariants.length,
+                        processed_at: new Date(),
+                    },
+                ]);
+                logger.info(`------Completed processing record ${record.id}: ${affectedVariants.length} variants affected------`);
+            }
+            catch (recordError) {
+                const affectedVariants = await (0, variant_helper_1.findVariantsAffectedByMasterUpdate)(query, record.master_type, record.master_code);
+                logger.error(`------Error processing record ${record.id}: ${recordError?.message}------ (affected variants: ${affectedVariants.length})`, recordError);
+                // Mark record as failed
+                await syncQueueService.updateVariantOptionSyncQueues([
+                    {
+                        id: record.id,
+                        status: "failed",
+                        error_message: recordError?.message || "Unknown error",
+                        affected_variant_count: affectedVariants.length,
+                        processed_at: new Date(),
+                    },
+                ]);
+            }
+        }
+        logger.info("Variant option sync job completed");
+    }
+    catch (error) {
+        logger.error("Error in variant option sync job:", error);
+        throw error;
+    }
+}
+exports.config = {
+    name: "process-variant-option-sync",
+    // schedule: "0 3 * * *",  // At 3:00 AM every day
+    schedule: "*/30 * * * *", // Every 30 minutes
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"process-variant-option-sync.js","sourceRoot":"","sources":["../../../../src/jobs/process-variant-option-sync.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/modules/category-group-master/migrations/Migration20251031061116.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20251031061116 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20251031061116 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`alter table if exists "category_group_master" add column if not exists "title" text null;`);
+    }
+    async down() {
+        this.addSql(`alter table if exists "category_group_master" drop column if exists "title";`);
+    }
+}
+exports.Migration20251031061116 = Migration20251031061116;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTEwMzEwNjExMTYuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jYXRlZ29yeS1ncm91cC1tYXN0ZXIvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI1MTAzMTA2MTExNi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBa0Q7QUFFbEQsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMsMkZBQTJGLENBQUMsQ0FBQztJQUMzRyxDQUFDO0lBRVEsS0FBSyxDQUFDLElBQUk7UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyw4RUFBOEUsQ0FBQyxDQUFDO0lBQzlGLENBQUM7Q0FFRjtBQVZELDBEQVVDIn0=

package/.medusa/server/src/modules/category-group-master/migrations/Migration20251104045912.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20251104045912 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20251104045912 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`alter table if exists "category_group_master" drop column if exists "title";`);
+    }
+    async down() {
+        this.addSql(`alter table if exists "category_group_master" add column if not exists "title" text null;`);
+    }
+}
+exports.Migration20251104045912 = Migration20251104045912;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTExMDQwNDU5MTIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jYXRlZ29yeS1ncm91cC1tYXN0ZXIvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI1MTEwNDA0NTkxMi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBa0Q7QUFFbEQsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMsOEVBQThFLENBQUMsQ0FBQztJQUM5RixDQUFDO0lBRVEsS0FBSyxDQUFDLElBQUk7UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQywyRkFBMkYsQ0FBQyxDQUFDO0lBQzNHLENBQUM7Q0FFRjtBQVZELDBEQVVDIn0=

package/.medusa/server/src/modules/category-master/migrations/Migration20251031061327.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20251031061327 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20251031061327 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`alter table if exists "category_master" add column if not exists "title" text null;`);
+    }
+    async down() {
+        this.addSql(`alter table if exists "category_master" drop column if exists "title";`);
+    }
+}
+exports.Migration20251031061327 = Migration20251031061327;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTEwMzEwNjEzMjcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jYXRlZ29yeS1tYXN0ZXIvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI1MTAzMTA2MTMyNy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBa0Q7QUFFbEQsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMscUZBQXFGLENBQUMsQ0FBQztJQUNyRyxDQUFDO0lBRVEsS0FBSyxDQUFDLElBQUk7UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyx3RUFBd0UsQ0FBQyxDQUFDO0lBQ3hGLENBQUM7Q0FFRjtBQVZELDBEQVVDIn0=

package/.medusa/server/src/modules/category-master/migrations/Migration20251104045755.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20251104045755 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20251104045755 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`alter table if exists "category_master" drop column if exists "title";`);
+    }
+    async down() {
+        this.addSql(`alter table if exists "category_master" add column if not exists "title" text null;`);
+    }
+}
+exports.Migration20251104045755 = Migration20251104045755;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTExMDQwNDU3NTUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jYXRlZ29yeS1tYXN0ZXIvbWlncmF0aW9ucy9NaWdyYXRpb24yMDI1MTEwNDA0NTc1NS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxzREFBa0Q7QUFFbEQsTUFBYSx1QkFBd0IsU0FBUSxzQkFBUztJQUUzQyxLQUFLLENBQUMsRUFBRTtRQUNmLElBQUksQ0FBQyxNQUFNLENBQUMsd0VBQXdFLENBQUMsQ0FBQztJQUN4RixDQUFDO0lBRVEsS0FBSyxDQUFDLElBQUk7UUFDakIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxxRkFBcUYsQ0FBQyxDQUFDO0lBQ3JHLENBQUM7Q0FFRjtBQVZELDBEQVVDIn0=

package/.medusa/server/src/modules/collection-group-master/migrations/Migration20251031061432.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20251031061432 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20251031061432 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`alter table if exists "collection_group_master" add column if not exists "title" text null;`);
+    }
+    async down() {
+        this.addSql(`alter table if exists "collection_group_master" drop column if exists "title";`);
+    }
+}
+exports.Migration20251031061432 = Migration20251031061432;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTEwMzEwNjE0MzIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jb2xsZWN0aW9uLWdyb3VwLW1hc3Rlci9taWdyYXRpb25zL01pZ3JhdGlvbjIwMjUxMDMxMDYxNDMyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHNEQUFrRDtBQUVsRCxNQUFhLHVCQUF3QixTQUFRLHNCQUFTO0lBRTNDLEtBQUssQ0FBQyxFQUFFO1FBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQyw2RkFBNkYsQ0FBQyxDQUFDO0lBQzdHLENBQUM7SUFFUSxLQUFLLENBQUMsSUFBSTtRQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLGdGQUFnRixDQUFDLENBQUM7SUFDaEcsQ0FBQztDQUVGO0FBVkQsMERBVUMifQ==

package/.medusa/server/src/modules/collection-group-master/migrations/Migration20251104050102.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20251104050102 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20251104050102 extends migrations_1.Migration {
+    async up() {
+        this.addSql(`alter table if exists "collection_group_master" drop column if exists "title";`);
+    }
+    async down() {
+        this.addSql(`alter table if exists "collection_group_master" add column if not exists "title" text null;`);
+    }
+}
+exports.Migration20251104050102 = Migration20251104050102;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWlncmF0aW9uMjAyNTExMDQwNTAxMDIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9jb2xsZWN0aW9uLWdyb3VwLW1hc3Rlci9taWdyYXRpb25zL01pZ3JhdGlvbjIwMjUxMTA0MDUwMTAyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHNEQUFrRDtBQUVsRCxNQUFhLHVCQUF3QixTQUFRLHNCQUFTO0lBRTNDLEtBQUssQ0FBQyxFQUFFO1FBQ2YsSUFBSSxDQUFDLE1BQU0sQ0FBQyxnRkFBZ0YsQ0FBQyxDQUFDO0lBQ2hHLENBQUM7SUFFUSxLQUFLLENBQUMsSUFBSTtRQUNqQixJQUFJLENBQUMsTUFBTSxDQUFDLDZGQUE2RixDQUFDLENBQUM7SUFDN0csQ0FBQztDQUVGO0FBVkQsMERBVUMifQ==