feed-common 1.77.1 → 1.77.2

package/src/utils/feed-templates/index.ts

@@ -1,514 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { SafeParseReturnType, z, ZodType } from 'zod';
-import { SOURCE_FB_CATEGORY, SOURCE_GOOGLE_PRODUCT_HIGHLIGHT, XMLFeedType } from '../../constants/profile.constants.js';
-import { customFeedTemplate } from './custom.template.js';
-import { facebookFeedTemplate } from './facebook.template.js';
-import { XmlFeedTemplateType } from '../../types/profile.types.js';
-import { googleFeedTemplate } from './google.template.js';
-import { tiktokFeedTemplate } from './tiktok.template.js';
-import { microsoftTemplate } from './microsoft.template.js';
-import { googleApiTemplate } from './google-api.template.js';
-import { getSourceTagValue } from '../utils.js';
-import { eBayFeedTemplate } from './ebay.template.js';
-
-export const hasMacro = (v: string) => /{{[^}]+}}/.test(v.replaceAll(/{{source\..+?}}/g, ''));
-export const removeMacro = (v: string) => v.replaceAll(/{{.+?}}/g, '');
-
-export function validate(
-    value: string | number,
-    validator: ZodType<any, any>,
-    skipEmpty = true
-): SafeParseReturnType<any, any> {
-    let valueToValidate = value;
-
-    if (typeof value === 'string') {
-        valueToValidate = removeMacro(value);
-    }
-
-    if (!value && skipEmpty) {
-        return { success: true, data: value };
-    }
-
-    return validator.safeParse(valueToValidate);
-}
-
-export function validateIfNoMacro(value: string | number, validator: ZodType<any, any> | ZodType<any, any>[]): SafeParseReturnType<any, any> {
-    if (typeof value === 'string' && hasMacro(value)) {
-        return { success: true, data: value };
-    }
-
-    if (Array.isArray(validator)) {
-        for (const v of validator) {
-            const result = v.safeParse(resolveSourceMacro(value));
-            if (!result.success) {
-                return result;
-            }
-        }
-        return { success: true, data: value };
-    }
-
-    return validator.safeParse(resolveSourceMacro(value));
-}
-
-export function resolveSourceMacro(macro: any): any {
-    if (typeof macro !== 'string') {
-        return macro;
-    }
-    return macro.replace(/{{source\..+?}}/g, (macro) => {
-        const { tag, value } = getSourceTagValue(macro.slice(2, -2));
-        return value?.map(v => v.value)?.join(getSourceValueSeparator(tag)) ?? '';
-    });
-}
-
-export const dateRangeSchema = z
-    .string()
-    .refine(v => !v || v.split('/').length === 2, {
-        message: 'The date range start and end should be separated by a "/"',
-    })
-    .refine(v => !v || z.string().datetime({ offset: true }).safeParse(v.split('/')[0]).success, {
-        message: 'Date from should be a valid date',
-    })
-    .refine(v => !v || z.string().datetime({ offset: true }).safeParse(v.split('/')[1]).success, {
-        message: 'Date to should be a valid date',
-    })
-    .refine(v => !v || new Date(v.split('/')[1]) > new Date(v.split('/')[0]), {
-        message: 'Date to should be greater than date from',
-    });
-
-const unitMeasureRegex = /^(?<quantity>[\d.,]+)\s*(?<units>\w+)$/;
-
-export const measureUnitsSchema = (units: string[]) =>
-    z.string().superRefine((v, ctx) => {
-        if (!v) {
-            return true;
-        }
-
-        const match = unitMeasureRegex.exec(v);
-
-        if (!match) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Invalid format',
-            });
-        } else if (!units.map(u => u.toLowerCase()).includes(match.groups?.units?.toLowerCase() as string)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: `Invalid unit. Valid units are: ${units.join(', ')}`,
-            });
-        }
-    });
-
-export const sameUnitScheme = (other: string, errorMessage: string) => z.string().superRefine((v, ctx) => {
-    if (!v || !other) {
-        return true;
-    }
-
-    const match = unitMeasureRegex.exec(v);
-    const otherMatch = unitMeasureRegex.exec(other);
-
-    if (!match || !otherMatch) {
-        return true;
-    }
-
-    if (match.groups?.units !== otherMatch.groups?.units) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: errorMessage,
-        });
-    }
-})
-
-export const optionalUrlSchema = z
-    .string()
-    .refine(v => !v || z.string().url().safeParse(v).success, { message: 'invalid URL' });
-
-export function getTemplate(type: XMLFeedType): XmlFeedTemplateType {
-    switch (type) {
-        case XMLFeedType.Custom:
-            return customFeedTemplate;
-        case XMLFeedType.Facebook:
-            return facebookFeedTemplate;
-        case XMLFeedType.Google:
-            return googleFeedTemplate;
-        case XMLFeedType.TikTok:
-            return tiktokFeedTemplate;
-        case XMLFeedType.Microsoft:
-            return microsoftTemplate;
-        case XMLFeedType.GMC_API:
-            return googleApiTemplate;
-        case XMLFeedType.eBay:
-            return eBayFeedTemplate;
-        default:
-            throw new Error(`Invalid feed type: ${type}`);
-    }
-}
-
-export const currencySchema = z.enum([
-    'AED', 'AFN', 'ALL', 'AMD', 'ANG', 'AOA', 'ARS', 'AUD', 'AWG', 'AZN', 'BAM', 'BBD',
-    'BDT', 'BGN', 'BHD', 'BIF', 'BMD', 'BND', 'BOB', 'BOV', 'BRL', 'BSD', 'BTN', 'BWP',
-    'BYN', 'BZD', 'CAD', 'CDF', 'CHE', 'CHF', 'CHW', 'CLF', 'CLP', 'CNY', 'COP', 'COU',
-    'CRC', 'CUC', 'CUP', 'CVE', 'CZK', 'DJF', 'DKK', 'DOP', 'DZD', 'EGP', 'ERN', 'ETB',
-    'EUR', 'FJD', 'FKP', 'FOK', 'GBP', 'GEL', 'GGP', 'GHS', 'GIP', 'GMD', 'GNF', 'GTQ',
-    'GYD', 'HKD', 'HNL', 'HRK', 'HTG', 'HUF', 'IDR', 'ILS', 'IMP', 'INR', 'IQD', 'IRR',
-    'ISK', 'JMD', 'JOD', 'JPY', 'KES', 'KGS', 'KHR', 'KID', 'KMF', 'KRW', 'KWD', 'KYD',
-    'KZT', 'LAK', 'LBP', 'LKR', 'LRD', 'LSL', 'LYD', 'MAD', 'MDL', 'MGA', 'MKD', 'MMK',
-    'MNT', 'MOP', 'MRU', 'MUR', 'MVR', 'MWK', 'MXN', 'MXV', 'MYR', 'MZN', 'NAD', 'NGN',
-    'NIO', 'NOK', 'NPR', 'NZD', 'OMR', 'PAB', 'PEN', 'PGK', 'PHP', 'PKR', 'PLN', 'PYG',
-    'QAR', 'RON', 'RSD', 'RUB', 'RWF', 'SAR', 'SBD', 'SCR', 'SDG', 'SEK', 'SGD', 'SHP',
-    'SLE', 'SLL', 'SOS', 'SRD', 'SSP', 'STN', 'SYP', 'SZL', 'THB', 'TJS', 'TMT', 'TND',
-    'TOP', 'TRY', 'TTD', 'TVD', 'TWD', 'TZS', 'UAH', 'UGX', 'USD', 'USN', 'UYI', 'UYU',
-    'UYW', 'UZS', 'VED', 'VES', 'VND', 'VUV', 'WST', 'XAF', 'XAG', 'XAU', 'XBA', 'XBB',
-    'XBC', 'XBD', 'XCD', 'XDR', 'XOF', 'XPD', 'XPF', 'XPT', 'XSU', 'XTS', 'XUA', 'XXX',
-    'YER', 'ZAR', 'ZMW', 'ZWL'
-]);
-
-export const languageSchema = z.string().refine(v => !v || [
-    'aa', 'ab', 'ae', 'af', 'ak', 'am', 'an', 'ar', 'as', 'av', 'ay', 'az',
-    'ba', 'be', 'bg', 'bh', 'bi', 'bm', 'bn', 'bo', 'br', 'bs', 'ca', 'ce',
-    'ch', 'co', 'cr', 'cs', 'cu', 'cv', 'cy', 'da', 'de', 'dv', 'dz', 'ee',
-    'el', 'en', 'eo', 'es', 'et', 'eu', 'fa', 'ff', 'fi', 'fj', 'fo', 'fr',
-    'fy', 'ga', 'gd', 'gl', 'gn', 'gu', 'gv', 'ha', 'he', 'hi', 'ho', 'hr',
-    'ht', 'hu', 'hy', 'hz', 'ia', 'id', 'ie', 'ig', 'ii', 'ik', 'io', 'is',
-    'it', 'iu', 'ja', 'jv', 'ka', 'kg', 'ki', 'kj', 'kk', 'kl', 'km', 'kn',
-    'ko', 'kr', 'ks', 'ku', 'kv', 'kw', 'ky', 'la', 'lb', 'lg', 'li', 'ln',
-    'lo', 'lt', 'lu', 'lv', 'mg', 'mh', 'mi', 'mk', 'ml', 'mn', 'mr', 'ms',
-    'mt', 'my', 'na', 'nb', 'nd', 'ne', 'ng', 'nl', 'nn', 'no', 'nr', 'nv',
-    'ny', 'oc', 'oj', 'om', 'or', 'os', 'pa', 'pi', 'pl', 'ps', 'pt', 'qu',
-    'rm', 'rn', 'ro', 'ru', 'rw', 'sa', 'sc', 'sd', 'se', 'sg', 'si', 'sk',
-    'sl', 'sm', 'sn', 'so', 'sq', 'sr', 'ss', 'st', 'su', 'sv', 'sw', 'ta',
-    'te', 'tg', 'th', 'ti', 'tk', 'tl', 'tn', 'to', 'tr', 'ts', 'tt', 'tw',
-    'ty', 'ug', 'uk', 'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi',
-    'yo', 'za', 'zh', 'zu'
-].includes(v.toLowerCase()), { message: 'Invalid language code' });
-
-export const countrySchema = z.string().refine(v => !v || [
-    'AD', 'AE', 'AF', 'AG', 'AI', 'AL', 'AM', 'AO', 'AQ', 'AR', 'AS', 'AT', 'AU', 'AW', 'AX', 'AZ',
-    'BA', 'BB', 'BD', 'BE', 'BF', 'BG', 'BH', 'BI', 'BJ', 'BL', 'BM', 'BN', 'BO', 'BQ', 'BR', 'BS',
-    'BT', 'BV', 'BW', 'BY', 'BZ', 'CA', 'CC', 'CD', 'CF', 'CG', 'CH', 'CI', 'CK', 'CL', 'CM', 'CN',
-    'CO', 'CR', 'CU', 'CV', 'CW', 'CX', 'CY', 'CZ', 'DE', 'DJ', 'DK', 'DM', 'DO', 'DZ', 'EC', 'EE',
-    'EG', 'EH', 'ER', 'ES', 'ET', 'FI', 'FJ', 'FM', 'FO', 'FR', 'GA', 'GB', 'GD', 'GE', 'GF', 'GG',
-    'GH', 'GI', 'GL', 'GM', 'GN', 'GP', 'GQ', 'GR', 'GT', 'GU', 'GW', 'GY', 'HK', 'HM', 'HN', 'HR',
-    'HT', 'HU', 'ID', 'IE', 'IL', 'IM', 'IN', 'IO', 'IQ', 'IR', 'IS', 'IT', 'JE', 'JM', 'JO', 'JP',
-    'KE', 'KG', 'KH', 'KI', 'KM', 'KN', 'KP', 'KR', 'KW', 'KY', 'KZ', 'LA', 'LB', 'LC', 'LI', 'LK',
-    'LR', 'LS', 'LT', 'LU', 'LV', 'LY', 'MA', 'MC', 'MD', 'ME', 'MF', 'MG', 'MH', 'MK', 'ML', 'MM',
-    'MN', 'MO', 'MP', 'MQ', 'MR', 'MS', 'MT', 'MU', 'MV', 'MW', 'MX', 'MY', 'MZ', 'NA', 'NC', 'NE',
-    'NF', 'NG', 'NI', 'NL', 'NO', 'NP', 'NR', 'NU', 'NZ', 'OM', 'PA', 'PE', 'PF', 'PG', 'PH', 'PK',
-    'PL', 'PM', 'PN', 'PR', 'PT', 'PW', 'PY', 'QA', 'RE', 'RO', 'RS', 'RU', 'RW', 'SA', 'SB', 'SC',
-    'SD', 'SE', 'SG', 'SH', 'SI', 'SJ', 'SK', 'SL', 'SM', 'SN', 'SO', 'SR', 'SS', 'ST', 'SV', 'SX',
-    'SY', 'SZ', 'TC', 'TD', 'TF', 'TG', 'TH', 'TJ', 'TK', 'TL', 'TM', 'TN', 'TO', 'TR', 'TT', 'TV',
-    'TZ', 'UA', 'UG', 'UM', 'US', 'UY', 'UZ', 'VA', 'VC', 'VE', 'VG', 'VI', 'VN', 'VU', 'WF', 'WS',
-    'YE', 'YT', 'ZA', 'ZM', 'ZW'
-].includes(v.toUpperCase()), { message: 'Invalid country code' });
-
-export const priceRegex = /^(?<value>\d+(?:\.\d{1,2})?)\s*(?<currency>\w+)$/;
-
-export const priceSchema = ({ min = 0, max = 1000000 } = {}) =>
-    z.string().superRefine((v, ctx) => {
-        if (!v) {
-            return true;
-        }
-
-        try {
-            parsePriceString({ price: v, min, max });
-            return true;
-        } catch (e: any) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: e.message,
-            });
-        }
-    });
-
-export const salePriceSchema = ({ min = 0, max = 1000000, price = '' } = {}) =>
-    z.string().superRefine((v, ctx) => {
-        if (!v) {
-            return true;
-        }
-
-        try {
-            const { currency, value } = parsePriceString({ price: v, min, max });
-
-            if (price) {
-                try {
-                    const { currency: priceCurrency, value: priceAmount } = parsePriceString({ price, min, max });
-
-                    if (currency !== priceCurrency) {
-                        ctx.addIssue({
-                            code: z.ZodIssueCode.custom,
-                            message: 'Sale price currency should be the same as the price currency',
-                        });
-                        return;
-                    }
-
-                    if (Number(value) >= Number(priceAmount)) {
-                        ctx.addIssue({
-                            code: z.ZodIssueCode.custom,
-                            message: 'Sale price should be lower than the price',
-                        });
-                        return;
-                    }
-                } catch (e: any) { }
-            }
-            return true;
-        } catch (e: any) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: e.message,
-            });
-        }
-    });
-
-const ee = ['A+++', 'A++', 'A+', 'A', 'B', 'C', 'D', 'E', 'F', 'G',];
-
-/**
- * Check if minEfficiency is less or equal to maxEfficiency
- * @param minEfficiency 
- * @param maxEfficiency 
- * @returns 
- */
-const compareEfficiency = (minEfficiency: string, maxEfficiency: string): boolean => {
-    const minIndex = ee.findIndex(e => e === minEfficiency);
-    const maxIndex = ee.findIndex(e => e === maxEfficiency);
-
-    if (minIndex === -1 || maxIndex === -1) {
-        return false;
-    }
-
-    return minIndex >= maxIndex;
-}
-
-export const energyEfficiencyClassSchema = ({ minEfficiency = '', maxEfficiency } = {} as { minEfficiency?: string, maxEfficiency?: string }) => {
-    return z.string().superRefine((v, ctx) => {
-        if (!v) {
-            if (maxEfficiency || minEfficiency) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: 'Energy efficiency class is required',
-                });
-                return false;
-            }
-            return true;
-        }
-
-        if (!ee.includes(v)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Invalid energy efficiency class',
-            });
-            return false;
-        }
-
-        if (minEfficiency && !compareEfficiency(minEfficiency, v)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Energy efficiency class should be greater or equal to the minimum energy efficiency class',
-            });
-            return false;
-        }
-
-        if (maxEfficiency && !compareEfficiency(v, maxEfficiency)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Energy efficiency class should be lower or equal to the maximum energy efficiency class',
-            });
-            return false;
-        }
-        return true;
-    });
-}
-
-export const minEnergyEfficiencyClassSchema = ({ efficiency = '', maxEfficiency } = {} as { efficiency?: string, maxEfficiency?: string }) => {
-    return z.string().superRefine((v, ctx) => {
-        if (!v) {
-            if (maxEfficiency || efficiency) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: 'Minimum energy efficiency class is required',
-                });
-                return false;
-            }
-            return true;
-        }
-
-        if (!ee.includes(v)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Invalid energy efficiency class',
-            });
-            return false;
-        }
-
-        if (efficiency && !compareEfficiency(v, efficiency)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Minimum energy efficiency class should be lower or equal to the energy efficiency class',
-            });
-            return false;
-        }
-
-        if (maxEfficiency && !compareEfficiency(v, maxEfficiency)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Minimum energy efficiency class should be lower or equal to the maximum energy efficiency class',
-            });
-            return false;
-        }
-        return true;
-    });
-}
-
-export const maxEnergyEfficiencyClassSchema = ({ efficiency = '', minEfficiency } = {} as { efficiency?: string, minEfficiency?: string }) => {
-    return z.string().superRefine((v, ctx) => {
-        if (!v) {
-            if (minEfficiency || efficiency) {
-                ctx.addIssue({
-                    code: z.ZodIssueCode.custom,
-                    message: 'Maximum energy efficiency class is required',
-                });
-                return false;
-            }
-            return true;
-        }
-
-        if (!ee.includes(v)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Invalid energy efficiency class',
-            });
-            return false;
-        }
-
-        if (efficiency && !compareEfficiency(efficiency, v)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Maximum energy efficiency class should be greater or equal to the energy efficiency class',
-            });
-            return false;
-        }
-
-        if (minEfficiency && !compareEfficiency(minEfficiency, v)) {
-            ctx.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: 'Maximum energy efficiency class should be greater or equal to the minimum energy efficiency class',
-            });
-            return false;
-        }
-        return true;
-    });
-}
-
-export const gtinSchema = z.string().refine((gtin) => {
-    if (!gtin) {
-        return true;
-    }
-
-    const length = gtin.length;
-
-    if (![8, 12, 13, 14].includes(length)) {
-        return false;
-    }
-
-    const digits = gtin.split('').map(Number);
-    const checkDigit = digits.pop();
-    const sum = digits.reverse().reduce((acc, digit, idx) => {
-        return acc + digit * (idx % 2 === 0 ? 3 : 1);
-    }, 0);
-
-    const calculatedCheckDigit = (10 - (sum % 10)) % 10;
-    return checkDigit === calculatedCheckDigit;
-}, {
-    message: 'Invalid GTIN',
-});
-
-export const requiredIfOtherPresentSchema = (other: string[], errorMessage: string) => z.string().superRefine((v, ctx) => {
-    if (!v && other.some(o => o)) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: errorMessage,
-        });
-    }
-});
-
-export function splitByCommaAndTrim(str: string): string[] {
-    return typeof str === 'string'
-        ? str
-            .split(',')
-            .map(s => s.trim())
-            .filter(Boolean)
-        : [];
-}
-
-export function parsePriceString({ price, min = 0, max = 1000000 }: { price: string; min?: number; max?: number }): {
-    value: string;
-    currency: string;
-} {
-    const match = priceRegex.exec(price);
-
-    if (!match) {
-        throw new Error('Invalid format');
-    } else if (
-        !Number.isFinite(Number(match.groups?.value)) ||
-        Number(match.groups?.value) < min ||
-        Number(match.groups?.value) > max
-    ) {
-
-        throw new Error(`Value should be between ${min} and ${max}`)
-
-    } else if (!currencySchema.safeParse(match.groups?.currency).success) {
-        throw new Error('Invalid currency');
-    }
-
-    return { value: match.groups?.value as string, currency: match.groups?.currency as string };
-}
-
-export const dimensionRegex = /^(?<value>[\d.,]+)\s*(?<unit>\w+)$/;
-
-export function parseDimensionString({ dimension, min = 0, max = 1000000 }: { dimension: string; min?: number; max?: number }): {
-    value: string;
-    unit: string;
-} {
-    const match = dimensionRegex.exec(dimension);
-
-    if (!match) {
-        throw new Error('Invalid format');
-    } else if (
-        !Number.isFinite(Number(match.groups?.value)) ||
-        Number(match.groups?.value) < min ||
-        Number(match.groups?.value) > max
-    ) {
-        throw new Error(`Value should be between ${min} and ${max}`);
-    }
-
-    return { value: match.groups?.value as string, unit: match.groups?.unit as string };
-}
-
-export function convertToBoolean(value: string): boolean {
-    if (value === 'true') {
-        return true;
-    }
-
-    if (value === 'false') {
-        return false;
-    }
-
-    throw new Error('Invalid boolean value');
-}
-
-export function castToArray(value: string): string[] {
-    return Array.isArray(value) ? value : [value];
-}
-
-export function castToInt(value: string): number {
-    return typeof value === 'string' ? parseInt(value, 10) : value;
-}
-
-export function getSourceValueSeparator(source = ''): string {
-    switch (source) {
-        case SOURCE_GOOGLE_PRODUCT_HIGHLIGHT:
-            return '|';
-        case SOURCE_FB_CATEGORY:
-            return ':';
-        default:
-            return ',';
-    }
-}