@shushed/helpers 0.0.248 → 0.0.249-fh-20260130152735

package/dist/cjs/src-public/fredhopper/fredhopper.base.js

@@ -0,0 +1,500 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto = __importStar(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const child_process = __importStar(require("node:child_process"));
+const stream_1 = require("stream");
+const archiver_1 = __importDefault(require("archiver"));
+const fredhopper_types_1 = require("./fredhopper.types");
+const defaultConfig = {
+    username: 'hush',
+    password: '',
+    baseUrl: 'https://test.fredhopperservices.com',
+    environment: 'test1',
+    region: 'eu1',
+};
+class FredHelperBase {
+    logging;
+    config;
+    attributes;
+    categories;
+    constructor(logging, config, attributes, categories) {
+        this.logging = logging;
+        this.config = config;
+        this.attributes = attributes;
+        this.categories = categories;
+        this.config = { ...defaultConfig, ...config };
+        this.config.base64Credentials = btoa(`${this.config.username}:${this.config.password}`);
+    }
+    updateType = 'incremental';
+    get timestamp() {
+        const now = new Date();
+        return (now.getUTCFullYear() +
+            '-' +
+            String(now.getUTCMonth() + 1).padStart(2, '0') +
+            '-' +
+            String(now.getUTCDate()).padStart(2, '0') +
+            '_' +
+            String(now.getUTCHours()).padStart(2, '0') +
+            '-' +
+            String(now.getUTCMinutes()).padStart(2, '0') +
+            '-' +
+            String(now.getUTCSeconds()).padStart(2, '0'));
+    }
+    get authHeader() {
+        return FredHelperBase.authHeader(this.config);
+    }
+    get baseFilesUrl() {
+        return `${this.baseUrl}/fas:${this.config.environment}`;
+    }
+    get baseUrl() {
+        return `https://my.eu1.fredhopperservices.com`;
+    }
+    static validateCategoryId(categoryId) {
+        return (/^[a-z0-9_-]+$/i.test(categoryId) &&
+            categoryId?.length > 0 &&
+            categoryId?.length <= 50);
+    }
+    static validateAttributeId(attributeId) {
+        return (/^[a-z0-9_-]+$/i.test(attributeId) &&
+            attributeId?.length > 0 &&
+            attributeId?.length <= 50);
+    }
+    static validateProductId(productId) {
+        return (/^[a-z0-9_]+$/.test(productId) &&
+            productId?.length > 0 &&
+            productId?.length <= 100);
+    }
+    static authHeader(config) {
+        return `Basic ${btoa(`${config.username}:${config.password}`)}`;
+    }
+    async getCategories() {
+        const categories = this.categories;
+        for (const category of categories) {
+            if (!category.locales || category.locales?.length === 0) {
+                category.locales = [];
+            }
+        }
+        return categories;
+    }
+    async getAttributesMeta() {
+        return this.attributes;
+    }
+    async validateProducts(products) {
+        const attributeMap = new Map(this.attributes.map(attr => [attr.attribute_id, attr]));
+        for (const product of products) {
+            if (!FredHelperBase.validateProductId(product.product_id)) {
+                throw new fredhopper_types_1.FredhopperValidationError(`Invalid product ID: ${product.product_id}`);
+            }
+            if (product.operation_type &&
+                !['add', 'update', 'replace', 'delete'].includes(product.operation_type)) {
+                throw new fredhopper_types_1.FredhopperValidationError(`Invalid operation type: ${product.operation_type}`);
+            }
+            for (const [attributeId, value] of Object.entries(product.attributes)) {
+                if (!FredHelperBase.validateAttributeId(attributeId)) {
+                    throw new fredhopper_types_1.FredhopperValidationError(`Invalid attribute ID: ${attributeId} in product ${product.product_id}`);
+                }
+                const attributeMeta = attributeMap.get(attributeId);
+                if (!attributeMeta) {
+                    throw new fredhopper_types_1.FredhopperValidationError(`Unknown attribute: ${attributeId} in product ${product.product_id}`);
+                }
+                if (attributeMeta.type === 'float' &&
+                    typeof value !== 'number' &&
+                    !Number.isFinite(Number(value))) {
+                    throw new fredhopper_types_1.FredhopperValidationError(`Attribute ${attributeId} in product ${product.product_id} must be a number`);
+                }
+            }
+        }
+    }
+    async uploadProductUpdate(products) {
+        await this.validateProducts(products);
+        const { blob, checksum } = await this.createProductUpdateZip(products);
+        return this.uploadToFredhopper(blob, checksum);
+    }
+    async uploadToFredhopper(zipData, checksum) {
+        const timestamp = this.timestamp;
+        const uploadUrl = `${this.baseFilesUrl}/data/input/${timestamp}/${this.uploadFileName}?checksum=${checksum}`;
+        const response = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/zip',
+                Authorization: this.authHeader,
+            },
+            body: zipData,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to upload data: ${response.status} ${response.statusText}`);
+        }
+        await this.uploadChecksumFile(checksum, timestamp);
+        const responseText = await response.text();
+        const dataIdMatch = responseText.match(/data-id=([^\s]+)/);
+        if (!dataIdMatch) {
+            throw new Error('Could not extract data-id from response');
+        }
+        return dataIdMatch[1];
+    }
+    async uploadChecksumFile(checksum, timestamp) {
+        const uploadUrl = `${this.baseFilesUrl}/data/input/${timestamp}/${this.uploadFileName}.md5`;
+        const response = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'text/plain',
+                Authorization: `Basic ${btoa(`${this.config.username}:${this.config.password}`)}`,
+            },
+            body: checksum,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to upload checksum: ${response.status} ${response.statusText}`);
+        }
+    }
+    async triggerIncrementalUpdate(dataId) {
+        const triggerUrl = `${this.baseFilesUrl}/trigger/load-data`;
+        const response = await fetch(triggerUrl, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'text/plain',
+                Authorization: `Basic ${btoa(`${this.config.username}:${this.config.password}`)}`,
+            },
+            body: `data-id=${dataId}`,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to trigger update: ${response.status} ${response.statusText}`);
+        }
+        const location = response.headers.get('Location');
+        if (!location) {
+            throw new Error('Could not get trigger location from response');
+        }
+        const triggerIdMatch = location.match(/\/([^/]+)$/);
+        if (!triggerIdMatch) {
+            throw new Error('Could not extract trigger ID from location');
+        }
+        return triggerIdMatch[1];
+    }
+    async checkUpdateStatus(triggerId) {
+        const statusUrl = `${this.baseFilesUrl}/trigger/load-data/${triggerId}/status`;
+        const response = await fetch(statusUrl, {
+            method: 'GET',
+            headers: {
+                Authorization: `Basic ${btoa(`${this.config.username}:${this.config.password}`)}`,
+            },
+        });
+        if (!response.ok) {
+            return 'UNKNOWN';
+        }
+        const status = (await response.text()).trim();
+        return status;
+    }
+    async getUpdateLogs(triggerId) {
+        const logsUrl = `${this.baseFilesUrl}/trigger/load-data/${triggerId}/logs/kitchen-incremental.log`;
+        const response = await fetch(logsUrl, {
+            method: 'GET',
+            headers: {
+                Authorization: `Basic ${btoa(`${this.config.username}:${this.config.password}`)}`,
+            },
+        });
+        const t = await response.text();
+        return t.trim();
+    }
+    async waitForUpdateCompletion(triggerId, pollInterval = 15000, timeout = 1200000) {
+        const startTime = Date.now();
+        let status = 'UNKNOWN';
+        while (!status.includes('SUCCESS') &&
+            !status.includes('FAILURE') &&
+            Date.now() - startTime < timeout) {
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            const newStatus = await this.checkUpdateStatus(triggerId);
+            if (newStatus !== status) {
+                status = newStatus;
+                this.logging.log(`status: ${status}\n`);
+            }
+            else {
+                this.logging.log(`...polling again in ${pollInterval / 1000}s`);
+            }
+        }
+        if (status === 'UNKNOWN' || status.includes('RUNNING')) {
+            throw new Error('Update timed out');
+        }
+        return status;
+    }
+    async triggerUpdate(dataId) {
+        const triggerId = await this.triggerIncrementalUpdate(dataId);
+        this.logging.log('Update triggered successfully', { triggerId });
+        const status = await this.checkUpdateStatus(triggerId);
+        this.logging.log('Initial status check', { status });
+        return { dataId, triggerId, status };
+    }
+    generateCategoriesCSV(categories) {
+        const lines = [
+            this.createCSVLine('category_id', 'parent_category_id', 'locale', 'name'),
+        ];
+        const normalizeLocale = (value) => {
+            if (!value)
+                return '';
+            const [lang, region] = value.split('-');
+            if (!lang || !region)
+                return value;
+            return `${lang.toLowerCase()}_${region.toUpperCase()}`;
+        };
+        lines.push(this.createCSVLine('catalog01', 'catalog01', 'en_GB', 'Hush Master Catalog'), this.createCSVLine('catalog01', 'catalog01', 'en_US', 'Hush Master Catalog'));
+        for (const category of categories) {
+            for (const locale of (category.locales ?? []).filter(l => l.name)) {
+                const localeFormatted = normalizeLocale(locale.locale);
+                const nameTrimmed = (locale.name || '').trim();
+                const parentCategoryId = category.parent_id && category.parent_id.length > 0
+                    ? category.parent_id
+                    : 'catalog01';
+                lines.push(this.createCSVLine(category.category_id, parentCategoryId, localeFormatted, nameTrimmed));
+            }
+        }
+        return lines.join('\n') + '\n';
+    }
+    generateAttributesMetaCSV(attributes) {
+        const lines = [
+            this.createCSVLine('attribute_id', 'type', 'locale', 'name'),
+        ];
+        for (const attribute of attributes) {
+            if (!attribute.locales || attribute.locales?.length <= 0) {
+                lines.push(this.createCSVLine(attribute.attribute_id, attribute.type, '', ''));
+            }
+            else {
+                for (const locale of attribute.locales ?? []) {
+                    lines.push(this.createCSVLine(attribute.attribute_id, attribute.type, locale.locale, locale.name));
+                }
+            }
+        }
+        return lines.join('\n') + '\n';
+    }
+    generateProductsCSV(products) {
+        const lines = [this.createCSVLine('product_id', 'locale', 'category_ids')];
+        for (const product of products) {
+            const categories = (product.categories || []).join(' ');
+            lines.push(this.createCSVLine(product.product_id, 'en_GB', categories));
+        }
+        return lines.join('\n') + '\n';
+    }
+    generateVariantsCSV(inputs) {
+        const lines = [this.createCSVLine('variant_id', 'product_id', 'locale')];
+        inputs.forEach(input => input.variants.forEach(variant => {
+            lines.push(this.createCSVLine(variant.id, input.productId, 'en_GB'));
+        }));
+        return lines.join('\n') + '\n';
+    }
+    generateCustomVariantAttributesCSV(input) {
+        const lines = [
+            this.createCSVLine('variant_id', 'locale', 'attribute_id', 'attribute_value_id', 'attribute_value'),
+        ];
+        input.forEach(variants => {
+            for (const variant of variants) {
+                lines.push(this.createCSVLine(variant.id, 'en_GB', 'operation_type', '', 'update'));
+                const { id, ...rest } = variant;
+                Object.entries(rest).forEach(([key, value]) => {
+                    const valueId = this.attributes.find(a => a.attribute_id === key)?.type === 'list'
+                        || this.attributes.find(a => a.attribute_id === key)?.type === 'set' ?
+                        (Array.isArray(value) ? value.map(v => `_${v}`).join(' | ') : `_${value}`) : '';
+                    lines.push(this.createCSVLine(variant.id, 'en_GB', key, valueId, Array.isArray(value) ? value.join(' | ') : String(value)));
+                });
+            }
+        });
+        return lines.join('\n') + '\n';
+    }
+    generateProductAttributesCSV(products) {
+        const lines = [
+            this.createCSVLine('product_id', 'locale', 'attribute_id', 'attribute_value_id', 'attribute_value'),
+        ];
+        for (const product of products) {
+            if (product.operation_type) {
+                lines.push(this.createCSVLine(product.product_id, 'en_GB', 'operation_type', ' ', product.operation_type));
+            }
+            for (const [attributeId, value] of Object.entries(product.attributes)) {
+                if (attributeId === 'variants') {
+                    continue;
+                }
+                if (attributeId !== 'operation_type') {
+                    if (!value) {
+                        continue;
+                    }
+                    const valueId = this.attributes.find(a => a.attribute_id === attributeId)?.type === 'list'
+                        || this.attributes.find(a => a.attribute_id === attributeId)?.type === 'set' ?
+                        (Array.isArray(value) ? value.map(v => `_${v}`).join(' | ') : `_${value}`) : '';
+                    const valueStr = Array.isArray(value)
+                        ? value.join(' | ')
+                        : String(value);
+                    if (valueStr) {
+                        lines.push(this.createCSVLine(product.product_id, 'en_GB', attributeId, valueId, valueStr));
+                    }
+                }
+            }
+        }
+        return lines.join('\n') + '\n';
+    }
+    async createProductUpdateZip(products) {
+        const files = await this.createProductZipContent(products);
+        return this.createZip(files);
+    }
+    async getProductCategories(productId) {
+        const product = await this.getProduct(productId);
+        if (!product?.attribute) {
+            return ['catalog01'];
+        }
+        const categoryContainer = product.attribute.find((a) => a?.name === 'categories');
+        return categoryContainer.value
+            .map((c) => c['non-ml'])
+            .map((c) => c.split('_').pop());
+    }
+    async createZip(files) {
+        return new Promise((resolve, reject) => {
+            const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+            const passthrough = new stream_1.PassThrough();
+            const chunks = [];
+            const fileStream = fs_1.default.createWriteStream('./' + this.uploadFileName);
+            const hash = crypto.createHash('md5');
+            passthrough.on('data', chunk => {
+                chunks.push(chunk);
+                hash.update(chunk);
+            });
+            passthrough.on('end', async () => {
+                const buffer = Buffer.concat(chunks);
+                const blob = new Blob([buffer], { type: 'application/zip' });
+                const checksum = hash.digest('hex');
+                resolve({ blob, checksum });
+            });
+            archive.on('error', (err) => reject(err));
+            fileStream.on('error', err => reject(err));
+            archive.pipe(passthrough);
+            archive.pipe(fileStream);
+            for (const [filename, content] of Object.entries(files)) {
+                archive.append(content, { name: filename });
+            }
+            archive.finalize();
+        });
+    }
+    async calculateChecksum(filename) {
+        return new Promise((resolve, reject) => {
+            child_process.exec(`md5sum ${filename} | cut -d ' ' -f1`, (error, stdout) => {
+                if (error)
+                    reject(error);
+                resolve(stdout.trim().replace(/\n/g, ''));
+            });
+        });
+    }
+    createCSVLine(...parts) {
+        return parts
+            .reduce((acc, next) => (acc ? `${acc}\t\t${next}` : next), '')
+            .toString();
+    }
+    async getProduct(id) {
+        const items = await this.queryProduct({ fh_secondid: id });
+        return items?.[0];
+    }
+    async queryProduct(query) {
+        const queryString = Object.entries(query)
+            .map(([key, value]) => `&${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+            .join('');
+        const url = `https://query.prepublished.${this.config.environment}.fas.eu1.fredhopperservices.com/fredhopper/query?fh_displayfields_mode=all${queryString}`;
+        const res = await fetch(url, {
+            headers: {
+                Authorization: `Basic ${this.config.base64Credentials}`,
+                Accept: 'application/json'
+            }
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to fetch product: ${res.status} ${res.statusText}`);
+        }
+        try {
+            const json = await res.json();
+            return json.universes.universe['1']['items-section']?.items.item;
+        }
+        catch (error) {
+            throw new Error(`Failed to parse product JSON: ${error}`);
+        }
+    }
+    mapAttributesFromExistingProduct(product) {
+        const keysToSkip = ['categories', 'secondid', 'search_categories'];
+        return product?.attribute?.reduce((acc, attr) => {
+            if (keysToSkip.includes(attr.name)) {
+                return acc;
+            }
+            if (attr.name.startsWith('analytics_') || attr.name.startsWith('_')) {
+                return acc;
+            }
+            if (!this.attributes.find(a => a.attribute_id === attr.name)) {
+                return acc;
+            }
+            const value = attr.value[0]?.['non-ml'];
+            if (value) {
+                acc[attr.name] = attr.basetype === 'datetime' ? new Date(+value).toISOString() : value;
+            }
+            return acc;
+        }, {}) || {};
+    }
+    async updateProducts(products) {
+        this.logging.log('Starting incremental product update');
+        try {
+            const dataId = await this.uploadProductUpdate(products);
+            this.logging.log('Data uploaded successfully', { dataId });
+            this.logging.log(`https://my.eu1.fredhopperservices.com/hush/input/fas/${this.config.environment}/${dataId}/${this.uploadFileName}`);
+            return this.triggerUpdate(dataId);
+        }
+        catch (error) {
+            this.logging.error('Failed to update products', {
+                error: error?.message,
+            });
+            throw error;
+        }
+    }
+    async createProductZipContent(products) {
+        const categories = await this.getCategories();
+        const attributes = await this.getAttributesMeta();
+        const files = {
+            'categories.csv': this.generateCategoriesCSV(categories),
+            'products.csv': this.generateProductsCSV(products),
+            'custom_attributes_meta.csv': this.generateAttributesMetaCSV(attributes),
+            'custom_attributes_values.csv': this.generateProductAttributesCSV(products)
+        };
+        if (products.some(p => p.variants && p.variants.length > 0)) {
+            files['variants.csv'] = this.generateVariantsCSV(products.map(p => ({ variants: p.variants || [], productId: p.product_id })));
+            files['custom_variant_attributes.csv'] = this.generateCustomVariantAttributesCSV(products.map(p => p.variants || []));
+        }
+        return files;
+    }
+    get uploadFileName() {
+        return this.updateType === 'full' ? 'data.zip' : 'data-incremental.zip';
+    }
+}
+exports.default = FredHelperBase;

package/dist/cjs/src-public/fredhopper/fredhopper.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fredhopper_base_1 = __importDefault(require("./fredhopper.base"));
+class FredHelper extends fredhopper_base_1.default {
+    async patchAttributes(updates) {
+        const products = await Promise.all(updates.map(async ({ productId, attributes }) => {
+            const categories = await this.getProductCategories(productId);
+            return {
+                product_id: productId,
+                attributes,
+                categories,
+                operation_type: 'update'
+            };
+        }));
+        return this.updateProducts(products);
+    }
+    async updateProductCategories(updates) {
+        const products = await Promise.all(updates.map(async ({ productId, categories }) => {
+            const existingProduct = await this.getProduct(productId);
+            return {
+                product_id: productId,
+                attributes: this.mapAttributesFromExistingProduct(existingProduct),
+                categories,
+                operation_type: 'update'
+            };
+        }));
+        return this.updateProducts(products);
+    }
+    async updateProductAndVariants(items) {
+        const products = items.map(item => item.product);
+        await this.validateProducts(products);
+        const files = await this.createProductZipContent(products);
+        const variantsInput = items.map(item => ({
+            variants: item.variants,
+            productId: item.product.product_id
+        }));
+        files['variants.csv'] = this.generateVariantsCSV(variantsInput);
+        const allVariants = items.map(item => item.variants);
+        files['custom_variant_attributes.csv'] = this.generateCustomVariantAttributesCSV(allVariants);
+        const { blob, checksum } = await this.createZip(files);
+        const dataId = await this.uploadToFredhopper(blob, checksum);
+        this.logging.log(`https://my.eu1.fredhopperservices.com/hush/input/fas/${this.config.environment}/${dataId}/data-incremental.zip`);
+        return this.triggerUpdate(dataId);
+    }
+    async updateCategory(updatedCentraCategory) {
+        const existingCategory = this.categories.find((c) => c.category_id === updatedCentraCategory.category_code);
+        let updatedCategories = [];
+        let changeType = 'none';
+        if (['INACTIVE', 'DISABLED'].includes(updatedCentraCategory.status) && existingCategory) {
+            updatedCategories = this.categories.filter((c) => c.category_id !== existingCategory.category_id);
+            changeType = 'remove';
+        }
+        else if (existingCategory) {
+            const locales = updatedCentraCategory.translations?.map((t) => ({ locale: t.language_code, name: t.name })) ?? [];
+            updatedCategories = this.categories.map((c) => c.category_id === existingCategory.category_id ? {
+                ...existingCategory,
+                parent_id: updatedCentraCategory.parent_category_code ?? '',
+                locales
+            } : c);
+            changeType = 'update';
+        }
+        else if (updatedCentraCategory.status === 'ACTIVE') {
+            updatedCategories = [...this.categories, {
+                    category_id: updatedCentraCategory.category_code,
+                    parent_id: updatedCentraCategory.parent_category_code ?? '',
+                    locales: updatedCentraCategory.translations?.map((t) => ({ locale: t.language_code, name: t.name })) ?? []
+                }];
+            changeType = 'create';
+        }
+        if (!updatedCategories.length) {
+            return `No changes to apply: a new category was added (${updatedCentraCategory.category_code}) but the status is ${updatedCentraCategory.status}`;
+        }
+        let categorySearch = 'catalog01';
+        if (changeType !== 'create') {
+            let parentCategory = this.categories.find(c => c.category_id === existingCategory?.parent_id);
+            while (parentCategory) {
+                categorySearch = `${categorySearch}_${parentCategory.category_id}`;
+                parentCategory = this.categories.find(c => c.category_id === parentCategory?.parent_id);
+            }
+            categorySearch = `${categorySearch}_${updatedCentraCategory.category_code}`;
+        }
+        const products = await this.queryProduct({ fh_location: `//catalog01/en_GB/categories<{${categorySearch}` });
+        this.categories = updatedCategories;
+        const { triggerId } = await this.updateProducts(products.map((p) => {
+            let updatedProductCategories = p.attribute.find((a) => a.name === 'categories').value.map((c) => c['non-ml'].split('_').pop());
+            if (changeType === 'remove') {
+                updatedProductCategories = updatedProductCategories.filter((c) => c !== existingCategory?.category_id);
+            }
+            if (!updatedProductCategories.length) {
+                updatedProductCategories = ['catalog01'];
+            }
+            return {
+                product_id: p.id,
+                attributes: this.mapAttributesFromExistingProduct(p),
+                categories: updatedProductCategories,
+            };
+        }));
+        console.log(`https://my.eu1.fredhopperservices.com/hush/track/fas/${this.config.environment}/load-data/${triggerId}/logs/kitchen-incremental.log`);
+        return triggerId;
+    }
+}
+exports.default = FredHelper;

package/dist/cjs/src-public/fredhopper/fredhopper.types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FredhopperValidationError = void 0;
+class FredhopperValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'FredhopperValidationError';
+    }
+}
+exports.FredhopperValidationError = FredhopperValidationError;

