@unchainedshop/api 4.0.0-rc.8 → 4.0.0

package/src/express/createERCMetadataMiddleware.ts

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import { createLogger } from '@unchainedshop/logger';
 import { Context } from '../context.js';
 import { Request, RequestHandler } from 'express';
@@ -9,8 +8,7 @@ const { ROOT_URL = 'http://localhost:4010' } = process.env;
 
 const methodWrongHandler = (res) => {
   logger.error('Method not supported, return 404');
-  res.writeHead(404);
-  res.end();
+  res.status(404).end();
   return;
 };
 
@@ -25,16 +23,22 @@ const ercMetadataMiddleware: RequestHandler = async (
 
     const { services, modules, loaders, locale } = req.unchainedContext;
     const url = new URL(req.url, ROOT_URL);
-    const parsedPath = path.parse(url.pathname);
 
-    if (parsedPath.ext !== '.json') throw new Error('Invalid ERC Metadata URI');
+    // Replace path.parse with URL/string methods
+    const pathname = url.pathname;
+    if (!pathname.toLowerCase().endsWith('.json')) throw new Error('Invalid ERC Metadata URI');
+
+    const fileName = pathname.split('/').pop();
+
+    if (!fileName) throw new Error('Invalid ERC Metadata URI');
+    const tokenSerialNumber = fileName.slice(0, fileName.lastIndexOf('.'));
 
     const [, productId, localeOrTokenFilename, tokenFileName] = url.pathname.split('/');
 
     const product = await loaders.productLoader.load({ productId });
 
     const [token] = await modules.warehousing.findTokens({
-      chainTokenId: parsedPath.name,
+      tokenSerialNumber,
       contractAddress: product?.tokenization?.contractAddress,
     });
 
@@ -48,16 +52,12 @@ const ercMetadataMiddleware: RequestHandler = async (
       return methodWrongHandler(res);
     }
 
-    const body = JSON.stringify(ercMetadata);
-    res.writeHead(200, {
-      'Content-Length': Buffer.byteLength(body),
-      'Content-Type': 'text/plain',
-    });
-    res.end(body);
+    res.status(200);
+    return res.send(ercMetadata);
   } catch (e) {
-    logger.error(e.message);
-    res.writeHead(503);
-    res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    logger.error(e);
+    res.status(503);
+    res.send({ name: e.name, code: e.code, message: e.message });
     return;
   }
 };

package/src/express/createMCPMiddleware.ts

@@ -34,7 +34,7 @@ const handlePostRequest: RequestHandler = async (req: Request & { unchainedConte
       }
     };
 
-    const roles = req.unchainedContext.user.roles || [];
+    const roles = req.unchainedContext.user?.roles || [];
     const server = createMcpServer(req.unchainedContext, roles);
     await server.connect(transport);
   } else {

package/src/express/createTempUploadMiddleware.ts

@@ -8,8 +8,7 @@ const logger = createLogger('unchained:temp-upload');
 
 const methodWrongHandler = (res) => {
   logger.error('Method not supported, return 404');
-  res.writeHead(404);
-  res.end();
+  res.status(404).end();
   return;
 };
 
@@ -46,15 +45,12 @@ export default async function tempUploadMiddleware(
 
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
+    if (!rawUrl) throw new Error('Could not create download URL for file');
     const url = context.modules.files.normalizeUrl(rawUrl, {});
-    const body = JSON.stringify({ fileId: file._id, url, expires: expires.toISOString() });
-
-    res.writeHead(200);
-    res.end(body);
+    res.status(200).send({ fileId: file._id, url, expires: expires.toISOString() });
   } catch (e) {
-    logger.error(e.message);
-    res.writeHead(503);
-    res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    logger.error(e);
+    res.status(503).send({ name: e.name, code: e.code, message: e.message });
     return;
   }
 }

package/src/express/index.ts

@@ -16,6 +16,8 @@ import createTempUploadMiddleware from './createTempUploadMiddleware.js';
 import createMCPMiddleware from './createMCPMiddleware.js';
 import { API_EVENTS } from '../events.js';
 
