@mercurjs/core 2.1.2 → 2.2.0-canary.1

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

@@ -0,0 +1,1471 @@
+"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 _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const types_1 = require("@mercurjs/types");
+const models_1 = require("./models");
+const ProductModuleServiceBase = (0, utils_1.MedusaService)({
+    Product: models_1.Product,
+    ProductAttribute: models_1.ProductAttribute,
+    ProductAttributeValue: models_1.ProductAttributeValue,
+    ProductBrand: models_1.ProductBrand,
+    ProductCategory: models_1.ProductCategory,
+    ProductChange: models_1.ProductChange,
+    ProductChangeAction: models_1.ProductChangeAction,
+    ProductCollection: models_1.ProductCollection,
+    ProductImage: models_1.ProductImage,
+    ProductTag: models_1.ProductTag,
+    ProductType: models_1.ProductType,
+    ProductVariant: models_1.ProductVariant,
+    ProductVariantProductImage: models_1.ProductVariantProductImage,
+});
+class ProductModuleService extends ProductModuleServiceBase {
+    constructor(container) {
+        super(...arguments);
+        this.productCategoryService_ = container.productCategoryService;
+    }
+    __joinerConfig() {
+        return (0, utils_1.defineJoinerConfig)(utils_1.Modules.PRODUCT, {
+            models: [
+                models_1.Product,
+                models_1.ProductAttribute,
+                models_1.ProductAttributeValue,
+                models_1.ProductBrand,
+                models_1.ProductCategory,
+                models_1.ProductChange,
+                models_1.ProductChangeAction,
+                models_1.ProductCollection,
+                models_1.ProductImage,
+                models_1.ProductTag,
+                models_1.ProductType,
+                models_1.ProductVariant,
+                models_1.ProductVariantProductImage,
+            ],
+            alias: [
+                {
+                    name: [
+                        "product_variant",
+                        "product_variants",
+                        "variant",
+                        "variants",
+                    ],
+                    entity: "ProductVariant",
+                    args: {
+                        methodSuffix: "ProductVariants",
+                    },
+                },
+            ],
+        });
+    }
+    async retrieveProduct(id, config, sharedContext) {
+        const product = await super.retrieveProduct(id, config, sharedContext);
+        const productChange = await this.getActiveProductChange_(product.id, true, sharedContext);
+        product.product_change = productChange;
+        this.formatProductAttributes_(product);
+        return product;
+    }
+    async listProducts(filters, config, sharedContext) {
+        const products = await super.listProducts(filters, config, sharedContext);
+        for (const product of products) {
+            this.formatProductAttributes_(product);
+        }
+        return products;
+    }
+    async listAndCountProducts(filters, config, sharedContext) {
+        const [products, count] = await super.listAndCountProducts(filters, config, sharedContext);
+        for (const product of products) {
+            this.formatProductAttributes_(product);
+        }
+        return [products, count];
+    }
+    /**
+     * Computes a unified `attributes` array on the product by merging
+     * variant_attributes, custom_attributes, and attribute_values into
+     * a single grouped structure with values nested under each attribute.
+     */
+    formatProductAttributes_(product) {
+        const hasAttrData = product.variant_attributes ||
+            product.custom_attributes ||
+            product.attribute_values;
+        if (!hasAttrData)
+            return;
+        const attrsById = new Map();
+        // Add variant_attributes (global or product-scoped, used as variant axes)
+        for (const attr of product.variant_attributes ?? []) {
+            attrsById.set(attr.id, { ...attr, values: [...(attr.values ?? [])] });
+        }
+        // Add custom_attributes (product-scoped, non-variant)
+        for (const attr of product.custom_attributes ?? []) {
+            if (!attrsById.has(attr.id)) {
+                attrsById.set(attr.id, {
+                    ...attr,
+                    values: [...(attr.values ?? [])],
+                });
+            }
+        }
+        // Add attributes discovered only via attribute_values
+        // (global non-variant attributes linked through values)
+        for (const val of product.attribute_values ?? []) {
+            if (!val.attribute)
+                continue;
+            const attrId = val.attribute.id ?? val.attribute_id;
+            if (!attrId || attrsById.has(attrId))
+                continue;
+            attrsById.set(attrId, { ...val.attribute, values: [] });
+        }
+        // Filter each attribute's values to only those linked to this product
+        const productValueIds = new Set((product.attribute_values ?? []).map((v) => v.id));
+        for (const attr of attrsById.values()) {
+            attr.values = (attr.values ?? []).filter((v) => productValueIds.has(v.id));
+            attr.values.sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+        }
+        // Sort attributes by rank
+        product.attributes = [...attrsById.values()].sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    }
+    async getActiveProductChange_(productId, includeActions, sharedContext) {
+        const options = {
+            select: [
+                "id",
+                "product_id",
+                "status",
+                "internal_note",
+                "external_note",
+                "created_by",
+                "confirmed_by",
+                "confirmed_at",
+                "declined_by",
+                "declined_at",
+                "declined_reason",
+                "canceled_by",
+                "canceled_at",
+            ],
+            relations: [],
+            order: {},
+        };
+        if (includeActions) {
+            options.select.push("actions");
+            options.relations.push("actions");
+            options.order = {
+                actions: {
+                    ordering: "ASC",
+                },
+            };
+        }
+        const [productChange] = await this.listProductChanges({
+            product_id: productId,
+            status: [types_1.ProductChangeStatus.PENDING],
+        }, options, sharedContext);
+        return productChange;
+    }
+    validateProductHandle_(handle) {
+        if (handle && !(0, utils_1.isValidHandle)(handle)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid product handle '${handle}'. It must contain URL safe characters`);
+        }
+    }
+    validateProductAttributeType_(attr) {
+        const VARIANT_AXIS_ALLOWED = new Set([
+            types_1.AttributeType.MULTI_SELECT,
+        ]);
+        const FILTERABLE_ALLOWED = new Set([
+            types_1.AttributeType.SINGLE_SELECT,
+            types_1.AttributeType.MULTI_SELECT,
+            types_1.AttributeType.TOGGLE,
+            types_1.AttributeType.UNIT,
+        ]);
+        if (attr.is_variant_axis &&
+            attr.type &&
+            !VARIANT_AXIS_ALLOWED.has(attr.type)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute '${attr.name ?? attr.id ?? "(unnamed)"}' (type=${attr.type}) cannot be a variant axis. Only multi_select attributes may drive variants.`);
+        }
+        if (attr.is_filterable &&
+            attr.type &&
+            !FILTERABLE_ALLOWED.has(attr.type)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute '${attr.name ?? attr.id ?? "(unnamed)"}' (type=${attr.type}) cannot be filterable. Only single_select, multi_select, toggle, and unit attributes are filterable.`);
+        }
+    }
+    async normalizeProductInput_(products, sharedContext) {
+        for (const product of products) {
+            // Handle
+            this.validateProductHandle_(product.handle);
+            if (!product.handle && product.title) {
+                product.handle = (0, utils_1.toHandle)(product.title);
+            }
+            // Dimension fields: API accepts numbers, model stores as text
+            if ("weight" in product) {
+                product.weight = product.weight?.toString();
+            }
+            if ("length" in product) {
+                product.length = product.length?.toString();
+            }
+            if ("height" in product) {
+                product.height = product.height?.toString();
+            }
+            if ("width" in product) {
+                product.width = product.width?.toString();
+            }
+            // M:M refs → plain IDs (Medusa pattern: MikroORM needs IDs, not { id } objects)
+            if (product.categories?.length) {
+                product.categories = product.categories.map((c) => (typeof c === "string" ? c : c.id));
+            }
+            if (product.tags?.length) {
+                product.tags = product.tags.map((t) => (typeof t === "string" ? t : t.id));
+            }
+        }
+        // Attribute normalization (variant attrs, product-level attr values, variant attr values)
+        const hasAttributeInput = products.some((p) => p.variant_attributes !== undefined ||
+            p.product_attributes !== undefined ||
+            (Array.isArray(p.variants) &&
+                p.variants.some((v) => v?.attribute_values !== undefined)));
+        if (hasAttributeInput) {
+            await this.normalizeAttributes_(products, sharedContext);
+        }
+        return products;
+    }
+    /**
+     * Normalizes product attribute inputs:
+     *
+     * **`variant_attributes`** — each entry is either:
+     *   1. Global attribute ref: `{ attribute_id, value_ids }` → links via M2M
+     *   2. Inline custom attr: `{ name, type, values }` → creates ProductAttribute + values
+     *
+     * **`product_attributes`** — non-variant attributes, same format as variant_attributes.
+     *   Creates product-scoped attributes and links their values to the product.
+     *
+     * **`variant.attribute_values`** — `Record<string, string | string[]>`
+     *   keyed by attribute name/handle, resolved to ProductAttributeValue IDs per variant.
+     */
+    async normalizeAttributes_(products, sharedContext) {
+        // Collect all global attribute IDs referenced (from variant_attributes and product attribute_values)
+        const attrIds = new Set();
+        for (const product of products) {
+            for (const input of product.variant_attributes ?? []) {
+                if (input.attribute_id)
+                    attrIds.add(input.attribute_id);
+            }
+            for (const input of product.product_attributes ?? []) {
+                if (input.attribute_id)
+                    attrIds.add(input.attribute_id);
+            }
+        }
+        // Batch-load referenced global attributes with their values
+        const attrsById = new Map();
+        if (attrIds.size) {
+            const attrs = await super.listProductAttributes({ id: Array.from(attrIds) }, { relations: ["values"] }, sharedContext);
+            for (const a of attrs) {
+                attrsById.set(a.id, a);
+            }
+        }
+        // Process each product
+        for (const product of products) {
+            // Lookup: attr name/handle/id → value name → ProductAttributeValue id
+            // Shared across variant_attributes + product attribute_values + variant attribute_values
+            const valueLookup = new Map();
+            const variantAttrValueIds = [];
+            const variantCustomAttributeIds = [];
+            const productAttrValueIds = [];
+            const customAttributeIds = [];
+            // Collect IDs of all inline-created attributes so we can batch-fetch
+            // their values in a single query after both loops.
+            const createdInlineAttrIds = [];
+            // --- Process variant_attributes ---
+            const attrsInput = product.variant_attributes;
+            if (attrsInput?.length) {
+                const variantAttributeIds = [];
+                for (const input of attrsInput) {
+                    if (input.attribute_id) {
+                        // Global attribute reference
+                        const attr = attrsById.get(input.attribute_id);
+                        if (!attr) {
+                            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Product attribute with id '${input.attribute_id}' was not found`);
+                        }
+                        variantAttributeIds.push(attr.id);
+                        // Validate value_ids if provided
+                        const attrValuesById = new Map();
+                        for (const v of attr.values ?? []) {
+                            attrValuesById.set(v.id, v);
+                        }
+                        if (input.value_ids?.length) {
+                            for (const vid of input.value_ids) {
+                                if (!attrValuesById.has(vid)) {
+                                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute value with id '${vid}' was not found on attribute '${attr.name}'`);
+                                }
+                                variantAttrValueIds.push(vid);
+                            }
+                        }
+                        // Build lookup
+                        this.addAttrToLookup_(attr, valueLookup);
+                    }
+                    else {
+                        // Inline custom attribute — create ProductAttribute + values
+                        const customAttr = await this.createProductAttributes({
+                            name: input.name,
+                            type: input.type,
+                            handle: input.name ? (0, utils_1.toHandle)(input.name) : undefined,
+                            is_variant_axis: input.is_variant_axis ?? false,
+                            is_filterable: input.is_filterable ?? false,
+                            is_required: input.is_required ?? false,
+                            description: input.description ?? null,
+                            product_id: product.id ?? null,
+                            metadata: input.metadata ?? null,
+                            values: (input.values ?? []).map((v, i) => ({
+                                name: v,
+                                handle: (0, utils_1.toHandle)(v),
+                                rank: i,
+                            })),
+                        }, sharedContext);
+                        variantAttributeIds.push(customAttr.id);
+                        variantCustomAttributeIds.push(customAttr.id);
+                        createdInlineAttrIds.push(customAttr.id);
+                    }
+                }
+                // Set M2M variant_attributes as IDs
+                product.variant_attributes = variantAttributeIds;
+            }
+            // --- Process product_attributes (non-variant) ---
+            const productAttrsInput = product.product_attributes;
+            if (productAttrsInput?.length) {
+                for (const input of productAttrsInput) {
+                    if (input.attribute_id) {
+                        // Global attribute reference
+                        const attr = attrsById.get(input.attribute_id);
+                        if (!attr) {
+                            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Product attribute with id '${input.attribute_id}' was not found`);
+                        }
+                        this.addAttrToLookup_(attr, valueLookup);
+                        // Collect specified value IDs
+                        if (input.value_ids?.length) {
+                            const attrValuesById = new Map();
+                            for (const v of attr.values ?? []) {
+                                attrValuesById.set(v.id, v);
+                            }
+                            for (const vid of input.value_ids) {
+                                if (!attrValuesById.has(vid)) {
+                                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute value with id '${vid}' was not found on attribute '${attr.name}'`);
+                                }
+                                productAttrValueIds.push(vid);
+                            }
+                        }
+                        // Upsert values by name (for text/unit/toggle attributes)
+                        if (input.values?.length) {
+                            const existingByName = new Map();
+                            for (const v of attr.values ?? []) {
+                                existingByName.set(v.name, v.id);
+                            }
+                            const toCreate = [];
+                            for (const name of input.values) {
+                                const existingId = existingByName.get(name);
+                                if (existingId) {
+                                    productAttrValueIds.push(existingId);
+                                }
+                                else {
+                                    toCreate.push(name);
+                                }
+                            }
+                            if (toCreate.length) {
+                                const created = await this.createProductAttributeValues(toCreate.map((name, i) => ({
+                                    name,
+                                    handle: (0, utils_1.toHandle)(name),
+                                    rank: (attr.values?.length ?? 0) + i,
+                                    attribute_id: attr.id,
+                                })), sharedContext);
+                                const createdArr = Array.isArray(created)
+                                    ? created
+                                    : [created];
+                                for (const v of createdArr) {
+                                    productAttrValueIds.push(v.id);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Inline custom attribute — create and collect value IDs
+                        const customAttr = await this.createProductAttributes({
+                            name: input.name,
+                            type: input.type,
+                            handle: input.name ? (0, utils_1.toHandle)(input.name) : undefined,
+                            is_variant_axis: false,
+                            is_filterable: input.is_filterable ?? false,
+                            is_required: input.is_required ?? false,
+                            description: input.description ?? null,
+                            product_id: product.id ?? null,
+                            metadata: input.metadata ?? null,
+                            values: (input.values ?? []).map((v, i) => ({
+                                name: v,
+                                handle: (0, utils_1.toHandle)(v),
+                                rank: i,
+                            })),
+                        }, sharedContext);
+                        customAttributeIds.push(customAttr.id);
+                        createdInlineAttrIds.push(customAttr.id);
+                    }
+                }
+                delete product.product_attributes;
+            }
+            // Batch-fetch all inline-created attributes with their values in a single query
+            // instead of calling retrieveProductAttribute inside each loop iteration.
+            if (createdInlineAttrIds.length) {
+                const createdAttrs = await super.listProductAttributes({ id: createdInlineAttrIds }, { relations: ["values"] }, sharedContext);
+                const createdAttrsById = new Map();
+                for (const a of createdAttrs) {
+                    createdAttrsById.set(a.id, a);
+                }
+                // Collect value IDs and build lookups from inline-created attributes
+                for (const attrId of variantCustomAttributeIds) {
+                    const attr = createdAttrsById.get(attrId);
+                    if (!attr)
+                        continue;
+                    this.addAttrToLookup_(attr, valueLookup);
+                    for (const v of attr.values ?? []) {
+                        variantAttrValueIds.push(v.id);
+                    }
+                }
+                for (const attrId of customAttributeIds) {
+                    const attr = createdAttrsById.get(attrId);
+                    if (!attr)
+                        continue;
+                    this.addAttrToLookup_(attr, valueLookup);
+                    for (const v of attr.values ?? []) {
+                        productAttrValueIds.push(v.id);
+                    }
+                }
+            }
+            // Stash custom attribute IDs — product_id will be set after product creation
+            const allPendingCustomAttrIds = [
+                ...variantCustomAttributeIds,
+                ...customAttributeIds,
+            ];
+            if (allPendingCustomAttrIds.length) {
+                product.__pending_custom_attribute_ids = allPendingCustomAttrIds;
+            }
+            // Merge variant + product attribute value IDs into attribute_values
+            const allAttrValueIds = [
+                ...variantAttrValueIds,
+                ...productAttrValueIds,
+            ];
+            if (allAttrValueIds.length) {
+                const existing = Array.isArray(product.attribute_values)
+                    ? product.attribute_values
+                    : [];
+                product.attribute_values = [...existing, ...allAttrValueIds];
+            }
+            // --- Resolve variant.attribute_values ---
+            if (Array.isArray(product.variants)) {
+                const hasMapValues = product.variants.some((v) => v?.attribute_values !== undefined &&
+                    !Array.isArray(v.attribute_values));
+                // If variants use map-style attribute_values but no variant_attributes
+                // were provided in this call, load existing product variant attributes
+                // to build the lookup for resolution.
+                if (hasMapValues && valueLookup.size === 0 && product.id) {
+                    const existingProduct = await this.retrieveProduct(product.id, {
+                        select: ["id"],
+                        relations: ["variant_attributes", "variant_attributes.values"],
+                    }, sharedContext);
+                    for (const attr of existingProduct.variant_attributes ??
+                        []) {
+                        this.addAttrToLookup_(attr, valueLookup);
+                    }
+                }
+                for (const variant of product.variants) {
+                    if (variant?.attribute_values === undefined)
+                        continue;
+                    if (Array.isArray(variant.attribute_values))
+                        continue;
+                    variant.attribute_values = this.resolveValueMap_(variant.attribute_values, valueLookup);
+                }
+            }
+        }
+    }
+    /**
+     * Resolves map-style `attribute_values` on variants to arrays of
+     * `ProductAttributeValue` IDs. Variants with `attribute_values` already
+     * an array of IDs (or undefined) are left untouched.
+     *
+     * Looks up each variant's parent product's `variant_attributes` (and their
+     * values) to translate `{ attrKey: "valueName" }` to value IDs.
+     */
+    async normalizeVariantAttributeValues_(variants, sharedContext) {
+        const mapVariants = variants.filter((v) => v.attribute_values !== undefined &&
+            !Array.isArray(v.attribute_values) &&
+            typeof v.attribute_values === "object");
+        if (!mapVariants.length)
+            return;
+        // Resolve missing product_ids by looking up variants by id
+        const variantIdsNeedingProductId = mapVariants
+            .filter((v) => !v.product_id && v.id)
+            .map((v) => v.id);
+        if (variantIdsNeedingProductId.length) {
+            const existing = await super.listProductVariants({ id: variantIdsNeedingProductId }, { select: ["id", "product_id"] }, sharedContext);
+            const variantToProductId = new Map();
+            for (const v of existing) {
+                if (v.product_id)
+                    variantToProductId.set(v.id, v.product_id);
+            }
+            for (const v of mapVariants) {
+                if (!v.product_id && v.id) {
+                    v.product_id = variantToProductId.get(v.id);
+                }
+            }
+        }
+        const productIds = Array.from(new Set(mapVariants.map((v) => v.product_id).filter(Boolean)));
+        if (!productIds.length)
+            return;
+        // Build per-product lookup from variant_attributes + values
+        const products = await this.listProducts({ id: productIds }, {
+            select: ["id"],
+            relations: ["variant_attributes", "variant_attributes.values"],
+        }, sharedContext);
+        const productLookups = new Map();
+        for (const product of products) {
+            const lookup = new Map();
+            for (const attr of product.variant_attributes ?? []) {
+                this.addAttrToLookup_(attr, lookup);
+            }
+            productLookups.set(product.id, lookup);
+        }
+        for (const variant of mapVariants) {
+            if (!variant.product_id)
+                continue;
+            const lookup = productLookups.get(variant.product_id);
+            if (!lookup)
+                continue;
+            variant.attribute_values = this.resolveValueMap_(variant.attribute_values, lookup);
+        }
+    }
+    /**
+     * Adds an attribute's values to the lookup map (name/handle/id → value name → value id).
+     */
+    addAttrToLookup_(attr, lookup) {
+        const valueMap = new Map();
+        for (const v of attr.values ?? []) {
+            valueMap.set(v.name, v.id);
+            if (v.handle)
+                valueMap.set(v.handle, v.id);
+        }
+        if (attr.handle)
+            lookup.set(attr.handle, valueMap);
+        if (attr.name)
+            lookup.set(attr.name, valueMap);
+        lookup.set(attr.id, valueMap);
+    }
+    /**
+     * Resolves `{ attrKey: "valueName" | ["v1", "v2"] }` → array of ProductAttributeValue IDs.
+     */
+    resolveValueMap_(input, lookup) {
+        const resolvedIds = [];
+        for (const [key, raw] of Object.entries(input)) {
+            const valueMap = lookup.get(key);
+            if (!valueMap)
+                continue;
+            const vals = Array.isArray(raw) ? raw : [raw];
+            for (const v of vals) {
+                const valueId = valueMap.get(v);
+                if (valueId)
+                    resolvedIds.push(valueId);
+            }
+        }
+        return resolvedIds;
+    }
+    async retrieveProductAttribute(id, config, sharedContext) {
+        const attribute = await super.retrieveProductAttribute(id, config, sharedContext);
+        await this.resolveSelectAttributeValues_([attribute], config, sharedContext);
+        return attribute;
+    }
+    async listProductAttributes(filters, config, sharedContext) {
+        const attributes = await super.listProductAttributes(filters, config, sharedContext);
+        await this.resolveSelectAttributeValues_(attributes, config, sharedContext);
+        return attributes;
+    }
+    async listAndCountProductAttributes(filters, config, sharedContext) {
+        const [attributes, count] = await super.listAndCountProductAttributes(filters, config, sharedContext);
+        await this.resolveSelectAttributeValues_(attributes, config, sharedContext);
+        return [attributes, count];
+    }
+    /**
+     * For attributes with type single_select or multi_select, resolves their
+     * values via listProductAttributeValues. Non-select attributes keep values empty.
+     * Only runs when the caller requested the "values" relation.
+     */
+    async resolveSelectAttributeValues_(attributes, config, sharedContext) {
+        const requestedRelations = (config?.relations ?? []);
+        if (!requestedRelations.includes("values"))
+            return;
+        if (!attributes.length)
+            return;
+        const SELECT_TYPES = new Set([
+            types_1.AttributeType.SINGLE_SELECT,
+            types_1.AttributeType.MULTI_SELECT,
+        ]);
+        const selectAttrIds = [];
+        for (const attr of attributes) {
+            if (SELECT_TYPES.has(attr.type)) {
+                selectAttrIds.push(attr.id);
+            }
+            else {
+                // Non-select types: clear values
+                attr.values = [];
+            }
+        }
+        if (!selectAttrIds.length)
+            return;
+        // Batch-fetch values for all select-type attributes
+        const values = await super.listProductAttributeValues({ attribute_id: selectAttrIds }, { order: { rank: "ASC" } }, sharedContext);
+        // Group values by attribute_id
+        const valuesByAttrId = new Map();
+        for (const val of values) {
+            const attrId = val.attribute_id ?? val.attribute?.id;
+            if (!attrId)
+                continue;
+            if (!valuesByAttrId.has(attrId)) {
+                valuesByAttrId.set(attrId, []);
+            }
+            valuesByAttrId.get(attrId).push(val);
+        }
+        // Map values onto attributes
+        for (const attr of attributes) {
+            if (SELECT_TYPES.has(attr.type)) {
+                attr.values = valuesByAttrId.get(attr.id) ?? [];
+            }
+        }
+    }
+    // @ts-ignore
+    async createProductAttributes(data, sharedContext) {
+        const input = (Array.isArray(data) ? data : [data]).map((attr) => {
+            this.validateProductAttributeType_(attr);
+            if (!attr.handle && attr.name) {
+                attr.handle = (0, utils_1.toHandle)(attr.name);
+            }
+            return attr;
+        });
+        const result = await super.createProductAttributes(input, sharedContext);
+        // When product_id is set, link created attributes and their values to the product
+        const created = Array.isArray(result) ? result : [result];
+        const attrsWithProductId = created.filter((attr) => !!attr.product_id);
+        if (attrsWithProductId.length) {
+            // Batch-fetch all created attributes with values in a single query
+            const attrIdsToFetch = attrsWithProductId.map((a) => a.id);
+            const fetchedAttrs = await super.listProductAttributes({ id: attrIdsToFetch }, { relations: ["values"] }, sharedContext);
+            const fetchedAttrsById = new Map();
+            for (const a of fetchedAttrs) {
+                fetchedAttrsById.set(a.id, a);
+            }
+            // Batch-fetch all referenced products in a single query
+            const productIds = [
+                ...new Set(attrsWithProductId.map((a) => a.product_id)),
+            ];
+            const products = await this.listProducts({ id: productIds }, {
+                select: ["id"],
+                relations: ["attribute_values", "variant_attributes"],
+            }, sharedContext);
+            const productsById = new Map();
+            for (const p of products) {
+                productsById.set(p.id, p);
+            }
+            // Build update payloads per product
+            const updatesByProductId = new Map();
+            for (const attr of attrsWithProductId) {
+                const productId = attr.product_id;
+                const fetchedAttr = fetchedAttrsById.get(attr.id);
+                const product = productsById.get(productId);
+                if (!product)
+                    continue;
+                if (!updatesByProductId.has(productId)) {
+                    updatesByProductId.set(productId, {
+                        id: productId,
+                        attribute_values: [
+                            ...new Set((product.attribute_values ?? []).map((v) => v.id)),
+                        ],
+                        variant_attributes: [
+                            ...new Set((product.variant_attributes ?? []).map((a) => a.id)),
+                        ],
+                    });
+                }
+                const payload = updatesByProductId.get(productId);
+                // Merge attribute value IDs
+                const valueIds = (fetchedAttr?.values ?? []).map((v) => v.id);
+                for (const vid of valueIds) {
+                    if (!payload.attribute_values.includes(vid)) {
+                        payload.attribute_values.push(vid);
+                    }
+                }
+                // Merge variant attribute ID
+                if (attr.is_variant_axis) {
+                    if (!payload.variant_attributes.includes(attr.id)) {
+                        payload.variant_attributes.push(attr.id);
+                    }
+                }
+            }
+            // Apply all product updates
+            await (0, utils_1.promiseAll)(Array.from(updatesByProductId.values()).map((payload) => super.updateProducts(payload, sharedContext)));
+        }
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    /**
+     * Adds existing global attributes to a product by linking them via the
+     * variant_attributes M2M and their values via the attribute_values M2M.
+     */
+    async addAttributesToProduct(productId, items, sharedContext) {
+        if (!items.length)
+            return;
+        const product = await this.retrieveProduct(productId, {
+            select: ["id"],
+            relations: ["variant_attributes", "attribute_values"],
+        }, sharedContext);
+        const existingVariantAttrIds = new Set((product.variant_attributes ?? []).map((a) => a.id));
+        const existingValueIds = new Set((product.attribute_values ?? []).map((v) => v.id));
+        // Batch-fetch all referenced attributes with their values in a single query
+        const attrIdsToFetch = items.map((item) => item.attribute_id);
+        const fetchedAttrs = await super.listProductAttributes({ id: attrIdsToFetch }, { relations: ["values"] }, sharedContext);
+        const fetchedAttrsById = new Map();
+        for (const a of fetchedAttrs) {
+            fetchedAttrsById.set(a.id, a);
+        }
+        const newAttrIds = new Set();
+        const newValueIds = new Set();
+        for (const item of items) {
+            const attr = fetchedAttrsById.get(item.attribute_id);
+            if (!attr) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Product attribute with id '${item.attribute_id}' was not found`);
+            }
+            if (attr.product_id) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute '${item.attribute_id}' is product-scoped and cannot be linked to another product`);
+            }
+            newAttrIds.add(attr.id);
+            // Determine which value IDs to link
+            const attrValues = (attr.values ?? []);
+            if (item.attribute_value_ids?.length) {
+                // Select types — reference existing value IDs
+                const validIds = new Set(attrValues.map((v) => v.id));
+                for (const vid of item.attribute_value_ids) {
+                    if (!validIds.has(vid)) {
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute value '${vid}' not found on attribute '${attr.name}'`);
+                    }
+                    newValueIds.add(vid);
+                }
+            }
+            else if (item.values?.length) {
+                // Text/unit/toggle types — find-or-create values by name
+                const existingByName = new Map();
+                for (const v of attrValues) {
+                    existingByName.set(v.name, v.id);
+                }
+                const toCreate = [];
+                for (const name of item.values) {
+                    const existingId = existingByName.get(name);
+                    if (existingId) {
+                        newValueIds.add(existingId);
+                    }
+                    else {
+                        toCreate.push(name);
+                    }
+                }
+                if (toCreate.length) {
+                    const created = await this.createProductAttributeValues(toCreate.map((name, i) => ({
+                        name,
+                        handle: (0, utils_1.toHandle)(name),
+                        rank: attrValues.length + i,
+                        attribute_id: attr.id,
+                    })), sharedContext);
+                    const createdArr = Array.isArray(created) ? created : [created];
+                    for (const v of createdArr) {
+                        newValueIds.add(v.id);
+                    }
+                }
+            }
+            else {
+                // No specific values — link all existing values
+                for (const v of attrValues) {
+                    newValueIds.add(v.id);
+                }
+            }
+        }
+        const mergedAttrIds = [
+            ...new Set([...existingVariantAttrIds, ...newAttrIds]),
+        ];
+        const mergedValueIds = [
+            ...new Set([...existingValueIds, ...newValueIds]),
+        ];
+        await super.updateProducts({
+            id: productId,
+            variant_attributes: mergedAttrIds,
+            attribute_values: mergedValueIds,
+        }, sharedContext);
+    }
+    /**
+     * Removes attributes from a product.
+     *
+     * - If an attribute is a variant axis and any product variant references its
+     *   values, the removal is rejected (variants must be deleted first).
+     * - If an attribute is global (no product_id), it is unlinked from the
+     *   product's M2M relations.
+     * - If an attribute is product-scoped (product_id matches), it is soft-deleted.
+     */
+    async removeAttributeFromProduct(productId, attributeIds, sharedContext) {
+        const ids = Array.isArray(attributeIds) ? attributeIds : [attributeIds];
+        if (!ids.length)
+            return;
+        const product = await this.retrieveProduct(productId, {
+            select: ["id"],
+            relations: [
+                "variant_attributes",
+                "attribute_values",
+                "variants",
+                "variants.attribute_values",
+            ],
+        }, sharedContext);
+        // Batch-fetch all attributes with their values
+        const attributes = await super.listProductAttributes({ id: ids }, { relations: ["values"] }, sharedContext);
+        const attributesById = new Map();
+        for (const a of attributes) {
+            attributesById.set(a.id, a);
+        }
+        // Collect all value IDs to remove and validate variant axis constraints
+        const allAttrValueIds = new Set();
+        const attrIdsToRemove = new Set();
+        const productScopedToDelete = [];
+        const variants = (product.variants ?? []);
+        for (const attrId of ids) {
+            const attribute = attributesById.get(attrId);
+            if (!attribute)
+                continue;
+            const valueIds = (attribute.values ?? []).map((v) => v.id);
+            // If attribute is a variant axis, check for variants using its values
+            if (attribute.is_variant_axis) {
+                const valueIdSet = new Set(valueIds);
+                const hasVariantsWithAttr = variants.some((variant) => (variant.attribute_values ?? []).some((v) => valueIdSet.has(v.id)));
+                if (hasVariantsWithAttr) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot remove variant axis attribute '${attribute.name}' because product variants are using it. Delete those variants first.`);
+                }
+            }
+            attrIdsToRemove.add(attrId);
+            for (const vid of valueIds) {
+                allAttrValueIds.add(vid);
+            }
+            if (attribute.product_id === productId) {
+                productScopedToDelete.push(attrId);
+            }
+        }
+        // Build a single update payload to unlink everything at once
+        const updatePayload = { id: productId };
+        let needsUpdate = false;
+        // Remove attributes from variant_attributes M2M
+        const existingVariantAttrIds = (product.variant_attributes ?? []).map((a) => a.id);
+        const filteredVariantAttrIds = existingVariantAttrIds.filter((id) => !attrIdsToRemove.has(id));
+        if (filteredVariantAttrIds.length !== existingVariantAttrIds.length) {
+            updatePayload.variant_attributes = filteredVariantAttrIds;
+            needsUpdate = true;
+        }
+        // Remove attribute values from product's attribute_values M2M
+        if (allAttrValueIds.size) {
+            const existingValueIds = (product.attribute_values ?? []).map((v) => v.id);
+            const filteredValueIds = existingValueIds.filter((id) => !allAttrValueIds.has(id));
+            if (filteredValueIds.length !== existingValueIds.length) {
+                updatePayload.attribute_values = filteredValueIds;
+                needsUpdate = true;
+            }
+        }
+        if (needsUpdate) {
+            await super.updateProducts(updatePayload, sharedContext);
+        }
+        // Soft-delete product-scoped attributes
+        if (productScopedToDelete.length) {
+            await this.softDeleteProductAttributes(productScopedToDelete, {}, sharedContext);
+        }
+    }
+    async updateProductAttributes(idOrSelectorOrData, dataOrContext, sharedContext) {
+        const isSelectorForm = typeof idOrSelectorOrData === "string" ||
+            (!Array.isArray(idOrSelectorOrData) &&
+                dataOrContext &&
+                typeof dataOrContext === "object");
+        if (isSelectorForm) {
+            const update = dataOrContext;
+            this.validateProductAttributeType_(update);
+            // @ts-ignore
+            return await super.updateProductAttributes(idOrSelectorOrData, update, sharedContext);
+        }
+        const data = idOrSelectorOrData;
+        for (const attr of data) {
+            this.validateProductAttributeType_(attr);
+        }
+        // @ts-ignore
+        return await super.updateProductAttributes(data, dataOrContext);
+    }
+    // @ts-ignore
+    async createProductAttributeValues(data, sharedContext) {
+        const input = (Array.isArray(data) ? data : [data]).map((val) => {
+            if (!val.handle && val.name) {
+                val.handle = (0, utils_1.toHandle)(val.name);
+            }
+            return val;
+        });
+        const result = await super.createProductAttributeValues(input, sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    async upsertProductAttributeValues(data, sharedContext) {
+        const forCreate = data.filter((v) => !("id" in v) || !v.id);
+        const forUpdate = data.filter((v) => "id" in v && !!v.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            created = await this.createProductAttributeValues(forCreate, sharedContext);
+        }
+        if (forUpdate.length) {
+            updated = await super.updateProductAttributeValues(forUpdate, sharedContext);
+        }
+        return [...created, ...updated];
+    }
+    async createProductBrands(data, sharedContext) {
+        const input = (Array.isArray(data) ? data : [data]).map((brand) => {
+            if (!brand.handle && brand.name) {
+                brand.handle = (0, utils_1.toHandle)(brand.name);
+            }
+            return brand;
+        });
+        const result = await super.createProductBrands(input, sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    async updateProductBrands(idOrSelectorOrData, dataOrContext, sharedContext) {
+        const isSelectorForm = typeof idOrSelectorOrData === "string" ||
+            (!Array.isArray(idOrSelectorOrData) &&
+                dataOrContext &&
+                typeof dataOrContext === "object");
+        if (isSelectorForm) {
+            const update = dataOrContext;
+            if (!update.handle && update.name) {
+                update.handle = (0, utils_1.toHandle)(update.name);
+            }
+            // @ts-ignore
+            return await super.updateProductBrands(idOrSelectorOrData, update, sharedContext);
+        }
+        const data = idOrSelectorOrData;
+        const input = data.map((brand) => {
+            if (!brand.handle && brand.name) {
+                brand.handle = (0, utils_1.toHandle)(brand.name);
+            }
+            return brand;
+        });
+        // @ts-ignore
+        return await super.updateProductBrands(input, dataOrContext);
+    }
+    async createProducts(data, sharedContext) {
+        const input = Array.isArray(data) ? data : [data];
+        await this.normalizeProductInput_(input, sharedContext);
+        // Extract pending custom attribute IDs before passing to super
+        const pendingCustomAttrs = new Map();
+        for (let i = 0; i < input.length; i++) {
+            if (input[i].__pending_custom_attribute_ids) {
+                pendingCustomAttrs.set(i, input[i].__pending_custom_attribute_ids);
+                delete input[i].__pending_custom_attribute_ids;
+            }
+        }
+        const result = await super.createProducts(input, sharedContext);
+        const products = (Array.isArray(result) ? result : [result]);
+        // Assign product_id to custom attributes now that products have IDs
+        for (const [index, attrIds] of pendingCustomAttrs) {
+            const productId = products[index].id;
+            await this.updateProductAttributes(attrIds.map((id) => ({ id, product_id: productId })), sharedContext);
+        }
+        return (Array.isArray(data) ? products : products[0]);
+    }
+    async updateProducts(idOrSelectorOrData, dataOrContext, sharedContext) {
+        const isSelectorForm = typeof idOrSelectorOrData === "string" ||
+            (!Array.isArray(idOrSelectorOrData) &&
+                dataOrContext &&
+                typeof dataOrContext === "object");
+        if (isSelectorForm) {
+            const update = dataOrContext;
+            // For selector/id form with attributes, expand to array form
+            const hasAttributeInput = update.variant_attributes !== undefined ||
+                update.product_attributes !== undefined ||
+                (Array.isArray(update.variants) &&
+                    update.variants.some((v) => v?.attribute_values !== undefined));
+            if (hasAttributeInput) {
+                const wasIdForm = typeof idOrSelectorOrData === "string";
+                let productIds;
+                if (wasIdForm) {
+                    productIds = [idOrSelectorOrData];
+                }
+                else {
+                    const products = await this.listProducts(idOrSelectorOrData, { select: ["id"] }, sharedContext);
+                    productIds = products.map((p) => p.id);
+                }
+                if (!productIds.length) {
+                    return wasIdForm ? undefined : [];
+                }
+                const batch = productIds.map((id) => ({
+                    id,
+                    ...update,
+                }));
+                await this.normalizeProductInput_(batch, sharedContext);
+                // @ts-ignore
+                const results = await super.updateProducts(batch, sharedContext);
+                const arr = Array.isArray(results) ? results : [results];
+                return (wasIdForm ? arr[0] : arr);
+            }
+            // Simple path: normalize in place
+            await this.normalizeProductInput_([update], sharedContext);
+            // @ts-ignore
+            return await super.updateProducts(idOrSelectorOrData, update, sharedContext);
+        }
+        const input = idOrSelectorOrData;
+        await this.normalizeProductInput_(input, sharedContext);
+        // @ts-ignore
+        return await super.updateProducts(input, dataOrContext);
+    }
+    async createProductVariants(data, sharedContext) {
+        const input = Array.isArray(data) ? data : [data];
+        await this.normalizeVariantAttributeValues_(input, sharedContext);
+        // @ts-ignore
+        const result = await super.createProductVariants(input, sharedContext);
+        const variants = (Array.isArray(result) ? result : [result]);
+        return Array.isArray(data) ? variants : variants[0];
+    }
+    async upsertProductVariants(data, sharedContext) {
+        const input = Array.isArray(data) ? data : [data];
+        const forUpdate = input.filter((v) => !!v.id);
+        const forCreate = input.filter((v) => !v.id);
+        let created = [];
+        let updated = [];
+        if (forCreate.length) {
+            const result = await this.createProductVariants(forCreate, sharedContext);
+            created = (Array.isArray(result) ? result : [result]);
+        }
+        if (forUpdate.length) {
+            const result = await this.updateProductVariants(forUpdate, sharedContext);
+            updated = (Array.isArray(result) ? result : [result]);
+        }
+        const all = [...created, ...updated];
+        return Array.isArray(data) ? all : all[0];
+    }
+    async updateProductVariants(idOrSelectorOrData, dataOrContext, sharedContext) {
+        const isSelectorForm = typeof idOrSelectorOrData === "string" ||
+            (!Array.isArray(idOrSelectorOrData) &&
+                dataOrContext &&
+                typeof dataOrContext === "object");
+        if (isSelectorForm) {
+            const update = dataOrContext;
+            // Map-style attribute_values must resolve per variant (each may have a
+            // different parent product), so expand selector/id form to array form.
+            const hasMapAttrValues = update?.attribute_values !== undefined &&
+                !Array.isArray(update.attribute_values) &&
+                typeof update.attribute_values === "object";
+            if (hasMapAttrValues) {
+                const wasIdForm = typeof idOrSelectorOrData === "string";
+                let variantIds;
+                if (wasIdForm) {
+                    variantIds = [idOrSelectorOrData];
+                }
+                else {
+                    const variants = await super.listProductVariants(idOrSelectorOrData, { select: ["id"] }, sharedContext);
+                    variantIds = variants.map((v) => v.id);
+                }
+                if (!variantIds.length) {
+                    return wasIdForm ? undefined : [];
+                }
+                const batch = variantIds.map((id) => ({
+                    id,
+                    ...update,
+                }));
+                await this.normalizeVariantAttributeValues_(batch, sharedContext);
+                // @ts-ignore
+                const results = await super.updateProductVariants(batch, sharedContext);
+                const arr = Array.isArray(results) ? results : [results];
+                return (wasIdForm ? arr[0] : arr);
+            }
+            // @ts-ignore
+            return await super.updateProductVariants(idOrSelectorOrData, update, sharedContext);
+        }
+        const data = idOrSelectorOrData;
+        await this.normalizeVariantAttributeValues_(data, sharedContext);
+        // @ts-ignore
+        return await super.updateProductVariants(data, dataOrContext);
+    }
+    async createProductCategories(data, sharedContext) {
+        const input = (Array.isArray(data) ? data : [data]).map((category) => {
+            category.handle ??= (0, utils_1.kebabCase)(category.name);
+            return category;
+        });
+        const categories = await this.productCategoryService_.create(input, sharedContext);
+        return Array.isArray(data) ? categories : categories[0];
+    }
+    async updateProductCategories(data, sharedContext) {
+        let normalizedInput;
+        if (typeof data === "object" && !Array.isArray(data) && data.id) {
+            normalizedInput = [data];
+        }
+        else if (Array.isArray(data)) {
+            normalizedInput = data;
+        }
+        else {
+            normalizedInput = [data];
+        }
+        const categories = await this.productCategoryService_.update(normalizedInput, sharedContext);
+        return Array.isArray(data) ? categories : categories[0];
+    }
+    async retrieveProductCategory(id, config, sharedContext) {
+        return await this.productCategoryService_.retrieve(id, config, sharedContext);
+    }
+    async listProductCategories(filters, config, sharedContext) {
+        return await this.productCategoryService_.list(filters, config, sharedContext);
+    }
+    async listAndCountProductCategories(filters, config, sharedContext) {
+        return await this.productCategoryService_.listAndCount(filters, config, sharedContext);
+    }
+    async deleteProductCategories(ids, sharedContext) {
+        const idsArray = Array.isArray(ids) ? ids : [ids];
+        return await this.productCategoryService_.delete(idsArray, sharedContext);
+    }
+    async softDeleteProductCategories(ids, sharedContext) {
+        const idsArray = Array.isArray(ids) ? ids : [ids];
+        return await this.productCategoryService_.softDelete(idsArray, sharedContext);
+    }
+    async restoreProductCategories(ids, sharedContext) {
+        const idsArray = Array.isArray(ids) ? ids : [ids];
+        return await this.productCategoryService_.restore(idsArray, sharedContext);
+    }
+    // --- ProductChange lifecycle methods ---
+    /**
+     * Confirms one or more pending product changes and applies their actions
+     * to the underlying products. Mirrors Medusa's `confirmOrderChange`:
+     * validation + status update + action application happen atomically.
+     *
+     * `internal_note` is operator-only context. `external_note` is the
+     * vendor-visible message (e.g. rejection / changes-required reason)
+     * that is also forwarded to notification subscribers.
+     */
+    async confirmProductChange(data, sharedContext) {
+        const items = Array.isArray(data) ? data : [data];
+        const ids = items.map((i) => i.id);
+        const changes = await this.listProductChanges({ id: ids }, {
+            select: ["id", "status", "actions"],
+            relations: ["actions"],
+            order: { actions: { ordering: "ASC" } },
+        }, sharedContext);
+        if (changes.length !== ids.length) {
+            const found = new Set(changes.map((c) => c.id));
+            const missing = ids.filter((id) => !found.has(id));
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Product change(s) not found: ${missing.join(", ")}`);
+        }
+        for (const change of changes) {
+            if (change.status !== types_1.ProductChangeStatus.PENDING) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot confirm product change '${change.id}' with status '${change.status}'. Only pending changes can be confirmed.`);
+            }
+        }
+        await this.updateProductChanges(items.map((item) => {
+            const update = {
+                id: item.id,
+                status: types_1.ProductChangeStatus.CONFIRMED,
+                confirmed_by: item.confirmed_by,
+                confirmed_at: new Date(),
+            };
+            if (item.internal_note !== undefined) {
+                update.internal_note = item.internal_note;
+            }
+            if (item.external_note !== undefined) {
+                update.external_note = item.external_note;
+            }
+            return update;
+        }), sharedContext);
+        const allActions = changes.flatMap((c) => c.actions ?? []);
+        await this.applyProductChangeActions_(allActions, sharedContext);
+    }
+    /**
+     * Applies pending change actions to their products. Public entrypoint
+     * for callers that want to apply without confirming (e.g. previewing
+     * effects). Internally delegates to the same routine `confirmProductChange`
+     * uses.
+     */
+    async applyProductChangeActions(actions, sharedContext) {
+        await this.applyProductChangeActions_(actions, sharedContext);
+    }
+    async applyProductChangeActions_(actions, sharedContext) {
+        const pending = (actions ?? []).filter((a) => !a.applied);
+        if (!pending.length)
+            return;
+        // Bucket actions per type so each kind dispatches in one DB round.
+        const productUpdatesByProductId = new Map();
+        const variantsToCreate = [];
+        const variantUpdates = [];
+        const variantsToDelete = [];
+        const attributeAddsByProductId = new Map();
+        const attributeRemovesByProductId = new Map();
+        const productsToDelete = new Set();
+        for (const action of pending) {
+            const details = (action.details ?? {});
+            switch (action.action) {
+                case types_1.ProductChangeActionType.STATUS_CHANGE: {
+                    const status = details.status;
+                    if (status === undefined)
+                        break;
+                    const update = productUpdatesByProductId.get(action.product_id) ??
+                        { id: action.product_id };
+                    update.status = status;
+                    productUpdatesByProductId.set(action.product_id, update);
+                    break;
+                }
+                case types_1.ProductChangeActionType.UPDATE: {
+                    const { field, value } = details;
+                    if (!field)
+                        break;
+                    const update = productUpdatesByProductId.get(action.product_id) ??
+                        { id: action.product_id };
+                    update[field] = value;
+                    productUpdatesByProductId.set(action.product_id, update);
+                    break;
+                }
+                case types_1.ProductChangeActionType.VARIANT_ADD: {
+                    const variant = details
+                        .variant;
+                    if (!variant)
+                        break;
+                    variantsToCreate.push({
+                        ...variant,
+                        product_id: action.product_id,
+                    });
+                    break;
+                }
+                case types_1.ProductChangeActionType.VARIANT_UPDATE: {
+                    const { variant_id, fields } = details;
+                    if (!variant_id || !fields || !Object.keys(fields).length)
+                        break;
+                    variantUpdates.push({
+                        id: variant_id,
+                        ...fields,
+                    });
+                    break;
+                }
+                case types_1.ProductChangeActionType.VARIANT_REMOVE: {
+                    const { variant_id } = details;
+                    if (variant_id)
+                        variantsToDelete.push(variant_id);
+                    break;
+                }
+                case types_1.ProductChangeActionType.ATTRIBUTE_ADD: {
+                    const { attribute_id, attribute_value_ids, values } = details;
+                    if (!attribute_id)
+                        break;
+                    const list = attributeAddsByProductId.get(action.product_id) ?? [];
+                    list.push({ attribute_id, attribute_value_ids, values });
+                    attributeAddsByProductId.set(action.product_id, list);
+                    break;
+                }
+                case types_1.ProductChangeActionType.ATTRIBUTE_REMOVE: {
+                    const { attribute_id } = details;
+                    if (!attribute_id)
+                        break;
+                    const list = attributeRemovesByProductId.get(action.product_id) ?? [];
+                    list.push(attribute_id);
+                    attributeRemovesByProductId.set(action.product_id, list);
+                    break;
+                }
+                case types_1.ProductChangeActionType.PRODUCT_DELETE: {
+                    productsToDelete.add(action.product_id);
+                    break;
+                }
+            }
+        }
+        // Top-level Product field + status updates — one call per product.
+        const productUpdates = Array.from(productUpdatesByProductId.values()).filter((u) => Object.keys(u).length > 1);
+        if (productUpdates.length) {
+            await this.updateProducts(productUpdates, sharedContext);
+        }
+        // Variant deletes first — frees up SKU/title uniqueness for adds in the
+        // same change. Updates last so they see a stable variant set.
+        if (variantsToDelete.length) {
+            await this.deleteProductVariants(variantsToDelete, sharedContext);
+        }
+        if (variantsToCreate.length) {
+            await this.createProductVariants(variantsToCreate, sharedContext);
+        }
+        if (variantUpdates.length) {
+            await this.updateProductVariants(variantUpdates, sharedContext);
+        }
+        // Attribute removes before adds so the same attribute can be re-linked
+        // with a different value set in a single change.
+        for (const [productId, attrIds] of attributeRemovesByProductId) {
+            await this.removeAttributeFromProduct(productId, attrIds, sharedContext);
+        }
+        for (const [productId, items] of attributeAddsByProductId) {
+            await this.addAttributesToProduct(productId, items, sharedContext);
+        }
+        // Product deletes happen last — any audit-trail updates above still
+        // write through before the product is gone. Soft-delete preserves the
+        // ProductChange record (it stays linked to the now-deleted product so
+        // the change history remains queryable).
+        if (productsToDelete.size) {
+            await this.softDeleteProducts(Array.from(productsToDelete), {}, sharedContext);
+        }
+        await this.updateProductChangeActions(pending.map((a) => ({ id: a.id, applied: true })), sharedContext);
+    }
+    async declineProductChange(id, data, sharedContext) {
+        const change = await this.retrieveProductChange(id, {}, sharedContext);
+        if (change.status !== types_1.ProductChangeStatus.PENDING) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot decline product change with status '${change.status}'. Only pending changes can be declined.`);
+        }
+        await this.updateProductChanges({
+            id,
+            status: types_1.ProductChangeStatus.DECLINED,
+            declined_by: data.declined_by,
+            declined_at: new Date(),
+            declined_reason: data.declined_reason,
+        }, sharedContext);
+    }
+    async cancelProductChange(id, data, sharedContext) {
+        const change = await this.retrieveProductChange(id, {}, sharedContext);
+        if (change.status !== types_1.ProductChangeStatus.PENDING) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot cancel product change with status '${change.status}'. Only pending changes can be canceled.`);
+        }
+        const update = {
+            id,
+            status: types_1.ProductChangeStatus.CANCELED,
+            canceled_by: data.canceled_by,
+            canceled_at: new Date(),
+        };
+        if (data.internal_note !== undefined) {
+            update.internal_note = data.internal_note;
+        }
+        await this.updateProductChanges(update, sharedContext);
+    }
+    async addProductAction(data, sharedContext) {
+        const items = Array.isArray(data) ? data : [data];
+        for (const item of items) {
+            if (item.applied)
+                continue;
+            const change = await this.retrieveProductChange(item.product_change_id, {}, sharedContext);
+            if (change.status !== types_1.ProductChangeStatus.PENDING) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, `Cannot add action to product change with status '${change.status}'. Only pending changes accept actions.`);
+            }
+        }
+        const result = await this.createProductChangeActions(items.map((item) => ({
+            product_change_id: item.product_change_id,
+            product_id: item.product_id,
+            action: item.action,
+            details: item.details ?? {},
+            internal_note: item.internal_note,
+            applied: item.applied,
+        })), sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+}
+__decorate([
+    (0, utils_1.InjectTransactionManager)()
+    // @ts-ignore
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_a = typeof TInput !== "undefined" && TInput) === "function" ? _a : Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createProductAttributes", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "addAttributesToProduct", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "removeAttributeFromProduct", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProductAttributes", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)()
+    // @ts-ignore
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [typeof (_b = typeof TInput !== "undefined" && TInput) === "function" ? _b : Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createProductAttributeValues", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertProductAttributeValues", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createProductBrands", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProductBrands", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createProducts", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProducts", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "createProductVariants", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "upsertProductVariants", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "updateProductVariants", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "confirmProductChange", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "applyProductChangeActions", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "declineProductChange", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "cancelProductChange", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], ProductModuleService.prototype, "addProductAction", null);
+exports.default = ProductModuleService;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/product/service.ts"],"names":[],"mappings":"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"}