@shushed/helpers 0.0.251 → 0.0.252

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

@@ -141,6 +141,18 @@ class CentraHelper extends env_1.default {
     getCacheKeyForCentraPricelist(pricelistExternalId) {
         return `${this.getCacheKeyForCentraPricelists()}_${pricelistExternalId}`;
     }
+    getCacheKeyForCentraCategory(categoryId) {
+        return `centra_${this.shaToken}_category_${categoryId}`;
+    }
+    getCacheKeyForCentraCategories() {
+        return `centra_${this.shaToken}_categories`;
+    }
+    getCacheKeyForCentraMeasurementCharts() {
+        return `centra_${this.shaToken}_measurement_charts`;
+    }
+    getCacheKeyForCentraMeasurementChart(name) {
+        return `centra_${this.shaToken}_measurement_chart_${name}`;
+    }
     async fetchCountries(iso2Codes) {
         const result = [];
         const limit = 200;
@@ -1093,5 +1105,269 @@ class CentraHelper extends env_1.default {
         }
         return centraSizeName;
     }
+    async fetchCentraCategories(categoryIds) {
+        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 GetCategories($limit: Int, $page: Int${categoryIds ? `, $categoryIds: CategoryFilter` : ''}) {
+                            categories(${categoryIds ? `where: $categoryIds, ` : ''}limit: $limit, page: $page) {
+                                id
+                                name
+                                uri
+                                isTopCategory
+                            }
+                        }
+                    `,
+                    variables: {
+                        page,
+                        limit,
+                        categoryIds: categoryIds ? { uri: categoryIds } : undefined
+                    }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.categories?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const category of data.data?.categories || []) {
+                result.push({
+                    id: category.id,
+                    name: category.name,
+                    uri: category.uri,
+                    isTopCategory: category.isTopCategory
+                });
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async getCentraCategories(categoryIds, alwaysFetch = false) {
+        if (categoryIds && !categoryIds.length) {
+            return {};
+        }
+        let categoryInCache = {};
+        let dedupedCategoryIds = [];
+        let categoriesToFetch = null;
+        if (!alwaysFetch) {
+            if (!categoryIds) {
+                categoryIds = await this.get(this.getCacheKeyForCentraCategories(), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                }).then(x => x ? JSON.parse(x) : null);
+            }
+            if (categoryIds) {
+                dedupedCategoryIds = categoryIds.filter((x, index, self) => self.indexOf(x) === index);
+                const cachedValues = await this.get(dedupedCategoryIds.map(x => this.getCacheKeyForCentraCategory(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                });
+                categoryInCache = Object.fromEntries(Object.entries(cachedValues)
+                    .map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined])
+                    .filter((entry) => entry[1]));
+                categoriesToFetch = dedupedCategoryIds.filter(x => !categoryInCache[x]);
+            }
+        }
+        const categoryToSet = {};
+        if (!categoriesToFetch || categoriesToFetch.length) {
+            const categoriesFetched = await this.fetchCentraCategories(categoriesToFetch);
+            if (CentraHelper.isCentraErrors(categoriesFetched)) {
+                if (categoriesToFetch) {
+                    for (const categoryId of categoriesToFetch) {
+                        categoryToSet[categoryId] = new Error(`Failed to fetch category ${categoryId}: ${categoriesFetched.errors.map((x) => x.message).join(', ')}`);
+                    }
+                }
+                else {
+                    return new Error(`Failed to fetch categories: ${categoriesFetched.errors.map((x) => x.message).join(', ')}`);
+                }
+            }
+            else {
+                for (const category of categoriesFetched) {
+                    categoryToSet[category.uri] = category;
+                }
+                await this.set(Object.entries(categoryToSet)
+                    .filter((entry) => !(entry[1] instanceof Error))
+                    .map(([key, value]) => ({ name: this.getCacheKeyForCentraCategory(key), value: JSON.stringify(value) })), 'env', { ephemeralMs: CACHE_EXPIRATION_MS, encrypted: false });
+                if (!categoriesToFetch) {
+                    await this.set([{
+                            name: this.getCacheKeyForCentraCategories(),
+                            value: JSON.stringify(Object.keys(categoryToSet)),
+                        }], 'env', { ephemeralMs: CACHE_EXPIRATION_MS, encrypted: false });
+                }
+            }
+        }
+        return Object.assign({}, categoryInCache, categoryToSet);
+    }
+    async fetchCentraMeasurementCharts() {
+        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 GetMeasurementCharts($limit: Int, $page: Int) {
+                            measurementCharts(limit: $limit, page: $page) {
+                                id
+                                name
+                            }
+                        }
+                    `,
+                    variables: { page, limit }
+                })
+            });
+            if (CentraHelper.isCentraErrors(data)) {
+                return data;
+            }
+            if ((data.data?.measurementCharts?.length || 0) < limit) {
+                hasNextPage = false;
+            }
+            else {
+                page++;
+            }
+            for (const chart of data.data?.measurementCharts || []) {
+                result.push({
+                    id: chart.id,
+                    name: chart.name
+                });
+            }
+        } while (hasNextPage);
+        return result;
+    }
+    async getCentraMeasurementCharts(alwaysFetch = false) {
+        let chartInCache = {};
+        let dedupedChartNamesInCache = [];
+        let chartsToFetch = null;
+        if (!alwaysFetch) {
+            const chartNamesInCache = await this.get(this.getCacheKeyForCentraMeasurementCharts(), 'env', {
+                isEphemeral: true,
+                encrypted: false,
+            }).then(x => x ? JSON.parse(x) : null);
+            if (chartNamesInCache) {
+                dedupedChartNamesInCache = chartNamesInCache.filter((x, index, self) => self.indexOf(x) === index);
+                const cachedValues = await this.get(dedupedChartNamesInCache.map(x => this.getCacheKeyForCentraMeasurementChart(x)), 'env', {
+                    isEphemeral: true,
+                    encrypted: false,
+                });
+                chartInCache = Object.fromEntries(Object.entries(cachedValues)
+                    .map(([key, value]) => [key, value ? JSON.parse(value || 'null') : undefined])
+                    .filter((entry) => entry[1]));
+                chartsToFetch = dedupedChartNamesInCache.filter(x => !chartInCache[x]);
+            }
+        }
+        const chartToSet = {};
+        if (!chartsToFetch || chartsToFetch.length) {
+            const charts = await this.fetchCentraMeasurementCharts();
+            if (CentraHelper.isCentraErrors(charts)) {
+                return new Error(`Failed to fetch measurement charts: ${charts.errors.map((x) => x.message).join(', ')}`);
+            }
+            else {
+                for (const chart of charts) {
+                    chartToSet[chart.name] = chart;
+                }
+                await this.set(Object.entries(chartToSet)
+                    .filter((entry) => !(entry[1] instanceof Error))
+                    .map(([key, value]) => ({ name: this.getCacheKeyForCentraMeasurementChart(key), value: JSON.stringify(value) })), 'env', { ephemeralMs: CACHE_EXPIRATION_MS, encrypted: false });
+                await this.set([{
+                        name: this.getCacheKeyForCentraMeasurementCharts(),
+                        value: JSON.stringify(Object.keys(chartToSet)),
+                    }], 'env', { ephemeralMs: CACHE_EXPIRATION_MS, encrypted: false });
+            }
+        }
+        return Object.assign({}, chartInCache, chartToSet);
+    }
+    async getCentraDisplaysByUris(uris) {
+        if (uris.length === 0) {
+            return {};
+        }
+        const uniqueUris = [...new Set(uris.filter(Boolean))];
+        const result = {};
+        for (const uri of uniqueUris) {
+            result[uri] = [];
+        }
+        const limit = uniqueUris.length > 200 ? 200 : uniqueUris.length;
+        let nextCursor = null;
+        do {
+            try {
+                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
+                                            uri
+                                            name
+                                            product {
+                                                id
+                                                externalId
+                                            }
+                                            productVariants {
+                                                id
+                                                externalId
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        `,
+                        variables: {
+                            input: {
+                                uri: {
+                                    contains: uniqueUris
+                                }
+                            },
+                            after: nextCursor,
+                            limit: limit
+                        }
+                    })
+                });
+                if (CentraHelper.isCentraErrors(data)) {
+                    return new Error(`Failed to query displays by URIs: ${data.errors.map(e => e.message).join(', ')}`);
+                }
+                const displayConnection = data.data?.displayConnection;
+                if (displayConnection?.pageInfo?.hasNextPage &&
+                    displayConnection.pageInfo.endCursor &&
+                    displayConnection.pageInfo.endCursor !== nextCursor) {
+                    nextCursor = displayConnection.pageInfo.endCursor;
+                }
+                else {
+                    nextCursor = null;
+                }
+                if (displayConnection?.edges?.length) {
+                    for (const edge of displayConnection.edges) {
+                        const display = edge.node;
+                        if (display.uri && uniqueUris.includes(display.uri)) {
+                            if (!result[display.uri]) {
+                                result[display.uri] = [];
+                            }
+                            result[display.uri].push(display);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                return error instanceof Error ? error : new Error(String(error));
+            }
+        } while (nextCursor !== null);
+        return result;
+    }
 }
 exports.default = CentraHelper;

package/dist/types/src-public/centra.d.ts

@@ -1,5 +1,28 @@
 import EnvEngine from './env';
 import Runtime from './runtime';
+export type BasicCentraCategory = {
+    id: number;
+    name: string;
+    uri: string;
+    isTopCategory: boolean;
+};
+export type BasicCentraMeasurementChart = {
+    id: number;
+    name: string;
+};
+export type BasicCentraDisplayForSlugCheck = {
+    id: number;
+    uri: string;
+    name: string;
+    product: {
+        id: number;
+        externalId: string;
+    };
+    productVariants: Array<{
+        id: number;
+        externalId: string;
+    }>;
+};
 export type BasicCentraProduct = {
     id: number;
     name: string;
@@ -154,6 +177,10 @@ export default class CentraHelper extends EnvEngine {
     getCacheKeyForCentraWarehouse(warehouseExternalId: string): string;
     getCacheKeyForCentraPricelists(): string;
     getCacheKeyForCentraPricelist(pricelistExternalId: string): string;
+    getCacheKeyForCentraCategory(categoryId: string): string;
+    getCacheKeyForCentraCategories(): string;
+    getCacheKeyForCentraMeasurementCharts(): string;
+    getCacheKeyForCentraMeasurementChart(name: string): string;
     fetchCountries(iso2Codes?: string[] | undefined | null): Promise<CentraErrors | Array<BasicCentraCountry>>;
     fetchCentraWarehouses(externalIds?: string[] | undefined | null): Promise<CentraErrors | Array<BasicCentraWarehouse>>;
     fetchCentraCampaigns(names?: string[] | undefined | null): Promise<CentraErrors | Record<string, BasicCentraCampaign | Error>>;
@@ -174,4 +201,9 @@ export default class CentraHelper extends EnvEngine {
     getCentraDisplaysByProductIds(centraProductIds: number[]): Promise<Record<string, BasicCentraDisplay[] | Error>>;
     getCentraVariants(productIds: string[]): Promise<Record<string, BasicCentraVariant | Error>>;
     static centraSizeNameToSize(centraSizeName: string): string;
+    fetchCentraCategories(categoryIds?: string[] | null): Promise<CentraErrors | BasicCentraCategory[]>;
+    getCentraCategories(categoryIds?: string[] | null, alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraCategory>>;
+    fetchCentraMeasurementCharts(): Promise<CentraErrors | BasicCentraMeasurementChart[]>;
+    getCentraMeasurementCharts(alwaysFetch?: boolean): Promise<Error | Record<string, Error | BasicCentraMeasurementChart>>;
+    getCentraDisplaysByUris(uris: string[]): Promise<Record<string, BasicCentraDisplayForSlugCheck[]> | Error>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.251",
+  "version": "0.0.252",
   "author": "",
   "license": "UNLICENSED",
   "description": "",