@unchainedshop/api 4.0.0-rc.2 → 4.0.0-rc.3

package/src/express/createTempUploadMiddleware.ts

@@ -0,0 +1,60 @@
+import { createLogger } from '@unchainedshop/logger';
+import { checkAction } from '../acl.js';
+import { actions } from '../roles/index.js';
+import { Context } from '../context.js';
+import { getFileAdapter } from '@unchainedshop/core-files';
+
+const logger = createLogger('unchained:temp-upload');
+
+const methodWrongHandler = (res) => {
+  logger.error('Method not supported, return 404');
+  res.writeHead(404);
+  res.end();
+  return;
+};
+
+export default async function tempUploadMiddleware(
+  req: Request & { query?: any; files: any; unchainedContext: Context },
+  res,
+) {
+  try {
+    const context = req.unchainedContext;
+
+    if (req.method !== 'POST') {
+      return methodWrongHandler(res);
+    }
+
+    await checkAction(context, (actions as any).uploadTempFile);
+
+    const [data] = req.files || [];
+
+    const file = await context.services.files.uploadFileFromStream({
+      directoryName: 'temp-uploads',
+      rawFile: {
+        filename: data.originalname,
+        buffer: data.buffer,
+        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.writeHead(200);
+    res.end(body);
+  } catch (e) {
+    logger.error(e.message);
+    res.writeHead(503);
+    res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return;
+  }
+}

package/src/express/index.ts

@@ -1,17 +1,21 @@
 import e from 'express';
-import { getCurrentContextResolver, LoginFn, LogoutFn } from '../context.js';
-import createBulkImportMiddleware from './createBulkImportMiddleware.js';
-import createERCMetadataMiddleware from './createERCMetadataMiddleware.js';
 import session from 'express-session';
+import multer from 'multer';
 import MongoStore from 'connect-mongo';
 import { Passport } from 'passport';
 import { YogaServerInstance } from 'graphql-yoga';
 import { mongodb } from '@unchainedshop/mongodb';
 import { UnchainedCore } from '@unchainedshop/core';
 import { emit } from '@unchainedshop/events';
-import { API_EVENTS } from '../events.js';
 import { User } from '@unchainedshop/core-users';
 
+import { getCurrentContextResolver, LoginFn, LogoutFn } from '../context.js';
+import createBulkImportMiddleware from './createBulkImportMiddleware.js';
+import createERCMetadataMiddleware from './createERCMetadataMiddleware.js';
+import createTempUploadMiddleware from './createTempUploadMiddleware.js';
+import createMCPMiddleware from './createMCPMiddleware.js';
+import { API_EVENTS } from '../events.js';
+
 const resolveUserRemoteAddress = (req: e.Request) => {
   const remoteAddress =
     (req.headers['x-real-ip'] as string) ||
@@ -23,9 +27,14 @@ const resolveUserRemoteAddress = (req: e.Request) => {
   return { remoteAddress, remotePort };
 };
 
+const storage = multer.memoryStorage();
+const upload = multer({ storage: storage });
+
 const {
   BULK_IMPORT_API_PATH = '/bulk-import',
   ERC_METADATA_API_PATH = '/erc-metadata',
+  TEMP_UPLOAD_API_PATH = '/temp-upload',
+  MCP_API_PATH = '/mcp',
   GRAPHQL_API_PATH = '/graphql',
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
@@ -126,10 +135,16 @@ 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 } = {},
+  }: {
+    allowRemoteToLocalhostSecureCookies?: boolean;
+  } = {},
 ) => {
   if (allowRemoteToLocalhostSecureCookies) {
     // Workaround: Allow to use sandbox with localhost
@@ -137,6 +152,16 @@ export const connect = (
     expressApp.use((req, res, next) => {
       req.headers['x-forwarded-proto'] = 'https';
       res.setHeader('Access-Control-Allow-Private-Network', 'true');
+      res.setHeader('Access-Control-Allow-Origin', req.headers.origin || '*');
+      res.setHeader('Access-Control-Allow-Credentials', 'true');
+      res.setHeader(
+        'Access-Control-Allow-Methods',
+        ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'].join(', '),
+      );
+      res.setHeader(
+        'Access-Control-Allow-Headers',
+        req.headers['access-control-request-headers'] || '*',
+      );
       next();
     });
   }
@@ -189,4 +214,8 @@ export const connect = (
   expressApp.use(GRAPHQL_API_PATH, graphqlHandler.handle);
   expressApp.use(ERC_METADATA_API_PATH, createERCMetadataMiddleware);
   expressApp.use(BULK_IMPORT_API_PATH, createBulkImportMiddleware);
+  expressApp.use(TEMP_UPLOAD_API_PATH, upload.any(), createTempUploadMiddleware);
+
+  expressApp.use(MCP_API_PATH, e.json({ limit: '10mb' }));
+  expressApp.use(MCP_API_PATH, createMCPMiddleware);
 };

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 = '/',
@@ -112,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 } = {},
@@ -123,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'] || '*',
       });
     });
   }
@@ -190,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/assortmentMediaTextLoader.ts

