@unchainedshop/api 5.0.0-alpha.2 → 5.0.0-alpha.4

package/lib/fastify/chatHandler.js

@@ -1,89 +1,69 @@
 import generateImageHandler from "../chat/generateImageHandler.js";
 import defaultSystemPrompt from "../chat/defaultSystemPrompt.js";
 import normalizeToolsIndex from "../chat/normalizeToolsIndex.js";
-import { errorHandler } from "../chat/utils.js";
+import { chatErrorStatus, createChatRequestLifecycle, errorHandler, logOptionalPeerLoadError, } from "../chat/utils.js";
+import { buildChatResourceContext } from "../mcp/resources/localization.js";
 import { createLogger } from '@unchainedshop/logger';
 const logger = createLogger('unchained:api:chat');
 let convertToModelMessages;
 let stepCountIs;
 let streamText;
 let createMCPClient;
-let StreamableHTTPClientTransport;
-let Client;
 try {
     const aiTools = await import('ai');
-    const mcpTools = await import('@ai-sdk/mcp');
-    const mcpSDKClientLibrary = await import('@modelcontextprotocol/sdk/client/streamableHttp.js');
-    const mcpSDKClient = await import('@modelcontextprotocol/sdk/client/index.js');
-    StreamableHTTPClientTransport = mcpSDKClientLibrary.StreamableHTTPClientTransport;
-    Client = mcpSDKClient.Client;
     convertToModelMessages = aiTools.convertToModelMessages;
     stepCountIs = aiTools.stepCountIs;
     streamText = aiTools.streamText;
+}
+catch (error) {
+    logOptionalPeerLoadError('ai', error);
+}
+try {
+    const mcpTools = await import('@ai-sdk/mcp');
     createMCPClient = mcpTools.createMCPClient;
 }
