@unchainedshop/api 4.0.0-rc.15 → 4.0.0-rc.17

package/lib/schema/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/schema/query.ts"],"names":[],"mappings":";AAAA,wBAmgBE"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/schema/query.ts"],"names":[],"mappings":";AAAA,wBAqgBE"}

package/lib/schema/query.js

@@ -22,6 +22,7 @@ export default [
         sort: [SortOptionInput!]
         emailVerified: Boolean
         lastLogin: DateFilterInput
+        tags: [LowerCaseString!]
       ): [User!]!
 
       """
@@ -32,6 +33,7 @@ export default [
         queryString: String
         emailVerified: Boolean
         lastLogin: DateFilterInput
+        tags: [LowerCaseString!]
       ): Int!
 
       """

package/lib/schema/query.js.map

@@ -1 +1 @@
-{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/schema/query.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAigBb;CACF,CAAC"}
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/schema/query.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmgBb;CACF,CAAC"}

package/lib/schema/types/shop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shop.d.ts","sourceRoot":"","sources":["../../../src/schema/types/shop.ts"],"names":[],"mappings":";AAAA,wBAuCE"}
+{"version":3,"file":"shop.d.ts","sourceRoot":"","sources":["../../../src/schema/types/shop.ts"],"names":[],"mappings":";AAAA,wBA0CE"}

package/lib/schema/types/shop.js

@@ -25,6 +25,9 @@ export default [
       customProperties: [AdminUiConfigCustomEntityInterface!]!
       externalLinks: [AdminUiLink!]!
       singleSignOnURL: String
+      productTags: [String!]!
+      assortmentTags: [String!]!
+      userTags: [String!]!
     }
 
     type Shop @cacheControl(maxAge: 180) {

package/lib/schema/types/shop.js.map

@@ -1 +1 @@
-{"version":3,"file":"shop.js","sourceRoot":"","sources":["../../../src/schema/types/shop.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCb;CACF,CAAC"}
+{"version":3,"file":"shop.js","sourceRoot":"","sources":["../../../src/schema/types/shop.ts"],"names":[],"mappings":"AAAA,eAAe;IACb,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCb;CACF,CAAC"}

package/lib/schema/types/warehousing.js

@@ -58,7 +58,7 @@ export default [
       contractAddress: String
       walletAddress: String
       chainId: String
-      chainTokenId: String
+      tokenSerialNumber: String
       ercMetadata(forceLocale: Locale): JSON
     }
   `,

package/lib/user-context.d.ts

@@ -0,0 +1,7 @@
+import { IncomingMessage, OutgoingMessage } from 'http';
+import { UnchainedUserContext } from '@unchainedshop/types/api.js';
+import { UnchainedCore } from '@unchainedshop/types/core.js';
+export declare const getUserContext: (req: IncomingMessage & {
+    cookies?: any;
+}, res: OutgoingMessage, unchainedAPI: UnchainedCore) => Promise<UnchainedUserContext>;
+//# sourceMappingURL=user-context.d.ts.map

package/lib/user-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-context.d.ts","sourceRoot":"","sources":["../src/user-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,MAAM,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AA0C7D,eAAO,MAAM,cAAc,QACpB,eAAe,GAAG;IAAE,OAAO,CAAC,EAAE,GAAG,CAAA;CAAE,OACnC,eAAe,gBACN,aAAa,KAC1B,OAAO,CAAC,oBAAoB,CAsD9B,CAAC"}

package/lib/user-context.js

@@ -0,0 +1,76 @@
+import cookie from 'cookie';
+function isString(input) {
+    return typeof input === 'string' && Object.prototype.toString.call(input) === '[object String]';
+}
+const { UNCHAINED_COOKIE_NAME = 'unchained_token', UNCHAINED_COOKIE_PATH = '/', UNCHAINED_COOKIE_DOMAIN, UNCHAINED_COOKIE_SAMESITE, UNCHAINED_COOKIE_INSECURE, } = process.env;
+function setLoginToken(res, token, expires) {
+    const cookieName = UNCHAINED_COOKIE_NAME;
+    const domain = UNCHAINED_COOKIE_DOMAIN;
+    const path = UNCHAINED_COOKIE_PATH;
+    const secure = UNCHAINED_COOKIE_INSECURE ? false : true;
+    const sameSite = ({
+        none: 'none',
+        lax: 'lax',
+        strict: 'strict',
+        '1': true,
+        '0': false,
+    }[UNCHAINED_COOKIE_SAMESITE?.trim()?.toLowerCase()] || false);
+    if (!cookieName)
+        return;
+    const authCookie = cookie.serialize(cookieName, token || null, {
+        domain,
+        httpOnly: true,
+        path,
+        expires: token && expires ? expires : undefined,
+        maxAge: token ? undefined : -1,
+        sameSite,
+        secure,
+    });
+    res.setHeader('Set-Cookie', authCookie);
+}
+export const getUserContext = async (req, res, unchainedAPI) => {
+    // there is a possible current user connected!
+    const cookieName = UNCHAINED_COOKIE_NAME;
+    let loginToken = req.cookies?.[cookieName];
+    if (req.headers.authorization) {
+        const [type, token] = req.headers.authorization.split(' ');
+        if (type === 'Bearer') {
+            loginToken = token;
+        }
+    }
+    if (loginToken) {
+        // throw an error if the token is not a string
+        if (!isString(loginToken))
+            throw new Error('Access Token is not a string');
+        // the hashed token is the key to find the possible current user in the db
+        const hashedToken = unchainedAPI.modules.accounts.createHashLoginToken(loginToken);
+        const currentUser = await unchainedAPI.modules.users.findUserByToken({
+            hashedToken,
+        });
+        // the current user exists
+        if (currentUser) {
+            // find the right login token corresponding, the current user may have
+            // several sessions logged on different browsers / computers
+            const tokenInformation = currentUser.services.resume.loginTokens.find((tokenInfo) => tokenInfo.hashedToken === hashedToken); // eslint-disable-line
+            // true if the token is expired
+            const isExpired = new Date(tokenInformation.when) < new Date();
+            // if the token is still valid, give access to the current user
+            // information in the resolvers context
+            if (!isExpired) {
+                // return a new context object with the current user & her id
+                return {
+                    user: currentUser,
+                    userId: currentUser._id,
+                    loginToken: loginToken,
+                    setLoginToken,
+                };
+            }
+        }
+        // If there is no user with this token or the token is expires/invalid,
+        // we should remove that cookie from the client
+        setLoginToken(res, null);
+        return { loginToken: loginToken, setLoginToken };
+    }
+    return { setLoginToken };
+};
+//# sourceMappingURL=user-context.js.map

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.15",
+  "version": "4.0.0-rc.17",
   "main": "lib/api-index.js",
   "types": "lib/api-index.d.ts",
   "type": "module",
@@ -35,8 +35,10 @@
     "@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",
@@ -49,6 +51,9 @@
     "@modelcontextprotocol/sdk": {
       "optional": false
     },
+    "ai": {
+      "optional": true
+    },
     "graphql-yoga": {
       "optional": false
     },
@@ -67,6 +72,9 @@
     "@fastify/session": {
       "optional": true
     },
+    "@fastify/static": {
+      "optional": true
+    },
     "express": {
       "optional": true
     },
@@ -87,25 +95,27 @@
     }
   },
   "dependencies": {
-    "@unchainedshop/core": "^4.0.0-rc.15",
-    "@unchainedshop/events": "^4.0.0-rc.15",
-    "@unchainedshop/logger": "^4.0.0-rc.15",
-    "@unchainedshop/roles": "^4.0.0-rc.15",
-    "@unchainedshop/utils": "^4.0.0-rc.15",
-    "accounting": "0.4.1",
+    "@unchainedshop/core": "^4.0.0-rc.17",
+    "@unchainedshop/events": "^4.0.0-rc.17",
+    "@unchainedshop/logger": "^4.0.0-rc.17",
+    "@unchainedshop/roles": "^4.0.0-rc.17",
+    "@unchainedshop/utils": "^4.0.0-rc.17",
+    "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": "^8.0.0",
-    "zod": "^3.25.76"
+    "zod": "^3.25.76 || ^4"
   },
   "devDependencies": {
+    "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({
     typeDefs: [
       ...buildDefaultTypeDefs({
         actions: Object.keys(actions),
       }),
-      ...additionalTypeDefs,
+      ...(additionalTypeDefs || []),
     ],
-    resolvers: [resolvers, ...additionalResolvers],
+    resolvers: [resolvers, ...(additionalResolvers || [])],
     ...serverOptions,
   });
 };

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 {
@@ -96,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,25 @@
 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 type 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 +27,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',