@unchainedshop/api 3.1.13 → 4.0.0-rc.10

package/src/loaders/assortmentLinksLoader.ts

@@ -0,0 +1,46 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { AssortmentLink } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<
+    { parentAssortmentId?: string; childAssortmentId?: string; assortmentId?: string },
+    AssortmentLink[]
+  >(async (queries) => {
+    const parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean);
+    const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean);
+    const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean);
+
+    const allLinks = await unchainedAPI.modules.assortments.links.findLinks({
+      assortmentIds: [...new Set([...parentAssortmentIds, ...childAssortmentIds, ...assortmentIds])],
+    });
+
+    const parentAssortmentLinkMap = {};
+    const childAssortmentLinkMap = {};
+
+    for (const link of allLinks) {
+      if (!parentAssortmentLinkMap[link.parentAssortmentId]) {
+        parentAssortmentLinkMap[link.parentAssortmentId] = [link];
+      } else {
+        parentAssortmentLinkMap[link.parentAssortmentId].push(link);
+      }
+
+      if (!childAssortmentLinkMap[link.childAssortmentId]) {
+        childAssortmentLinkMap[link.childAssortmentId] = [link];
+      } else {
+        childAssortmentLinkMap[link.childAssortmentId].push(link);
+      }
+    }
+
+    return queries.map((q) => {
+      if (q.parentAssortmentId) {
+        return parentAssortmentLinkMap[q.parentAssortmentId] || [];
+      } else if (q.childAssortmentId) {
+        return childAssortmentLinkMap[q.childAssortmentId] || [];
+      }
+      return [
+        ...(parentAssortmentLinkMap[q.assortmentId] || []),
+        ...(childAssortmentLinkMap[q.assortmentId] || []),
+      ];
+    });
+  });

package/src/loaders/assortmentLoader.ts

@@ -0,0 +1,20 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Assortment } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ assortmentId: string }, Assortment>(async (queries) => {
+    const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+
+    const assortments = await unchainedAPI.modules.assortments.findAssortments({
+      assortmentIds,
+      includeInactive: true,
+      includeLeaves: true,
+    });
+
+    const assortmentMap = {};
+    for (const assortment of assortments) {
+      assortmentMap[assortment._id] = assortment;
+    }
+    return queries.map((q) => assortmentMap[q.assortmentId]);
+  });

package/src/loaders/assortmentMediaTextLoader.ts

@@ -0,0 +1,26 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { AssortmentMediaText } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ assortmentMediaId: string; locale: Intl.Locale }, AssortmentMediaText>(
+    async (queries) => {
+      const assortmentMediaIds = [...new Set(queries.map((q) => q.assortmentMediaId).filter(Boolean))];
+
+      const texts = await unchainedAPI.modules.assortments.media.texts.findMediaTexts(
+        { assortmentMediaId: { $in: assortmentMediaIds } },
+        {
+          sort: {
+            assortmentMediaId: 1,
+          },
+        },
+      );
+
+      const localeMap = buildLocaleMap(queries, texts);
+      const textsMap = buildTextMap(localeMap, texts, (text) => text.assortmentMediaId);
+
+      return queries.map((q) => textsMap[q.locale + q.assortmentMediaId]);
+    },
+  );

package/src/loaders/assortmentMediasLoader.ts

@@ -0,0 +1,21 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { AssortmentMediaType } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>(async (queries) => {
+    const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+    const assortmentMediaItems = await unchainedAPI.modules.assortments.media.findAssortmentMedias({
+      assortmentId: { $in: assortmentIds },
+    });
+
+    const assortmentMediaMap = {};
+    for (const assortmentMedia of assortmentMediaItems) {
+      if (!assortmentMediaMap[assortmentMedia.assortmentId]) {
+        assortmentMediaMap[assortmentMedia.assortmentId] = [assortmentMedia];
+      } else {
+        assortmentMediaMap[assortmentMedia.assortmentId].push(assortmentMedia);
+      }
+    }
+    return queries.map((q) => assortmentMediaMap[q.assortmentId] || []);
+  });

package/src/loaders/assortmentProductLoader.ts

@@ -0,0 +1,19 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { AssortmentProduct } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ assortmentId: string; productId: string }, AssortmentProduct>(async (queries) => {
+    const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+
+    const assortmentProducts = await unchainedAPI.modules.assortments.products.findAssortmentProducts({
+      assortmentIds,
+    });
+
+    const assortmentProductMap = {};
+    for (const assortmentProduct of assortmentProducts) {
+      assortmentProductMap[assortmentProduct.assortmentId + assortmentProduct.productId] =
+        assortmentProduct;
+    }
+    return queries.map((q) => assortmentProductMap[q.assortmentId + q.productId]);
+  });

package/src/loaders/assortmentProductsLoader.ts