@@ -1,8 +1,8 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import { AssortmentMediaText } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
   new DataLoader<{ assortmentMediaId: string; locale: Intl.Locale }, AssortmentMediaText>(

package/src/loaders/assortmentTextLoader.ts

@@ -1,8 +1,8 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import { AssortmentText } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import buildTextMap from './buildTextMap.js';
+import buildLocaleMap from './buildLocaleMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
   new DataLoader<{ assortmentId: string; locale: Intl.Locale }, AssortmentText>(async (queries) => {

package/src/loaders/buildLocaleMap.test.ts

@@ -0,0 +1,65 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import buildLocaleMap from './buildLocaleMap.js';
+
+const testTexts = [
+  // 1 has translations in French and German
+  { locale: 'fr', _id: '1', entityId: '1' },
+  { locale: 'de', _id: '2', entityId: '1' },
+
+  // 2 only has Ialien translations
+  { locale: 'it', _id: '3', entityId: '2' },
+
+  // 3 only has English translations
+  { locale: 'en', _id: '4', entityId: '3' },
+
+  // 4 only has German translations
+  { locale: 'de', _id: '5', entityId: '4' },
+];
+
+describe('buildLocaleMap', () => {
+  it('Mixed usage of default locale and forced languages', () => {
+    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'],
+      it: ['it'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it('Mixed usage of forced languages', () => {
+    const queries = [{ locale: new Intl.Locale('fr') }, { locale: new Intl.Locale('it') }];
+    const expected = {
+      de: ['fr', 'it'],
+      fr: ['fr'],
+      it: ['it'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it('Only default locale', () => {
+    const queries = [{ locale: new Intl.Locale('de-CH') }];
+    const expected = {
+      de: ['de-CH'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+
+  it('Only one forced language locale', () => {
+    const queries = [{ locale: new Intl.Locale('fr') }];
+    const expected = {
+      fr: ['fr'],
+      de: ['fr'],
+    };
+    const result = buildLocaleMap(queries, testTexts);
+    assert.deepStrictEqual(result, expected);
+  });
+});

package/src/loaders/buildLocaleMap.ts

@@ -0,0 +1,73 @@
+import { systemLocale } from '@unchainedshop/utils';
+
+function getLocaleStrings(locale: Intl.Locale): string[] {
+  try {
+    const locales = new Set<string>();
+    locales.add(locale.baseName);
+    locales.add(locale.language);
+    locales.add(systemLocale.baseName);
+    locales.add(systemLocale.language);
+    return Array.from(locales);
+  } catch {
+    // Optimized Set creation and spread
+    const locales = new Set<string>();
+    locales.add(systemLocale.baseName);
+    locales.add(systemLocale.language);
+    return Array.from(locales);
+  }
+}
+export default function buildLocaleMap(
+  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: 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.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.test.ts

@@ -0,0 +1,54 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import buildTextMap from './buildTextMap.js';
+
+const testTexts = [
+  // 1 has translations in French and German
+  { locale: 'fr', _id: 'french-1', entityId: '1' },
+  { locale: 'de', _id: 'german-1', entityId: '1' },
+
+  // 2 only has Ialien translations
+  { locale: 'it', _id: 'italian-2', entityId: '2' },
+
+  // 3 only has English translations
+  { locale: 'en', _id: 'english-3', entityId: '3' },
+
+  // 4 only has German translations
+  { locale: 'de', _id: 'german-4', entityId: '4' },
+];
+
+describe('buildTextMap', () => {
+  it('Generate a correct text map for all fallbacks', () => {
+    const localeMap = {
+      de: ['de-CH', 'fr', 'it'],
+      fr: ['fr'],
+      it: ['it'],
+    };
+    const expected = {
+      'de-CH1': {
+        _id: 'german-1',
+      },
+      fr1: {
+        _id: 'french-1',
+      },
+      it1: {
+        _id: 'german-1',
+      },
+      'de-CH4': {
+        _id: 'german-4',
+      },
+      fr4: {
+        _id: 'german-4',
+      },
+      it4: {
+        _id: 'german-4',
+      },
+      it2: {
+        _id: 'italian-2',
+      },
+    };
+    const result = buildTextMap(localeMap, testTexts, (text) => text.entityId);
+
+    assert.partialDeepStrictEqual(result, expected);
+  });
+});

package/src/loaders/buildTextMap.ts

@@ -1,17 +1,36 @@
 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 { locale?: string }[]>(
   localeMap: Record<string, string[]>,
   texts: Readonly<T>,
   buildId: (item: ArrayElement<T>) => string,
 ) {
-  const textsMap = {};
-  for (const [originLocale, localesForText] of Object.entries(localeMap)) {
-    for (const text of texts) {
+  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;
-      for (const locale of localesForText) {
-        if (textsMap[locale + buildId(text as any)]) continue;
-        textsMap[locale + buildId(text as any)] = text;
+
+      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;
+        if (textsMap[key] && locale !== text.locale) {
+          // If the key already exists and the locale is a fallback, skip this text
+          continue;
+        }
+        textsMap[key] = text as ArrayElement<T>; // Ensured correct type for assignment
       }
     }
   }

package/src/loaders/filterTextLoader.ts

@@ -1,6 +1,6 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
+import buildLocaleMap from './buildLocaleMap.js';
 import { FilterText } from '@unchainedshop/core-filters';
 import buildTextMap from './buildTextMap.js';
 

package/src/loaders/productMediaTextLoader.ts

@@ -1,7 +1,7 @@
 import { UnchainedCore } from '@unchainedshop/core';
 import DataLoader from 'dataloader';
-import { buildLocaleMap } from './utils.js';
 import { ProductMediaText } from '@unchainedshop/core-products';
+import buildLocaleMap from './buildLocaleMap.js';
 import buildTextMap from './buildTextMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>

package/src/loaders/productTextLoader.ts

@@ -1,8 +1,8 @@
 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';
+import buildLocaleMap from './buildLocaleMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
   new DataLoader<{ productId: string; locale: Intl.Locale }, ProductText>(async (queries) => {