n8n-nodes-amazon-creator-api 0.1.0

package/dist/nodes/AmazonCreatorsApi/AmazonCreatorsApi.node.js

@@ -0,0 +1,656 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmazonCreatorsApi = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+const shared_1 = require("./shared");
+const ITEM_OPS = ['getItems', 'searchItems', 'getVariations'];
+class AmazonCreatorsApi {
+    constructor() {
+        this.description = {
+            displayName: 'Amazon Creators API',
+            name: 'amazonCreatorsApi',
+            icon: 'file:amazon.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Interact with the Amazon Creators API (successor to PA-API 5.0)',
+            defaults: {
+                name: 'Amazon Creators API',
+                color: '#FF9900',
+            },
+            usableAsTool: true,
+            inputs: ['main'],
+            outputs: '={{ $parameter["splitErrors"] ? [{ "type": "main", "displayName": "Data" }, { "type": "main", "displayName": "Errors" }] : [{ "type": "main", "displayName": "Data" }] }}',
+            credentials: [
+                {
+                    name: 'amazonCreatorsApi',
+                    required: true,
+                    testedBy: 'creatorsApiCredentialTest',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Get Items',
+                            value: 'getItems',
+                            description: 'Get item attributes by ASIN',
+                            action: 'Get items by ASIN',
+                        },
+                        {
+                            name: 'Search Items',
+                            value: 'searchItems',
+                            description: 'Search for items on Amazon',
+                            action: 'Search for items',
+                        },
+                        {
+                            name: 'Get Variations',
+                            value: 'getVariations',
+                            description: 'Get variations (size, color, etc.) of an ASIN',
+                            action: 'Get variations of an ASIN',
+                        },
+                        {
+                            name: 'Get Browse Nodes',
+                            value: 'getBrowseNodes',
+                            description: 'Get browse node information and traverse the category hierarchy',
+                            action: 'Get browse nodes',
+                        },
+                    ],
+                    default: 'getItems',
+                },
+                {
+                    displayName: 'Partner Tag',
+                    name: 'partnerTag',
+                    type: 'string',
+                    default: '',
+                    description: 'Associate/Partner Tag. Leave empty to use the credential default.',
+                },
+                {
+                    displayName: 'Marketplace',
+                    name: 'marketplace',
+                    type: 'options',
+                    options: shared_1.MARKETPLACE_OPTIONS_WITH_DEFAULT,
+                    default: '',
+                    description: 'Target Amazon marketplace. Leave on default to use the credential value.',
+                },
+                {
+                    displayName: 'Item IDs',
+                    name: 'itemIds',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { operation: ['getItems'] } },
+                    default: '',
+                    placeholder: 'B0199980K4,B000HZD168',
+                    description: 'Comma-separated list of item identifiers. More than 10 are automatically split into batched requests.',
+                },
+                {
+                    displayName: 'Item ID Type',
+                    name: 'itemIdType',
+                    type: 'options',
+                    displayOptions: { show: { operation: ['getItems'] } },
+                    options: [{ name: 'ASIN', value: 'ASIN' }],
+                    default: 'ASIN',
+                    description: 'The type of item identifier used in Item IDs',
+                },
+                {
+                    displayName: 'Condition',
+                    name: 'condition',
+                    type: 'options',
+                    displayOptions: { show: { operation: ['getItems', 'getVariations'] } },
+                    options: shared_1.CONDITION_OPTIONS,
+                    default: 'Any',
+                    description: 'Filter offers by condition',
+                },
+                {
+                    displayName: 'Keywords',
+                    name: 'keywords',
+                    type: 'string',
+                    displayOptions: { show: { operation: ['searchItems'] } },
+                    default: '',
+                    description: 'Search query. At least one of Keywords, Actor, Artist, Author, Brand or Title is required.',
+                },
+                {
+                    displayName: 'Search Index (Category)',
+                    name: 'searchIndex',
+                    type: 'string',
+                    displayOptions: { show: { operation: ['searchItems'] } },
+                    default: 'All',
+                    description: 'Product category to search in. Values differ by marketplace (e.g. Electronics, Books). Defaults to All.',
+                },
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    displayOptions: { show: { operation: ['searchItems', 'getVariations'] } },
+                    default: false,
+                    description: 'Whether to return all results by paging through the API, up to a limit',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: { minValue: 1 },
+                    displayOptions: { show: { operation: ['searchItems', 'getVariations'], returnAll: [true] } },
+                    default: 50,
+                    description: 'Max number of results to return',
+                },
+                {
+                    displayName: 'Item Count (Page Size)',
+                    name: 'itemCount',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 10 },
+                    displayOptions: { show: { operation: ['searchItems'] } },
+                    default: 10,
+                    description: 'Number of items per page (1-10)',
+                },
+                {
+                    displayName: 'Item Page',
+                    name: 'itemPage',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 10 },
+                    displayOptions: { show: { operation: ['searchItems'], returnAll: [false] } },
+                    default: 1,
+                    description: 'Page of results to return (1-10)',
+                },
+                {
+                    displayName: 'Additional Fields',
+                    name: 'searchAdditionalFields',
+                    type: 'collection',
+                    placeholder: 'Add Field',
+                    default: {},
+                    displayOptions: { show: { operation: ['searchItems'] } },
+                    options: [
+                        { displayName: 'Actor', name: 'actor', type: 'string', default: '' },
+                        { displayName: 'Artist', name: 'artist', type: 'string', default: '' },
+                        { displayName: 'Author', name: 'author', type: 'string', default: '' },
+                        {
+                            displayName: 'Availability',
+                            name: 'availability',
+                            type: 'options',
+                            options: shared_1.AVAILABILITY_OPTIONS,
+                            default: 'Available',
+                        },
+                        { displayName: 'Brand', name: 'brand', type: 'string', default: '' },
+                        {
+                            displayName: 'Browse Node ID',
+                            name: 'browseNodeId',
+                            type: 'string',
+                            default: '',
+                            description: 'Restrict the search to a specific browse node (category) ID',
+                        },
+                        {
+                            displayName: 'Condition',
+                            name: 'condition',
+                            type: 'options',
+                            options: shared_1.CONDITION_OPTIONS,
+                            default: 'Any',
+                        },
+                        {
+                            displayName: 'Delivery Flags',
+                            name: 'deliveryFlags',
+                            type: 'multiOptions',
+                            options: shared_1.DELIVERY_FLAGS_OPTIONS,
+                            default: [],
+                        },
+                        {
+                            displayName: 'Max Price',
+                            name: 'maxPrice',
+                            type: 'number',
+                            typeOptions: { minValue: 0 },
+                            default: 0,
+                            description: 'Max offer price in the lowest currency denomination (e.g. 3241 = $32.41 in the US)',
+                        },
+                        {
+                            displayName: 'Min Price',
+                            name: 'minPrice',
+                            type: 'number',
+                            typeOptions: { minValue: 0 },
+                            default: 0,
+                            description: 'Min offer price in the lowest currency denomination (e.g. 3241 = $32.41 in the US)',
+                        },
+                        {
+                            displayName: 'Min Reviews Rating',
+                            name: 'minReviewsRating',
+                            type: 'number',
+                            typeOptions: { minValue: 1, maxValue: 4 },
+                            default: 0,
+                            description: 'Filter to items with a customer review rating above this value (1-4)',
+                        },
+                        {
+                            displayName: 'Min Saving Percent',
+                            name: 'minSavingPercent',
+                            type: 'number',
+                            typeOptions: { minValue: 1, maxValue: 99 },
+                            default: 0,
+                            description: 'Filter to items with an offer saving above this percentage (1-99)',
+                        },
+                        {
+                            displayName: 'Sort By',
+                            name: 'sortBy',
+                            type: 'options',
+                            options: shared_1.SORT_BY_OPTIONS,
+                            default: 'Relevance',
+                        },
+                        {
+                            displayName: 'Title',
+                            name: 'title',
+                            type: 'string',
+                            default: '',
+                            description: 'Title associated with the item (a subset of a Keywords search)',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'ASIN',
+                    name: 'asin',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { operation: ['getVariations'] } },
+                    default: '',
+                    description: 'Parent or child ASIN to get variations for',
+                },
+                {
+                    displayName: 'Variation Count (Page Size)',
+                    name: 'variationCount',
+                    type: 'number',
+                    typeOptions: { minValue: 1, maxValue: 10 },
+                    displayOptions: { show: { operation: ['getVariations'] } },
+                    default: 10,
+                    description: 'Number of variations per page (1-10)',
+                },
+                {
+                    displayName: 'Variation Page',
+                    name: 'variationPage',
+                    type: 'number',
+                    typeOptions: { minValue: 1 },
+                    displayOptions: { show: { operation: ['getVariations'], returnAll: [false] } },
+                    default: 1,
+                    description: 'Page of variations to return',
+                },
+                {
+                    displayName: 'Browse Node IDs',
+                    name: 'browseNodeIds',
+                    type: 'string',
+                    required: true,
+                    displayOptions: { show: { operation: ['getBrowseNodes'] } },
+                    default: '',
+                    placeholder: '283155,3040',
+                    description: 'Comma-separated list of Browse Node IDs. More than 10 are automatically split into batched requests.',
+                },
+                {
+                    displayName: 'Resources',
+                    name: 'browseNodeResources',
+                    type: 'multiOptions',
+                    displayOptions: { show: { operation: ['getBrowseNodes'] } },
+                    options: shared_1.BROWSE_NODE_RESOURCES,
+                    default: ['browseNodes.ancestor', 'browseNodes.children'],
+                    description: 'Which data to return for each browse node',
+                },
+                {
+                    displayName: 'Resource Preset',
+                    name: 'resourcePreset',
+                    type: 'options',
+                    displayOptions: { show: { operation: ITEM_OPS } },
+                    options: shared_1.RESOURCE_PRESET_OPTIONS,
+                    default: 'custom',
+                    description: 'Quick-select a set of resources, or choose Custom to pick individually',
+                },
+                {
+                    displayName: 'Resources',
+                    name: 'resourcesGetItems',
+                    type: 'multiOptions',
+                    displayOptions: { show: { operation: ['getItems'], resourcePreset: ['custom'] } },
+                    options: shared_1.ITEM_RESOURCES,
+                    default: ['itemInfo.title', 'images.primary.large', 'offersV2.listings.price'],
+                    description: 'Which data to return for each item',
+                },
+                {
+                    displayName: 'Resources',
+                    name: 'resourcesSearchItems',
+                    type: 'multiOptions',
+                    displayOptions: { show: { operation: ['searchItems'], resourcePreset: ['custom'] } },
+                    options: shared_1.SEARCH_RESOURCES,
+                    default: ['itemInfo.title', 'images.primary.large', 'offersV2.listings.price'],
+                    description: 'Which data to return for each item',
+                },
+                {
+                    displayName: 'Resources',
+                    name: 'resourcesGetVariations',
+                    type: 'multiOptions',
+                    displayOptions: { show: { operation: ['getVariations'], resourcePreset: ['custom'] } },
+                    options: shared_1.VARIATION_RESOURCES,
+                    default: [
+                        'itemInfo.title',
+                        'offersV2.listings.price',
+                        'variationSummary.variationDimension',
+                    ],
+                    description: 'Which data to return for each variation',
+                },
+                {
+                    displayName: 'Languages of Preference',
+                    name: 'languagesOfPreference',
+                    type: 'multiOptions',
+                    typeOptions: {
+                        loadOptionsMethod: 'getLanguages',
+                        loadOptionsDependsOn: ['marketplace'],
+                    },
+                    default: [],
+                    description: 'Response language(s) valid for the selected marketplace. Amazon currently honours only a single language.',
+                },
+                {
+                    displayName: 'Currency of Preference',
+                    name: 'currencyOfPreference',
+                    type: 'string',
+                    displayOptions: { show: { operation: ITEM_OPS } },
+                    default: '',
+                    placeholder: 'USD',
+                    description: 'ISO 4217 currency code for returned prices (e.g. USD, EUR). Defaults to the marketplace currency.',
+                },
+                {
+                    displayName: 'Simplify',
+                    name: 'simplify',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to return a flattened item per result (asin, title, price, image, url…) instead of the raw API response',
+                },
+                {
+                    displayName: 'Split Errors',
+                    name: 'splitErrors',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to route per-item API errors (e.g. inaccessible ASINs) to a separate "Errors" output',
+                },
+            ],
+        };
+        this.methods = {
+            credentialTest: {
+                async creatorsApiCredentialTest(credential) {
+                    try {
+                        await (0, GenericFunctions_1.requestAccessToken)(async (options) => (await this.helpers.request(options)), credential.data);
+                        return { status: 'OK', message: 'Authentication successful' };
+                    }
+                    catch (error) {
+                        return { status: 'Error', message: error.message };
+                    }
+                },
+            },
+            loadOptions: {
+                async getLanguages() {
+                    var _a;
+                    let marketplace = '';
+                    try {
+                        marketplace = this.getCurrentNodeParameter('marketplace') || '';
+                    }
+                    catch {
+                    }
+                    if (!marketplace) {
+                        try {
+                            const creds = await this.getCredentials('amazonCreatorsApi');
+                            marketplace = creds.marketplace || '';
+                        }
+                        catch {
+                        }
+                    }
+                    const info = (_a = shared_1.LOCALE_INFO[marketplace]) !== null && _a !== void 0 ? _a : shared_1.LOCALE_INFO['www.amazon.com'];
+                    return info.languages.map((lang) => ({
+                        name: lang === info.defaultLanguage ? `${lang} (default)` : lang,
+                        value: lang,
+                    }));
+                },
+            },
+        };
+    }
+    async execute() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const items = this.getInputData();
+        const dataItems = [];
+        const errorItems = [];
+        const credentials = await this.getCredentials('amazonCreatorsApi');
+        const version = credentials.credentialVersion;
+        const accessToken = await GenericFunctions_1.getCreatorsAccessToken.call(this, credentials);
+        const splitErrors = this.getNodeParameter('splitErrors', 0, false);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const operation = this.getNodeParameter('operation', i);
+                const simplify = this.getNodeParameter('simplify', i, false);
+                const partnerTag = this.getNodeParameter('partnerTag', i, '') ||
+                    credentials.partnerTag;
+                if (!partnerTag) {
+                    throw (0, GenericFunctions_1.operationError)(this, 'Partner Tag is required (node or credential).', i);
+                }
+                const marketplace = this.getNodeParameter('marketplace', i, '') ||
+                    credentials.marketplace;
+                const commonBody = { partnerTag, marketplace };
+                const languages = this.getNodeParameter('languagesOfPreference', i, []);
+                if (languages.length > 0)
+                    commonBody.languagesOfPreference = languages;
+                if (ITEM_OPS.includes(operation)) {
+                    const currency = this.getNodeParameter('currencyOfPreference', i, '');
+                    if (currency)
+                        commonBody.currencyOfPreference = currency;
+                }
+                const doRequest = (op, body) => GenericFunctions_1.creatorsApiRequest.call(this, op, body, marketplace, accessToken, version);
+                let responseData;
+                if (operation === 'getItems') {
+                    const itemIds = (0, shared_1.csvToArray)(this.getNodeParameter('itemIds', i));
+                    if (itemIds.length === 0)
+                        throw (0, GenericFunctions_1.operationError)(this, 'At least one Item ID is required.', i);
+                    const base = { ...commonBody };
+                    base.itemIdType = this.getNodeParameter('itemIdType', i, 'ASIN');
+                    const condition = this.getNodeParameter('condition', i, 'Any');
+                    if (condition !== 'Any')
+                        base.condition = condition;
+                    const resources = getResources.call(this, i, operation);
+                    if (resources.length > 0)
+                        base.resources = resources;
+                    const mergedItems = [];
+                    const mergedErrors = [];
+                    for (const group of (0, shared_1.chunk)(itemIds, 10)) {
+                        const res = await doRequest('getItems', { ...base, itemIds: group });
+                        mergedItems.push(...extractArray(res, 'itemResults.items'));
+                        mergedErrors.push(...((_a = res.errors) !== null && _a !== void 0 ? _a : []));
+                    }
+                    responseData = { itemResults: { items: mergedItems }, errors: mergedErrors };
+                }
+                else if (operation === 'searchItems') {
+                    const base = { ...commonBody };
+                    const keywords = this.getNodeParameter('keywords', i, '');
+                    if (keywords)
+                        base.keywords = keywords;
+                    const searchIndex = this.getNodeParameter('searchIndex', i, 'All');
+                    if (searchIndex)
+                        base.searchIndex = searchIndex;
+                    const resources = getResources.call(this, i, operation);
+                    if (resources.length > 0)
+                        base.resources = resources;
+                    applySearchExtras.call(this, i, base);
+                    const pageSize = this.getNodeParameter('itemCount', i, 10);
+                    const returnAll = this.getNodeParameter('returnAll', i, false);
+                    const collected = [];
+                    let lastResult = {};
+                    if (returnAll) {
+                        const limit = this.getNodeParameter('limit', i, 50);
+                        for (let page = 1; page <= 10 && collected.length < limit; page++) {
+                            const res = await doRequest('searchItems', { ...base, itemCount: pageSize, itemPage: page });
+                            lastResult = (_b = res.searchResult) !== null && _b !== void 0 ? _b : {};
+                            const pageItems = extractArray(res, 'searchResult.items');
+                            collected.push(...pageItems);
+                            if (pageItems.length < pageSize)
+                                break;
+                        }
+                        collected.splice(limit);
+                    }
+                    else {
+                        base.itemCount = pageSize;
+                        base.itemPage = this.getNodeParameter('itemPage', i, 1);
+                        const res = await doRequest('searchItems', base);
+                        lastResult = (_c = res.searchResult) !== null && _c !== void 0 ? _c : {};
+                        collected.push(...extractArray(res, 'searchResult.items'));
+                    }
+                    responseData = {
+                        searchResult: { ...lastResult, items: collected },
+                    };
+                }
+                else if (operation === 'getVariations') {
+                    const asin = this.getNodeParameter('asin', i);
+                    if (!asin)
+                        throw (0, GenericFunctions_1.operationError)(this, 'ASIN is required for Get Variations.', i);
+                    const base = { ...commonBody, asin: asin.trim() };
+                    const condition = this.getNodeParameter('condition', i, 'Any');
+                    if (condition !== 'Any')
+                        base.condition = condition;
+                    const resources = getResources.call(this, i, operation);
+                    if (resources.length > 0)
+                        base.resources = resources;
+                    const pageSize = this.getNodeParameter('variationCount', i, 10);
+                    const returnAll = this.getNodeParameter('returnAll', i, false);
+                    const collected = [];
+                    let summary;
+                    if (returnAll) {
+                        const limit = this.getNodeParameter('limit', i, 50);
+                        for (let page = 1; collected.length < limit; page++) {
+                            const res = await doRequest('getVariations', {
+                                ...base,
+                                variationCount: pageSize,
+                                variationPage: page,
+                            });
+                            const vr = (_d = res.variationsResult) !== null && _d !== void 0 ? _d : {};
+                            if (!summary)
+                                summary = vr.variationSummary;
+                            const pageItems = extractArray(res, 'variationsResult.items');
+                            collected.push(...pageItems);
+                            const pageCount = (_e = summary === null || summary === void 0 ? void 0 : summary.pageCount) !== null && _e !== void 0 ? _e : page;
+                            if (pageItems.length < pageSize || page >= pageCount)
+                                break;
+                        }
+                        collected.splice(limit);
+                    }
+                    else {
+                        base.variationCount = pageSize;
+                        base.variationPage = this.getNodeParameter('variationPage', i, 1);
+                        const res = await doRequest('getVariations', base);
+                        const vr = (_f = res.variationsResult) !== null && _f !== void 0 ? _f : {};
+                        summary = vr.variationSummary;
+                        collected.push(...extractArray(res, 'variationsResult.items'));
+                    }
+                    responseData = {
+                        variationsResult: { items: collected, variationSummary: summary !== null && summary !== void 0 ? summary : null },
+                    };
+                }
+                else if (operation === 'getBrowseNodes') {
+                    const browseNodeIds = (0, shared_1.csvToArray)(this.getNodeParameter('browseNodeIds', i));
+                    if (browseNodeIds.length === 0)
+                        throw (0, GenericFunctions_1.operationError)(this, 'At least one Browse Node ID is required.', i);
+                    const base = { ...commonBody };
+                    const resources = this.getNodeParameter('browseNodeResources', i, []);
+                    if (resources.length > 0)
+                        base.resources = resources;
+                    const mergedNodes = [];
+                    const mergedErrors = [];
+                    for (const group of (0, shared_1.chunk)(browseNodeIds, 10)) {
+                        const res = await doRequest('getBrowseNodes', { ...base, browseNodeIds: group });
+                        mergedNodes.push(...extractArray(res, 'browseNodesResult.browseNodes'));
+                        mergedErrors.push(...((_g = res.errors) !== null && _g !== void 0 ? _g : []));
+                    }
+                    responseData = { browseNodesResult: { browseNodes: mergedNodes }, errors: mergedErrors };
+                }
+                else {
+                    throw (0, GenericFunctions_1.operationError)(this, `Unknown operation: ${operation}`, i);
+                }
+                const apiErrors = (_h = responseData.errors) !== null && _h !== void 0 ? _h : [];
+                const productArray = operation === 'getBrowseNodes'
+                    ? extractArray(responseData, 'browseNodesResult.browseNodes')
+                    : operation === 'getItems'
+                        ? extractArray(responseData, 'itemResults.items')
+                        : operation === 'searchItems'
+                            ? extractArray(responseData, 'searchResult.items')
+                            : extractArray(responseData, 'variationsResult.items');
+                if (simplify) {
+                    for (const product of productArray) {
+                        const flat = operation === 'getBrowseNodes' ? (0, shared_1.simplifyBrowseNode)(product) : (0, shared_1.simplifyItem)(product);
+                        dataItems.push({ json: flat, pairedItem: { item: i } });
+                    }
+                }
+                else {
+                    const main = { ...responseData };
+                    if (splitErrors)
+                        delete main.errors;
+                    dataItems.push({ json: main, pairedItem: { item: i } });
+                }
+                for (const err of apiErrors) {
+                    const target = splitErrors ? errorItems : dataItems;
+                    target.push({ json: { ...err, __isError: true }, pairedItem: { item: i } });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const target = splitErrors ? errorItems : dataItems;
+                    target.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return splitErrors ? [dataItems, errorItems] : [dataItems];
+    }
+}
+exports.AmazonCreatorsApi = AmazonCreatorsApi;
+function getResources(i, operation) {
+    const preset = this.getNodeParameter('resourcePreset', i, 'custom');
+    const paramName = operation === 'getItems'
+        ? 'resourcesGetItems'
+        : operation === 'searchItems'
+            ? 'resourcesSearchItems'
+            : 'resourcesGetVariations';
+    const custom = this.getNodeParameter(paramName, i, []);
+    const allResources = operation === 'getItems'
+        ? shared_1.ITEM_RESOURCES
+        : operation === 'searchItems'
+            ? shared_1.SEARCH_RESOURCES
+            : shared_1.VARIATION_RESOURCES;
+    return (0, shared_1.resolveResourcePreset)(preset, custom, allResources);
+}
+function applySearchExtras(i, body) {
+    const extra = this.getNodeParameter('searchAdditionalFields', i, {});
+    if (extra.actor)
+        body.actor = extra.actor;
+    if (extra.artist)
+        body.artist = extra.artist;
+    if (extra.author)
+        body.author = extra.author;
+    if (extra.brand)
+        body.brand = extra.brand;
+    if (extra.title)
+        body.title = extra.title;
+    if (extra.browseNodeId)
+        body.browseNodeId = extra.browseNodeId;
+    if (extra.availability && extra.availability !== 'Available')
+        body.availability = extra.availability;
+    if (extra.condition && extra.condition !== 'Any')
+        body.condition = extra.condition;
+    if (extra.sortBy)
+        body.sortBy = extra.sortBy;
+    if (Array.isArray(extra.deliveryFlags) && extra.deliveryFlags.length > 0)
+        body.deliveryFlags = extra.deliveryFlags;
+    if (typeof extra.minPrice === 'number' && extra.minPrice > 0)
+        body.minPrice = extra.minPrice;
+    if (typeof extra.maxPrice === 'number' && extra.maxPrice > 0)
+        body.maxPrice = extra.maxPrice;
+    if (typeof extra.minReviewsRating === 'number' && extra.minReviewsRating > 0)
+        body.minReviewsRating = extra.minReviewsRating;
+    if (typeof extra.minSavingPercent === 'number' && extra.minSavingPercent > 0)
+        body.minSavingPercent = extra.minSavingPercent;
+}
+function extractArray(obj, path) {
+    const value = path.split('.').reduce((acc, key) => {
+        if (acc && typeof acc === 'object')
+            return acc[key];
+        return undefined;
+    }, obj);
+    return Array.isArray(value) ? value : [];
+}
+//# sourceMappingURL=AmazonCreatorsApi.node.js.map