@@ -0,0 +1,22 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { AssortmentProduct } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ productId: string }, AssortmentProduct[]>(async (queries) => {
+    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+    const assortmentProducts = await unchainedAPI.modules.assortments.products.findAssortmentProducts({
+      productIds,
+    });
+
+    const assortmentProductsMap = {};
+    for (const assortmentProduct of assortmentProducts) {
+      if (!assortmentProductsMap[assortmentProduct.productId]) {
+        assortmentProductsMap[assortmentProduct.productId] = [assortmentProduct];
+      } else {
+        assortmentProductsMap[assortmentProduct.productId].push(assortmentProduct);
+      }
+    }
+    return queries.map((q) => assortmentProductsMap[q.productId] || []);
+  });

package/src/loaders/assortmentTextLoader.ts

@@ -0,0 +1,24 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { AssortmentText } from '@unchainedshop/core-assortments';
+import DataLoader from 'dataloader';
+import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ assortmentId: string; locale: Intl.Locale }, AssortmentText>(async (queries) => {
+    const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+
+    const texts = await unchainedAPI.modules.assortments.texts.findTexts(
+      { assortmentId: { $in: assortmentIds } },
+      {
+        sort: {
+          assortmentId: 1,
+        },
+      },
+    );
+
+    const localeMap = buildLocaleMap(queries, texts);
+    const textsMap = buildTextMap(localeMap, texts, (text) => text.assortmentId);
+
+    return queries.map((q) => textsMap[q.locale + q.assortmentId]);
+  });

package/src/loaders/buildLocaleMap.test.ts

