@hed-hog/catalog 0.0.293 → 0.0.295

package/dist/catalog.service.js

@@ -13,12 +13,14 @@ exports.CatalogService = void 0;
 const api_locale_1 = require("@hed-hog/api-locale");
 const api_pagination_1 = require("@hed-hog/api-pagination");
 const api_prisma_1 = require("@hed-hog/api-prisma");
+const core_1 = require("@hed-hog/core");
 const common_1 = require("@nestjs/common");
 const catalog_resource_config_1 = require("./catalog-resource.config");
 let CatalogService = class CatalogService {
-    constructor(prisma, pagination) {
+    constructor(prisma, pagination, aiService) {
         this.prisma = prisma;
         this.pagination = pagination;
+        this.aiService = aiService;
     }
     getConfig(resource, locale) {
         const config = catalog_resource_config_1.catalogResourceMap.get(resource);
@@ -29,7 +31,11 @@ let CatalogService = class CatalogService {
     }
     getModel(resource, locale) {
         const config = this.getConfig(resource, locale);
-        return this.prisma[config.model];
+        const model = this.prisma[config.model];
+        if (!model) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('resourceNotSupported', locale, `Model "${config.model}" is not available`));
+        }
+        return model;
     }
     normalizeValue(value) {
         if (value === 'true') {
@@ -43,11 +49,500 @@ let CatalogService = class CatalogService {
         }
         return value;
     }
+    extractJsonObject(content) {
+        var _a;
+        const trimmed = String(content !== null && content !== void 0 ? content : '').trim();
+        if (!trimmed) {
+            throw new common_1.BadRequestException('AI returned an empty response');
+        }
+        const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+        const candidate = ((_a = fencedMatch === null || fencedMatch === void 0 ? void 0 : fencedMatch[1]) === null || _a === void 0 ? void 0 : _a.trim()) || trimmed;
+        try {
+            return JSON.parse(candidate);
+        }
+        catch (_b) {
+            const firstBraceIndex = candidate.indexOf('{');
+            const lastBraceIndex = candidate.lastIndexOf('}');
+            if (firstBraceIndex >= 0 && lastBraceIndex > firstBraceIndex) {
+                try {
+                    return JSON.parse(candidate.slice(firstBraceIndex, lastBraceIndex + 1));
+                }
+                catch (_c) {
+                    throw new common_1.BadRequestException('AI returned an invalid JSON payload');
+                }
+            }
+            throw new common_1.BadRequestException('AI returned an invalid JSON payload');
+        }
+    }
+    normalizeComparableText(value) {
+        return String(value !== null && value !== void 0 ? value : '')
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .trim()
+            .toLowerCase();
+    }
+    normalizeAiFieldContext(resource, fields) {
+        const config = catalog_resource_config_1.catalogResourceMap.get(resource);
+        if (!config) {
+            return [];
+        }
+        const allowedKeys = new Set(config.fields);
+        return fields
+            .map((field) => {
+            var _a, _b, _c, _d;
+            const key = String((_a = field.key) !== null && _a !== void 0 ? _a : '').trim();
+            if (!key || !allowedKeys.has(key)) {
+                return null;
+            }
+            const options = Array.isArray(field.options)
+                ? field.options
+                    .map((option) => {
+                    var _a, _b;
+                    return ({
+                        value: String((_a = option.value) !== null && _a !== void 0 ? _a : '').trim(),
+                        label: String((_b = option.label) !== null && _b !== void 0 ? _b : '').trim(),
+                    });
+                })
+                    .filter((option) => option.value && option.label)
+                : [];
+            const relationData = field.relation && typeof field.relation === 'object'
+                ? field.relation
+                : null;
+            return {
+                key,
+                label: String((_b = field.label) !== null && _b !== void 0 ? _b : key),
+                type: String((_c = field.type) !== null && _c !== void 0 ? _c : 'text'),
+                required: Boolean((_d = field.required) !== null && _d !== void 0 ? _d : false),
+                options,
+                relation: relationData
+                    ? {
+                        endpoint: relationData.endpoint
+                            ? String(relationData.endpoint)
+                            : undefined,
+                        resource: relationData.resource
+                            ? String(relationData.resource)
+                            : undefined,
+                        labelKeys: Array.isArray(relationData.labelKeys)
+                            ? relationData.labelKeys.map((item) => String(item))
+                            : [],
+                    }
+                    : null,
+            };
+        })
+            .filter(Boolean);
+    }
+    normalizeBooleanSuggestion(value) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'number') {
+            return value !== 0;
+        }
+        const normalized = this.normalizeComparableText(value);
+        if (!normalized) {
+            return null;
+        }
+        if (['true', '1', 'yes', 'y', 'sim', 'ativo', 'active', 'enabled'].includes(normalized)) {
+            return true;
+        }
+        if (['false', '0', 'no', 'n', 'nao', 'não', 'inativo', 'inactive', 'disabled'].includes(normalized)) {
+            return false;
+        }
+        return null;
+    }
+    normalizeNumberSuggestion(value) {
+        if (typeof value === 'number') {
+            return Number.isFinite(value) ? value : null;
+        }
+        const raw = String(value !== null && value !== void 0 ? value : '').trim();
+        if (!raw) {
+            return null;
+        }
+        const normalized = raw.replace(/[^\d,.\-]/g, '').replace(',', '.');
+        const parsed = Number(normalized);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    normalizeSelectSuggestion(rawValue, options) {
+        var _a;
+        const normalized = this.normalizeComparableText(rawValue);
+        if (!normalized) {
+            return null;
+        }
+        const exact = options.find((option) => {
+            return (this.normalizeComparableText(option.value) === normalized ||
+                this.normalizeComparableText(option.label) === normalized);
+        });
+        if (exact) {
+            return exact.value;
+        }
+        const partial = options.find((option) => {
+            return (this.normalizeComparableText(option.value).includes(normalized) ||
+                normalized.includes(this.normalizeComparableText(option.value)) ||
+                this.normalizeComparableText(option.label).includes(normalized) ||
+                normalized.includes(this.normalizeComparableText(option.label)));
+        });
+        return (_a = partial === null || partial === void 0 ? void 0 : partial.value) !== null && _a !== void 0 ? _a : null;
+    }
+    async resolveRelationSuggestion(field, rawValue) {
+        if (rawValue === null || rawValue === undefined || rawValue === '') {
+            return null;
+        }
+        const relation = field.relation;
+        if (!relation) {
+            return null;
+        }
+        const modelInfo = (() => {
+            var _a, _b, _c;
+            if (relation.resource) {
+                const config = catalog_resource_config_1.catalogResourceMap.get(relation.resource);
+                if (config) {
+                    return {
+                        model: config.model,
+                        searchFields: ((_a = relation.labelKeys) === null || _a === void 0 ? void 0 : _a.length) ? relation.labelKeys : config.searchFields,
+                        idField: 'id',
+                    };
+                }
+            }
+            if (relation.endpoint === '/locale') {
+                return {
+                    model: 'locale',
+                    searchFields: ((_b = relation.labelKeys) === null || _b === void 0 ? void 0 : _b.length) ? relation.labelKeys : ['name', 'code'],
+                    idField: 'id',
+                };
+            }
+            if (relation.endpoint === '/content') {
+                return {
+                    model: 'content',
+                    searchFields: ((_c = relation.labelKeys) === null || _c === void 0 ? void 0 : _c.length) ? relation.labelKeys : ['title', 'slug'],
+                    idField: 'id',
+                };
+            }
+            return null;
+        })();
+        if (!modelInfo) {
+            return null;
+        }
+        const model = this.prisma[modelInfo.model];
+        if (!(model === null || model === void 0 ? void 0 : model.findMany)) {
+            return null;
+        }
+        const numericId = this.normalizeNumberSuggestion(rawValue);
+        if (numericId && Number.isInteger(numericId)) {
+            const byId = await model.findUnique({
+                where: { [modelInfo.idField]: numericId },
+            });
+            if (byId) {
+                return Number(byId[modelInfo.idField]);
+            }
+        }
+        const needle = String(rawValue !== null && rawValue !== void 0 ? rawValue : '').trim();
+        if (!needle) {
+            return null;
+        }
+        const results = await model.findMany({
+            where: {
+                OR: modelInfo.searchFields.map((fieldKey) => ({
+                    [fieldKey]: {
+                        contains: needle,
+                        mode: 'insensitive',
+                    },
+                })),
+            },
+            take: 5,
+        });
+        if (!results.length) {
+            return null;
+        }
+        const normalizedNeedle = this.normalizeComparableText(needle);
+        const exact = results.find((result) => modelInfo.searchFields.some((fieldKey) => {
+            return this.normalizeComparableText(result[fieldKey]) === normalizedNeedle;
+        }));
+        if (exact) {
+            return Number(exact[modelInfo.idField]);
+        }
+        return results.length === 1 ? Number(results[0][modelInfo.idField]) : null;
+    }
+    async normalizeAiFieldSuggestion(field, rawValue, warnings) {
+        if (rawValue === undefined) {
+            return undefined;
+        }
+        if (rawValue === null) {
+            return null;
+        }
+        switch (field.type) {
+            case 'switch': {
+                const value = this.normalizeBooleanSuggestion(rawValue);
+                if (value === null) {
+                    warnings.push(`Boolean field "${field.label}" could not be resolved safely.`);
+                    return undefined;
+                }
+                return value;
+            }
+            case 'number':
+            case 'currency': {
+                const value = this.normalizeNumberSuggestion(rawValue);
+                if (value === null) {
+                    warnings.push(`Numeric field "${field.label}" could not be resolved safely.`);
+                    return undefined;
+                }
+                return value;
+            }
+            case 'select': {
+                const value = this.normalizeSelectSuggestion(rawValue, field.options);
+                if (!value) {
+                    warnings.push(`Select field "${field.label}" returned an invalid option.`);
+                    return undefined;
+                }
+                return value;
+            }
+            case 'relation': {
+                const value = await this.resolveRelationSuggestion(field, rawValue);
+                if (!value) {
+                    warnings.push(`Relation field "${field.label}" could not be resolved safely.`);
+                    return undefined;
+                }
+                return value;
+            }
+            case 'upload':
+                warnings.push(`File field "${field.label}" must still be filled manually.`);
+                return undefined;
+            case 'json':
+                if (typeof rawValue === 'object') {
+                    return rawValue;
+                }
+                try {
+                    return JSON.parse(String(rawValue));
+                }
+                catch (_a) {
+                    warnings.push(`JSON field "${field.label}" returned an invalid value.`);
+                    return undefined;
+                }
+            case 'date':
+            case 'datetime':
+            case 'text':
+            case 'url':
+            case 'textarea':
+            case 'richtext':
+            default:
+                return String(rawValue).trim() || null;
+        }
+    }
+    buildCurrentAttributeValueMap(values) {
+        var _a;
+        const valueMap = new Map();
+        for (const value of values) {
+            const attributeId = Number((_a = value.attribute_id) !== null && _a !== void 0 ? _a : 0);
+            if (!attributeId) {
+                continue;
+            }
+            valueMap.set(attributeId, value);
+        }
+        return valueMap;
+    }
+    buildAttributeContext(attributesPayload, currentAttributeValues) {
+        var _a;
+        const currentMap = this.buildCurrentAttributeValueMap(currentAttributeValues);
+        return ((_a = attributesPayload.groups) !== null && _a !== void 0 ? _a : []).flatMap((group) => group.attributes.map((attribute) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            const current = (_b = (_a = currentMap.get(Number(attribute.id))) !== null && _a !== void 0 ? _a : attribute.value) !== null && _b !== void 0 ? _b : null;
+            const relation = ((_c = attribute.category_attribute) !== null && _c !== void 0 ? _c : {});
+            return {
+                id: Number(attribute.id),
+                slug: String((_d = attribute.slug) !== null && _d !== void 0 ? _d : ''),
+                name: String((_g = (_f = (_e = attribute.label) !== null && _e !== void 0 ? _e : attribute.name) !== null && _f !== void 0 ? _f : attribute.slug) !== null && _g !== void 0 ? _g : ''),
+                data_type: String((_h = attribute.data_type) !== null && _h !== void 0 ? _h : 'text'),
+                unit: attribute.unit ? String(attribute.unit) : null,
+                group_name: String((_j = group.name) !== null && _j !== void 0 ? _j : 'General'),
+                is_required: Boolean((_k = relation.is_required) !== null && _k !== void 0 ? _k : false),
+                is_highlight: Boolean((_l = relation.is_highlight) !== null && _l !== void 0 ? _l : false),
+                is_filter_visible: Boolean((_m = relation.is_filter_visible) !== null && _m !== void 0 ? _m : true),
+                is_comparison_visible: Boolean((_o = relation.is_comparison_visible) !== null && _o !== void 0 ? _o : false),
+                options: Array.isArray(attribute.options)
+                    ? attribute.options.map((option) => {
+                        var _a, _b, _c, _d;
+                        return ({
+                            id: Number(option.id),
+                            slug: String((_a = option.slug) !== null && _a !== void 0 ? _a : ''),
+                            label: String((_c = (_b = option.label) !== null && _b !== void 0 ? _b : option.option_value) !== null && _c !== void 0 ? _c : ''),
+                            option_value: String((_d = option.option_value) !== null && _d !== void 0 ? _d : ''),
+                            normalized_value: option.normalized_value
+                                ? String(option.normalized_value)
+                                : null,
+                        });
+                    })
+                    : [],
+                current_value: current,
+            };
+        }));
+    }
+    async normalizeAiProductAttributeSuggestions(categoryId, rawSuggestions, currentAttributeValues, warnings) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (!categoryId || rawSuggestions === undefined || rawSuggestions === null) {
+            return [];
+        }
+        const attributesPayload = await this.buildCategoryAttributePayload(categoryId);
+        const attributeContext = this.buildAttributeContext(attributesPayload, currentAttributeValues);
+        const normalizedEntries = Array.isArray(rawSuggestions)
+            ? rawSuggestions
+            : rawSuggestions && typeof rawSuggestions === 'object'
+                ? Object.entries(rawSuggestions).map(([slug, value]) => (Object.assign({ slug }, (value && typeof value === 'object'
+                    ? value
+                    : { value }))))
+                : [];
+        const normalizedSuggestions = [];
+        for (const entry of normalizedEntries) {
+            const entryRecord = (entry && typeof entry === 'object'
+                ? entry
+                : { value: entry });
+            const rawIdentifier = (_e = (_d = (_c = (_b = (_a = entryRecord.slug) !== null && _a !== void 0 ? _a : entryRecord.attribute_slug) !== null && _b !== void 0 ? _b : entryRecord.code) !== null && _c !== void 0 ? _c : entryRecord.name) !== null && _d !== void 0 ? _d : entryRecord.attribute) !== null && _e !== void 0 ? _e : null;
+            const normalizedIdentifier = this.normalizeComparableText(rawIdentifier);
+            const attribute = attributeContext.find((item) => {
+                var _a;
+                return (item.id === Number((_a = entryRecord.attribute_id) !== null && _a !== void 0 ? _a : 0) ||
+                    this.normalizeComparableText(item.slug) === normalizedIdentifier ||
+                    this.normalizeComparableText(item.name) === normalizedIdentifier);
+            });
+            if (!attribute) {
+                if (rawIdentifier) {
+                    warnings.push(`Structured attribute "${String(rawIdentifier)}" is not available for the selected category.`);
+                }
+                continue;
+            }
+            const rawValue = (_l = (_k = (_j = (_h = (_g = (_f = entryRecord.value) !== null && _f !== void 0 ? _f : entryRecord.value_text) !== null && _g !== void 0 ? _g : entryRecord.value_number) !== null && _h !== void 0 ? _h : entryRecord.value_boolean) !== null && _j !== void 0 ? _j : entryRecord.option) !== null && _k !== void 0 ? _k : entryRecord.option_value) !== null && _l !== void 0 ? _l : entryRecord.label;
+            const draft = {
+                attribute_id: attribute.id,
+                attribute_slug: attribute.slug,
+                attribute_name: attribute.name,
+                data_type: attribute.data_type,
+                group_name: attribute.group_name,
+                value_unit: (_m = attribute.unit) !== null && _m !== void 0 ? _m : null,
+            };
+            if (attribute.data_type === 'option') {
+                const normalizedOption = this.normalizeComparableText((_q = (_p = (_o = entryRecord.option) !== null && _o !== void 0 ? _o : entryRecord.option_value) !== null && _p !== void 0 ? _p : entryRecord.label) !== null && _q !== void 0 ? _q : rawValue);
+                const option = attribute.options.find((item) => {
+                    return (this.normalizeComparableText(item.option_value) === normalizedOption ||
+                        this.normalizeComparableText(item.label) === normalizedOption ||
+                        this.normalizeComparableText(item.slug) === normalizedOption);
+                });
+                if (!option) {
+                    warnings.push(`Option value for "${attribute.name}" could not be resolved safely.`);
+                    continue;
+                }
+                draft.attribute_option_id = option.id;
+                draft.value_text = option.option_value;
+            }
+            else if (attribute.data_type === 'number') {
+                const numberValue = this.normalizeNumberSuggestion(rawValue);
+                if (numberValue === null) {
+                    warnings.push(`Numeric attribute "${attribute.name}" could not be resolved safely.`);
+                    continue;
+                }
+                draft.value_number = numberValue;
+                draft.raw_value = String(numberValue);
+                draft.normalized_value = String(numberValue);
+                if (entryRecord.unit) {
+                    draft.value_unit = String(entryRecord.unit).trim() || attribute.unit || null;
+                }
+            }
+            else if (attribute.data_type === 'boolean') {
+                const booleanValue = this.normalizeBooleanSuggestion(rawValue);
+                if (booleanValue === null) {
+                    warnings.push(`Boolean attribute "${attribute.name}" could not be resolved safely.`);
+                    continue;
+                }
+                draft.value_boolean = booleanValue;
+                draft.raw_value = String(booleanValue);
+                draft.normalized_value = String(booleanValue);
+            }
+            else {
+                const textValue = String(rawValue !== null && rawValue !== void 0 ? rawValue : '').trim();
+                if (!textValue) {
+                    continue;
+                }
+                draft.value_text = textValue;
+                draft.raw_value = textValue;
+                draft.normalized_value = textValue;
+            }
+            normalizedSuggestions.push(draft);
+        }
+        return normalizedSuggestions;
+    }
+    buildAiSystemPrompt(resource, locale, fieldContext, currentValues, productAttributes) {
+        const isPt = locale === null || locale === void 0 ? void 0 : locale.startsWith('pt');
+        const fieldLines = fieldContext.map((field) => {
+            const optionText = field.options.length
+                ? ` options=${field.options.map((option) => `${option.label} (${option.value})`).join(', ')}`
+                : '';
+            const relationText = field.relation
+                ? ` relation=${field.relation.resource || field.relation.endpoint || 'external'}`
+                : '';
+            return `- ${field.key}: type=${field.type}; required=${field.required ? 'yes' : 'no'}; label="${field.label}"${optionText}${relationText}`;
+        });
+        const productAttributeLines = productAttributes.map((attribute) => {
+            const options = Array.isArray(attribute.options) ? attribute.options : [];
+            const optionText = options.length
+                ? ` options=${options
+                    .map((option) => { var _a, _b; return `${String((_a = option.label) !== null && _a !== void 0 ? _a : '')} (${String((_b = option.option_value) !== null && _b !== void 0 ? _b : '')})`; })
+                    .join(', ')}`
+                : '';
+            return `- ${String(attribute.slug)}: type=${String(attribute.data_type)}; name="${String(attribute.name)}"; required=${Boolean(attribute.is_required) ? 'yes' : 'no'}; group="${String(attribute.group_name)}"${optionText}`;
+        });
+        return [
+            isPt
+                ? 'Voce preenche formularios administrativos do catalogo. Responda apenas com JSON valido.'
+                : 'You fill catalog admin forms. Respond with valid JSON only.',
+            isPt
+                ? `Recurso atual: ${resource}.`
+                : `Current resource: ${resource}.`,
+            isPt
+                ? 'Use apenas os campos permitidos listados abaixo. Nao invente ids, arquivos ou campos extras.'
+                : 'Use only the allowed fields listed below. Do not invent ids, files, or extra fields.',
+            isPt
+                ? 'Para campos relacionais, prefira nomes/slug legiveis; o backend tentara resolver com seguranca.'
+                : 'For relation fields, prefer readable names/slugs; the backend will resolve them safely.',
+            isPt
+                ? 'Para selects, prefira os valores validos informados.'
+                : 'For selects, prefer the valid values provided.',
+            isPt
+                ? 'Estrutura da resposta: {"fields": { ... }, "product_attributes": { ... }, "notes": ["..."]}.'
+                : 'Response shape: {"fields": { ... }, "product_attributes": { ... }, "notes": ["..."]}.',
+            isPt
+                ? 'Se nao souber um campo, simplesmente omita.'
+                : 'If you are unsure about a field, omit it.',
+            `Allowed fields:\n${fieldLines.join('\n')}`,
+            productAttributeLines.length
+                ? `Structured product attributes:\n${productAttributeLines.join('\n')}`
+                : '',
+            `Current values: ${JSON.stringify(currentValues)}`,
+        ]
+            .filter(Boolean)
+            .join('\n\n');
+    }
     sanitizePayload(config, body) {
+        const normalizedBody = Object.assign({}, body);
+        if (config.resource === 'attributes') {
+            if (normalizedBody.name === undefined &&
+                normalizedBody.label !== undefined) {
+                normalizedBody.name = normalizedBody.label;
+            }
+            if (normalizedBody.data_type === 'select') {
+                normalizedBody.data_type = 'option';
+            }
+        }
+        if (config.resource === 'category-attributes') {
+            if (normalizedBody.is_highlight === undefined &&
+                normalizedBody.is_highlighted !== undefined) {
+                normalizedBody.is_highlight = normalizedBody.is_highlighted;
+            }
+            if (normalizedBody.sort_order === undefined &&
+                normalizedBody.display_order !== undefined) {
+                normalizedBody.sort_order = normalizedBody.display_order;
+            }
+        }
         const payload = {};
         for (const field of config.fields) {
-            if (Object.prototype.hasOwnProperty.call(body, field) && body[field] !== undefined) {
-                payload[field] = body[field];
+            if (Object.prototype.hasOwnProperty.call(normalizedBody, field) && normalizedBody[field] !== undefined) {
+                payload[field] = normalizedBody[field];
             }
         }
         return payload;
@@ -68,22 +563,369 @@ let CatalogService = class CatalogService {
         }
         return { OR, AND };
     }
+    async ensureCategoryExists(categoryId) {
+        const category = await this.prisma.catalog_category.findUnique({
+            where: { id: categoryId },
+        });
+        if (!category) {
+            throw new common_1.NotFoundException('Catalog category not found');
+        }
+        return category;
+    }
+    normalizeCategoryTree(items) {
+        var _a;
+        const byId = new Map();
+        const roots = [];
+        for (const item of items) {
+            byId.set(item.id, Object.assign(Object.assign({}, item), { children: [] }));
+        }
+        for (const item of byId.values()) {
+            if (item.parent_category_id && byId.has(item.parent_category_id)) {
+                (_a = byId.get(item.parent_category_id)) === null || _a === void 0 ? void 0 : _a.children.push(item);
+            }
+            else {
+                roots.push(item);
+            }
+        }
+        return roots;
+    }
+    async buildCategoryAttributePayload(categoryId, productId) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const category = await this.ensureCategoryExists(categoryId);
+        const categoryAttributes = await this.prisma.catalog_category_attribute.findMany({
+            where: { catalog_category_id: categoryId },
+            orderBy: [{ sort_order: 'asc' }, { id: 'asc' }],
+        });
+        const attributeIds = [...new Set(categoryAttributes.map((item) => item.attribute_id))];
+        const attributes = attributeIds.length
+            ? await this.prisma.catalog_attribute.findMany({
+                where: { id: { in: attributeIds } },
+                orderBy: [{ display_order: 'asc' }, { id: 'asc' }],
+            })
+            : [];
+        const groupIds = [...new Set(attributes.map((item) => item.group_id).filter((value) => typeof value === 'number'))];
+        const groups = groupIds.length
+            ? await this.prisma.catalog_attribute_group.findMany({
+                where: { id: { in: groupIds } },
+            })
+            : [];
+        const options = attributeIds.length
+            ? await this.prisma.catalog_attribute_option.findMany({
+                where: { attribute_id: { in: attributeIds } },
+                orderBy: [{ sort_order: 'asc' }, { id: 'asc' }],
+            })
+            : [];
+        const values = productId && attributeIds.length
+            ? await this.prisma.catalog_product_attribute_value.findMany({
+                where: { product_id: productId, attribute_id: { in: attributeIds } },
+                include: {
+                    catalog_attribute_option: true,
+                },
+            })
+            : [];
+        const categoryAttributeMap = new Map(categoryAttributes.map((item) => [item.attribute_id, item]));
+        const optionMap = new Map();
+        const valueMap = new Map(values.map((item) => [item.attribute_id, item]));
+        const groupMap = new Map(groups.map((item) => [item.id, item]));
+        for (const option of options) {
+            const bucket = (_a = optionMap.get(option.attribute_id)) !== null && _a !== void 0 ? _a : [];
+            bucket.push(option);
+            optionMap.set(option.attribute_id, bucket);
+        }
+        const grouped = new Map();
+        for (const attribute of attributes) {
+            const relation = categoryAttributeMap.get(attribute.id);
+            if (!relation) {
+                continue;
+            }
+            const groupId = (_b = attribute.group_id) !== null && _b !== void 0 ? _b : 0;
+            const group = attribute.group_id ? groupMap.get(attribute.group_id) : null;
+            const fallbackGroupName = String((_c = attribute.group_name) !== null && _c !== void 0 ? _c : '').trim() || 'General';
+            const groupKey = attribute.group_id ? String(groupId) : `name:${fallbackGroupName}`;
+            const existingGroup = (_d = grouped.get(groupKey)) !== null && _d !== void 0 ? _d : {
+                id: (_e = group === null || group === void 0 ? void 0 : group.id) !== null && _e !== void 0 ? _e : null,
+                slug: (_f = group === null || group === void 0 ? void 0 : group.slug) !== null && _f !== void 0 ? _f : fallbackGroupName.toLowerCase().replace(/\s+/g, '-'),
+                name: (_g = group === null || group === void 0 ? void 0 : group.name) !== null && _g !== void 0 ? _g : fallbackGroupName,
+                attributes: [],
+            };
+            existingGroup.attributes.push(Object.assign(Object.assign({}, attribute), { category_attribute: relation, options: (_h = optionMap.get(attribute.id)) !== null && _h !== void 0 ? _h : [], value: (_j = valueMap.get(attribute.id)) !== null && _j !== void 0 ? _j : null }));
+            grouped.set(groupKey, existingGroup);
+        }
+        const resultGroups = [...grouped.values()].map((group) => (Object.assign(Object.assign({}, group), { attributes: group.attributes.sort((left, right) => {
+                var _a, _b, _c, _d, _e, _f, _g, _h;
+                const leftRelation = left.category_attribute;
+                const rightRelation = right.category_attribute;
+                return (Number((_a = leftRelation.sort_order) !== null && _a !== void 0 ? _a : 0) - Number((_b = rightRelation.sort_order) !== null && _b !== void 0 ? _b : 0) ||
+                    Number((_c = leftRelation.display_order) !== null && _c !== void 0 ? _c : 0) - Number((_d = rightRelation.display_order) !== null && _d !== void 0 ? _d : 0) ||
+                    Number((_e = left.display_order) !== null && _e !== void 0 ? _e : 0) - Number((_f = right.display_order) !== null && _f !== void 0 ? _f : 0) ||
+                    Number((_g = left.id) !== null && _g !== void 0 ? _g : 0) - Number((_h = right.id) !== null && _h !== void 0 ? _h : 0));
+            }) })));
+        resultGroups.sort((left, right) => String(left.name).localeCompare(String(right.name)));
+        return {
+            category,
+            product_id: productId !== null && productId !== void 0 ? productId : null,
+            groups: resultGroups,
+            attributes: resultGroups.flatMap((group) => group.attributes),
+        };
+    }
+    isMeaningfulAttributeValue(value) {
+        var _a;
+        if (value.attribute_option_id !== undefined && value.attribute_option_id !== null) {
+            return true;
+        }
+        if (value.value_number !== undefined && value.value_number !== null) {
+            return true;
+        }
+        if (value.value_boolean !== undefined && value.value_boolean !== null) {
+            return true;
+        }
+        return String((_a = value.value_text) !== null && _a !== void 0 ? _a : '').trim().length > 0;
+    }
+    buildAttributeSnapshotValue(attribute) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const value = ((_a = attribute.value) !== null && _a !== void 0 ? _a : null);
+        const dataType = String((_b = attribute.data_type) !== null && _b !== void 0 ? _b : 'text');
+        const option = (_c = value === null || value === void 0 ? void 0 : value.catalog_attribute_option) !== null && _c !== void 0 ? _c : null;
+        if (!value) {
+            return {
+                value: null,
+                value_text: null,
+                value_number: null,
+                value_boolean: null,
+                normalized_value: null,
+                raw_value: null,
+                option: null,
+            };
+        }
+        if (dataType === 'option') {
+            const optionPayload = option
+                ? {
+                    id: Number(option.id),
+                    slug: String((_d = option.slug) !== null && _d !== void 0 ? _d : ''),
+                    label: String((_f = (_e = option.label) !== null && _e !== void 0 ? _e : option.option_value) !== null && _f !== void 0 ? _f : ''),
+                    option_value: String((_g = option.option_value) !== null && _g !== void 0 ? _g : ''),
+                }
+                : null;
+            return {
+                value: (_j = (_h = optionPayload === null || optionPayload === void 0 ? void 0 : optionPayload.option_value) !== null && _h !== void 0 ? _h : value.value_text) !== null && _j !== void 0 ? _j : null,
+                value_text: value.value_text ? String(value.value_text) : null,
+                value_number: null,
+                value_boolean: null,
+                normalized_value: value.normalized_value ? String(value.normalized_value) : null,
+                raw_value: value.raw_value ? String(value.raw_value) : null,
+                option: optionPayload,
+            };
+        }
+        if (dataType === 'number') {
+            return {
+                value: value.value_number === null || value.value_number === undefined
+                    ? null
+                    : Number(value.value_number),
+                value_text: value.value_text ? String(value.value_text) : null,
+                value_number: value.value_number === null || value.value_number === undefined
+                    ? null
+                    : Number(value.value_number),
+                value_boolean: null,
+                normalized_value: value.normalized_value ? String(value.normalized_value) : null,
+                raw_value: value.raw_value ? String(value.raw_value) : null,
+                option: null,
+            };
+        }
+        if (dataType === 'boolean') {
+            return {
+                value: value.value_boolean === null || value.value_boolean === undefined
+                    ? null
+                    : Boolean(value.value_boolean),
+                value_text: value.value_text ? String(value.value_text) : null,
+                value_number: null,
+                value_boolean: value.value_boolean === null || value.value_boolean === undefined
+                    ? null
+                    : Boolean(value.value_boolean),
+                normalized_value: value.normalized_value ? String(value.normalized_value) : null,
+                raw_value: value.raw_value ? String(value.raw_value) : null,
+                option: null,
+            };
+        }
+        return {
+            value: value.value_text ? String(value.value_text) : null,
+            value_text: value.value_text ? String(value.value_text) : null,
+            value_number: null,
+            value_boolean: null,
+            normalized_value: value.normalized_value ? String(value.normalized_value) : null,
+            raw_value: value.raw_value ? String(value.raw_value) : null,
+            option: null,
+        };
+    }
+    toAttributeSnapshot(attribute) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        const relation = ((_a = attribute.category_attribute) !== null && _a !== void 0 ? _a : {});
+        const snapshotValue = this.buildAttributeSnapshotValue(attribute);
+        return Object.assign({ slug: String((_b = attribute.slug) !== null && _b !== void 0 ? _b : ''), name: String((_d = (_c = attribute.name) !== null && _c !== void 0 ? _c : attribute.slug) !== null && _d !== void 0 ? _d : ''), data_type: String((_e = attribute.data_type) !== null && _e !== void 0 ? _e : 'text'), unit: attribute.unit ? String(attribute.unit) : null, group_name: String((_f = attribute.group_name) !== null && _f !== void 0 ? _f : 'General'), is_required: Boolean((_g = relation.is_required) !== null && _g !== void 0 ? _g : false), is_highlight: Boolean((_h = relation.is_highlight) !== null && _h !== void 0 ? _h : false), is_filter_visible: Boolean((_j = relation.is_filter_visible) !== null && _j !== void 0 ? _j : false), is_comparison_visible: Boolean((_k = relation.is_comparison_visible) !== null && _k !== void 0 ? _k : false) }, snapshotValue);
+    }
+    async decorateProductRecords(records) {
+        if (!records.length) {
+            return records;
+        }
+        const brandIds = [...new Set(records
+                .map((record) => record.brand_id)
+                .filter((value) => typeof value === 'number'))];
+        const categoryIds = [...new Set(records
+                .map((record) => record.catalog_category_id)
+                .filter((value) => typeof value === 'number'))];
+        const [brands, categories] = await Promise.all([
+            brandIds.length
+                ? this.prisma.catalog_brand.findMany({
+                    where: { id: { in: brandIds } },
+                    select: { id: true, name: true, slug: true, logo_file_id: true },
+                })
+                : Promise.resolve([]),
+            categoryIds.length
+                ? this.prisma.catalog_category.findMany({
+                    where: { id: { in: categoryIds } },
+                    select: { id: true, name: true, slug: true },
+                })
+                : Promise.resolve([]),
+        ]);
+        const brandMap = new Map(brands.map((item) => [item.id, item]));
+        const categoryMap = new Map(categories.map((item) => [item.id, item]));
+        return records.map((record) => {
+            var _a, _b, _c, _d, _e;
+            const brand = record.brand_id ? brandMap.get(record.brand_id) : null;
+            const category = record.catalog_category_id
+                ? categoryMap.get(record.catalog_category_id)
+                : null;
+            return Object.assign(Object.assign({}, record), { brand_name: (_a = brand === null || brand === void 0 ? void 0 : brand.name) !== null && _a !== void 0 ? _a : null, brand_slug: (_b = brand === null || brand === void 0 ? void 0 : brand.slug) !== null && _b !== void 0 ? _b : null, brand_logo_file_id: (_c = brand === null || brand === void 0 ? void 0 : brand.logo_file_id) !== null && _c !== void 0 ? _c : null, category_name: (_d = category === null || category === void 0 ? void 0 : category.name) !== null && _d !== void 0 ? _d : null, category_slug: (_e = category === null || category === void 0 ? void 0 : category.slug) !== null && _e !== void 0 ? _e : null });
+        });
+    }
+    validateAttributeValueByType(attribute, value) {
+        var _a;
+        const hasText = String((_a = value.value_text) !== null && _a !== void 0 ? _a : '').trim().length > 0;
+        const hasNumber = value.value_number !== undefined && value.value_number !== null;
+        const hasBoolean = value.value_boolean !== undefined && value.value_boolean !== null;
+        const hasOption = value.attribute_option_id !== undefined && value.attribute_option_id !== null;
+        const filledKinds = [hasText, hasNumber, hasBoolean, hasOption].filter(Boolean).length;
+        const attributeLabel = attribute.name || attribute.slug || `#${attribute.id}`;
+        if (filledKinds > 1) {
+            throw new common_1.BadRequestException(`Attribute "${attributeLabel}" must use a single value field compatible with its type`);
+        }
+        switch (attribute.data_type) {
+            case 'text':
+            case 'long_text':
+                if (hasNumber || hasBoolean || hasOption) {
+                    throw new common_1.BadRequestException(`Attribute "${attributeLabel}" only accepts text values`);
+                }
+                break;
+            case 'number':
+                if (hasText || hasBoolean || hasOption) {
+                    throw new common_1.BadRequestException(`Attribute "${attributeLabel}" only accepts number values`);
+                }
+                break;
+            case 'boolean':
+                if (hasText || hasNumber || hasOption) {
+                    throw new common_1.BadRequestException(`Attribute "${attributeLabel}" only accepts boolean values`);
+                }
+                break;
+            case 'option':
+                if (hasText || hasNumber || hasBoolean) {
+                    throw new common_1.BadRequestException(`Attribute "${attributeLabel}" only accepts option values`);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    async buildProductStructuredPayload(productId) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const product = await this.getById('products', productId, 'en');
+        const attributes = await this.listProductAttributes(productId);
+        const groups = ((_a = attributes.groups) !== null && _a !== void 0 ? _a : []).map((group) => ({
+            id: group.id,
+            slug: group.slug,
+            name: group.name,
+            attributes: group.attributes.map((attribute) => this.toAttributeSnapshot(attribute)),
+        }));
+        const flatAttributes = groups.flatMap((group) => group.attributes);
+        return {
+            product,
+            category: attributes.category,
+            groups,
+            attributes: flatAttributes,
+            comparison: {
+                category: {
+                    id: (_c = (_b = attributes.category) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : null,
+                    slug: (_e = (_d = attributes.category) === null || _d === void 0 ? void 0 : _d.slug) !== null && _e !== void 0 ? _e : null,
+                    name: (_g = (_f = attributes.category) === null || _f === void 0 ? void 0 : _f.name) !== null && _g !== void 0 ? _g : null,
+                },
+                highlights: flatAttributes.filter((attribute) => attribute.is_highlight),
+                comparable_attributes: flatAttributes.filter((attribute) => attribute.is_comparison_visible),
+                filter_attributes: flatAttributes.filter((attribute) => attribute.is_filter_visible),
+            },
+        };
+    }
+    async materializeProductSnapshots(productId) {
+        const structured = await this.buildProductStructuredPayload(productId);
+        const specSnapshot = {
+            version: 1,
+            source: 'catalog_product_attribute_value',
+            category: structured.category
+                ? {
+                    id: structured.category.id,
+                    slug: structured.category.slug,
+                    name: structured.category.name,
+                }
+                : null,
+            groups: structured.groups,
+            attributes: structured.attributes.reduce((acc, attribute) => {
+                acc[attribute.slug] = attribute;
+                return acc;
+            }, {}),
+            generated_at: new Date().toISOString(),
+        };
+        const comparisonSnapshot = {
+            version: 1,
+            source: 'catalog_product_attribute_value',
+            category: structured.comparison.category,
+            highlights: structured.comparison.highlights,
+            comparable_attributes: structured.comparison.comparable_attributes,
+            generated_at: new Date().toISOString(),
+        };
+        await this.prisma.catalog_product.update({
+            where: { id: productId },
+            data: {
+                // Snapshots remain secondary/derived fields for legacy reads and fast payloads.
+                spec_snapshot_json: specSnapshot,
+                comparison_snapshot_json: comparisonSnapshot,
+            },
+        });
+        return {
+            spec_snapshot_json: specSnapshot,
+            comparison_snapshot_json: comparisonSnapshot,
+        };
+    }
     async list(resource, locale, paginationParams, query) {
         var _a;
         const config = this.getConfig(resource, locale);
         const model = this.getModel(resource, locale);
         const where = this.buildWhere(config, paginationParams, query);
-        return this.pagination.paginate(model, paginationParams, {
+        const result = await this.pagination.paginate(model, paginationParams, {
             where,
             orderBy: (_a = config.defaultOrderBy) !== null && _a !== void 0 ? _a : { id: 'desc' },
         }, locale);
+        if (resource === 'products' && Array.isArray(result.data)) {
+            return Object.assign(Object.assign({}, result), { data: await this.decorateProductRecords(result.data) });
+        }
+        return result;
     }
     async stats(resource, locale) {
+        var _a;
         const config = this.getConfig(resource, locale);
         const model = this.getModel(resource, locale);
         const total = await model.count({});
         const result = { total };
-        if (config.statusField && config.activeStatusValue) {
+        const availableFields = Object.keys(((_a = model === null || model === void 0 ? void 0 : model.fields) !== null && _a !== void 0 ? _a : {}));
+        if (config.statusField &&
+            config.activeStatusValue &&
+            availableFields.includes(config.statusField)) {
             result.active = await model.count({
                 where: {
                     [config.statusField]: config.activeStatusValue,
@@ -93,6 +935,44 @@ let CatalogService = class CatalogService {
         return result;
     }
     async getById(resource, id, locale) {
+        if (resource === 'products') {
+            const item = await this.prisma.catalog_product.findUnique({
+                where: { id },
+                include: {
+                    catalog_brand: {
+                        select: {
+                            id: true,
+                            name: true,
+                            slug: true,
+                            logo_file_id: true,
+                        },
+                    },
+                    catalog_category: {
+                        select: {
+                            id: true,
+                            name: true,
+                            slug: true,
+                        },
+                    },
+                    catalog_product_image: {
+                        orderBy: [{ sort_order: 'asc' }, { id: 'asc' }],
+                        select: {
+                            id: true,
+                            file_id: true,
+                            role: true,
+                            sort_order: true,
+                            is_primary: true,
+                            alt_text: true,
+                        },
+                    },
+                },
+            });
+            if (!item) {
+                throw new common_1.NotFoundException((0, api_locale_1.getLocaleText)('resourceNotFound', locale, 'Catalog resource not found'));
+            }
+            const [decorated] = await this.decorateProductRecords([item]);
+            return decorated;
+        }
         const model = this.getModel(resource, locale);
         const item = await model.findUnique({ where: { id } });
         if (!item) {
@@ -132,11 +1012,245 @@ let CatalogService = class CatalogService {
             },
         }, locale);
     }
+    async getCategoriesTree() {
+        const categories = await this.prisma.catalog_category.findMany({
+            orderBy: [{ sort_order: 'asc' }, { name: 'asc' }],
+        });
+        return this.normalizeCategoryTree(categories);
+    }
+    async listCategoryAttributes(categoryId) {
+        return this.buildCategoryAttributePayload(categoryId);
+    }
+    async listProductAttributes(productId) {
+        const product = await this.prisma.catalog_product.findUnique({
+            where: { id: productId },
+        });
+        if (!product) {
+            throw new common_1.NotFoundException('Catalog product not found');
+        }
+        return this.buildCategoryAttributePayload(product.catalog_category_id, productId);
+    }
+    async getProductStructuredPayload(productId) {
+        return this.buildProductStructuredPayload(productId);
+    }
+    async getProductComparisonPayload(productId) {
+        const structured = await this.buildProductStructuredPayload(productId);
+        return structured.comparison;
+    }
+    async updateProductAttributes(productId, values) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v;
+        const product = await this.prisma.catalog_product.findUnique({
+            where: { id: productId },
+        });
+        if (!product) {
+            throw new common_1.NotFoundException('Catalog product not found');
+        }
+        const categoryAttributes = await this.prisma.catalog_category_attribute.findMany({
+            where: { catalog_category_id: product.catalog_category_id },
+        });
+        const allowedAttributeIds = new Set(categoryAttributes.map((item) => item.attribute_id));
+        const requiredAttributeIds = new Set(categoryAttributes
+            .filter((item) => item.is_required)
+            .map((item) => item.attribute_id));
+        const attributes = allowedAttributeIds.size
+            ? await this.prisma.catalog_attribute.findMany({
+                where: { id: { in: [...allowedAttributeIds] } },
+                select: {
+                    id: true,
+                    slug: true,
+                    name: true,
+                    data_type: true,
+                },
+            })
+            : [];
+        const attributeMap = new Map(attributes.map((item) => [item.id, item]));
+        const existingValues = await this.prisma.catalog_product_attribute_value.findMany({
+            where: { product_id: productId },
+        });
+        const optionIds = values
+            .map((value) => value.attribute_option_id)
+            .filter((value) => typeof value === 'number');
+        const options = optionIds.length
+            ? await this.prisma.catalog_attribute_option.findMany({
+                where: { id: { in: optionIds } },
+            })
+            : [];
+        const optionMap = new Map(options.map((item) => [item.id, item]));
+        const incomingByAttribute = new Map();
+        for (const value of values) {
+            const attributeId = Number((_a = value.attribute_id) !== null && _a !== void 0 ? _a : 0);
+            if (!attributeId || !allowedAttributeIds.has(attributeId)) {
+                throw new common_1.BadRequestException(`Attribute ${attributeId} is not allowed for this category`);
+            }
+            const attribute = attributeMap.get(attributeId);
+            if (!attribute) {
+                throw new common_1.BadRequestException(`Attribute ${attributeId} was not found`);
+            }
+            this.validateAttributeValueByType(attribute, value);
+            incomingByAttribute.set(attributeId, value);
+        }
+        const incomingAttributeIds = new Set(incomingByAttribute.keys());
+        for (const attributeId of requiredAttributeIds) {
+            const requiredValue = incomingByAttribute.get(attributeId);
+            if (!requiredValue || !this.isMeaningfulAttributeValue(requiredValue)) {
+                const attribute = attributeMap.get(attributeId);
+                throw new common_1.BadRequestException(`Attribute "${(_c = (_b = attribute === null || attribute === void 0 ? void 0 : attribute.name) !== null && _b !== void 0 ? _b : attribute === null || attribute === void 0 ? void 0 : attribute.slug) !== null && _c !== void 0 ? _c : attributeId}" is required for this category`);
+            }
+        }
+        for (const existingValue of existingValues) {
+            if (!incomingAttributeIds.has(existingValue.attribute_id)) {
+                await this.prisma.catalog_product_attribute_value.delete({
+                    where: { id: existingValue.id },
+                });
+            }
+        }
+        for (const [attributeId, value] of incomingByAttribute.entries()) {
+            const option = value.attribute_option_id ? optionMap.get(value.attribute_option_id) : null;
+            const attribute = attributeMap.get(attributeId);
+            if (value.attribute_option_id && (!option || option.attribute_id !== attributeId)) {
+                throw new common_1.BadRequestException(`Option ${value.attribute_option_id} does not belong to attribute ${(_d = attribute === null || attribute === void 0 ? void 0 : attribute.name) !== null && _d !== void 0 ? _d : attributeId}`);
+            }
+            const normalizedText = (_h = (_g = (_f = (_e = value.normalized_text) !== null && _e !== void 0 ? _e : option === null || option === void 0 ? void 0 : option.normalized_value) !== null && _f !== void 0 ? _f : option === null || option === void 0 ? void 0 : option.option_value) !== null && _g !== void 0 ? _g : value.value_text) !== null && _h !== void 0 ? _h : null;
+            const sourceType = value.source_type === 'import' || value.source_type === 'computed'
+                ? value.source_type
+                : 'manual';
+            const payload = {
+                attribute_option_id: (_j = value.attribute_option_id) !== null && _j !== void 0 ? _j : null,
+                value_text: (_k = option === null || option === void 0 ? void 0 : option.option_value) !== null && _k !== void 0 ? _k : (String((_l = value.value_text) !== null && _l !== void 0 ? _l : '').trim() || null),
+                value_number: (_m = value.value_number) !== null && _m !== void 0 ? _m : null,
+                value_boolean: (_o = value.value_boolean) !== null && _o !== void 0 ? _o : null,
+                raw_value: (_p = option === null || option === void 0 ? void 0 : option.option_value) !== null && _p !== void 0 ? _p : (value.value_number !== undefined && value.value_number !== null
+                    ? String(value.value_number)
+                    : value.value_boolean !== undefined && value.value_boolean !== null
+                        ? String(value.value_boolean)
+                        : String((_q = value.value_text) !== null && _q !== void 0 ? _q : '').trim() || null),
+                value_unit: String((_r = value.value_unit) !== null && _r !== void 0 ? _r : '').trim() || null,
+                normalized_value: normalizedText
+                    ? String(normalizedText).trim()
+                    : value.value_number !== undefined && value.value_number !== null
+                        ? String(value.value_number)
+                        : value.value_boolean !== undefined && value.value_boolean !== null
+                            ? String(value.value_boolean)
+                            : null,
+                normalized_text: normalizedText ? String(normalizedText).trim() : null,
+                normalized_number: (_t = (_s = value.normalized_number) !== null && _s !== void 0 ? _s : value.value_number) !== null && _t !== void 0 ? _t : null,
+                source_type: sourceType,
+                confidence_score: (_u = value.confidence_score) !== null && _u !== void 0 ? _u : null,
+                is_verified: Boolean((_v = value.is_verified) !== null && _v !== void 0 ? _v : false),
+            };
+            const existingValue = existingValues.find((item) => item.attribute_id === attributeId);
+            if (!this.isMeaningfulAttributeValue(payload)) {
+                if (existingValue) {
+                    await this.prisma.catalog_product_attribute_value.delete({
+                        where: { id: existingValue.id },
+                    });
+                }
+                continue;
+            }
+            if (existingValue) {
+                const updatePayload = {
+                    attribute_option_id: payload.attribute_option_id,
+                    value_text: payload.value_text,
+                    value_number: payload.value_number,
+                    value_boolean: payload.value_boolean,
+                    raw_value: payload.raw_value,
+                    value_unit: payload.value_unit,
+                    normalized_value: payload.normalized_value,
+                    normalized_text: payload.normalized_text,
+                    normalized_number: payload.normalized_number,
+                    source_type: payload.source_type,
+                    confidence_score: payload.confidence_score,
+                    is_verified: payload.is_verified,
+                };
+                await this.prisma.catalog_product_attribute_value.update({
+                    where: { id: existingValue.id },
+                    data: updatePayload,
+                });
+            }
+            else {
+                const createPayload = {
+                    product_id: productId,
+                    attribute_id: attributeId,
+                    attribute_option_id: payload.attribute_option_id,
+                    value_text: payload.value_text,
+                    value_number: payload.value_number,
+                    value_boolean: payload.value_boolean,
+                    raw_value: payload.raw_value,
+                    value_unit: payload.value_unit,
+                    normalized_value: payload.normalized_value,
+                    normalized_text: payload.normalized_text,
+                    normalized_number: payload.normalized_number,
+                    source_type: payload.source_type,
+                    confidence_score: payload.confidence_score,
+                    is_verified: payload.is_verified,
+                };
+                await this.prisma.catalog_product_attribute_value.create({
+                    data: createPayload,
+                });
+            }
+        }
+        await this.materializeProductSnapshots(productId);
+        return this.listProductAttributes(productId);
+    }
+    async generateFormAssistSuggestion(resource, input, locale) {
+        var _a, _b, _c, _d, _e, _f;
+        const config = this.getConfig(resource, locale);
+        const fieldContext = this.normalizeAiFieldContext(resource, (_a = input.fields) !== null && _a !== void 0 ? _a : []);
+        const currentValues = (_b = input.current_values) !== null && _b !== void 0 ? _b : {};
+        const warnings = [];
+        const categoryId = resource === 'products'
+            ? Number((_c = currentValues.catalog_category_id) !== null && _c !== void 0 ? _c : 0) || null
+            : null;
+        const productAttributeContext = categoryId
+            ? this.buildAttributeContext(await this.buildCategoryAttributePayload(categoryId), (_d = input.current_attribute_values) !== null && _d !== void 0 ? _d : [])
+            : [];
+        const systemPrompt = this.buildAiSystemPrompt(resource, locale, fieldContext, currentValues, productAttributeContext);
+        const aiResponse = await this.aiService.chat({
+            provider: 'openai',
+            model: 'gpt-4o-mini',
+            message: input.prompt,
+            systemPrompt,
+        });
+        const parsed = this.extractJsonObject(String((_e = aiResponse.content) !== null && _e !== void 0 ? _e : ''));
+        const rawFields = parsed.fields && typeof parsed.fields === 'object'
+            ? parsed.fields
+            : {};
+        const normalizedFields = {};
+        for (const field of fieldContext) {
+            if (!Object.prototype.hasOwnProperty.call(rawFields, field.key)) {
+                continue;
+            }
+            const normalizedValue = await this.normalizeAiFieldSuggestion(field, rawFields[field.key], warnings);
+            if (normalizedValue !== undefined) {
+                normalizedFields[field.key] = normalizedValue;
+            }
+        }
+        const productAttributes = await this.normalizeAiProductAttributeSuggestions(categoryId, parsed.product_attributes, (_f = input.current_attribute_values) !== null && _f !== void 0 ? _f : [], warnings);
+        const appliedFields = fieldContext
+            .filter((field) => Object.prototype.hasOwnProperty.call(normalizedFields, field.key))
+            .map((field) => ({
+            key: field.key,
+            label: field.label,
+            type: field.type,
+            value: normalizedFields[field.key],
+        }));
+        return {
+            resource: config.resource,
+            fields: normalizedFields,
+            applied_fields: appliedFields,
+            product_attributes: productAttributes,
+            warnings: [
+                ...warnings,
+                ...(Array.isArray(parsed.notes) ? parsed.notes.map((note) => String(note)) : []),
+            ],
+        };
+    }
 };
 exports.CatalogService = CatalogService;
 exports.CatalogService = CatalogService = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [api_prisma_1.PrismaService,
-        api_pagination_1.PaginationService])
+        api_pagination_1.PaginationService,
+        core_1.AiService])
 ], CatalogService);
 //# sourceMappingURL=catalog.service.js.map