@unchainedshop/api 3.1.11 → 4.0.0-rc.2

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 './utils.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]);
+    },
+  );

package/src/loaders/index.ts

@@ -1,375 +1,63 @@
-import DataLoader from 'dataloader';
-import { systemLocale } from '@unchainedshop/utils';
 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';
-
-function getLocaleStrings(locale: string) {
-  try {
-    const localeObj = new Intl.Locale(locale);
-    return [
-      ...new Set([localeObj.baseName, localeObj.language, systemLocale.baseName, systemLocale.language]),
-    ];
-  } catch {
-    return [...new Set([systemLocale.baseName, systemLocale.language])];
-  }
-}
-
-function buildLocaleMap(
-  queries: Readonly<Array<{ locale: string }>>,
-  texts: Readonly<Array<{ locale?: string }>>,
-): Record<string, string[]> {
-  // key = texts.locale
-  // value = input query locale
-  const queryLocales: Array<any> = [...new Set(queries.map((q) => q.locale))];
-  const textLocales: Array<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;
-}
-
-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 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),
 
-        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 { buildLocaleMap } from './utils.js';
+import { ProductMediaText } from '@unchainedshop/core-products';
+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/productTextLoader.ts

@@ -0,0 +1,22 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import DataLoader from 'dataloader';
+import { buildLocaleMap } from './utils.js';
+import { ProductText } from '@unchainedshop/core-products';
+import buildTextMap from './buildTextMap.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]);
+  });