@@ -19,7 +19,11 @@ const testTexts = [
 
 describe('buildLocaleMap', () => {
   it('Mixed usage of default locale and forced languages', () => {
-    const queries = [{ locale: 'de-CH' }, { locale: 'fr' }, { locale: 'it' }];
+    const queries = [
+      { locale: new Intl.Locale('de-CH') },
+      { locale: new Intl.Locale('fr') },
+      { locale: new Intl.Locale('it') },
+    ];
     const expected = {
       de: ['de-CH', 'fr', 'it'],
       fr: ['fr'],
@@ -30,7 +34,7 @@ describe('buildLocaleMap', () => {
   });
 
   it('Mixed usage of forced languages', () => {
-    const queries = [{ locale: 'fr' }, { locale: 'it' }];
+    const queries = [{ locale: new Intl.Locale('fr') }, { locale: new Intl.Locale('it') }];
     const expected = {
       de: ['fr', 'it'],
       fr: ['fr'],
@@ -41,16 +45,16 @@ describe('buildLocaleMap', () => {
   });
 
   it('Only default locale', () => {
-    const queries = [{ locale: 'de_CH' }];
+    const queries = [{ locale: new Intl.Locale('de-CH') }];
     const expected = {
-      de: ['de_CH'],
+      de: ['de-CH'],
     };
     const result = buildLocaleMap(queries, testTexts);
     assert.deepStrictEqual(result, expected);
   });
 
   it('Only one forced language locale', () => {
-    const queries = [{ locale: 'fr' }];
+    const queries = [{ locale: new Intl.Locale('fr') }];
     const expected = {
       fr: ['fr'],
       de: ['fr'],

package/src/loaders/buildLocaleMap.ts

@@ -1,12 +1,10 @@
 import { systemLocale } from '@unchainedshop/utils';
 
-function getLocaleStrings(locale: string): string[] {
+function getLocaleStrings(locale: Intl.Locale): string[] {
   try {
-    const localeObj = new Intl.Locale(locale);
-    // Optimized Set creation and spread
     const locales = new Set<string>();
-    locales.add(localeObj.baseName);
-    locales.add(localeObj.language);
+    locales.add(locale.baseName);
+    locales.add(locale.language);
     locales.add(systemLocale.baseName);
     locales.add(systemLocale.language);
     return Array.from(locales);
@@ -19,20 +17,20 @@ function getLocaleStrings(locale: string): string[] {
   }
 }
 export default function buildLocaleMap(
-  queries: Readonly<Array<{ locale: string }>>,
-  texts: Readonly<Array<{ locale?: string }>>,
+  queries: readonly { locale: Intl.Locale }[],
+  texts: readonly { locale?: string }[],
 ): Record<string, string[]> {
   // key = texts.locale
   // value = input query locale
   const queryLocales = new Set(queries.map((q) => q.locale));
   const textLocales = new Set(texts.map((t) => t.locale));
-  const localeMap = {};
+  const localeMap: Record<string, string[]> = {};
   for (const queryLocale of queryLocales) {
     const potentialMatches = getLocaleStrings(queryLocale);
     const matches = potentialMatches.filter((l) => textLocales.has(l));
     for (const match of matches) {
       if (!localeMap[match]) localeMap[match] = [];
-      localeMap[match].push(queryLocale);
+      localeMap[match].push(queryLocale.toString());
     }
   }
   return localeMap;

package/src/loaders/buildTextMap.ts

@@ -2,7 +2,7 @@ type ArrayElement<T> = T extends (infer U)[] ? U : never;
 
 /* This file has been optimized for performance to the last drop. Don't refactor! */
 
-export default function buildTextMap<T extends Array<{ locale?: string }>>(
+export default function buildTextMap<T extends { locale?: string }[]>(
   localeMap: Record<string, string[]>,
   texts: Readonly<T>,
   buildId: (item: ArrayElement<T>) => string,
@@ -10,16 +10,19 @@ export default function buildTextMap<T extends Array<{ locale?: string }>>(
   const textsMap: Record<string, ArrayElement<T>> = {}; // Added type for textsMap
   const localeMapKeys = Object.keys(localeMap);
 
+  // eslint-disable-next-line
   for (let i = 0; i < localeMapKeys.length; i++) {
     const originLocale = localeMapKeys[i];
     const localesForText = localeMap[originLocale];
 
+    // eslint-disable-next-line
     for (let j = 0; j < texts.length; j++) {
       const text = texts[j];
       if (originLocale !== text.locale) continue;
 
       const idPart = buildId(text as ArrayElement<T>); // Ensured correct type for buildId argument
 
+      // eslint-disable-next-line
       for (let k = 0; k < localesForText.length; k++) {
         const locale = localesForText[k];
         const key = locale + idPart;

package/src/loaders/countryLoader.ts

@@ -0,0 +1,20 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Country } from '@unchainedshop/core-countries';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ isoCode: string }, Country>(async (queries) => {
+    const isoCodes = [...new Set(queries.map((q) => q.isoCode).filter(Boolean))];
+
+    const countries = await unchainedAPI.modules.countries.findCountries({
+      isoCode: { $in: isoCodes },
+      includeInactive: true,
+    });
+
+    const countryMap = {};
+    for (const country of countries) {
+      countryMap[country.isoCode] = country;
+    }
+
+    return queries.map((q) => countryMap[q.isoCode]);
+  });

package/src/loaders/currencyLoader.ts

@@ -0,0 +1,20 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Currency } from '@unchainedshop/core-currencies';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ isoCode: string }, Currency>(async (queries) => {
+    const isoCodes = [...new Set(queries.map((q) => q.isoCode).filter(Boolean))];
+
+    const currencies = await unchainedAPI.modules.currencies.findCurrencies({
+      isoCode: { $in: isoCodes },
+      includeInactive: true,
+    });
+
+    const currencyMap = {};
+    for (const currency of currencies) {
+      currencyMap[currency.isoCode] = currency;
+    }
+
+    return queries.map((q) => currencyMap[q.isoCode]);
+  });

package/src/loaders/deliveryProviderLoader.ts

@@ -0,0 +1,19 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { DeliveryProvider } from '@unchainedshop/core-delivery';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ deliveryProviderId: string }, DeliveryProvider>(async (queries) => {
+    const deliveryProviderIds = [...new Set(queries.map((q) => q.deliveryProviderId).filter(Boolean))];
+
+    const deliveryProviders = await unchainedAPI.modules.delivery.findProviders({
+      _id: { $in: deliveryProviderIds },
+    });
+
+    const deliveryProviderMap = {};
+    for (const deliveryProvider of deliveryProviders) {
+      deliveryProviderMap[deliveryProvider._id] = deliveryProvider;
+    }
+
+    return queries.map((q) => deliveryProviderMap[q.deliveryProviderId]);
+  });

package/src/loaders/fileLoader.ts

@@ -0,0 +1,19 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { File } from '@unchainedshop/core-files';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ fileId: string }, File>(async (queries) => {
+    const fileIds = [...new Set(queries.map((q) => q.fileId).filter(Boolean))];
+
+    const files = await unchainedAPI.modules.files.findFiles({
+      _id: { $in: fileIds },
+    });
+
+    const fileMap = {};
+    for (const file of files) {
+      fileMap[file._id] = file;
+    }
+
+    return queries.map((q) => fileMap[q.fileId]);
+  });

package/src/loaders/filterLoader.ts

@@ -0,0 +1,20 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Filter } from '@unchainedshop/core-filters';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ filterId: string }, Filter>(async (queries) => {
+    const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+
+    const filters = await unchainedAPI.modules.filters.findFilters({
+      filterIds,
+      includeInactive: true,
+    });
+
+    const filterMap = {};
+    for (const filter of filters) {
+      filterMap[filter._id] = filter;
+    }
+
+    return queries.map((q) => filterMap[q.filterId]);
+  });

package/src/loaders/filterTextLoader.ts

@@ -0,0 +1,26 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import DataLoader from 'dataloader';
+import buildLocaleMap from './buildLocaleMap.js';
+import { FilterText } from '@unchainedshop/core-filters';
+import buildTextMap from './buildTextMap.js';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ filterId: string; filterOptionValue?: string; locale: Intl.Locale }, FilterText>(
+    async (queries) => {
+      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+
+      const texts = await unchainedAPI.modules.filters.texts.findTexts(
+        { filterId: { $in: filterIds } },
+        {
+          sort: {
+            filterId: 1,
+          },
+        },
+      );
+
+      const localeMap = buildLocaleMap(queries, texts);
+      const textsMap = buildTextMap(localeMap, texts, (text) => text.filterId + text.filterOptionValue);
+
+      return queries.map((q) => textsMap[q.locale + q.filterId + q.filterOptionValue]);
+    },
+  );