@unchainedshop/api 3.1.13 → 4.0.0-rc.3

package/src/fastify/ercMetadataHandler.ts

@@ -17,18 +17,24 @@ const ercMetadataHandler: RouteHandlerMethod = async (
   res,
 ) => {
   try {
-    const { services, localeContext } = req.unchainedContext;
+    const { services, modules, locale, loaders } = req.unchainedContext;
     const url = new URL(req.url, ROOT_URL);
 
     if (!url.pathname.toLowerCase().endsWith('.json')) throw new Error('Invalid ERC Metadata URI');
 
     const { productId, localeOrTokenFilename, tokenFileName } = req.params as any;
-    const locale = tokenFileName ? new Intl.Locale(localeOrTokenFilename) : localeContext;
 
-    const ercMetadata = await services.warehousing.ercMetadata({
-      productId,
-      locale,
+    const product = await loaders.productLoader.load({ productId });
+
+    const [token] = await modules.warehousing.findTokens({
       chainTokenId: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
+      contractAddress: product?.tokenization?.contractAddress,
+    });
+
+    const ercMetadata = await services.warehousing.ercMetadata({
+      product,
+      token,
+      locale: tokenFileName ? new Intl.Locale(localeOrTokenFilename) : locale,
     });
 
     if (!ercMetadata) return notFoundHandler(res);

package/src/fastify/index.ts

@@ -10,8 +10,11 @@ import { API_EVENTS } from '../events.js';
 import { User } from '@unchainedshop/core-users';
 import fastifySession from '@fastify/session';
 import fastifyCookie from '@fastify/cookie';
+import fastifyMultipart from '@fastify/multipart';
 import { FastifyBaseLogger, FastifyInstance, FastifyRequest } from 'fastify';
 import { createLogger } from '@unchainedshop/logger';
+import mcpHandler from './mcpHandler.js';
+import tempUploadHandler from './tempUploadHandler.js';
 
 const resolveUserRemoteAddress = (req: FastifyRequest) => {
   const remoteAddress =
@@ -25,8 +28,10 @@ const resolveUserRemoteAddress = (req: FastifyRequest) => {
 };
 
 const {
+  MCP_API_PATH = '/mcp',
   GRAPHQL_API_PATH = '/graphql',
   BULK_IMPORT_API_PATH = '/bulk-import',
+  TEMP_UPLOAD_API_PATH = '/temp-upload',
   ERC_METADATA_API_PATH = '/erc-metadata/:productId/:localeOrTokenFilename/:tokenFileName?',
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
@@ -51,17 +56,16 @@ const middlewareHook = async function middlewareHook(req: any, reply: any) {
     const tokenObject = {
       _id: req.session.sessionId,
       userId: user._id,
-      // eslint-disable-next-line
+
       tokenExpires: new Date((req as any).session.cookie._expires),
     };
     await emit(API_EVENTS.API_LOGIN_TOKEN_CREATED, tokenObject);
-    /* eslint-disable-next-line */
+
     (user as any)._inLoginMethodResponse = true;
     return { user, ...tokenObject };
   };
 
   const logout: LogoutFn = async function logout() {
-    /* eslint-disable-line */
     const tokenObject = {
       _id: (req as any).session.sessionId,
       userId: req.session?.userId,
@@ -113,7 +117,11 @@ export const connect = (
   {
     graphqlHandler,
     db,
-  }: { graphqlHandler: YogaServerInstance<any, any>; db: mongodb.Db; unchainedAPI: UnchainedCore },
+  }: {
+    graphqlHandler: YogaServerInstance<any, any>;
+    db: mongodb.Db;
+    unchainedAPI: UnchainedCore;
+  },
   {
     allowRemoteToLocalhostSecureCookies = false,
   }: { allowRemoteToLocalhostSecureCookies?: boolean } = {},
@@ -124,9 +132,13 @@ export const connect = (
     fastify.addHook('preHandler', async function (request) {
       request.headers['x-forwarded-proto'] = 'https';
     });
-    fastify.addHook('onSend', async function (_, reply) {
+    fastify.addHook('onSend', async function (req, reply) {
       reply.headers({
         'Access-Control-Allow-Private-Network': 'true',
+        'Access-Control-Allow-Origin': req.headers.origin || '*',
+        'Access-Control-Allow-Credentials': 'true',
+        'Access-Control-Allow-Methods': ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'].join(', '),
+        'Access-Control-Allow-Headers': req.headers['access-control-request-headers'] || '*',
       });
     });
   }
@@ -191,6 +203,23 @@ export const connect = (
     handler: ercMetadataHandler,
   });
 
+  fastify.route({
+    url: MCP_API_PATH,
+    method: ['GET', 'POST', 'DELETE'],
+    handler: mcpHandler,
+  });
+
+  fastify.register((s, opts, registered) => {
+    s.register(fastifyMultipart);
+    s.route({
+      url: TEMP_UPLOAD_API_PATH,
+      method: ['POST'],
+      bodyLimit: 1024 * 1024 * 35, // 35MB
+      handler: tempUploadHandler,
+    });
+    registered();
+  });
+
   fastify.register((s, opts, registered) => {
     s.removeAllContentTypeParsers();
     s.addContentTypeParser('*', function (req, payload, done) {

package/src/fastify/mcpHandler.ts

@@ -0,0 +1,97 @@
+import { createLogger } from '@unchainedshop/logger';
+import { Context } from '../context.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import createMcpServer from '../mcp/index.js';
+
+const logger = createLogger('unchained:mcp-handler');
+
+const transports: Record<string, StreamableHTTPServerTransport> = {};
+
+const mcpHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & { unchainedContext: Context },
+  res,
+) => {
+  if (!req.unchainedContext.user) {
+    res.status(401);
+    res.header(
+      'WWW-Authenticate',
+      `Bearer realm="Unchained MCP", error="invalid_token", resource="${process.env.ROOT_URL || 'http://localhost:4010'}",`,
+    );
+    return res.send(
+      JSON.stringify({
+        error: 'invalid_token',
+        resource_metadata: `${process.env.ROOT_URL || 'http://localhost:4010'}/.well-known/oauth-protected-resource`,
+      }),
+    );
+  }
+
+  try {
+    if (req.method === 'POST') {
+      const sessionId = req.headers['mcp-session-id'] as string | undefined;
+
+      let transport: StreamableHTTPServerTransport;
+
+      if (sessionId && transports[sessionId]) {
+        // Reuse existing transport
+        transport = transports[sessionId];
+      } else if (!sessionId && isInitializeRequest(req.body)) {
+        // New initialization request
+        transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => crypto.randomUUID(),
+          onsessioninitialized: (sessionId) => {
+            // Store the transport by session ID
+            transports[sessionId] = transport;
+          },
+        });
+
+        // Clean up transport when closed
+        transport.onclose = () => {
+          if (transport.sessionId) {
+            delete transports[transport.sessionId];
+          }
+        };
+
+        const roles = req.unchainedContext.user.roles || [];
+        const server = createMcpServer(req.unchainedContext, roles);
+        await server.connect(transport);
+      } else {
+        // Invalid request
+        res.status(400);
+        return res.send(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            error: {
+              code: -32000,
+              message: 'Bad Request: No valid session ID provided',
+            },
+            id: null,
+          }),
+        );
+      }
+
+      await transport.handleRequest(req.raw, res.raw, req.body);
+      return res;
+    } else if (req.method === 'GET' || req.method === 'DELETE') {
+      const sessionId = req.headers['mcp-session-id'] as string | undefined;
+      if (!sessionId || !transports[sessionId]) {
+        res.status(400).send('Invalid or missing session ID');
+        return;
+      }
+
+      const transport = transports[sessionId];
+      await transport.handleRequest(req.raw, res.raw);
+      return res;
+    }
+
+    res.status(405);
+    return res.send('Method Not Allowed');
+  } catch (e) {
+    logger.error(e.message);
+    res.status(503);
+    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+  }
+};
+
+export default mcpHandler;

package/src/fastify/tempUploadHandler.ts

@@ -0,0 +1,52 @@
+import { createLogger } from '@unchainedshop/logger';
+import { getFileAdapter } from '@unchainedshop/core-files';
+import { checkAction } from '../acl.js';
+import { actions } from '../roles/index.js';
+import { Context } from '../context.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:temp-upload');
+
+const tempUploadHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & { file: any; unchainedContext: Context },
+  res,
+) => {
+  try {
+    const context = req.unchainedContext;
+
+    await checkAction(context, (actions as any).uploadTempFile);
+
+    const data = await req.file();
+
+    const file = await context.services.files.uploadFileFromStream({
+      directoryName: 'temp-uploads',
+      rawFile: Promise.resolve({
+        filename: data.filename,
+        createReadStream: () => data.file,
+        mimetype: data.mimetype,
+      }),
+      meta: { fieldname: data.fieldname, encoding: data.encoding },
+    });
+
+    // Add an expiration date to this file manually!
+    const expires = new Date(Date.now() + 24 * 60 * 60 * 1000);
+    await context.modules.files.update(file._id, {
+      expires, // Default to 1 hour
+    });
+
+    const fileUploadAdapter = getFileAdapter();
+    const rawUrl = await fileUploadAdapter.createDownloadURL(file);
+    const url = context.modules.files.normalizeUrl(rawUrl, {});
+    const body = JSON.stringify({ fileId: file._id, url, expires: expires.toISOString() });
+    res.status(200);
+    res.header('Content-Length', Buffer.byteLength(body));
+    res.header('Content-Type', 'application/json');
+    return res.send(body);
+  } catch (e) {
+    logger.error(e.message);
+    res.status(503);
+    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+  }
+};
+
+export default tempUploadHandler;

package/src/loaders/assortmentLinkLoader.ts

@@ -0,0 +1,32 @@
+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 }, 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];
+      });
+    },
+  );

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,21 +17,57 @@ 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;
 }
+
+// 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;
+// }

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]);
+  });