feed-common 1.77.1 → 1.77.3

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

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { resolveSourceValue } from '../profile.js';
+import { dimensionRegex } from './common-schemas.js';
+
+export function splitByCommaAndTrim(str: string): string[] {
+    return typeof str === 'string'
+        ? str
+              .split(',')
+              .map(s => s.trim())
+              .filter(Boolean)
+        : [];
+}
+
+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;
+}
+
+/**
+ * Create a macro string for use in feed templates
+ * @param source
+ * @param value
+ * @returns
+ */
+export function makeMacroString(source: string, value?: string[]): string {
+    if (value) {
+        if (source.startsWith('source.')) {
+            const resolved = resolveSourceValue(source)?.filter(v => value.includes(v.value));
+
+            if (resolved?.length) {
+                return `{{${source}:${JSON.stringify(resolved)}}}`;
+            }
+        } else {
+            // action
+            return `{{${source}:${value.join(',')}}}`;
+        }
+    }
+
+    return source.startsWith('source.') ? `{{${source}:}}` : `{{${source}}}`;
+}

package/src/utils/feed-templates/ebay.template.ts

@@ -1,7 +1,218 @@
-import { XmlFeedTemplateType } from "../../types/profile.types";
+import { z } from 'zod';
+import { makeMacroString } from './common.js';
+import { validateIfNoMacro } from './common-schemas.js';
+import {
+    ACTION_ARRAY_FIRST_ITEMS,
+    SOURCE_EBAY_GALLERY_TYPE,
+    SOURCE_EBAY_INVENTORY_TRACKING,
+    SOURCE_EBAY_LISTING_TYPE,
+    SOURCE_EBAY_YES_NO,
+    SOURCE_SHOPIFY_DESCRIPTION_HTML,
+    SOURCE_SHOPIFY_IMAGE,
+    SOURCE_SHOPIFY_IMAGES,
+    SOURCE_SHOPIFY_SHOP_COUNTRY,
+    SOURCE_SHOPIFY_SHOP_CURRENCY,
+} from '../../constants/profile.constants.js';
+import { SelectItem, XmlFeedTemplateType } from '../../types/profile.types.js';
+import { resolveSourceValue } from '../profile.js';
+import { countrySchema, currencySchema, oneOfOptionalSchema } from './common-schemas.js';
+
+const yesNoSchema = z.coerce.string().refine(
+    v =>
+        resolveSourceValue(SOURCE_EBAY_YES_NO)
+            ?.map(r => r.value)
+            .includes(v),
+    { message: 'Value must be 0 or 1' }
+);
 
 export const eBayFeedTemplate: XmlFeedTemplateType = {
     formats: [],
-    documentation: '',
-    mapping: []
-}
+    documentation: 'https://developer.ebay.com/devzone/xml/docs/reference/ebay/AddFixedPriceItem.html',
+    mapping: [
+        {
+            attribute: 'AutoPay',
+            label: 'AutoPay',
+            description: 'Indicates whether the seller requires immediate payment for the item',
+            required: false,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_EBAY_YES_NO, ['1']),
+            rules: { sections: [] },
+            baseMode: false,
+            validator: v => validateIfNoMacro(v, yesNoSchema),
+            fixedValue: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'BestOfferEnabled',
+            label: 'Best Offer Enabled',
+            description: 'Indicates whether the seller is accepting Best Offers for the item',
+            required: false,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_EBAY_YES_NO, ['0']),
+            rules: { sections: [] },
+            baseMode: false,
+            validator: v => validateIfNoMacro(v, yesNoSchema),
+            fixedValue: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'CategoryMappingAllowed',
+            label: 'Category Mapping Allowed',
+            description:
+                'This boolean field controls whether or not eBay automatically maps outdated Category ID(s) specified in a PrimaryCategory and/or SecondaryCategory container(s) to the updated Category ID(s) no longer exists in the current category structure',
+            required: false,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_EBAY_YES_NO, ['1']),
+            rules: { sections: [] },
+            baseMode: false,
+            validator: v => validateIfNoMacro(v, yesNoSchema),
+            fixedValue: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'ConditionID',
+            label: 'Condition',
+            description: 'The condition of the item. For example, New, Used, or Refurbished',
+            required: false,
+            type: 'macro-input',
+            defaultValue: '',
+            rules: { sections: [] },
+            baseMode: false,
+            singleChoice: true,
+        },
+        {
+            attribute: 'Country',
+            label: 'Country',
+            description: 'The country where the item is located',
+            required: true,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_SHOPIFY_SHOP_COUNTRY),
+            rules: { sections: [] },
+            validator: v => validateIfNoMacro(v, countrySchema),
+            baseMode: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'Currency',
+            label: 'Currency',
+            description: 'The currency of the item price',
+            required: true,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_SHOPIFY_SHOP_CURRENCY),
+            rules: { sections: [] },
+            validator: v => validateIfNoMacro(v, currencySchema),
+            baseMode: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'Description',
+            label: 'Description',
+            description: 'The description of the item',
+            required: true,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_SHOPIFY_DESCRIPTION_HTML),
+            rules: { sections: [] },
+            baseMode: true,
+            validator: v => validateIfNoMacro(v, z.string().max(500000)),
+            singleChoice: true,
+        },
+        {
+            attribute: 'DiscountPrice',
+            label: 'Description',
+            description: 'The discount price of the item',
+            required: false,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_SHOPIFY_DESCRIPTION_HTML),
+            rules: { sections: [] },
+            baseMode: false,
+            validator: v => validateIfNoMacro(v, z.coerce.number().positive()),
+            singleChoice: true,
+        },
+        {
+            attribute: 'DispatchTimeMax',
+            label: 'Dispatch Time Max',
+            description:
+                'The maximum number of business days the seller commits to for shipping an item to a buyer after receiving a cleared payment',
+            required: false,
+            type: 'macro-input',
+            defaultValue: '',
+            rules: { sections: [] },
+            baseMode: false,
+            validator: v => validateIfNoMacro(v, z.coerce.number().gte(0)),
+            singleChoice: true,
+        },
+        {
+            attribute: 'InventoryTrackingMethod',
+            label: 'Inventory Tracking Method',
+            description: 'The method used to track the inventory level of the item',
+            required: false,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_EBAY_INVENTORY_TRACKING),
+            rules: { sections: [] },
+            baseMode: false,
+            validator: v =>
+                validateIfNoMacro(
+                    v,
+                    oneOfOptionalSchema(resolveSourceValue(SOURCE_EBAY_INVENTORY_TRACKING) as SelectItem[])
+                ),
+            singleChoice: true,
+            fixedValue: true,
+        },
+        // TODO: add compatibility list items
+        // TODO: add item specifics
+        {
+            attribute: 'ListingDuration',
+            label: 'Listing Duration',
+            description: 'The length of time the listing will be active',
+            required: false,
+            type: 'macro-input',
+            defaultValue: '', // TODO: add source
+            rules: { sections: [] },
+            baseMode: false,
+            fixedValue: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'ListingType',
+            label: 'Listing Type',
+            description: 'The type of listing',
+            required: true,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_EBAY_LISTING_TYPE, ['FixedPriceItem']),
+            rules: { sections: [] },
+            baseMode: true,
+            fixedValue: true,
+            singleChoice: true,
+        },
+        {
+            attribute: 'GalleryType',
+            label: 'Gallery Type',
+            description: 'The type of gallery image to use for the listing. Waring: Plus type implies additional fee',
+            required: false,
+            type: 'macro-input',
+            defaultValue: makeMacroString(SOURCE_EBAY_GALLERY_TYPE, ['Gallery']),
+            rules: { sections: [] },
+            baseMode: false,
+            fixedValue: true,
+            singleChoice: true,
+        },
+        // TODO: set PictureSource to Vendor
+        {
+            attribute: 'PictureURL',
+            label: 'Picture URL',
+            description:
+                'Contains the URL for a picture of the item. You can pass in up to 24 picture URLs for each listing. The Gallery image will be the first PictureURL in the list',
+            required: false,
+            type: 'macro-input',
+            defaultValue:
+                makeMacroString(SOURCE_SHOPIFY_IMAGE) +
+                ',' +
+                makeMacroString(SOURCE_SHOPIFY_IMAGES) +
+                makeMacroString(ACTION_ARRAY_FIRST_ITEMS, ['24']),
+            rules: { sections: [] },
+            baseMode: false,
+            fixedValue: true,
+            singleChoice: true,
+        },
+    ],
+};