package/dist/cjs/src-public/fredhopper/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FredhopperValidationError = exports.FredHelper = void 0;
+var fredhopper_1 = require("./fredhopper");
+Object.defineProperty(exports, "FredHelper", { enumerable: true, get: function () { return __importDefault(fredhopper_1).default; } });
+var fredhopper_types_1 = require("./fredhopper.types");
+Object.defineProperty(exports, "FredhopperValidationError", { enumerable: true, get: function () { return fredhopper_types_1.FredhopperValidationError; } });

package/dist/cjs/src-public/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SitooHelper = exports.RedisConnectionError = exports.RateLimit = exports.setHeaders = exports.BCOrderHelper = exports.DatoHelper = exports.AirtableHelper = exports.CentraHelper = exports.BigQueryHelper = exports.JWKSHelper = exports.CloudTasksHelper = exports.Secrets = exports.SchedulerHelper = exports.Logging = exports.Runtime = exports.PubSubHelper = exports.EnvEngine = exports.validate = void 0;
+exports.RedisConnectionError = exports.RateLimit = exports.setHeaders = exports.BCOrderHelper = exports.DatoHelper = exports.AirtableHelper = exports.CentraHelper = exports.BigQueryHelper = exports.JWKSHelper = exports.CloudTasksHelper = exports.Secrets = exports.SchedulerHelper = exports.Logging = exports.Runtime = exports.PubSubHelper = exports.EnvEngine = exports.validate = void 0;
 var validate_1 = require("./validate");
 Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return __importDefault(validate_1).default; } });
 __exportStar(require("./sanitize"), exports);
