@unchainedshop/api 3.1.13 → 4.0.0-rc.10

package/src/loaders/index.ts

@@ -1,344 +1,65 @@
-import DataLoader from 'dataloader';
 import { UnchainedCore } from '@unchainedshop/core';
-import { Product, ProductText, ProductMediaText, ProductMedia } from '@unchainedshop/core-products';
-import { Filter, FilterText } from '@unchainedshop/core-filters';
-import {
-  Assortment,
-  AssortmentLink,
-  AssortmentProduct,
-  AssortmentText,
-  AssortmentMediaType,
-  AssortmentMediaText,
-} from '@unchainedshop/core-assortments';
-import { File } from '@unchainedshop/core-files';
-import buildTextMap from './buildTextMap.js';
-import buildLocaleMap from './buildLocaleMap.js';
-
-const loaders = async (unchainedAPI: UnchainedCore) => {
+import assortmentLoader from './assortmentLoader.js';
+import assortmentTextLoader from './assortmentTextLoader.js';
+import assortmentMediaTextLoader from './assortmentMediaTextLoader.js';
+import assortmentMediasLoader from './assortmentMediasLoader.js';
+import assortmentLinkLoader from './assortmentLinkLoader.js';
+import assortmentLinksLoader from './assortmentLinksLoader.js';
+import assortmentProductLoader from './assortmentProductLoader.js';
+import assortmentProductsLoader from './assortmentProductsLoader.js';
+import filterLoader from './filterLoader.js';
+import filterTextLoader from './filterTextLoader.js';
+import productLoader from './productLoader.js';
+import productLoaderBySKU from './productLoaderBySKU.js';
+import productTextLoader from './productTextLoader.js';
+import productMediaTextLoader from './productMediaTextLoader.js';
+import productMediasLoader from './productMediasLoader.js';
+import productProxiesLoader from './productProxiesLoader.js';
+import fileLoader from './fileLoader.js';
+import userLoader from './userLoader.js';
+import countryLoader from './countryLoader.js';
+import currencyLoader from './currencyLoader.js';
+import languageLoader from './languageLoader.js';
+import deliveryProviderLoader from './deliveryProviderLoader.js';
+import paymentProviderLoader from './paymentProviderLoader.js';
+import orderLoader from './orderLoader.js';
+
+const loaders = (unchainedAPI: UnchainedCore) => {
   return {
-    assortmentLoader: 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]);
-    }),
-
-    assortmentTextLoader: new DataLoader<{ assortmentId: string; locale: string }, 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]);
-      },
-    ),
-
-    assortmentMediaTextLoader: new DataLoader<
-      { assortmentMediaId: string; locale: string },
-      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]);
-    }),
-
-    assortmentMediasLoader: 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] || []);
-      },
-    ),
-
-    assortmentLinkLoader: new DataLoader<
-      { parentAssortmentId: string; childAssortmentId: string },
-      AssortmentLink
-    >(async (queries) => {
-      const parentAssortmentIds = [...new Set(queries.map((q) => q.parentAssortmentId).filter(Boolean))];
-
-      const links = await unchainedAPI.modules.assortments.links.findLinks({
-        parentAssortmentIds,
-      });
-
-      const assortmentLinkMap = {};
-      for (const link of links) {
-        if (!assortmentLinkMap[link.parentAssortmentId]) {
-          assortmentLinkMap[link.parentAssortmentId] = [link];
-        } else {
-          assortmentLinkMap[link.parentAssortmentId].push(link);
-        }
-      }
-
-      return queries.map((q) => {
-        if (q.childAssortmentId) {
-          return assortmentLinkMap[q.parentAssortmentId].find(
-            (link) => link.childAssortmentId === q.childAssortmentId,
-          );
-        }
-        return assortmentLinkMap[q.parentAssortmentId][0];
-      });
-    }),
-
-    assortmentLinksLoader: 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] || []),
-        ];
-      });
-    }),
-
-    assortmentProductLoader: 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]);
-    }),
-
-    assortmentProductsLoader: 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] || []);
-      },
-    ),
-
-    filterLoader: 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]);
-    }),
-
-    filterTextLoader: new DataLoader<
-      { filterId: string; filterOptionValue?: string; locale: string },
-      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]);
-    }),
-
-    productLoader: new DataLoader<{ productId: string }, Product>(async (queries) => {
-      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))]; // you don't need lodash, _.unique my ass
-
-      const products = await unchainedAPI.modules.products.findProducts({
-        productIds,
-        productSelector: {
-          status: { $exists: true },
-        },
-      });
-
-      const productMap = {};
-      for (const product of products) {
-        productMap[product._id] = product;
-      }
-
-      return queries.map((q) => productMap[q.productId]);
-    }),
-
-    productLoaderBySKU: new DataLoader<{ sku: string }, Product>(async (queries) => {
-      const skus = [...new Set(queries.map((q) => q.sku).filter(Boolean))]; // you don't need lodash, _.unique my ass
-
-      const products = await unchainedAPI.modules.products.findProducts({
-        productSelector: {
-          'warehousing.sku': { $in: skus },
-          status: { $exists: true },
-        },
-      });
-
-      const productMap = {};
-      for (const product of products) {
-        productMap[product.warehousing!.sku!] = product;
-      }
-
-      return queries.map((q) => productMap[q.sku]);
-    }),
+    assortmentLoader: assortmentLoader(unchainedAPI),
+    assortmentTextLoader: assortmentTextLoader(unchainedAPI),
+    assortmentMediaTextLoader: assortmentMediaTextLoader(unchainedAPI),
+    assortmentMediasLoader: assortmentMediasLoader(unchainedAPI),
+    assortmentLinkLoader: assortmentLinkLoader(unchainedAPI),
+    assortmentLinksLoader: assortmentLinksLoader(unchainedAPI),
+    assortmentProductLoader: assortmentProductLoader(unchainedAPI),
+    assortmentProductsLoader: assortmentProductsLoader(unchainedAPI),
 