package/src/utils/feed-templates/facebook.template.ts

@@ -2,7 +2,8 @@
 /* eslint-disable quotes */
 import * as z from 'zod';
 import { ulid } from 'ulid';
-import { dateRangeSchema, gtinSchema, measureUnitsSchema, priceSchema, salePriceSchema, validate, validateIfNoMacro } from './index.js';
+import { validate, validateIfNoMacro } from './common-schemas.js';
+import { dateRangeSchema, gtinSchema, measureUnitsSchema, priceSchema, salePriceSchema } from './common-schemas.js';
 import { XmlFeedTemplateType } from '../../types/profile.types.js';
 import { XmlFeedFormat } from '../../constants/profile.constants.js';
 

package/src/utils/feed-templates/google-api.template.ts

@@ -1,11 +1,20 @@
 /* eslint-disable quotes */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable max-len */
-import { countrySchema, dateRangeSchema, getSourceValueSeparator, gtinSchema, languageSchema, measureUnitsSchema, priceSchema, validateIfNoMacro } from './index.js';
+import { validateIfNoMacro } from './common-schemas.js';
+import {
+    countrySchema,
+    dateRangeSchema,
+    gtinSchema,
+    languageSchema,
+    measureUnitsSchema,
+    priceSchema,
+} from './common-schemas.js';
 import { SOURCE_GOOGLE_PRODUCT_HIGHLIGHT } from '../../constants/profile.constants.js';
 import { ProductUploadMapSource, XmlFeedTemplateType } from '../../types/profile.types.js';
 import { z } from 'zod';
 import { ulid } from 'ulid';