@@ -52,5 +52,4 @@ Object.defineProperty(exports, "setHeaders", { enumerable: true, get: function (
 var rateLimit_1 = require("./rateLimit");
 Object.defineProperty(exports, "RateLimit", { enumerable: true, get: function () { return __importDefault(rateLimit_1).default; } });
 Object.defineProperty(exports, "RedisConnectionError", { enumerable: true, get: function () { return rateLimit_1.RedisConnectionError; } });
-var sitoo_1 = require("./sitoo");
-Object.defineProperty(exports, "SitooHelper", { enumerable: true, get: function () { return __importDefault(sitoo_1).default; } });
+__exportStar(require("./fredhopper"), exports);

package/dist/package.json

@@ -9,6 +9,7 @@
     "@hackylabs/deep-redact": "^2.2.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
+    "archiver": "^7.0.1",
     "co-body": "^6.2.0",
     "jose": "^6.0.11",
     "lodash.chunk": "^4.2.0",

package/dist/types/src-public/fredhopper/fredhopper.base.d.ts

@@ -0,0 +1,59 @@
+import { ILogging } from '../runtime';
+import { FredhopperAttribute, FredhopperCategory, FredhopperConfig, FredhopperProduct, UpdateResult, UpdateStatus } from './fredhopper.types';
+export default abstract class FredHelperBase {
+    protected logging: ILogging;
+    protected readonly config: FredhopperConfig;
+    protected attributes: FredhopperAttribute[];
+    protected categories: FredhopperCategory[];
+    constructor(logging: ILogging, config: FredhopperConfig, attributes: FredhopperAttribute[], categories: FredhopperCategory[]);
+    updateType: 'full' | 'incremental';
+    protected get timestamp(): string;
+    protected get authHeader(): string;
+    protected get baseFilesUrl(): string;
+    protected get baseUrl(): string;
+    static validateCategoryId(categoryId: string): boolean;
+    static validateAttributeId(attributeId: string): boolean;
+    static validateProductId(productId: string): boolean;
+    static authHeader(config: FredhopperConfig): string;
+    getCategories(): Promise<FredhopperCategory[]>;
+    getAttributesMeta(): Promise<FredhopperAttribute[]>;
+    validateProducts(products: FredhopperProduct[]): Promise<void>;
+    uploadProductUpdate(products: FredhopperProduct[]): Promise<string>;
+    uploadToFredhopper(zipData: Blob, checksum: string): Promise<string>;
+    uploadChecksumFile(checksum: string, timestamp: string): Promise<void>;
+    triggerIncrementalUpdate(dataId: string): Promise<string>;
+    checkUpdateStatus(triggerId: string): Promise<UpdateStatus>;
+    getUpdateLogs(triggerId: string): Promise<string>;
+    waitForUpdateCompletion(triggerId: string, pollInterval?: number, timeout?: number): Promise<string>;
+    protected triggerUpdate(dataId: string): Promise<UpdateResult>;
+    protected generateCategoriesCSV(categories: FredhopperCategory[]): string;
+    protected generateAttributesMetaCSV(attributes: FredhopperAttribute[]): string;
+    protected generateProductsCSV(products: FredhopperProduct[]): string;
+    protected generateVariantsCSV(inputs: {
+        variants: any[];
+        productId: string;
+    }[]): string;
+    protected generateCustomVariantAttributesCSV(input: {
+        [key: string]: string | number;
+    }[][]): string;
+    protected generateProductAttributesCSV(products: FredhopperProduct[]): string;
+    protected createProductUpdateZip(products: FredhopperProduct[]): Promise<{
+        blob: Blob;
+        checksum: string;
+    }>;
+    getProductCategories(productId: string): Promise<any>;
+    protected createZip(files: Record<string, string>): Promise<{
+        blob: Blob;
+        checksum: string;
+    }>;
+    protected calculateChecksum(filename: string): Promise<string>;
+    protected createCSVLine(...parts: (string | number)[]): string;
+    getProduct(id: string): Promise<any>;
+    protected queryProduct(query: {
+        [key: string]: string;
+    }): Promise<any>;
+    protected mapAttributesFromExistingProduct(product: any): any;
+    protected updateProducts(products: FredhopperProduct[]): Promise<UpdateResult>;
+    protected createProductZipContent(products: FredhopperProduct[]): Promise<Record<string, string>>;
+    protected get uploadFileName(): "data.zip" | "data-incremental.zip";
+}

package/dist/types/src-public/fredhopper/fredhopper.d.ts

@@ -0,0 +1,21 @@
+import FredHelperBase from './fredhopper.base';
+import { CentraCategory, FredhopperProduct, UpdateResult } from './fredhopper.types';
+export default class FredHelper extends FredHelperBase {
+    patchAttributes(updates: Array<{
+        productId: string;
+        attributes: {
+            [attributeId: string]: any;
+        };
+    }>): Promise<UpdateResult>;
+    updateProductCategories(updates: Array<{
+        productId: string;
+        categories: string[];
+    }>): Promise<UpdateResult>;
+    updateProductAndVariants(items: Array<{
+        product: FredhopperProduct;
+        variants: {
+            [key: string]: string | number;
+        }[];
+    }>): Promise<UpdateResult>;
+    updateCategory(updatedCentraCategory: CentraCategory): Promise<any>;
+}

package/dist/types/src-public/fredhopper/fredhopper.types.d.ts

@@ -0,0 +1,70 @@
+export interface FredhopperCategory {
+    category_id: string;
+    parent_id: string;
+    locales: {
+        locale: string;
+        name: string;
+    }[];
+}
+export type UpdateStatus = 'RUNNING' | 'SUCCESS' | 'FAILURE' | 'UNKNOWN';
+export type UpdateResult = {
+    dataId: string;
+    triggerId: string;
+    status: string;
+};
+export interface FredhopperAttribute {
+    attribute_id: string;
+    type: 'float' | 'set' | 'list' | 'int' | 'datetime' | 'asset' | 'text' | 'hierarchical';
+    locales?: {
+        locale: string;
+        name: string;
+    }[];
+}
+export interface FredhopperProduct {
+    product_id: string;
+    attributes: {
+        [attributeId: string]: any;
+    };
+    categories?: string[];
+    operation_type?: 'add' | 'update' | 'replace' | 'delete';
+    variants?: {
+        [key: string]: string | number;
+    }[];
+}
+export interface FredhopperConfig {
+    username: string;
+    password: string;
+    baseUrl: string;
+    environment: string;
+    region?: string;
+    base64Credentials?: string;
+}
+export declare class FredhopperValidationError extends Error {
+    constructor(message: string);
+}
+export type LocalizedName = {
+    name: string;
+    locale: string;
+};
+export type CategoryNode = {
+    name: string;
+    localizedNames: LocalizedName[];
+    children: CategoryNode[];
+};
+export type Catalog = {
+    tenant: string;
+    environment: string;
+    version: number;
+    name: string;
+    children: CategoryNode[];
+    localizedNames: LocalizedName[];
+};
+export type CentraCategory = {
+    category_code: string;
+    parent_category_code?: string;
+    status: string;
+    translations?: {
+        language_code: string;
+        name: string;
+    }[];
+};

package/dist/types/src-public/fredhopper/index.d.ts

@@ -0,0 +1,2 @@
+export { default as FredHelper } from './fredhopper';
+export { FredhopperValidationError, type FredhopperCategory, type FredhopperAttribute, type FredhopperProduct, type FredhopperConfig, } from './fredhopper.types';

package/dist/types/src-public/index.d.ts

@@ -17,4 +17,4 @@ export { default as setHeaders } from './setHeaders';
 export { type CentraError, type CentraErrors, type BasicCentraCountry, type BasicCentraMarket, type BasicCentraSizeChart, type BasicPricelist, type BasicCentraWarehouse, type BasicCentraCampaign, type BasicCentraProduct, type BasicCentraVariant, type BasicCentraDisplay } from './centra';
 export { default as RateLimit, RedisConnectionError } from './rateLimit';
 export { type TriggerOnCreateOptions, type TriggerOnExecuteOptions, type NodeOptions, type RNConfiguration, type TriggerExtraOptions } from './types';
-export { default as SitooHelper, type UnitCost, type StockMovementInput, type BasicSitooWarehouse, type BasicSitooStore, type BasicWarehouseTransaction, type WarehouseTransactionEnvelope, type WarehouseTransactionSyncOptions } from './sitoo';
+export * from './fredhopper';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.248",
+  "version": "0.0.249-fh-20260130152735",
   "author": "",
   "license": "UNLICENSED",
   "description": "",
@@ -9,6 +9,7 @@
     "@hackylabs/deep-redact": "^2.2.1",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
+    "archiver": "^7.0.1",
     "co-body": "^6.2.0",
     "jose": "^6.0.11",
     "lodash.chunk": "^4.2.0",