-    productTextLoader: new DataLoader<{ productId: string; locale: string }, ProductText>(
-      async (queries) => {
-        const productIds = [...new Set(queries.map((q) => q.productId))].filter(Boolean);
-        const texts = await unchainedAPI.modules.products.texts.findTexts(
-          { productId: { $in: productIds } },
-          {
-            sort: {
-              productId: 1,
-            },
-          },
-        );
-        const localeMap = buildLocaleMap(queries, texts);
-        const textsMap = buildTextMap(localeMap, texts, (text) => text.productId);
-        return queries.map((q) => textsMap[q.locale + q.productId]);
-      },
-    ),
+    filterLoader: filterLoader(unchainedAPI),
+    filterTextLoader: filterTextLoader(unchainedAPI),
 
-    productMediaTextLoader: new DataLoader<{ productMediaId: string; locale: string }, ProductMediaText>(
-      async (queries) => {
-        const productMediaIds = [...new Set(queries.map((q) => q.productMediaId).filter(Boolean))];
+    productLoader: productLoader(unchainedAPI),
+    productLoaderBySKU: productLoaderBySKU(unchainedAPI),
+    productTextLoader: productTextLoader(unchainedAPI),
+    productMediaTextLoader: productMediaTextLoader(unchainedAPI),
+    productMediasLoader: productMediasLoader(unchainedAPI),
+    productProxiesLoader: productProxiesLoader(unchainedAPI),
 
-        const texts = await unchainedAPI.modules.products.media.texts.findMediaTexts(
-          { productMediaId: { $in: productMediaIds } },
-          {
-            sort: {
-              productMediaId: 1,
-            },
-          },
-        );
+    fileLoader: fileLoader(unchainedAPI),
 
-        const localeMap = buildLocaleMap(queries, texts);
-        const textsMap = buildTextMap(localeMap, texts, (text) => text.productMediaId);
-        return queries.map((q) => textsMap[q.locale + q.productMediaId]);
-      },
-    ),
+    userLoader: userLoader(unchainedAPI),
 
