@shushed/helpers 0.0.203-bug-erp-770-20251208112219 → 0.0.203-validate-fix-20251208135144

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

@@ -0,0 +1,1054 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = __importDefault(require("crypto"));
+const env_1 = __importDefault(require("./env"));
+const utils_1 = require("./utils");
+const CACHE_EXPIRATION_MS = 1000 * 60 * 60 * 3;
+class CentraHelper extends env_1.default {
+    opts;
+    shaToken;
+    graphqlUrl;
+    constructor(options, opts) {
+        super(options);
+        this.opts = opts;
+        this.shaToken = crypto_1.default.createHash('sha256').update(opts.accessToken).digest('hex').slice(0, 8);
+        const parsedUrl = new URL(opts.centraApiBase);
+        if (!parsedUrl.pathname.includes('/graphql')) {
+            this.graphqlUrl = `${opts.centraApiBase}/graphql`;
+        }
+        else {
+            this.graphqlUrl = opts.centraApiBase;
+        }
+    }
+    static isCentraErrors(data) {
+        return typeof data === 'object' && data !== null && 'errors' in data;
+    }
+    async fetch(arg1, arg2) {
+        let request;
+        if (typeof arg1 === 'string' || arg1 instanceof URL) {
+            request = new Request(arg1, arg2);
+        }
+        else if (arg1 instanceof Request) {
+            request = arg1;
+        }
+        else {
+            throw new Error('Invalid argument type');
+        }
+        request.headers.set('Authorization', `Bearer ${this.opts.accessToken}`);
+        request.headers.set('Content-Type', 'application/json');
+        const errors = [];
+        let response;
+        try {
+            response = await fetch(request);
+        }
+        catch (error) {
+            errors.push({ message: `Failed to fetch: ${error instanceof Error ? error.message : String(error)}`, path: 'global' });
+            return { errors };
+        }
+        if (response.status === 429) {
+            if (this.workflowRoot != null) {
+                (0, utils_1.setRetryAfterVariable)(response, { root: this.workflowRoot });
+            }
+            else {
+                this.logging.log('Warning: setRetryAfterVariable is not available because the runtime has not been initialized with a full options object');
+            }
+        }
+        let resp;
+        try {
+            resp = await response.json();
+        }
+        catch (error) {
+            errors.push({ message: `Failed to parse response: ${error instanceof Error ? error.message : String(error)}`, path: 'global' });
+            return { errors, limitExceeded: response.status === 429 };
+        }
+        if (resp.errors) {
+            errors.push(resp.errors.map((x) => x.message).join('\n'));
+        }
+        else if (resp.data) {
+            const userErrors = resp.data?.userErrors;
+            if (userErrors) {
+                errors.push(...userErrors.map((x) => ({ message: x.message, path: x.path })));
+                return { errors, limitExceeded: response.status === 429 };
+            }
+        }
+        if (response.status === 429) {
+            resp.limitExceeded = true;
+        }
+        return resp;
+    }
+    getCacheKeyForStyleId(styleId) {
+        return `centra_${this.shaToken}_style_id_${styleId}`;
+    }
+    getCacheKeyForCountryCode(countryCode) {
+        return `centra_${this.shaToken}_country_code_${countryCode}`;
+    }
+    getCacheKeyForMarkets() {
+        return `centra_${this.shaToken}_market_external_id`;
+    }
+    getCacheKeyForMarket(marketExternalId) {
+        return `${this.getCacheKeyForMarkets()}_${marketExternalId}`;
+    }
+    getCacheKeyForSizeCharts() {
+        return `centra_${this.shaToken}_size_chart_external_id`;
+    }
+    getCacheKeyForCountries() {
+        return `centra_${this.shaToken}_country_iso2_code`;
+    }
+    getCacheKeyForCountry(countryIso2Code) {
+        return `${this.getCacheKeyForCountries()}_${countryIso2Code}`;
+    }
+    getCacheKeyForSizeChart(sizeChartExternalId) {
+        return `${this.getCacheKeyForSizeCharts()}_${sizeChartExternalId}`;
+    }
+    getCacheKeyForCentraProduct(productExternalId) {
+        return `centra_${this.shaToken}_product_${productExternalId}`;
+    }
+    getCacheKeyForCentraVariant(variantExternalId) {
+        return `centra_${this.shaToken}_variant_${variantExternalId}`;
+    }
+    getCacheKeyForCentraDisplayByVariantId(centraVariantId) {
+        return `centra_${this.shaToken}_display_variant_${centraVariantId}`;
+    }
+    getCacheKeyForCentraDisplayByProductId(centraProductId) {
+        return `centra_${this.shaToken}_display_product_${centraProductId}`;
+    }
+    getCacheKeyForCentraWarehouses() {
+        return `centra_${this.shaToken}_warehouse_external_id`;
+    }
+    getCacheKeyForCentraWarehouse(warehouseExternalId) {
+        return `${this.getCacheKeyForCentraWarehouses()}_${warehouseExternalId}`;
+    }
+    getCacheKeyForCentraPricelists() {
+        return `centra_${this.shaToken}_pricelist_external_id`;
+    }
+    getCacheKeyForCentraPricelist(pricelistExternalId) {
+        return `${this.getCacheKeyForCentraPricelists()}_${pricelistExternalId}`;
+    }
+    async fetchCountries(iso2Codes) {
+        const result = [];
+        const limit = 200;
+        let page = 0;
+        let hasNextPage = true;
+        do {
+            const data = await this.fetch(this.graphqlUrl, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                            query countries($page: Int, $limit: Int, $iso2Codes: [String!]) {
+                                countries(limit: $limit, page: $page${iso2Codes ? `, where: { ISO2: $iso2Codes }` : ''} ) {
+                                    id
+                                    name
+                                    code
+                                }
+                            }
+                        `,
+                    variables: { page: page, limit: limit, iso2Codes: iso2Codes }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.countries?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const country of data.data?.countries || []) {
+                result.push({
+                    id: country.id,
+                    name: country.name,
+                    code: country.code
+                });
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async fetchCentraWarehouses(externalIds) {
+        const result = [];
+        const limit = 200;
+        let page = 0;
+        let hasNextPage = true;
+        do {
+            const data = await this.fetch(this.graphqlUrl, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query GetWarehouses($limit: Int, $page: Int${externalIds ? `, $externalIds: WarehousesFilter` : ''}) {
+                            warehouses(${externalIds ? `where: $externalIds, ` : ''}limit: $limit, page: $page) {
+                                id
+                                externalId
+                                name
+                                status
+                            }
+                        }
+                        `,
+                    variables: { page: page, limit: limit, externalIds: { externalId: externalIds } }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.warehouses?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const warehouse of data.data?.warehouses || []) {
+                result.push({
+                    id: warehouse.id,
+                    name: warehouse.name,
+                    status: warehouse.status,
+                    externalId: warehouse.externalId
+                });
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async fetchCentraCampaigns(names) {
+        const limit = (names?.length || 0) > 200 ? 200 : (names?.length || 0);
+        let nextCursor = null;
+        const result = {};
+        do {
+            const data = await this.fetch(`${this.graphqlUrl}`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query campaignConnection (${names ? `$input: CampaignFilter, ` : ''}$limit: Int, $after: String) {
+                            campaignConnection(${names ? `where: $input, ` : ''}first: $limit, after: $after) {
+                                pageInfo {
+                                    endCursor
+                                    hasNextPage
+                                }
+                                edges {
+                                    node {
+                                        id
+                                        name
+                                    }
+                                }
+                            }  
+                        }
+                    `,
+                    variables: {
+                        input: {
+                            name: {
+                                equals: names,
+                            }
+                        },
+                        after: nextCursor,
+                        limit: limit,
+                    }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                if (!names) {
+                    return data;
+                }
+                for (let i = 0; i < (names?.length || 0); i++) {
+                    const name = names[i];
+                    result[name] = new Error(data.errors.map((x, idx) => `${idx + 1}. ${x.message}`).join('\n'));
+                }
+            }
+            else {
+                const campaignConnection = data.data?.campaignConnection;
+                if (campaignConnection && campaignConnection.pageInfo?.hasNextPage && campaignConnection.pageInfo.endCursor && campaignConnection.pageInfo.endCursor !== nextCursor) {
+                    nextCursor = campaignConnection.pageInfo?.endCursor;
+                }
+                else {
+                    nextCursor = null;
+                }
+                if (campaignConnection && campaignConnection.edges?.length) {
+                    for (let i = campaignConnection.edges.length; i < (names?.length || 0); i++) {
+                        const { node } = campaignConnection.edges[i];
+                        result[node.name] = node;
+                    }
+                }
+            }
+        } while (nextCursor !== null);
+        return result;
+    }
+    async fetchPricelists(names) {
+        const result = [];
+        const limit = 200;
+        let page = 0;
+        let hasNextPage = true;
+        do {
+            const data = await this.fetch(this.graphqlUrl, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query GetPricelists($limit: Int, $page: Int${names ? `, $input: PricelistFilter` : ''}) {
+                            pricelists(${names ? `where: $input, ` : ''}limit: $limit, page: $page) {
+                                id
+                                externalId
+                                name,
+                                campaigns {
+                                    id
+                                    name
+                                    status
+                                }
+                                currency {
+                                    id
+                                    name
+                                    code
+                                }
+                            }
+                        }
+                        `,
+                    variables: {
+                        page: page, limit: limit, input: {
+                            name: {
+                                equals: names
+                            }
+                        }
+                    }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.pricelists?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const pricelist of data.data?.pricelists || []) {
+                result.push(pricelist);
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async fetchCentraMarkets(externalIds) {
+        const result = [];
+        const limit = 200;
+        let page = 0;
+        let hasNextPage = true;
+        do {
+            const data = await this.fetch(this.graphqlUrl, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query GetMarkets($limit: Int, $page: Int${externalIds ? `, $externalIds: MarketsFilter` : ''}) {
+                            markets(${externalIds ? `where: $externalIds, ` : ''}limit: $limit, page: $page) {
+                                id
+                                externalId
+                                name
+                            }
+                        }
+                        `,
+                    variables: { page: page, limit: limit, externalIds: { externalId: externalIds } }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.markets?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const market of data.data?.markets || []) {
+                result.push(market);
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async fetchCentraSizeCharts(externalIds) {
+        const result = [];
+        const limit = 200;
+        let page = 0;
+        let hasNextPage = true;
+        do {
+            const data = await this.fetch(this.graphqlUrl, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                            query sizeCharts($page: Int, $limit: Int${externalIds ? `, $externalIds: SizeChartFilter` : ''}) {
+                                sizeCharts(${externalIds ? `where: $externalIds, ` : ''}limit: $limit, page: $page) {
+                                    id
+                                    name
+                                    externalId
+                                    sizes {
+                                        id
+                                        name
+                                        externalId
+                                        localized(where: { name: { equals: "System" } }) {
+                                            localizedName
+                                        }
+                                    }
+                                }
+                            }
+                        `,
+                    variables: { page: page, limit: limit, externalIds: { externalId: externalIds } }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.sizeCharts?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const sizeChart of data.data?.sizeCharts || []) {
+                result.push({
+                    id: sizeChart.id,
+                    name: sizeChart.name,
+                    externalId: sizeChart.externalId,
+                    sizes: sizeChart.sizes.map((x) => ({
+                        id: x.id,
+                        name: x.name,
+                        externalId: x.externalId,
+                        localizedName: x.localized[0]?.localizedName || undefined
+                    }))
+                });
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async fetchCentraProducts(styleIds) {
+        const limit = styleIds.length > 200 ? 200 : styleIds.length;
+        let nextCursor = null;
+        const result = {};
+        do {
+            const data = await this.fetch(`${this.graphqlUrl}`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query productConnection ($input: ProductFilter, $limit: Int, $after: String) {
+                            productConnection(where: $input, first: $limit, after: $after) {
+                                pageInfo {
+                                    endCursor
+                                    hasNextPage
+                                }
+                                edges {
+                                    node {
+                                        id
+                                        externalId
+                                        productNumber
+                                        name
+                                        status
+                                        prices {
+                                            price {
+                                                value
+                                            }
+                                            pricelist {
+                                                id
+                                                name
+                                            }
+                                        }
+                                    }
+                                }
+                            }  
+                        }
+                    `,
+                    variables: {
+                        input: {
+                            externalId: styleIds,
+                        },
+                        after: nextCursor,
+                        limit: limit,
+                    }
+                })
+            });
+            if (data && data.errors) {
+                for (let i = 0; i < styleIds.length; i++) {
+                    const styleId = styleIds[i];
+                    result[styleId] = new Error(data.errors.map((x, idx) => `${idx + 1}. ${x.message}`).join('\n'));
+                }
+            }
+            if (data && data.data?.productConnection?.pageInfo?.hasNextPage && data.data.productConnection.pageInfo.endCursor && data.data.productConnection.pageInfo.endCursor !== nextCursor) {
+                nextCursor = data.data.productConnection?.pageInfo?.endCursor;
+            }
+            else {
+                nextCursor = null;
+            }
+            if (data && data.data?.productConnection?.edges?.length) {
+                for (let i = data.data.productConnection.edges.length; i < styleIds.length; i++) {
+                    const { node } = data.data.productConnection.edges[i];
+                    result[node.externalId] = node;
+                }
+            }
+        } while (nextCursor !== null);
+        return result;
+    }
+    async fetchCentraDisplays(inputIds, inputIdType) {
+        const limit = inputIds.length > 200 ? 200 : inputIds.length;
+        let nextCursor = null;
+        const result = {};
+        do {
+            const data = await this.fetch(`${this.graphqlUrl}`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query displayConnection ($input: DisplayFilter, $limit: Int, $after: String) {
+                            displayConnection(where: $input, first: $limit, after: $after) {
+                                pageInfo {
+                                    endCursor,
+                                    hasNextPage
+                                }
+                                edges {
+                                    node {
+                                        id
+                                        externalId
+                                        status
+                                        url
+                                        metaTitle
+                                        metaDescription
+                                        name
+                                        categories {
+                                            id
+                                            name
+                                            url
+                                            isTopCategory
+                                        }
+                                        markets {
+                                            id
+                                            name
+                                        }
+                                        product {
+                                            id
+                                            externalId
+                                            status
+                                        }
+                                        productVariant {
+                                            id
+                                            externalId
+                                            status
+                                            variantNumber
+                                        }
+                                    }
+                                }
+                            }  
+                        }
+                    `,
+                    variables: {
+                        input: {
+                            ...(inputIdType === 'variant' ? { productVariantId: inputIds } : { productId: inputIds }),
+                        },
+                        after: nextCursor,
+                        limit: limit,
+                    }
+                })
+            });
+            if (data.limitExceeded) {
+                for (let i = 0; i < inputIds.length; i++) {
+                    const inputId = inputIds[i];
+                    if (!result[inputId]) {
+                        result[inputId] = new Error(`Rate limit exceeded for product ID ${inputId}`);
+                    }
+                }
+                return result;
+            }
+            if (data?.errors) {
+                nextCursor = null;
+                for (let i = 0; i < inputIds.length; i++) {
+                    const inputId = inputIds[i];
+                    result[inputId] = new Error(data.errors.map((x, idx) => `${idx + 1}. ${x.message}`).join('\n'));
+                }
+            }
+            if (data.data?.displayConnection?.pageInfo?.hasNextPage && data.data.displayConnection.pageInfo.endCursor && data.data.displayConnection.pageInfo.endCursor !== nextCursor) {
+                nextCursor = data.data.displayConnection?.pageInfo?.endCursor;
+            }
+            else {
+                nextCursor = null;
+            }
+            const edges = data.data?.displayConnection?.edges || [];
+            if (edges.length) {
+                for (let i = 0; i < edges.length; i++) {
+                    const { node } = edges[i];
+                    if (inputIdType === 'variant') {
+                        result[+node.productVariant[0].id] = [];
+                        result[+node.productVariant[0].id].push(node);
+                    }
+                    else {
+                        result[+node.product.id] = [];
+                        result[+node.product.id].push(node);
+                    }
+                }
+            }
+        } while (nextCursor !== null);
+        return result;
+    }
+    async fetchCentraVariants(productIds) {
+        const limit = productIds.length > 200 ? 200 : productIds.length;
+        let nextCursor = null;
+        const result = {};
+        do {
+            const data = await this.fetch(`${this.graphqlUrl}`, {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: `
+                        query productVariantConnection ($input: ProductVariantFilter, $limit: Int, $after: String) {
+                            productVariantConnection(where: $input, first: $limit, after: $after) {
+                                pageInfo {
+                                    endCursor,
+                                    hasNextPage
+                                }
+                                edges {
+                                    node {
+                                        id
+                                        externalId
+                                        status
+                                        name
+                                        variantNumber
+                                        product {
+                                            status
+                                            externalId
+                                            id
+                                            name
+                                            productNumber
+                                            prices {
+                                                price {
+                                                    value
+                                                }
+                                                pricelist {
+                                                    id
+                                                    name
+                                                }
+                                            }
+                                        }
+                                        sizeChart {
+                                            externalId
+                                            id
+                                        }
+                                        productSizes {
+                                            id
+                                            EAN
+                                            SKU
+                                            isActive
+                                            sizeNumber
+                                            size {
+                                                id
+                                                name
+                                            }
+                                        }
+                                    }
+                                }
+                            }  
+                        }
+                    `,
+                    variables: {
+                        input: {
+                            externalId: productIds,
+                        },
+                        after: nextCursor,
+                        limit: limit,
+                    }
+                })
+            });
+            if (data.limitExceeded) {
+                for (let i = 0; i < productIds.length; i++) {
+                    const productId = productIds[i];
+                    if (!result[productId]) {
+                        result[productId] = new Error(`Rate limit exceeded for product ID ${productId}`);
+                    }
+                }
+                return result;
+            }
+            if (data?.errors) {
+                nextCursor = null;
+                for (let i = 0; i < productIds.length; i++) {
+                    const productId = productIds[i];
+                    result[productId] = new Error(data.errors.map((x, idx) => `${idx + 1}. ${x.message}`).join('\n'));
+                }
+            }
+            if (data.data?.productVariantConnection?.pageInfo?.hasNextPage && data.data.productVariantConnection.pageInfo.endCursor && data.data.productVariantConnection.pageInfo.endCursor !== nextCursor) {
+                nextCursor = data.data.productVariantConnection?.pageInfo?.endCursor;
+            }
+            else {
+                nextCursor = null;
+            }
+            const edges = data.data?.productVariantConnection?.edges || [];
+            if (edges.length) {
+                for (let i = 0; i < edges.length; i++) {
+                    const { node } = edges[i];
+                    result[node.externalId] = node;
+                }
+            }
+        } while (nextCursor !== null);
+        return result;
+    }
+    async getCentraWarehouses(externalIds, alwaysFetch = false) {
+        if (externalIds && !externalIds.length) {
+            return {};
+        }
+        let warehouseInCache = {};
+        let dedupedExternalIds = [];
+        let warehousesToFetch = null;
+        if (!alwaysFetch) {
+            if (!externalIds) {
+                externalIds = (await this.get(this.getCacheKeyForCentraWarehouses(), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                }).then(x => x ? JSON.parse(x) : null));
+            }
+            if (externalIds) {
+                dedupedExternalIds = externalIds.filter((x, index, self) => self.indexOf(x) === index);
+                warehouseInCache = Object.fromEntries(Object.entries(await this.get(dedupedExternalIds.map(x => this.getCacheKeyForCentraWarehouse(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]).filter(([_, value]) => value));
+                warehousesToFetch = dedupedExternalIds.filter(x => !warehouseInCache[x]);
+            }
+        }
+        const warehouseToSet = {};
+        if (!warehousesToFetch || warehousesToFetch.length) {
+            const warehouses = await this.fetchCentraWarehouses(warehousesToFetch);
+            if (CentraHelper.isCentraErrors(warehouses)) {
+                if (warehousesToFetch) {
+                    for (const warehouseExternalId of warehousesToFetch) {
+                        warehouseToSet[warehouseExternalId] = new Error(`Failed to fetch warehouse ${warehouseExternalId}: ${warehouses.errors.map((x) => x.message).join(', ')}`);
+                    }
+                }
+                else {
+                    return new Error(`Failed to fetch warehouses: ${warehouses.errors.map((x) => x.message).join(', ')}`);
+                }
+            }
+            else {
+                for (const warehouse of warehouses) {
+                    warehouseToSet[warehouse.externalId] = warehouse;
+                }
+                await this.set(Object.entries(warehouseToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCentraWarehouse(key), value: JSON.stringify(value) })), 'env', {
+                    ephemeralMs: CACHE_EXPIRATION_MS,
+                    encrypted: false,
+                });
+                if (!warehousesToFetch) {
+                    await this.set([{
+                            name: this.getCacheKeyForCentraWarehouses(),
+                            value: JSON.stringify(Object.keys(warehouseToSet)),
+                        }], 'env', {
+                        ephemeralMs: CACHE_EXPIRATION_MS,
+                        encrypted: false,
+                    });
+                }
+            }
+        }
+        return Object.assign({}, warehouseInCache, warehouseToSet);
+    }
+    async getCentraPricelists(names, alwaysFetch = false) {
+        if (names && !names.length) {
+            return {};
+        }
+        let pricelistInCache = {};
+        let dedupedNames = [];
+        let pricelistsToFetch = null;
+        if (!alwaysFetch) {
+            if (!names) {
+                names = (await this.get(this.getCacheKeyForCentraPricelists(), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                }).then(x => x ? JSON.parse(x) : null));
+            }
+            if (names) {
+                dedupedNames = names.filter((x, index, self) => self.indexOf(x) === index);
+                pricelistInCache = Object.fromEntries(Object.entries(await this.get(dedupedNames.map(x => this.getCacheKeyForCentraPricelist(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]).filter(([_, value]) => value !== undefined));
+                pricelistsToFetch = dedupedNames.filter(x => !pricelistInCache[x]);
+            }
+        }
+        const pricelistToSet = {};
+        if (!pricelistsToFetch || pricelistsToFetch.length) {
+            const pricelists = await this.fetchPricelists(pricelistsToFetch);
+            if (CentraHelper.isCentraErrors(pricelists)) {
+                if (pricelistsToFetch) {
+                    for (const priceListName of pricelistsToFetch) {
+                        pricelistToSet[priceListName] = new Error(`Failed to fetch pricelist ${priceListName}: ${pricelists.errors.map((x) => x.message).join(', ')}`);
+                    }
+                }
+                else {
+                    return new Error(`Failed to fetch pricelists: ${pricelists.errors.map((x) => x.message).join(', ')}`);
+                }
+            }
+            else {
+                for (const pricelist of pricelists) {
+                    pricelistToSet[pricelist.name] = pricelist;
+                }
+                await this.set(Object.entries(pricelistToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCentraPricelist(key), value: JSON.stringify(value) })), 'env', {
+                    ephemeralMs: CACHE_EXPIRATION_MS,
+                    encrypted: false,
+                });
+                if (!pricelistsToFetch) {
+                    await this.set([{
+                            name: this.getCacheKeyForCentraPricelists(),
+                            value: JSON.stringify(Object.keys(pricelistToSet)),
+                        }], 'env', {
+                        ephemeralMs: CACHE_EXPIRATION_MS,
+                        encrypted: false,
+                    });
+                }
+            }
+        }
+        return Object.assign({}, pricelistInCache, pricelistToSet);
+    }
+    async getCentraMarkets(externalIds, alwaysFetch = false) {
+        if (externalIds && !externalIds.length) {
+            return {};
+        }
+        let marketInCache = {};
+        let dedupedExternalIds = [];
+        let marketsToFetch = null;
+        if (!alwaysFetch) {
+            if (!externalIds) {
+                externalIds = (await this.get(this.getCacheKeyForMarkets(), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                }).then(x => x ? JSON.parse(x) : null));
+            }
+            if (externalIds) {
+                dedupedExternalIds = externalIds.filter((x, index, self) => self.indexOf(x) === index);
+                marketInCache = Object.fromEntries(Object.entries(await this.get(dedupedExternalIds.map(x => this.getCacheKeyForMarket(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]).filter(([_, value]) => value));
+                marketsToFetch = dedupedExternalIds.filter(x => !marketInCache[x]);
+            }
+        }
+        const marketToSet = {};
+        if (!marketsToFetch || marketsToFetch.length) {
+            const markets = await this.fetchCentraMarkets(marketsToFetch);
+            if (CentraHelper.isCentraErrors(markets)) {
+                if (marketsToFetch) {
+                    for (const marketExternalId of marketsToFetch) {
+                        marketToSet[marketExternalId] = new Error(`Failed to fetch market ${marketExternalId}: ${markets.errors.map((x) => x.message).join(', ')}`);
+                    }
+                }
+                else {
+                    return new Error(`Failed to fetch markets: ${markets.errors.map((x) => x.message).join(', ')}`);
+                }
+            }
+            else {
+                for (const market of markets) {
+                    marketToSet[market.externalId] = market;
+                }
+                await this.set(Object.entries(marketToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForMarket(key), value: JSON.stringify(value) })), 'env', {
+                    ephemeralMs: CACHE_EXPIRATION_MS,
+                    encrypted: false,
+                });
+                if (!marketsToFetch) {
+                    await this.set([{
+                            name: this.getCacheKeyForMarkets(),
+                            value: JSON.stringify(Object.keys(marketToSet)),
+                        }], 'env', {
+                        ephemeralMs: CACHE_EXPIRATION_MS,
+                        encrypted: false,
+                    });
+                }
+            }
+        }
+        return Object.assign({}, marketInCache, marketToSet);
+    }
+    async getCentraCountries(iso2Codes, alwaysFetch = false) {
+        if (iso2Codes && !iso2Codes.length) {
+            return {};
+        }
+        let countryInCache = {};
+        let dedupedIso2Codes = [];
+        let countriesToFetch = null;
+        if (!alwaysFetch) {
+            if (!iso2Codes) {
+                iso2Codes = (await this.get(this.getCacheKeyForCountries(), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                }).then(x => x ? JSON.parse(x) : null));
+            }
+            if (iso2Codes) {
+                dedupedIso2Codes = iso2Codes.filter((x, index, self) => self.indexOf(x) === index);
+                countryInCache = Object.fromEntries(Object.entries(await this.get(dedupedIso2Codes.map(x => this.getCacheKeyForCountry(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]).filter(([_, value]) => value));
+                countriesToFetch = dedupedIso2Codes.filter(x => !countryInCache[x]);
+            }
+        }
+        const countryToSet = {};
+        if (!countriesToFetch || countriesToFetch.length) {
+            const countries = await this.fetchCountries(countriesToFetch);
+            if (CentraHelper.isCentraErrors(countries)) {
+                if (countriesToFetch) {
+                    for (const countryIso2Code of countriesToFetch) {
+                        countryToSet[countryIso2Code] = new Error(`Failed to fetch country ${countryIso2Code}: ${countries.errors.map((x) => x.message).join(', ')}`);
+                    }
+                }
+                else {
+                    return new Error(`Failed to fetch countries: ${countries.errors.map((x) => x.message).join(', ')}`);
+                }
+            }
+            else {
+                for (const country of countries) {
+                    countryToSet[country.code] = country;
+                }
+                await this.set(Object.entries(countryToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCountry(key), value: JSON.stringify(value) })), 'env', {
+                    ephemeralMs: CACHE_EXPIRATION_MS,
+                    encrypted: false,
+                });
+                if (!countriesToFetch) {
+                    await this.set([{
+                            name: this.getCacheKeyForCountries(),
+                            value: JSON.stringify(Object.keys(countryToSet)),
+                        }], 'env', {
+                        ephemeralMs: CACHE_EXPIRATION_MS,
+                        encrypted: false,
+                    });
+                }
+            }
+        }
+        return Object.assign({}, countryInCache, countryToSet);
+    }
+    async getCentraSizeCharts(externalIds, alwaysFetch = false) {
+        if (externalIds && !externalIds.length) {
+            return {};
+        }
+        let sizeChartInCache = {};
+        let dedupedExternalIds = [];
+        let sizeChartsToFetch = null;
+        if (!alwaysFetch) {
+            if (!externalIds) {
+                externalIds = (await this.get(this.getCacheKeyForSizeCharts(), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                }).then(x => x ? JSON.parse(x) : null));
+            }
+            if (externalIds) {
+                dedupedExternalIds = externalIds.filter((x, index, self) => self.indexOf(x) === index);
+                sizeChartInCache = Object.fromEntries(Object.entries(await this.get(dedupedExternalIds.map(x => this.getCacheKeyForSizeChart(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]).filter(([_, value]) => value));
+                sizeChartsToFetch = dedupedExternalIds.filter(x => !sizeChartInCache[x]);
+            }
+        }
+        const sizeChartToSet = {};
+        if (!sizeChartsToFetch || sizeChartsToFetch.length) {
+            const sizeCharts = await this.fetchCentraSizeCharts(sizeChartsToFetch);
+            if (CentraHelper.isCentraErrors(sizeCharts)) {
+                if (sizeChartsToFetch) {
+                    for (const sizeChartExternalId of sizeChartsToFetch) {
+                        sizeChartToSet[sizeChartExternalId] = new Error(`Failed to fetch size chart ${sizeChartExternalId}: ${sizeCharts.errors.map((x) => x.message).join(', ')}`);
+                    }
+                }
+                else {
+                    return new Error(`Failed to fetch size charts: ${sizeCharts.errors.map((x) => x.message).join(', ')}`);
+                }
+            }
+            else {
+                for (const sizeChart of sizeCharts) {
+                    sizeChartToSet[sizeChart.externalId] = sizeChart;
+                }
+                await this.set(Object.entries(sizeChartToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForSizeChart(key), value: JSON.stringify(value) })), 'env', {
+                    ephemeralMs: CACHE_EXPIRATION_MS,
+                    encrypted: false,
+                });
+                if (!sizeChartsToFetch) {
+                    await this.set([{
+                            name: this.getCacheKeyForSizeCharts(),
+                            value: JSON.stringify(Object.keys(sizeChartToSet)),
+                        }], 'env', {
+                        ephemeralMs: CACHE_EXPIRATION_MS,
+                        encrypted: false,
+                    });
+                }
+            }
+        }
+        return Object.assign({}, sizeChartInCache, sizeChartToSet);
+    }
+    async getCentraProducts(styleIds) {
+        const dedupedStyleIds = styleIds.filter((x, index, self) => self.indexOf(x) === index);
+        const productIdsInCache = await this.get(dedupedStyleIds.map(x => this.getCacheKeyForStyleId(x)), 'env', {
+            isEphemeral: true,
+            encrypted: false,
+        });
+        const productsToFetch = dedupedStyleIds.filter(x => !productIdsInCache[this.getCacheKeyForCentraProduct(x)]);
+        const products = await this.fetchCentraProducts(productsToFetch);
+        const productsToSet = {};
+        for (const styleId of dedupedStyleIds) {
+            const product = products[styleId];
+            productsToSet[styleId] = product;
+        }
+        this.set(Object.entries(productsToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCentraProduct(key), value: JSON.stringify(value) })), 'env', {
+            ephemeralMs: CACHE_EXPIRATION_MS,
+            encrypted: false,
+        });
+        return Object.assign({}, productIdsInCache, productsToSet);
+    }
+    async getCentraDisplaysByVariantIds(centraVariantIds) {
+        const dedupedCentraVariantIds = centraVariantIds.filter((x, index, self) => self.indexOf(x) === index);
+        const displaysInCache = Object.fromEntries(Object.entries(await this.get(dedupedCentraVariantIds.map(x => this.getCacheKeyForCentraDisplayByVariantId(x)), 'env', {
+            isEphemeral: true,
+            encrypted: false,
+        })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]));
+        const displaysToFetch = dedupedCentraVariantIds.filter(x => !displaysInCache[this.getCacheKeyForCentraDisplayByVariantId(x)]);
+        const displays = await this.fetchCentraDisplays(displaysToFetch, 'variant');
+        const displaysToSet = {};
+        for (const centraVariantId of dedupedCentraVariantIds) {
+            const display = displays[centraVariantId];
+            displaysToSet[centraVariantId] = display;
+        }
+        this.set(Object.entries(displaysToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCentraDisplayByVariantId(+key), value: JSON.stringify(value) })), 'env', {
+            ephemeralMs: CACHE_EXPIRATION_MS,
+            encrypted: false,
+        });
+        return Object.assign({}, displaysInCache, displaysToSet);
+    }
+    async getCentraDisplaysByProductIds(centraProductIds) {
+        const dedupedCentraProductIds = centraProductIds.filter((x, index, self) => self.indexOf(x) === index);
+        const displaysInCache = Object.fromEntries(Object.entries(await this.get(dedupedCentraProductIds.map(x => this.getCacheKeyForCentraDisplayByProductId(x)), 'env', {
+            isEphemeral: true,
+            encrypted: false,
+        })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]));
+        const displaysToFetch = dedupedCentraProductIds.filter(x => !displaysInCache[this.getCacheKeyForCentraDisplayByProductId(x)]);
+        const displays = await this.fetchCentraDisplays(displaysToFetch, 'product');
+        const displaysToSet = {};
+        for (const centraProductId of dedupedCentraProductIds) {
+            const display = displays[centraProductId];
+            displaysToSet[centraProductId] = display;
+        }
+        this.set(Object.entries(displaysToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCentraDisplayByProductId(+key), value: JSON.stringify(value) })), 'env', {
+            ephemeralMs: CACHE_EXPIRATION_MS,
+            encrypted: false,
+        });
+        return Object.assign({}, displaysInCache, displaysToSet);
+    }
+    async getCentraVariants(productIds) {
+        const dedupedProductIds = productIds.filter((x, index, self) => self.indexOf(x) === index);
+        const variantsInCache = Object.fromEntries(Object.entries(await this.get(dedupedProductIds.map(x => this.getCacheKeyForCentraVariant(x)), 'env', {
+            isEphemeral: true,
+            encrypted: false,
+        })).map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined]));
+        const variantsToFetch = dedupedProductIds.filter(x => !variantsInCache[this.getCacheKeyForCentraVariant(x)]);
+        const variants = await this.fetchCentraVariants(variantsToFetch);
+        const variantsToSet = {};
+        for (const productId of dedupedProductIds) {
+            const variant = variants[productId];
+            variantsToSet[productId] = variant;
+        }
+        this.set(Object.entries(variantsToSet).filter(([_, value]) => !(value instanceof Error)).map(([key, value]) => ({ name: this.getCacheKeyForCentraVariant(key), value: JSON.stringify(value) })), 'env', {
+            ephemeralMs: CACHE_EXPIRATION_MS,
+            encrypted: false,
+        });
+        return Object.assign({}, variantsInCache, variantsToSet);
+    }
+    static centraSizeNameToSize(centraSizeName) {
+        if (centraSizeName.endsWith('xS') && !centraSizeName.toLowerCase().endsWith('xxs')) {
+            return centraSizeName.slice(0, -2) + 'S';
+        }
+        if (centraSizeName.endsWith('xT')) {
+            return centraSizeName.slice(0, -2) + 'T';
+        }
+        if (centraSizeName.endsWith('xR')) {
+            return centraSizeName.slice(0, -2);
+        }
+        return centraSizeName;
+    }
+}
+exports.default = CentraHelper;
+//# sourceMappingURL=centra.js.map