-catch {
-    logger.warn(`optional peer npm packages 'ai' and '@ai-sdk/mcp' not installed, chat will not work`);
+catch (error) {
+    logOptionalPeerLoadError('@ai-sdk/mcp', error);
 }
 const setupMCPChatHandler = (chatConfiguration) => {
     if (!chatConfiguration?.model) {
         throw new Error('Model is required');
     }
-    const { tools: additionalTools = {}, unchainedMCPUrl = `${process.env.ROOT_URL}/mcp`, imageGenerationTool, ...restChatConfig } = chatConfiguration;
+    const { tools: additionalTools = {}, unchainedMCPUrl = `${process.env.ROOT_URL}/mcp`, model, imageGenerationTool, abortSignal: configuredAbortSignal, onAbort: configuredOnAbort, onEnd: configuredOnEnd, onFinish: configuredOnFinish, ...restChatConfig } = chatConfiguration;
     const system = chatConfiguration.system ?? defaultSystemPrompt;
     const mcpChatHandler = async (req, res) => {
+        if (req.method === 'OPTIONS') {
+            res.headers({
+                'access-control-allow-credentials': 'true',
+                'access-control-allow-private-network': 'true',
+            });
+            return res.status(200).send();
+        }
+        const unchainedContext = req.unchainedContext;
+        const user = unchainedContext?.user;
+        if (!user) {
+            return res.status(401).send({ error: 'unauthorized' });
+        }
+        if (!(user.roles || []).includes('admin')) {
+            return res.status(403).send({ error: 'forbidden', message: 'Chat requires admin privileges' });
+        }
         let client;
+        const lifecycle = createChatRequestLifecycle(res.raw, configuredAbortSignal);
         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' });
-            await sdkClient.connect(resourceTransport);
-            const transport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
-                requestInit: {
+            client = await createMCPClient({
+                transport: {
+                    type: 'http',
+                    url: unchainedMCPUrl,
                     headers: {
                         Cookie: req.headers.cookie || '',
+                        ...(req.headers.authorization ? { Authorization: req.headers.authorization } : {}),
                     },
                 },
+                initializationOptions: { signal: lifecycle.signal },
             });
-            client = await createMCPClient({
-                transport,
-            });
+            lifecycle.setClientClose(() => client.close());
             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.message}`);
-                        }
-                        return null;
-                    }));
-                    resourceContext =
-                        '\n\nAVAILABLE SHOP CONFIGURATION:\n' + resourceTexts.filter(Boolean).join('\n\n');
-                }
-            }
-            catch (e) {
-                logger.error(`Failed to fetch MCP resources: ${e.message}`);
-            }
+            const resourceContext = await buildChatResourceContext(unchainedContext);
             const tools = {
                 ...defaultUnchainedTools,
                 ...additionalTools,
@@ -92,6 +72,7 @@ const setupMCPChatHandler = (chatConfiguration) => {
                 tools.generateImage = generateImageHandler(req)(imageGenerationTool);
             }
             if (req.method === 'GET') {
+                await lifecycle.close();
                 return res.status(200).send({
                     tools: normalizeToolsIndex(tools),
                     cached: false,
@@ -127,14 +108,28 @@ const setupMCPChatHandler = (chatConfiguration) => {
             const messagesToInclude = normalizedMessages.slice(startIndex);
             const result = streamText({
                 stopWhen: stepCountIs(500),
-                temperature: 0.2,
                 maxRetries: 3,
                 ...restChatConfig,
+                abortSignal: lifecycle.signal,
                 messages: messagesToInclude,
                 system: system + resourceContext,
+                model,
                 tools: cacheControlledTools,
-                onFinish: async () => {
-                    await client?.close();
+                onEnd: async (event) => {
+                    try {
+                        await (configuredOnEnd ?? configuredOnFinish)?.(event);
+                    }
+                    finally {
+                        await lifecycle.close();
+                    }
+                },
+                onAbort: async (event) => {
+                    try {
+                        await configuredOnAbort?.(event);
+                    }
+                    finally {
+                        await lifecycle.close();
+                    }
                 },
                 providerOptions: {
                     anthropic: {
@@ -144,21 +139,26 @@ const setupMCPChatHandler = (chatConfiguration) => {
                     },
                 },
             });
+            void result.finishReason.then(undefined, async () => {
+                await lifecycle.close();
+            });
             return res.send(result.toUIMessageStreamResponse({
                 onError: errorHandler,
             }));
         }
         catch (err) {
             logger.error(err);
-            await client?.close();
-            res.status(500);
+            await lifecycle.close();
+            if (lifecycle.signal.aborted || res.raw.destroyed)
+                return res;
+            res.status(chatErrorStatus(err));
             return res.send({ error: errorHandler(err) });
         }
     };
     return mcpChatHandler;
 };
 export const connectChat = (app, chatConfiguration) => {
-    if (!createMCPClient) {
+    if (!createMCPClient || !streamText) {
         logger.warn('Optional dependencies for AI SDK Chat Handler are not installed. Please install @ai-sdk/mcp and ai packages to use this feature.');
         return;
     }

package/lib/fastify/index.d.ts

@@ -4,9 +4,13 @@ import type { UnchainedCore } from '@unchainedshop/core';
 import type { FastifyBaseLogger, FastifyInstance, FastifyPluginAsync } from 'fastify';
 import { connectChat } from './chatHandler.ts';
 import type { ChatConfiguration } from '../chat/utils.ts';
+import { type AdminUIPluginConfig, type AdminUIThemeConfig } from '../adminUiPlugins.ts';
+export type { AdminUIPluginConfig, AdminUIPluginEntityConfig, AdminUIPluginPageConfig, AdminUIPluginTabConfig, AdminUIPluginWidgetConfig, AdminUIPluginSlotConfig, AdminUIThemeTokens, AdminUIThemeConfig, } from '../adminUiPlugins.ts';
 export interface AdminUIRouterOptions {
-    prefix: string;
+    prefix?: string;
     enabled?: boolean;
+    theme?: AdminUIThemeConfig;
+    plugins?: AdminUIPluginConfig[];
 }
 export declare const unchainedLogger: (prefix: string) => FastifyBaseLogger;
 export declare const connect: (fastify: FastifyInstance, { graphqlHandler, unchainedAPI, }: {

package/lib/fastify/index.js

@@ -6,8 +6,11 @@ import { createLogger } from '@unchainedshop/logger';
 import mcpHandler from "./mcpHandler.js";
 import { connectChat } from "./chatHandler.js";
 import { mountRoutes } from "./mountRoutes.js";
-import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { createBackchannelLogoutRoute } from "../handlers/createBackchannelLogoutHandler.js";
+import { preparePluginAssets, resolveAdminUIPath, } from "../adminUiPlugins.js";
 const resolveUserRemoteAddress = (req, trustProxy = false) => {
     let remoteAddress;
     if (trustProxy) {
@@ -120,9 +123,60 @@ export const connect = async (fastify, { graphqlHandler, unchainedAPI, }, { allo
     }
     mountRoutes(fastify, unchainedAPI, routes);
     if (adminUI) {
+        const adminUIOptions = typeof adminUI === 'object' ? adminUI : undefined;
+        const adminUIPlugins = adminUIOptions?.plugins || [];
+        let themePromise;
+        const resolveThemeCSS = async () => {
+            let css = '/* default theme */';
+            if (adminUIOptions?.theme) {
+                try {
+                    const { generateThemeCSS } = await import('@unchainedshop/admin-ui/theme');
+                    css = generateThemeCSS(adminUIOptions.theme);
+                }
+                catch {
+                    fastify.log.warn("npm dependency @unchainedshop/admin-ui is not installed, can't apply admin-ui theme");
+                }
+            }
+            const etag = `"${createHash('sha256').update(css).digest('hex').slice(0, 8)}"`;
+            return { css, etag };
+        };
+        fastify.get('/admin-ui-theme.css', async (request, reply) => {
+            const { css, etag } = await (themePromise ||= resolveThemeCSS());
+            if (request.headers['if-none-match'] === etag) {
+                return reply.code(304).send();
+            }
+            return reply
+                .header('Cache-Control', 'public, max-age=0, must-revalidate')
+                .header('ETag', etag)
+                .type('text/css')
+                .send(css);
+        });
+        const devMode = process.env.NODE_ENV !== 'production';
+        const { routes: pluginRoutes } = preparePluginAssets(adminUIPlugins, fastify.log, {
+            devMode,
+        });
+        for (const [path, asset] of pluginRoutes) {
+            fastify.get(path, async (request, reply) => {
+                if (asset.etag) {
+                    const ifNoneMatch = request.headers['if-none-match'];
+                    if (ifNoneMatch === asset.etag) {
+                        return reply.code(304).send();
+                    }
+                    reply.header('ETag', asset.etag);
+                }
+                const body = typeof asset.content === 'function' ? asset.content() : asset.content;
+                return reply
+                    .header('Cache-Control', asset.cacheControl)
+                    .header('X-Content-Type-Options', 'nosniff')
+                    .header('Access-Control-Allow-Origin', '*')
+                    .type(asset.contentType)
+                    .send(body);
+            });
+        }
         fastify.register(adminUIRouter, {
             enabled: true,
-            prefix: typeof adminUI === 'object' ? adminUI.prefix : '/',
+            prefix: adminUIOptions?.prefix || '/',
+            plugins: adminUIPlugins,
         });
     }
 };
@@ -142,15 +196,6 @@ const fallbackLandingPageHandler = (request, reply) => {
         return reply.status(404).send();
     }
 };
-const resolveAdminUIPath = () => {
-    try {
-        const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
-        return new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
-    }
-    catch {
-        return null;
-    }
-};
 export const adminUIRouter = async (fastify, opts) => {
     try {
         let fastifyStatic;
@@ -164,9 +209,23 @@ export const adminUIRouter = async (fastify, opts) => {
         if (fastifyStatic) {
             const adminUIPath = resolveAdminUIPath();
             if (adminUIPath) {
+                const indexHtml = readFileSync(join(adminUIPath, 'index.html'), 'utf-8');
+                const extHtmlPath = join(adminUIPath, 'ext', '[[...slug]]', 'index.html');
+                const extHtml = existsSync(extHtmlPath) ? readFileSync(extHtmlPath, 'utf-8') : null;
                 await fastify.register(fastifyStatic, {
                     root: adminUIPath,
                     prefix: opts.prefix || '/',
+                    wildcard: false,
+                });
+                fastify.setNotFoundHandler(async (request, reply) => {
+                    if (request.method === 'GET' && !request.url.includes('.')) {
+                        const urlPath = request.url.split('?')[0].replace(/\/+$/, '');
+                        if (extHtml && (urlPath === '/ext' || urlPath.startsWith('/ext/'))) {
+                            return reply.type('text/html').send(extHtml);
+                        }
+                        return reply.type('text/html').send(indexHtml);
+                    }
+                    return reply.code(404).send({ error: 'Not Found' });
                 });
                 return;
             }

package/lib/fastify/mcpHandler.js

@@ -1,83 +1,32 @@
-import initMCPServer from "../mcp/index.js";
+import { Readable } from 'node:stream';
 import { createLogger } from '@unchainedshop/logger';
+import handleMcpHttpRequest from "../mcp/handleMcpHttpRequest.js";
+import { toWebRequest } from "../mcp/nodeHttpBridge.js";
 const logger = createLogger('unchained:api:mcp');
-let StreamableHTTPServerTransport;
-let isInitializeRequest;
-let McpServer;
-try {
-    const mcpSDKServerLibrary = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
-    const mcpSDKClient = await import('@modelcontextprotocol/sdk/types.js');
-    const mcpSDKServer = await import('@modelcontextprotocol/sdk/server/mcp.js');
-    StreamableHTTPServerTransport = mcpSDKServerLibrary.StreamableHTTPServerTransport;
-    isInitializeRequest = mcpSDKClient.isInitializeRequest;
-    McpServer = mcpSDKServer.McpServer;
-}
-catch {
-    logger.warn(`optional peer npm package '@modelcontextprotocol/sdk' not installed, mcp will not work`);
-}
-const transports = {};
 const mcpHandler = async (req, 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'];
-            let transport;
-            if (sessionId && transports[sessionId]) {
-                transport = transports[sessionId];
-            }
-            else if (!sessionId && isInitializeRequest(req.body)) {
-                transport = new StreamableHTTPServerTransport({
-                    sessionIdGenerator: () => crypto.randomUUID(),
-                    onsessioninitialized: (sessionId) => {
-                        transports[sessionId] = transport;
-                    },
-                });
-                transport.onclose = () => {
-                    if (transport.sessionId) {
-                        delete transports[transport.sessionId];
-                    }
-                };
-                const roles = req.unchainedContext.user.roles || [];
-                const server = initMCPServer(new McpServer({
-                    name: 'Unchained MCP Server',
-                    version: '1.0.0',
-                }), req.unchainedContext, roles);
-                await server.connect(transport);
-            }
-            else {
-                return res.status(400).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'];
-            if (!sessionId || !transports[sessionId]) {
-                return res.status(400).send('Invalid or missing session ID');
-            }
-            const transport = transports[sessionId];
-            await transport.handleRequest(req.raw, res.raw);
-            return res;
-        }
-        return res.status(405).send('Method Not Allowed');
+        const bodyText = req.method === 'POST' && req.body !== undefined ? JSON.stringify(req.body) : undefined;
+        const response = await handleMcpHttpRequest(req.unchainedContext, toWebRequest(req.raw, res.raw, bodyText), req.method === 'POST' ? req.body : undefined);
+        res.status(response.status);
+        response.headers.forEach((value, key) => {
+            if (key === 'set-cookie')
+                return;
+            res.header(key, value);
+        });
+        const setCookie = response.headers.getSetCookie();
+        if (setCookie.length)
+            res.header('set-cookie', setCookie);
+        if (!response.body)
+            return res.send();
+        return res.send(Readable.fromWeb(response.body));
     }
-    catch (e) {
-        logger.error(e);
-        return res.status(503).send({ name: e.name, code: e.code, message: e.message });
+    catch (error) {
+        logger.error(error);
+        if (!res.sent) {
+            return res.status(500).send({ error: 'Internal Server Error' });
+        }
+        res.raw.destroy();
+        return res;
     }
 };
 export default mcpHandler;

package/lib/loaders/assortmentLinksLoader.js

@@ -1,38 +1,40 @@
 import DataLoader from 'dataloader';
 export default (unchainedAPI) => new DataLoader(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 = [
+        ...new Set(queries.flatMap((q) => q.parentAssortmentId).filter(Boolean)),
+    ];
+    const childAssortmentIds = [
+        ...new Set(queries.flatMap((q) => q.childAssortmentId).filter(Boolean)),
+    ];
+    const assortmentIds = [
+        ...new Set(queries.flatMap((q) => q.assortmentId).filter(Boolean)),
+    ];
     const allLinks = await unchainedAPI.modules.assortments.links.findLinks({
-        assortmentIds: [...new Set([...parentAssortmentIds, ...childAssortmentIds, ...assortmentIds])],
+        ...(parentAssortmentIds.length ? { parentAssortmentIds } : {}),
+        ...(childAssortmentIds.length ? { childAssortmentIds } : {}),
+        ...(assortmentIds.length ? { assortmentIds } : {}),
     });
-    const parentAssortmentLinkMap = {};
-    const childAssortmentLinkMap = {};
+    const parentAssortmentLinkMap = new Map();
+    const childAssortmentLinkMap = new Map();
     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);
-        }
+        const parentLinks = parentAssortmentLinkMap.get(link.parentAssortmentId) || [];
+        parentLinks.push(link);
+        parentAssortmentLinkMap.set(link.parentAssortmentId, parentLinks);
+        const childLinks = childAssortmentLinkMap.get(link.childAssortmentId) || [];
+        childLinks.push(link);
+        childAssortmentLinkMap.set(link.childAssortmentId, childLinks);
     }
     return queries.map((q) => {
         if (q.parentAssortmentId) {
-            return parentAssortmentLinkMap[q.parentAssortmentId] || [];
+            return parentAssortmentLinkMap.get(q.parentAssortmentId) || [];
         }
         else if (q.childAssortmentId) {
-            return childAssortmentLinkMap[q.childAssortmentId] || [];
+            return childAssortmentLinkMap.get(q.childAssortmentId) || [];
         }
         if (q.assortmentId) {
             return [
-                ...(parentAssortmentLinkMap[q.assortmentId] || []),
-                ...(childAssortmentLinkMap[q.assortmentId] || []),
+                ...(parentAssortmentLinkMap.get(q.assortmentId) || []),
+                ...(childAssortmentLinkMap.get(q.assortmentId) || []),
             ];
         }
         return [];

package/lib/loaders/assortmentMediaTextLoader.js

@@ -6,6 +6,7 @@ export default (unchainedAPI) => new DataLoader(async (queries) => {
     const texts = await unchainedAPI.modules.assortments.media.texts.findMediaTexts({ assortmentMediaIds }, {
         sort: {
             assortmentMediaId: 1,
+            _id: 1,
         },
     });
     const localeMap = buildLocaleMap(queries, texts);

package/lib/loaders/assortmentProductLoader.js

@@ -1,13 +1,16 @@
 import DataLoader from 'dataloader';
 export default (unchainedAPI) => new DataLoader(async (queries) => {
     const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
+    const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
     const assortmentProducts = await unchainedAPI.modules.assortments.products.findAssortmentProducts({
         assortmentIds,
+        productIds,
     });
-    const assortmentProductMap = {};
+    const assortmentProductMap = new Map();
     for (const assortmentProduct of assortmentProducts) {
-        assortmentProductMap[assortmentProduct.assortmentId + assortmentProduct.productId] =
-            assortmentProduct;
+        const productsById = assortmentProductMap.get(assortmentProduct.assortmentId) || new Map();
+        productsById.set(assortmentProduct.productId, assortmentProduct);
+        assortmentProductMap.set(assortmentProduct.assortmentId, productsById);
     }
-    return queries.map((q) => assortmentProductMap[q.assortmentId + q.productId]);
+    return queries.map((q) => assortmentProductMap.get(q.assortmentId)?.get(q.productId));
 });

package/lib/loaders/assortmentTextLoader.js

@@ -6,6 +6,7 @@ export default (unchainedAPI) => new DataLoader(async (queries) => {
     const texts = await unchainedAPI.modules.assortments.texts.findTexts({ assortmentIds }, {
         sort: {
             assortmentId: 1,
+            _id: 1,
         },
     });
     const localeMap = buildLocaleMap(queries, texts);

package/lib/loaders/cartLoader.d.ts

@@ -0,0 +1,13 @@
+import type { UnchainedCore } from '@unchainedshop/core';
+import type { Order } from '@unchainedshop/core-orders';
+import DataLoader from 'dataloader';
+declare const _default: (unchainedAPI: UnchainedCore) => DataLoader<{
+    userId: string;
+    countryCode?: string;
+    orderNumber?: string;
+}, Order | null, {
+    userId: string;
+    countryCode?: string;
+    orderNumber?: string;
+}>;
+export default _default;

package/lib/loaders/cartLoader.js

@@ -0,0 +1,8 @@
+import DataLoader from 'dataloader';
+export default (unchainedAPI) => new DataLoader(async (queries) => {
+    const userIds = [...new Set(queries.map((q) => q.userId).filter(Boolean))];
+    const carts = await unchainedAPI.modules.orders.findCarts({ userIds });
+    return queries.map((q) => carts.find((cart) => cart.userId === q.userId &&
+        (!q.countryCode || cart.countryCode === q.countryCode) &&
+        (!q.orderNumber || cart.orderNumber === q.orderNumber)) || null);
+});

package/lib/loaders/filterTextLoader.js

@@ -6,6 +6,7 @@ export default (unchainedAPI) => new DataLoader(async (queries) => {
     const texts = await unchainedAPI.modules.filters.texts.findTexts({ filterIds }, {
         sort: {
             filterId: 1,
+            _id: 1,
         },
     });
     const localeMap = buildLocaleMap(queries, texts);

package/lib/loaders/index.d.ts

@@ -166,6 +166,15 @@ declare const loaders: (unchainedAPI: UnchainedCore) => {
     }, import("@unchainedshop/core-orders").Order, {
         orderId: string;
     }>;
+    cartLoader: import("dataloader")<{
+        userId: string;
+        countryCode?: string;
+        orderNumber?: string;
+    }, import("@unchainedshop/core-orders").Order | null, {
+        userId: string;
+        countryCode?: string;
+        orderNumber?: string;
+    }>;
     quotationLoader: import("dataloader")<{
         quotationId: string;
     }, import("@unchainedshop/core-quotations").Quotation | null, {

package/lib/loaders/index.js

@@ -26,6 +26,7 @@ import deliveryProviderLoader from "./deliveryProviderLoader.js";
 import paymentProviderLoader from "./paymentProviderLoader.js";
 import warehousingProviderLoader from "./warehousingProviderLoader.js";
 import orderLoader from "./orderLoader.js";
+import cartLoader from "./cartLoader.js";
 import quotationLoader from "./quotationLoader.js";
 import tokenExportStatusLoader from "./tokenExportStatusLoader.js";
 const loaders = (unchainedAPI) => {
@@ -58,6 +59,7 @@ const loaders = (unchainedAPI) => {
         paymentProviderLoader: paymentProviderLoader(unchainedAPI),
         warehousingProviderLoader: warehousingProviderLoader(unchainedAPI),
         orderLoader: orderLoader(unchainedAPI),
+        cartLoader: cartLoader(unchainedAPI),
         quotationLoader: quotationLoader(unchainedAPI),
         tokenExportStatusLoader: tokenExportStatusLoader(unchainedAPI),
     };

package/lib/loaders/productMediaTextLoader.js

@@ -6,6 +6,7 @@ export default (unchainedAPI) => new DataLoader(async (queries) => {
     const texts = await unchainedAPI.modules.products.media.texts.findMediaTexts({ productMediaIds }, {
         sort: {
             productMediaId: 1,
+            _id: 1,
         },
     });
     const localeMap = buildLocaleMap(queries, texts);

package/lib/loaders/productTextLoader.js

@@ -6,6 +6,7 @@ export default (unchainedAPI) => new DataLoader(async (queries) => {
     const texts = await unchainedAPI.modules.products.texts.findTexts({ productIds }, {
         sort: {
             productId: 1,
+            _id: 1,
         },
     });
     const localeMap = buildLocaleMap(queries, texts);

package/lib/loaders/productVariationTextLoader.js

@@ -8,6 +8,7 @@ export default (unchainedAPI) => new DataLoader(async (queries) => {
     }, {
         sort: {
             productVariationId: 1,
+            _id: 1,
         },
     });
     const localeMap = buildLocaleMap(queries, texts);

package/lib/locale-context.d.ts

@@ -6,12 +6,10 @@ export interface UnchainedLocaleContext {
     currencyCode: string;
 }
 export type GetHeaderFn = (key: string) => string | string[];
-export declare const resolveDefaultContext: (({ acceptLang, acceptCountry }: {
+export declare const resolveDefaultContext: import("@unchainedshop/utils/lib/memoize-with-ttl.js").MemoizedWithTTL<[{
     acceptLang: any;
     acceptCountry: any;
-}, unchainedAPI: UnchainedCore) => Promise<UnchainedLocaleContext>) & {
-    clear: () => void;
-};
+}, unchainedAPI: UnchainedCore], UnchainedLocaleContext>;
 export declare const getLocaleContext: ({ getHeader, }: {
     getHeader: UnchainedHTTPServerContext["getHeader"];
 }, unchainedAPI: UnchainedCore) => Promise<UnchainedLocaleContext>;