-    productMediasLoader: new DataLoader<{ productId?: string }, ProductMedia[]>(async (queries) => {
-      const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
-      const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
-        productId: { $in: productIds },
-      });
+    countryLoader: countryLoader(unchainedAPI),
 
-      const productMediaMap = {};
-      for (const productMedia of productMediaItems) {
-        if (!productMediaMap[productMedia.productId]) {
-          productMediaMap[productMedia.productId] = [productMedia];
-        } else {
-          productMediaMap[productMedia.productId].push(productMedia);
-        }
-      }
-      return queries.map((q) => productMediaMap[q.productId] || []);
-    }),
+    currencyLoader: currencyLoader(unchainedAPI),
 
-    fileLoader: new DataLoader<{ fileId: string }, File>(async (queries) => {
-      const fileIds = [...new Set(queries.map((q) => q.fileId).filter(Boolean))]; // you don't need lodash, _.unique my ass
+    languageLoader: languageLoader(unchainedAPI),
 
-      const files = await unchainedAPI.modules.files.findFiles({
-        _id: { $in: fileIds },
-      });
+    deliveryProviderLoader: deliveryProviderLoader(unchainedAPI),
 
-      const fileMap = {};
-      for (const file of files) {
-        fileMap[file._id] = file;
-      }
+    paymentProviderLoader: paymentProviderLoader(unchainedAPI),
 
-      return queries.map((q) => fileMap[q.fileId]);
-    }),
+    orderLoader: orderLoader(unchainedAPI),
   };
 };
 

package/src/loaders/languageLoader.ts

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

package/src/loaders/orderLoader.ts

@@ -0,0 +1,22 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Order } from '@unchainedshop/core-orders';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ orderId: string }, Order>(async (queries) => {
+    const orderIds = [...new Set(queries.map((q) => q.orderId).filter(Boolean))];
+
+    // It's important to also fetch deleted with the loader,
+    // because the loader fetches entities by id.
+    const orders = await unchainedAPI.modules.orders.findOrders({
+      includeCarts: true,
+      _id: { $in: orderIds },
+    });
+
+    const orderMap = {};
+    for (const order of orders) {
+      orderMap[order._id] = order;
+    }
+
+    return queries.map((q) => orderMap[q.orderId]);
+  });

package/src/loaders/paymentProviderLoader.ts

@@ -0,0 +1,19 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { PaymentProvider } from '@unchainedshop/core-payment';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ paymentProviderId: string }, PaymentProvider>(async (queries) => {
+    const paymentProviderIds = [...new Set(queries.map((q) => q.paymentProviderId).filter(Boolean))];
+
+    const paymentProviders = await unchainedAPI.modules.payment.paymentProviders.findProviders({
+      _id: { $in: paymentProviderIds },
+    });
+
+    const paymentProviderMap = {};
+    for (const paymentProvider of paymentProviders) {
+      paymentProviderMap[paymentProvider._id] = paymentProvider;
+    }
+
+    return queries.map((q) => paymentProviderMap[q.paymentProviderId]);
+  });

package/src/loaders/productLoader.ts

@@ -0,0 +1,22 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Product } from '@unchainedshop/core-products';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ productId: string }, Product>(async (queries) => {
+    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+    const products = await unchainedAPI.modules.products.findProducts({
+      productIds,
+      productSelector: {
+        status: { $exists: true },
+      },
+    });
+
+    const productMap = {};
+    for (const product of products) {
+      productMap[product._id] = product;
+    }
+
+    return queries.map((q) => productMap[q.productId]);
+  });

package/src/loaders/productLoaderBySKU.ts

@@ -0,0 +1,22 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Product } from '@unchainedshop/core-products';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ sku: string }, Product>(async (queries) => {
+    const skus = [...new Set(queries.map((q) => q.sku).filter(Boolean))];
+
+    const products = await unchainedAPI.modules.products.findProducts({
+      productSelector: {
+        'warehousing.sku': { $in: skus },
+        status: { $exists: true },
+      },
+    });
+
+    const productMap = {};
+    for (const product of products) {
+      productMap[product.warehousing!.sku!] = product;
+    }
+
+    return queries.map((q) => productMap[q.sku]);
+  });