+export * from './chatHandler.js';
+
 const resolveUserRemoteAddress = (req: e.Request) => {
   const remoteAddress =
     (req.headers['x-real-ip'] as string) ||
@@ -39,7 +41,7 @@ const {
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
-  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_SAMESITE = 'none',
   UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 

package/src/fastify/bulkImportHandler.ts

@@ -32,6 +32,11 @@ const bulkImportHandler: RouteHandlerMethod = async (
       chunkSizeBytes: 1024 * 1024 * 5, // 5MB chunks
     });
 
+    const validationStream = await context.services.files.createDownloadStream({ fileId: file._id });
+    if (!validationStream) throw new Error('Could not create download stream from uploaded file');
+
+    await context.bulkImporter.validateEventStream(validationStream);
+
     input.payloadId = file._id;
     input.payloadSize = file.size;
 
@@ -44,15 +49,12 @@ const bulkImportHandler: RouteHandlerMethod = async (
       priority: 10,
     });
 
-    const body = JSON.stringify(work);
     res.status(200);
-    res.header('Content-Length', Buffer.byteLength(body));
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send(work);
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/fastify/chatHandler.ts

@@ -0,0 +1,198 @@
+import { FastifyInstance, RouteHandlerMethod, FastifyRequest } from 'fastify';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import {
+  convertToModelMessages,
+  experimental_createMCPClient as createMCPClient,
+  MCPTransport,
+  stepCountIs,
+  streamText,
+  ToolSet,
+} from 'ai';
+import generateImageHandler from '../chat/generateImageHandler.js';
+import defaultSystemPrompt from '../chat/defaultSystemPrompt.js';
+import normalizeToolsIndex from '../chat/normalizeToolsIndex.js';
+import { ChatConfiguration, errorHandler } from '../chat/utils.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api:chat');
+
+const setupMCPChatHandler = (chatConfiguration: ChatConfiguration & any) => {
+  if (!chatConfiguration?.model) {
+    throw new Error('Model is required');
+  }
+
+  const {
+    tools: additionalTools = {},
+    unchainedMCPUrl = `${process.env.ROOT_URL}/mcp`,
+    imageGenerationTool,
+    ...restChatConfig
+  } = chatConfiguration;
+
+  const system = chatConfiguration.system ?? defaultSystemPrompt;
+
+  const mcpChatHandler: RouteHandlerMethod = async (req: FastifyRequest, res) => {
+    let client;
+    try {
+      if (req.method === 'OPTIONS') {
+        res.headers({
+          'access-control-allow-credentials': 'true',
+          'access-control-allow-private-network': 'true',
+        });
+        return res.status(200).send();
+      }
+
+      const resourceTransport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
+          },
+        },
+      });
+
+      const sdkClient = new Client(
+        { name: 'unchained-chat-client', version: '1.0.0' },
+        {
+          capabilities: { resources: {} },
+        },
+      );
+      await sdkClient.connect(resourceTransport as any);
+
+      const transport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
+          },
+        },
+      });
+
+      client = await createMCPClient({
+        transport: transport as MCPTransport,
+      });
+
+      const defaultUnchainedTools = await client.tools();
+
+      let resourceContext = '';
+      try {
+        const resources = await sdkClient.listResources();
+        if (resources?.resources) {
+          const resourceTexts = await Promise.all(
+            resources.resources.map(async (resource) => {
+              try {
+                const content = await sdkClient.readResource({ uri: resource.uri });
+                if (content?.contents?.[0]?.text) {
+                  return `${resource.name}:\n${content.contents[0].text}`;
+                }
+              } catch (e) {
+                logger.error(`Failed to read resource ${resource.uri}:`, e);
+              }
+              return null;
+            }),
+          );
+          resourceContext =
+            '\n\nAVAILABLE SHOP CONFIGURATION:\n' + resourceTexts.filter(Boolean).join('\n\n');
+        }
+      } catch (e) {
+        logger.error('Failed to fetch MCP resources:', e);
+      }
+
+      const tools: ToolSet = {
+        ...defaultUnchainedTools,
+        ...additionalTools,
+      };
+      if (imageGenerationTool) {
+        tools.generateImage = generateImageHandler(req)(imageGenerationTool) as any;
+      }
+
+      if (req.method === 'GET') {
+        return res.status(200).send({
+          tools: normalizeToolsIndex(tools),
+          cached: false,
+        });
+      }
+
+      const { messages } = req.body as any;
+
+      const cacheControlledTools = { ...tools };
+      const keys = Object.keys(cacheControlledTools);
+      const lastKey = keys[keys.length - 1];
+
+      cacheControlledTools[lastKey] = {
+        ...cacheControlledTools[lastKey],
+        providerOptions: {
+          anthropic: { cacheControl: { type: 'ephemeral' } },
+        },
+      };
+
+      const normalizedMessages = convertToModelMessages(messages, { tools: cacheControlledTools });
+
+      if (normalizedMessages.length > 0) {
+        const lastIndex = normalizedMessages.length - 1;
+        normalizedMessages[lastIndex] = {
+          ...normalizedMessages[lastIndex],
+          providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } } },
+        };
+      }
+
+      const MAX_MESSAGES = 10;
+      let startIndex = Math.max(0, normalizedMessages.length - MAX_MESSAGES);
+      while (startIndex < normalizedMessages.length) {
+        const msg = normalizedMessages[startIndex];
+        const hasOrphanedToolResult =
+          Array.isArray(msg.content) && msg.content.some((c: any) => c.type === 'tool-result');
+
+        if (!hasOrphanedToolResult) break;
+        startIndex++;
+      }
+      const messagesToInclude = normalizedMessages.slice(startIndex);
+
+      const result = streamText({
+        stopWhen: stepCountIs(500),
+        temperature: 0.2,
+        maxRetries: 3,
+        ...restChatConfig,
+        messages: messagesToInclude,
+        system: system + resourceContext,
+        tools: cacheControlledTools,
+        onFinish: async () => {
+          await client?.close();
+        },
+        providerOptions: {
+          anthropic: {
+            cacheControl: {
+              type: 'ephemeral',
+            },
+          },
+        },
+      });
+
+      return res.send(
+        result.toUIMessageStreamResponse({
+          onError: errorHandler,
+        }),
+      );
+    } catch (err: any) {
+      logger.error(err);
+      await client?.close();
+      res.status(500);
+      return res.send({ error: errorHandler(err) });
+    }
+  };
+  return mcpChatHandler;
+};
+
+export const connectChat = (app: FastifyInstance, chatConfiguration: ChatConfiguration) => {
+  const handler = setupMCPChatHandler(chatConfiguration);
+
+  app.route({
+    url: '/chat',
+    method: ['POST', 'OPTIONS'],
+    handler,
+  });
+
+  app.route({
+    url: '/chat/tools',
+    method: ['GET', 'OPTIONS'],
+    handler,
+  });
+};