+import { getSourceValueSeparator } from '../utils.js';
 
 const availabilityMapping: ProductUploadMapSource = {
     attribute: 'availability',
@@ -54,13 +63,18 @@ export const googleApiTemplate: XmlFeedTemplateType = {
         {
             attribute: 'contentLanguage',
             label: 'Content language',
-            description: 'The two-letter ISO 639-1 language code for the item. Use source Languages macro to set the language',
+            description:
+                'The two-letter ISO 639-1 language code for the item. Use source Languages macro to set the language',
             required: true,
             type: 'macro-input',
             defaultValue: '{{source.language:}}',
             rules: { sections: [] },
             baseMode: true,
-            validator: (v: string | number) => validateIfNoMacro(v, [languageSchema, z.string().min(2, { message: 'Language should be 2 characters long' })]),
+            validator: (v: string | number) =>
+                validateIfNoMacro(v, [
+                    languageSchema,
+                    z.string().min(2, { message: 'Language should be 2 characters long' }),
+                ]),
             singleChoice: true,
             fixedValue: true,
         },
@@ -72,7 +86,11 @@ export const googleApiTemplate: XmlFeedTemplateType = {
             type: 'macro-input',
             defaultValue: '{{source.country:}}',
             rules: { sections: [] },
-            validator: (v: string | number) => validateIfNoMacro(v, [countrySchema, z.string().min(2, { message: 'Country code should be 2 characters long' })]),
+            validator: (v: string | number) =>
+                validateIfNoMacro(v, [
+                    countrySchema,
+                    z.string().min(2, { message: 'Country code should be 2 characters long' }),
+                ]),
             baseMode: true,
             singleChoice: true,
             fixedValue: true,
@@ -238,8 +256,10 @@ export const googleApiTemplate: XmlFeedTemplateType = {
                     v,
                     z
                         .string()
-                        .refine(v => !v || z.string().datetime({ offset: true }).safeParse(v).success, { message: 'invalid date' })
-                        .refine(v => !v || new Date(v).getTime() < (1000 * 60 * 60 * 24 * 365 + new Date().getTime()), {
+                        .refine(v => !v || z.string().datetime({ offset: true }).safeParse(v).success, {
+                            message: 'invalid date',
+                        })
+                        .refine(v => !v || new Date(v).getTime() < 1000 * 60 * 60 * 24 * 365 + new Date().getTime(), {
                             message: 'The date should be up to one year in the future',
                         })
                 ),
@@ -270,8 +290,10 @@ export const googleApiTemplate: XmlFeedTemplateType = {
                     v,
                     z
                         .string()
-                        .refine(v => !v || z.string().datetime({ offset: true }).safeParse(v).success, { message: 'invalid date' })
-                        .refine(v => !v || new Date(v).getTime() < (1000 * 60 * 60 * 24 * 30 + new Date().getTime()), {
+                        .refine(v => !v || z.string().datetime({ offset: true }).safeParse(v).success, {
+                            message: 'invalid date',
+                        })
+                        .refine(v => !v || new Date(v).getTime() < 1000 * 60 * 60 * 24 * 30 + new Date().getTime(), {
                             message: 'The date should be less than 30 days in the future',
                         })
                 ),
@@ -798,30 +820,33 @@ export const googleApiTemplate: XmlFeedTemplateType = {
                 'The most relevant highlights of your products. Max 150 characters. Example: Supports thousands of apps, including Netflix, YouTube, and HBO Max',
             required: false,
             type: 'macro-input',
-            validator: (v: string | number) => validateIfNoMacro(v, z.string().superRefine((v, ctx) => {
-                if (!v) {
-                    return true;
-                }
-
-                const values = v.split(getSourceValueSeparator(SOURCE_GOOGLE_PRODUCT_HIGHLIGHT));
+            validator: (v: string | number) =>
+                validateIfNoMacro(
+                    v,
+                    z.string().superRefine((v, ctx) => {
+                        if (!v) {
+                            return true;
+                        }
 
-                if (values.length < 2) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        message: 'Minimum 2 values required',
-                    });
-                    return false;
-                }
+                        const values = v.split(getSourceValueSeparator(SOURCE_GOOGLE_PRODUCT_HIGHLIGHT));
 
-                if (values.some(val => val.length > 150)) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        message: 'Max 150 characters per value',
-                    });
-                    return false;
-                }
+                        if (values.length < 2) {
+                            ctx.addIssue({
+                                code: z.ZodIssueCode.custom,
+                                message: 'Minimum 2 values required',
+                            });
+                            return false;
+                        }
 
-            })),
+                        if (values.some(val => val.length > 150)) {
+                            ctx.addIssue({
+                                code: z.ZodIssueCode.custom,
+                                message: 'Max 150 characters per value',
+                            });
+                            return false;
+                        }
+                    })
+                ),
             defaultValue: '{{source.google_product_highlight:}}',
             rules: { sections: [] },
             fixedValue: true,

package/src/utils/feed-templates/google.template.ts

@@ -1,22 +1,22 @@
 /* eslint-disable quotes */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable max-len */
+import { resolveSourceMacro } from '../utils.js';
+import { validateIfNoMacro } from './common-schemas.js';
 import {
     countrySchema,
     dateRangeSchema,
     energyEfficiencyClassSchema,
-    getSourceValueSeparator,
     gtinSchema,
     maxEnergyEfficiencyClassSchema,
     measureUnitsSchema,
     minEnergyEfficiencyClassSchema,
     priceSchema,
     requiredIfOtherPresentSchema,
-    resolveSourceMacro,
     salePriceSchema,
     sameUnitScheme,
-    validateIfNoMacro,
-} from './index.js';
+} from './common-schemas.js';
+import { getSourceValueSeparator } from '../utils.js';
 import { SOURCE_GOOGLE_PRODUCT_HIGHLIGHT, XmlFeedFormat } from '../../constants/profile.constants.js';
 import { ProductUploadMapSource, XmlFeedTemplateType } from '../../types/profile.types.js';
 import { z } from 'zod';
@@ -39,18 +39,6 @@ const availabilityMapping: ProductUploadMapSource = {
     fixedValue: true,
 };
 
-const customLabelMapping: ProductUploadMapSource = {
-    attribute: '',
-    label: '',
-    description:
-        'Label that you assign to a product to help organize bidding and reporting in Shopping campaigns. Max 100 characters. Example: Seasonal',
-    required: false,
-    type: 'macro-input' as any,
-    validator: (v: string | number) => validateIfNoMacro(v, z.string().max(100)),
-    rules: { sections: [] },
-    defaultValue: '',
-};
-
 export const googleFeedTemplate: XmlFeedTemplateType = {
     formats: [XmlFeedFormat.XML],
     documentation: 'https://support.google.com/merchants/answer/7052112',
@@ -124,21 +112,20 @@ export const googleFeedTemplate: XmlFeedTemplateType = {
             validator: (v: string | number) =>
                 validateIfNoMacro(
                     v,
-                    z
-                        .string().superRefine((v, ctx) => {
-                            if (!v) {
-                                return;
-                            }
+                    z.string().superRefine((v, ctx) => {
+                        if (!v) {
+                            return;
+                        }
 
-                            const urls = v.split(getSourceValueSeparator());
+                        const urls = v.split(getSourceValueSeparator());
 
-                            if (urls.some(url => !z.string().url().safeParse(url).success)) {
-                                ctx.addIssue({
-                                    code: z.ZodIssueCode.custom,
-                                    message: 'invalid URL',
-                                });
-                            }
-                        })
+                        if (urls.some(url => !z.string().url().safeParse(url).success)) {
+                            ctx.addIssue({
+                                code: z.ZodIssueCode.custom,
+                                message: 'invalid URL',
+                            });
+                        }
+                    })
                 ),
             defaultValue: '',
             rules: { sections: [] },
@@ -898,30 +885,33 @@ export const googleFeedTemplate: XmlFeedTemplateType = {
                 'The most relevant highlights of your products. Max 150 characters. Example: Supports thousands of apps, including Netflix, YouTube, and HBO Max',
             required: false,
             type: 'macro-input',
-            validator: (v: string | number) => validateIfNoMacro(v, z.string().superRefine((v, ctx) => {
-                if (!v) {
-                    return true;
-                }
-
-                const values = v.split(getSourceValueSeparator(SOURCE_GOOGLE_PRODUCT_HIGHLIGHT));
+            validator: (v: string | number) =>
+                validateIfNoMacro(
+                    v,
+                    z.string().superRefine((v, ctx) => {
+                        if (!v) {
+                            return true;
+                        }
 
-                if (values.length < 2) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        message: 'Minimum 2 values required',
-                    });
-                    return false;
-                }
+                        const values = v.split(getSourceValueSeparator(SOURCE_GOOGLE_PRODUCT_HIGHLIGHT));
 
-                if (values.some(val => val.length > 150)) {
-                    ctx.addIssue({
-                        code: z.ZodIssueCode.custom,
-                        message: 'Max 150 characters per value',
-                    });
-                    return false;
-                }
+                        if (values.length < 2) {
+                            ctx.addIssue({
+                                code: z.ZodIssueCode.custom,
+                                message: 'Minimum 2 values required',
+                            });
+                            return false;
+                        }
 
-            })),
+                        if (values.some(val => val.length > 150)) {
+                            ctx.addIssue({
+                                code: z.ZodIssueCode.custom,
+                                message: 'Max 150 characters per value',
+                            });
+                            return false;
+                        }
+                    })
+                ),
             defaultValue: '{{source.google_product_highlight:}}',
             rules: { sections: [] },
             fixedValue: true,
@@ -1149,8 +1139,12 @@ export const googleFeedTemplate: XmlFeedTemplateType = {
                         if (!v) {
                             return true;
                         }
-                        const installment = getSourceTagValueAndStripTags(values.find(v => v.attribute === 'installment')?.value as string ?? "")?.value;
-                        const subscription = getSourceTagValueAndStripTags(values.find(v => v.attribute === 'subscription_cost')?.value as string ?? "")?.value;
+                        const installment = getSourceTagValueAndStripTags(
+                            (values.find(v => v.attribute === 'installment')?.value as string) ?? ''
+                        )?.value;
+                        const subscription = getSourceTagValueAndStripTags(
+                            (values.find(v => v.attribute === 'subscription_cost')?.value as string) ?? ''
+                        )?.value;
                         const shippingValue = v.split(',').map(val => val.trim());
                         const shipToSameCountry = new Set(shippingValue.map(v => v.split(':')[0])).size === 1;