package/src/loaders/productMediaTextLoader.ts

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

package/src/loaders/productMediasLoader.ts

@@ -0,0 +1,21 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { ProductMedia } from '@unchainedshop/core-products';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ productId?: string }, ProductMedia[]>(async (queries) => {
+    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+    const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
+      productId: { $in: productIds },
+    });
+
+    const productMediaMap = {};
+    for (const productMedia of productMediaItems) {
+      if (!productMediaMap[productMedia.productId]) {
+        productMediaMap[productMedia.productId] = [productMedia];
+      } else {
+        productMediaMap[productMedia.productId].push(productMedia);
+      }
+    }
+    return queries.map((q) => productMediaMap[q.productId] || []);
+  });

package/src/loaders/productProxiesLoader.ts

@@ -0,0 +1,37 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Product } from '@unchainedshop/core-products';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ productId?: string }, Product[]>(async (queries) => {
+    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
+
+    const productProxies = await unchainedAPI.modules.products.findProducts({
+      includeDrafts: true,
+      productSelector: {
+        $or: [
+          {
+            'bundleItems.productId': { $in: productIds },
+          },
+          {
+            'proxy.assignments.productId': { $in: productIds },
+          },
+        ],
+      },
+    });
+
+    const productProxyMap = {};
+    for (const productProxy of productProxies) {
+      const bundleItemIds = productProxy.bundleItems?.map((item) => item.productId) || [];
+      const proxyAssignmentIds =
+        productProxy.proxy?.assignments?.map((assignment) => assignment.productId) || [];
+
+      for (const productId of [...bundleItemIds, ...proxyAssignmentIds]) {
+        if (!productProxyMap[productId]) {
+          productProxyMap[productId] = [];
+        }
+        productProxyMap[productId].push(productProxy);
+      }
+    }
+    return queries.map((q) => productProxyMap[q.productId] || []);
+  });

package/src/loaders/productTextLoader.ts

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

package/src/loaders/userLoader.ts

@@ -0,0 +1,23 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { User } from '@unchainedshop/core-users';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  new DataLoader<{ userId: string }, User>(async (queries) => {
+    const userIds = [...new Set(queries.map((q) => q.userId).filter(Boolean))];
+
+    // It's important to also fetch deleted with the loader,
+    // because the loader fetches entities by id.
+    const users = await unchainedAPI.modules.users.findUsers({
+      includeGuests: true,
+      includeDeleted: true,
+      _id: { $in: userIds },
+    });
+
+    const userMap = {};
+    for (const user of users) {
+      userMap[user._id] = user;
+    }
+
+    return queries.map((q) => userMap[q.userId]);
+  });

package/src/loaders/utils.ts

@@ -0,0 +1,35 @@
+import { systemLocale } from '@unchainedshop/utils';
+
+export function getLocaleStrings(locale: Intl.Locale) {
+  try {
+    return [
+      ...new Set([locale.baseName, locale.language, systemLocale.baseName, systemLocale.language]),
+    ];
+  } catch {
+    return [...new Set([systemLocale.baseName, systemLocale.language])];
+  }
+}
+
+export function buildLocaleMap(
+  queries: readonly { locale: Intl.Locale }[],
+  texts: readonly { locale?: string }[],
+): Record<string, string[]> {
+  // key = texts.locale
+  // value = input query locale
+
+  const queryLocales = Object.values(
+    Object.fromEntries(queries.map((q) => [q.locale.baseName, q.locale])),
+  );
+
+  const textLocales: string[] = [...new Set(texts.map((t) => t.locale))];
+  const localeMap = {};
+  for (const queryLocale of queryLocales) {
+    const potentialMatches = getLocaleStrings(queryLocale);
+    const matches = potentialMatches.filter((l) => textLocales.includes(l));
+    for (const match of matches) {
+      if (!localeMap[match]) localeMap[match] = [];
+      localeMap[match].push(queryLocale);
+    }
+  }
+  return localeMap;
+}