@unchainedshop/api 4.0.0-rc.9 → 4.0.0

package/lib/user-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-context.js","sourceRoot":"","sources":["../src/user-context.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/api",
-  "version": "4.0.0-rc.9",
+  "version": "4.0.0",
   "main": "lib/api-index.js",
   "types": "lib/api-index.d.ts",
   "type": "module",
@@ -31,18 +31,21 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "peerDependencies": {
-    "@ethereumjs/util": ">= 10 < 11",
     "fastify": ">= 5.2 < 6",
     "@fastify/cookie": ">= 11 < 12",
     "@fastify/session": ">= 11 < 12",
     "@fastify/multipart": ">= 9 < 10",
+    "@fastify/static": ">= 8 < 9",
     "connect-mongo": ">= 5.1 < 6",
     "@modelcontextprotocol/sdk": ">= 1 < 2",
+    "ai": ">= 5 < 6",
     "express": ">= 5 < 6",
     "express-session": ">= 1.18 < 2",
     "multer": ">= 2 < 3",
     "graphql-yoga": ">= 5.9 < 6",
-    "passport": ">= 0.7 < 1"
+    "passport": ">= 0.7 < 1",
+    "@noble/curves": "^2.0.0",
+    "@noble/hashes": "^2.0.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
@@ -54,7 +57,7 @@
     "connect-mongo": {
       "optional": false
     },
-    "@ethereumjs/util": {
+    "ai": {
       "optional": true
     },
     "fastify": {
@@ -69,6 +72,9 @@
     "@fastify/session": {
       "optional": true
     },
+    "@fastify/static": {
+      "optional": true
+    },
     "express": {
       "optional": true
     },
@@ -80,27 +86,36 @@
     },
     "passport": {
       "optional": true
+    },
+    "@noble/curves": {
+      "optional": true
+    },
+    "@noble/hashes": {
+      "optional": true
     }
   },
   "dependencies": {
-    "@unchainedshop/core": "^4.0.0-rc.4",
-    "@unchainedshop/events": "^4.0.0-rc.4",
-    "@unchainedshop/logger": "^4.0.0-rc.4",
-    "@unchainedshop/roles": "^4.0.0-rc.4",
-    "@unchainedshop/utils": "^4.0.0-rc.4",
-    "accounting": "0.4.1",
+    "@unchainedshop/core": "^4.0.0",
+    "@unchainedshop/events": "^4.0.0",
+    "@unchainedshop/logger": "^4.0.0",
+    "@unchainedshop/roles": "^4.0.0",
+    "@unchainedshop/utils": "^4.0.0",
+    "file-type": "^21.0.0",
     "dataloader": "^2.2.3",
     "expiry-map": "^2.0.0",
     "graphql-scalars": "^1.24.2",
     "moniker": "0.1.2",
-    "p-memoize": "^7.1.1",
-    "zod": "^3.25.76"
+    "p-memoize": "^8.0.0",
+    "zod": "^3.25.76 || ^4"
   },
   "devDependencies": {
-    "@ethereumjs/util": "^10.0.0",
+    "ai": "^5.0.5",
+    "@noble/curves": "^2.0.0",
+    "@noble/hashes": "^2.0.0",
     "@fastify/cookie": "^11.0.2",
     "@fastify/multipart": "^9.0.3",
     "@fastify/session": "^11.1.0",
+    "@fastify/static": "^8.2.0",
     "@modelcontextprotocol/sdk": "^1.15.1",
     "@types/express": "^5.0.3",
     "@types/node": "^24.0.13",

package/src/api-index.ts

@@ -25,7 +25,7 @@ export type UnchainedServerOptions = {
   adminUiConfig?: AdminUiConfig;
   unchainedAPI: UnchainedCore;
   context?: (defaultResolver: UnchainedContextResolver) => UnchainedContextResolver;
-} & GraphQLServerOptions;
+} & Partial<GraphQLServerOptions>;
 
 export const startAPIServer = async (options: UnchainedServerOptions) => {
   const {
@@ -33,10 +33,8 @@ export const startAPIServer = async (options: UnchainedServerOptions) => {
     context: customContext,
     roles,
     adminUiConfig = {},
-    typeDefs: additionalTypeDefs = [],
-    resolvers: additionalResolvers = [],
     ...serverOptions
-  } = options || {};
+  } = options as UnchainedServerOptions;
 
   const contextResolver = createContextResolver(unchainedAPI, {
     roles,
@@ -51,14 +49,17 @@ export const startAPIServer = async (options: UnchainedServerOptions) => {
       : contextResolver,
   );
 
+  const additionalTypeDefs = 'typeDefs' in serverOptions ? serverOptions.typeDefs : [];
+  const additionalResolvers = 'resolvers' in serverOptions ? serverOptions.resolvers : [];
+
   return createGraphQLServer({
+    ...serverOptions,
     typeDefs: [
       ...buildDefaultTypeDefs({
         actions: Object.keys(actions),
       }),
-      ...additionalTypeDefs,
+      ...(additionalTypeDefs || []),
     ],
-    resolvers: [resolvers, ...additionalResolvers],
-    ...serverOptions,
+    resolvers: [resolvers, ...(additionalResolvers || [])],
   });
 };

package/src/chat/defaultSystemPrompt.ts

@@ -0,0 +1,16 @@
+const defaultSystemPrompt = `YOU MUST FOLLOW THIS RULE: After ANY tool execution, output NOTHING. No text. No explanation. No "done". Just STOP. Tool results are shown automatically.
+
+ONLY output text when:
+1. No tools were called this turn, OR
+2. User explicitly asks "explain" or "why"
+
+    Rules for using the Unchained MCP tools:
+    - All prices are integer type and to correctly determine the currency decimal points check the currencies resource.
+    - CRITICAL: Available languages, currencies, and countries are provided as MCP RESOURCES (unchained://shop/languages, unchained://shop/currencies, unchained://shop/countries). You MUST check these resources FIRST - DO NOT use localization_management tools with LIST action to check availability. The resources contain all available options.
+    - NEVER call localization_management with action LIST, GET, or COUNT to check if a language/currency/country exists. Use the resources instead.
+    - When validating localization codes, ONLY check against the resource data. If a code is not in the resources, it does not exist.
+    - If a user requests an operation with a non-existing language/currency/country, respond: "The [language/currency/country] '[code]' is not registered in the shop. Would you like me to add it first before proceeding?"
+    - If the user agrees, use localization_management with action: CREATE to add it, then proceed with the original operation.
+`;
+
+export default defaultSystemPrompt;

package/src/chat/generateImageHandler.ts

@@ -0,0 +1,78 @@
+import { experimental_generateImage, ImageModel, tool } from 'ai';
+import { fileTypeFromBuffer } from 'file-type';
+import { z } from 'zod';
+
+const inputSchema = z.object({
+  prompt: z.string().describe('The prompt to generate the image from'),
+  size: z
+    .enum([
+      '512x512',
+      '768x768',
+      '1024x1024',
+      '512x896',
+      '640x1120',
+      '768x1344',
+      '1024x1792',
+      '896x512',
+      '1120x640',
+      '1344x768',
+      '1792x1024',
+    ])
+    .optional()
+    .describe('The size of the image (default is 1024x1024).'),
+});
+
+const generateImageHandler =
+  (req: any) =>
+  ({
+    model,
+    uploadUrl = `${process.env.ROOT_URL}/temp-upload`,
+  }: {
+    model: ImageModel;
+    uploadUrl?: string;
+  }) => {
+    return tool<any>({
+      description: 'Generate an image based on the prompt',
+      inputSchema: inputSchema as any,
+      name: 'generate_image',
+      execute: async ({ prompt, size = '1024x1024' }) => {
+        try {
+          const { image } = await experimental_generateImage({
+            model,
+            prompt,
+            size: size as any,
+          });
+
+          const buffer = Buffer.from(image.base64, 'base64');
+          const fileType = await fileTypeFromBuffer(buffer);
+          const extension = fileType?.ext || 'png';
+          const mime = fileType?.mime || 'image/png';
+
+          const filename = `image-${Date.now()}.${extension}`;
+          const file = new File([buffer], filename, { type: mime });
+          const formData = new FormData();
+          formData.append('image', file);
+
+          const uploadRes = await fetch(uploadUrl, {
+            method: 'POST',
+            body: formData,
+            credentials: 'include',
+            headers: {
+              Cookie: req?.headers?.cookie || req?.headers?.get('cookie') || '',
+            },
+          });
+
+          if (!uploadRes.ok) {
+            throw new Error(`Image upload failed: ${uploadRes.statusText}`);
+          }
+
+          const { url } = await uploadRes.json();
+          return { imageUrl: url, prompt };
+        } catch (error) {
+          return `Error Generating image: ${(error as Error).message}`;
+        }
+      },
+    });
+  };
+
+export default generateImageHandler;

package/src/chat/normalizeToolsIndex.ts

@@ -0,0 +1,11 @@
+import { categorizeTools } from './utils.js';
+
+export default function normalizeToolsIndex(mcpTools: any) {
+  const tools = Object.entries(mcpTools).map(([name, tool]: any) => ({
+    name,
+    description: tool.description || '',
+    parameters: tool.parameters || {},
+    category: categorizeTools(name),
+  }));
+  return tools;
+}

package/src/chat/utils.ts

@@ -0,0 +1,31 @@
+import { ImageModel, NoSuchToolError, InvalidArgumentError, streamText } from 'ai';
+
+type StreamTextParams = Parameters<typeof streamText>[0];
+
+export type ChatConfiguration = Omit<StreamTextParams, 'messages'> & {
+  unchainedMCPUrl?: string;
+  imageGenerationTool?: { model: ImageModel; uploadUrl?: string };
+};
+
+export const errorHandler = (error: any): string => {
+  if (NoSuchToolError.isInstance(error)) return 'NoSuchToolError';
+  if (InvalidArgumentError.isInstance(error)) return 'InvalidToolArgumentsError';
+  /* if (ToolExecutionError.isInstance(error)) return 'ToolExecutionError'; */
+  if (error?.message?.toLowerCase()?.includes('forbidden')) return 'NetworkError';
+  if (error?.message?.toLowerCase()?.includes('limit')) return 'LimitExceeded';
+  return `Failed to stream response: ${error?.message || 'Unknown error'}`;
+};
+
+export const categorizeTools = (toolName: string): string => {
+  const name = toolName.toLowerCase();
+
+  if (name.includes('product')) return 'Product Management';
+  if (name.includes('order')) return 'Order Management';
+  if (name.includes('customer') || name.includes('user')) return 'Customer Management';
+  if (name.includes('shop') || name.includes('settings')) return 'Shop Configuration';
+  if (name.includes('assortment')) return 'Assortments';
+  if (name.includes('filter')) return 'Filters';
+  if (name.includes('image') || name.includes('generate')) return 'Media & Content';
+
+  return 'Other Tools';
+};

package/src/context.ts

@@ -29,6 +29,9 @@ export interface CustomAdminUiProperties {
 export interface AdminUiConfig {
   customProperties?: CustomAdminUiProperties[];
   singleSignOnURL?: string;
+  defaultProductTags?: string[];
+  defaultAssortmentTags?: string[];
+  defaultUserTags?: string[];
 }
 
 export interface UnchainedHTTPServerContext {
@@ -85,6 +88,7 @@ export const createContextResolver =
     const abstractHttpServerContext = { remoteAddress, remotePort, getHeader, setHeader };
     const loaders = instantiateLoaders(unchainedAPI);
     const localeContext = await getLocaleContext(abstractHttpServerContext, unchainedAPI);
+
     const userContext: UnchainedUserContext = { login, logout, impersonatorId };
 
     if (accessToken) {
@@ -95,8 +99,11 @@ export const createContextResolver =
       }
     }
     if (userId && !userContext.userId) {
-      userContext.user = await unchainedAPI.modules.users.findUserById(userId);
-      userContext.userId = userId;
+      const user = await unchainedAPI.modules.users.findUserById(userId);
+      if (user) {
+        userContext.user = user;
+        userContext.userId = user._id;
+      }
     }
 
     return {

package/src/createGraphQLServer.ts

@@ -1,22 +1,24 @@
 import { createLogger } from '@unchainedshop/logger';
-import { createYoga, createSchema, YogaServerOptions } from 'graphql-yoga';
+import { createYoga, createSchema, YogaServerOptions, YogaSchemaDefinition } from 'graphql-yoga';
 
 const logger = createLogger('unchained:api');
 
-export type GraphQLServerOptions = YogaServerOptions<any, any> & {
-  typeDefs?: string[];
-  resolvers?: Record<string, any>[];
-};
+export interface UnchainedSchemaExtension {
+  typeDefs: string[];
+  resolvers: Record<string, any>[];
+  schema?: YogaSchemaDefinition<any, any>;
+}
 
-export default async (options: GraphQLServerOptions) => {
-  const { typeDefs, resolvers, schema: customSchema, ...graphQLServerOptions } = options || {};
+export type GraphQLServerOptions = YogaServerOptions<any, any> & UnchainedSchemaExtension;
 
+export default async (options: GraphQLServerOptions) => {
   const schema =
-    customSchema ||
-    createSchema({
-      typeDefs,
-      resolvers,
-    });
+    'schema' in options
+      ? options.schema
+      : createSchema({
+          typeDefs: options.typeDefs,
+          resolvers: options.resolvers,
+        });
 
   const server = createYoga({
     schema,
@@ -24,7 +26,7 @@ export default async (options: GraphQLServerOptions) => {
     context: async (ctx: any) => {
       return (ctx.req as any)?.unchainedContext;
     },
-    ...graphQLServerOptions,
+    ...options,
   });
 
   return server;

package/src/errors.ts

@@ -172,6 +172,12 @@ export const QuotationWrongStatusError = createError(
   'QuotationWrongStatusError',
   'The current status of the quotation does not allow this operation',
 );
+
+export const QuotationItemConfigurationError = createError(
+  'QuotationItemConfigurationError',
+  'Could not transform quotation item',
+);
+
 export const QuotationNotFoundError = createError('QuotationNotFoundError', 'Quotation not found');
 export const BookmarkAlreadyExistsError = createError(
   'BookmarkAlreadyExistsError',

package/src/express/chatHandler.ts

@@ -0,0 +1,207 @@
+import express from 'express';
+import type { Express, Request, RequestHandler, Response } from 'express';
+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 { ChatConfiguration, errorHandler } from '../chat/utils.js';
+import generateImageHandler from '../chat/generateImageHandler.js';
+import defaultSystemPrompt from '../chat/defaultSystemPrompt.js';
+import normalizeToolsIndex from '../chat/normalizeToolsIndex.js';
+import { createLogger } from '@unchainedshop/logger';
+
+const logger = createLogger('unchained:api:chat');
+
+export const expressRouter = () => {
+  const router = express.Router();
+
+  const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+  const staticPath = new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+
+  router.use(express.static(staticPath));
+
+  router.get(/(.*)/, (_, res) => {
+    res.sendFile(`${staticPath}/index.html`);
+  });
+
+  return router;
+};
+
+const setupMCPChatHandler = (chatConfiguration: ChatConfiguration & any): RequestHandler => {
+  if (!chatConfiguration || !chatConfiguration.model) {
+    throw new Error('Model is required');
+  }
+
+  const {
+    tools: additionalTools = {},
+    unchainedMCPUrl = `${process.env.ROOT_URL}/mcp`,
+    model,
+    imageGenerationTool,
+    ...restChatConfig
+  }: any = chatConfiguration;
+
+  const system = chatConfiguration.system ?? defaultSystemPrompt;
+
+  const mcpChatHandler: RequestHandler = async (req: Request, res: Response): Promise<void> => {
+    if (req.method === 'OPTIONS') {
+      res.setHeader('access-control-allow-credentials', 'true');
+      res.setHeader('access-control-allow-private-network', 'true');
+      res.status(200).end();
+      return;
+    }
+    if (req.method !== 'POST' && req.method !== 'GET') {
+      res.status(405).json({ error: 'Method Not Allowed. Use POST.' });
+      return;
+    }
+    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 || '',
+        },
+      },
+    });
+
+    const client = await createMCPClient({
+      transport: transport as MCPTransport,
+    });
+
+    try {
+      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') {
+        res.status(200).json({
+          tools: normalizeToolsIndex(tools),
+          cached: false,
+        });
+        return;
+      }
+      const { messages } = req.body;
+
+      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(10),
+        temperature: 0.2,
+        maxRetries: 3,
+        ...restChatConfig,
+        system: system + resourceContext,
+        model,
+        tools: cacheControlledTools,
+        onFinish: async () => {
+          await client?.close();
+        },
+        messages: messagesToInclude,
+        providerOptions: {
+          anthropic: {
+            cacheControl: {
+              type: 'ephemeral',
+            },
+          },
+        },
+      });
+
+      result.pipeUIMessageStreamToResponse(res, {
+        onError: errorHandler,
+      });
+    } catch (err) {
+      await client?.close();
+      await sdkClient?.close();
+      res.status(500).json({ error: errorHandler(err) });
+    }
+  };
+
+  return mcpChatHandler;
+};
+
+export const connectChat = (app: Express, chatConfiguration: ChatConfiguration) => {
+  const handler = setupMCPChatHandler(chatConfiguration);
+  if (!handler) {
+    throw new Error('Invalid chat configuration: model is required.');
+  }
+  app.post('/chat', express.json({ limit: '10mb' }), handler);
+  app.options('/chat', handler);
+  app.get('/chat/tools', handler);
+};

package/src/express/createBulkImportMiddleware.ts

@@ -7,8 +7,7 @@ const logger = createLogger('unchained:bulk-import');
 
 const methodWrongHandler = (res) => {
   logger.error('Method not supported, return 404');
-  res.writeHead(404);
-  res.end();
+  res.status(404).end();
   return;
 };
 
@@ -41,6 +40,10 @@ export default async function bulkImportMiddleware(
       meta: {},
     });
 
+    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;
 
@@ -53,12 +56,10 @@ export default async function bulkImportMiddleware(
       priority: 10,
     });
 
-    res.writeHead(200);
-    res.end(JSON.stringify(work));
+    res.status(200).send(work);
   } 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;
   }
 }