@shushed/helpers 0.0.202 → 0.0.203-bug-erp-770-20251208112219

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

@@ -1,1053 +0,0 @@
-"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;