feed-common 1.77.1 → 1.77.2

package/src/utils/feed-templates/common-schemas.ts

@@ -0,0 +1,1014 @@
+import { SafeParseReturnType, z, ZodType } from 'zod';
+import { SelectItem } from '../../types/profile.types';
+import { resolveSourceMacro } from '../utils';
+
+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',
+    });
+
+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 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 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,
+            });
+        }
+    });
+
+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 const oneOfSchema = (values: SelectItem[]) =>
+    z.string().refine(v => values.map(v => v.value).includes(v), {
+        message: `Invalid value. Valid values are: ${values.map(v => v.label).join(', ')}`,
+    });
+
+export const oneOfOptionalSchema = (values: SelectItem[]) => z.string().refine(v => !v || oneOfSchema(values).parse(v));
+
+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 unitMeasureRegex = /^(?<quantity>[\d.,]+)\s*(?<units>\w+)$/;
+
+export const priceRegex = /^(?<value>\d+(?:\.\d{1,2})?)\s*(?<currency>\w+)$/;
+
+export const hasMacro = (v: string) => /{{[^}]+}}/.test(v.replaceAll(/{{source\..+?}}/g, ''));
+
+export const removeMacro = (v: string) => v.replaceAll(/{{.+?}}/g, '');
+
+export const dimensionRegex = /^(?<value>[\d.,]+)\s*(?<unit>\w+)$/;
+
+export 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
+ */
+
+export 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 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));
+}