package/src/fastify/ercMetadataHandler.ts

@@ -27,7 +27,7 @@ const ercMetadataHandler: RouteHandlerMethod = async (
     const product = await loaders.productLoader.load({ productId });
 
     const [token] = await modules.warehousing.findTokens({
-      chainTokenId: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
+      tokenSerialNumber: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
       contractAddress: product?.tokenization?.contractAddress,
     });
 
@@ -39,15 +39,12 @@ const ercMetadataHandler: RouteHandlerMethod = async (
 
     if (!ercMetadata) return notFoundHandler(res);
 
-    const body = JSON.stringify(ercMetadata);
     res.status(200);
-    res.header('Content-Length', Buffer.byteLength(body));
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send(ercMetadata);
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/fastify/index.ts

@@ -11,10 +11,12 @@ 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 { FastifyBaseLogger, FastifyInstance, FastifyPluginAsync, FastifyRequest } from 'fastify';
 import { createLogger } from '@unchainedshop/logger';
 import mcpHandler from './mcpHandler.js';
 import tempUploadHandler from './tempUploadHandler.js';
+import fastifyStatic from '@fastify/static';
+export * from './chatHandler.js';
 
 const resolveUserRemoteAddress = (req: FastifyRequest) => {
   const remoteAddress =
@@ -36,7 +38,7 @@ const {
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
-  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_SAMESITE = 'none',
   UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 
@@ -158,7 +160,7 @@ export const connect = (
   if (!fastify.hasPlugin('@fastify/cookie')) {
     fastify.register(fastifyCookie);
   }
-  fastify.register(fastifySession, {
+  fastify.register(fastifySession as any, {
     secret: process.env.UNCHAINED_TOKEN_SECRET,
     cookieName,
     store: MongoStore.create({
@@ -210,7 +212,7 @@ export const connect = (
   });
 
   fastify.register((s, opts, registered) => {
-    s.register(fastifyMultipart);
+    s.register(fastifyMultipart, { throwFileSizeLimit: true, limits: { fileSize: 1024 * 1024 * 35 } }); // 35MB
     s.route({
       url: TEMP_UPLOAD_API_PATH,
       method: ['POST'],
@@ -234,3 +236,37 @@ export const connect = (
     registered();
   });
 };
+
+interface FastifyRouterOptions {
+  prefix?: string;
+}
+
+export const fastifyRouter: FastifyPluginAsync<FastifyRouterOptions> = async (
+  fastify: FastifyInstance,
+  opts,
+) => {
+  try {
+    const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+    const staticPath = new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+
+    await fastify.register(fastifyStatic, {
+      root: staticPath,
+      prefix: opts.prefix || '/',
+    });
+
+    fastify.setNotFoundHandler((request, reply) => {
+      if (request.raw.method === 'GET') {
+        return reply.type('text/html').sendFile('index.html');
+      } else {
+        return reply.status(404).send();
+      }
+    });
+  } catch {
+    if (process.env.NODE_ENV !== 'production') {
+      // Trying the default admin ui dev port
+      fastify.get('/', async (request, reply) => {
+        return reply.redirect('http://localhost:3000');
+      });
+    }
+  }
+};

package/src/fastify/mcpHandler.ts

@@ -58,8 +58,7 @@ const mcpHandler: RouteHandlerMethod = async (
         await server.connect(transport);
       } else {
         // Invalid request
-        res.status(400);
-        return res.send(
+        return res.status(400).send(
           JSON.stringify({
             jsonrpc: '2.0',
             error: {
@@ -76,8 +75,7 @@ const mcpHandler: RouteHandlerMethod = async (
     } 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;
+        return res.status(400).send('Invalid or missing session ID');
       }
 
       const transport = transports[sessionId];
@@ -85,12 +83,10 @@ const mcpHandler: RouteHandlerMethod = async (
       return res;
     }
 
-    res.status(405);
-    return res.send('Method Not Allowed');
+    return res.status(405).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 }));
+    logger.error(e);
+    return res.status(503).send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/fastify/tempUploadHandler.ts

@@ -36,16 +36,14 @@ const tempUploadHandler: RouteHandlerMethod = async (
 
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
+    if (!rawUrl) throw new Error('Could not create download URL for 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);
+    return res.send({ fileId: file._id, url, expires: expires.toISOString() });
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

package/src/loaders/assortmentLinksLoader.ts

@@ -7,9 +7,9 @@ export default (unchainedAPI: UnchainedCore) =>
     { 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 parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean) as string[];
+    const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean) as string[];
+    const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean) as string[];
 
     const allLinks = await unchainedAPI.modules.assortments.links.findLinks({
       assortmentIds: [...new Set([...parentAssortmentIds, ...childAssortmentIds, ...assortmentIds])],
@@ -38,9 +38,12 @@ export default (unchainedAPI: UnchainedCore) =>
       } else if (q.childAssortmentId) {
         return childAssortmentLinkMap[q.childAssortmentId] || [];
       }
-      return [
-        ...(parentAssortmentLinkMap[q.assortmentId] || []),
-        ...(childAssortmentLinkMap[q.assortmentId] || []),
-      ];
+      if (q.assortmentId) {
+        return [
+          ...(parentAssortmentLinkMap[q.assortmentId] || []),
+          ...(childAssortmentLinkMap[q.assortmentId] || []),
+        ];
+      }
+      return [];
     });
   });

package/src/loaders/assortmentMediasLoader.ts

@@ -3,7 +3,7 @@ import { AssortmentMediaType } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>(async (queries) => {
+  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 },

package/src/loaders/buildLocaleMap.ts

@@ -35,39 +35,3 @@ export default function buildLocaleMap(
   }
   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/filterTextLoader.ts

@@ -5,22 +5,23 @@ 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))];
+  new DataLoader<
+    { filterId: string; filterOptionValue?: string | null; 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 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);
+    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]);
-    },
-  );
+    return queries.map((q) => textsMap[q.locale + q.filterId + q.filterOptionValue]);
+  });

package/src/loaders/productMediasLoader.ts

@@ -3,7 +3,7 @@ import { ProductMedia } from '@unchainedshop/core-products';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ productId?: string }, ProductMedia[]>(async (queries) => {
+  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 },

package/src/loaders/productProxiesLoader.ts

@@ -3,7 +3,7 @@ import { Product } from '@unchainedshop/core-products';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ productId?: string }, Product[]>(async (queries) => {
+  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({

package/src/loaders/utils.ts

@@ -21,7 +21,7 @@ export function buildLocaleMap(
     Object.fromEntries(queries.map((q) => [q.locale.baseName, q.locale])),
   );
 
-  const textLocales: string[] = [...new Set(texts.map((t) => t.locale))];
+  const textLocales = [...new Set(texts.map((t) => t.locale))].filter(Boolean) as string[];
   const localeMap = {};
   for (const queryLocale of queryLocales) {
     const potentialMatches = getLocaleStrings(queryLocale);