@unchainedshop/api 4.8.18 → 4.8.20

package/lib/adminUiPlugins.d.ts

@@ -0,0 +1,73 @@
+export interface AdminUIPluginEntityConfig {
+    path: string;
+    label: string;
+    icon?: string;
+    requiredRole?: string;
+    sortOrder?: number;
+    components: {
+        list: string;
+        detail: string;
+        create?: string;
+    };
+}
+export interface AdminUIPluginPageConfig {
+    path: string;
+    label: string;
+    icon?: string;
+    requiredRole?: string;
+    sortOrder?: number;
+    component: string;
+}
+export interface AdminUIPluginTabConfig {
+    label: string;
+    component: string;
+    requiredRole?: string;
+}
+export interface AdminUIPluginWidgetConfig {
+    component: string;
+    width?: 'full' | 'half' | 'third';
+}
+export interface AdminUIPluginSlotConfig {
+    component: string;
+}
+export interface AdminUIPluginConfig {
+    name: string;
+    version?: string;
+    bundlePath: string;
+    navigation?: {
+        label: string;
+        icon?: string;
+        requiredRole?: string;
+        sortOrder?: number;
+    };
+    slots: {
+        entities?: AdminUIPluginEntityConfig[];
+        pages?: AdminUIPluginPageConfig[];
+        'dashboard:widgets'?: AdminUIPluginWidgetConfig[];
+        'product:tabs'?: AdminUIPluginTabConfig[];
+        'assortment:tabs'?: AdminUIPluginTabConfig[];
+        'filter:tabs'?: AdminUIPluginTabConfig[];
+        'user:tabs'?: AdminUIPluginTabConfig[];
+        'order:tabs'?: AdminUIPluginTabConfig[];
+        [key: string]: AdminUIPluginTabConfig[] | AdminUIPluginSlotConfig[] | AdminUIPluginEntityConfig[] | AdminUIPluginPageConfig[] | AdminUIPluginWidgetConfig[] | undefined;
+    };
+}
+interface StaticAsset {
+    content: string | (() => string);
+    contentType: string;
+    cacheControl: string;
+    etag?: string;
+}
+export interface PreparedPluginAssets {
+    routes: Map<string, StaticAsset>;
+    validPlugins: AdminUIPluginConfig[];
+}
+export declare const resolveAdminUIPath: () => string | null;
+export declare const parseBundleExports: (bundle: string) => Set<string> | null;
+export declare function preparePluginAssets(plugins: AdminUIPluginConfig[], log: {
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+}, options?: {
+    devMode?: boolean;
+}): PreparedPluginAssets;
+export {};

package/lib/adminUiPlugins.js

@@ -0,0 +1,164 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { resolve } from 'node:path';
+const PLUGIN_NAME_RE = /^[a-z0-9]([a-z0-9_-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9_-]*[a-z0-9])?)*$/i;
+const IMMUTABLE_CACHE = 'public, max-age=31536000, immutable';
+export const resolveAdminUIPath = () => {
+    try {
+        const staticURL = import.meta.resolve('@unchainedshop/admin-ui');
+        return new URL(staticURL).pathname.split('/').slice(0, -1).join('/');
+    }
+    catch {
+        return null;
+    }
+};
+const contentHash = (content) => createHash('sha256').update(content).digest('hex').slice(0, 8);
+export const parseBundleExports = (bundle) => {
+    const returnMatch = bundle.match(/return __toCommonJS\(([\w$]+)\);/);
+    if (!returnMatch)
+        return null;
+    const blockMatch = bundle.match(new RegExp(`__export\\(${returnMatch[1].replace(/\$/g, '\\$')},\\s*\\{([\\s\\S]*?)\\}\\);`));
+    if (!blockMatch)
+        return null;
+    const names = new Set();
+    for (const m of blockMatch[1].matchAll(/(?:^|,)\s*(?:"([^"]+)"|([\w$]+)):\s*\(\)\s*=>/g)) {
+        names.add(m[1] ?? m[2]);
+    }
+    return names.size > 0 ? names : null;
+};
+const collectReferencedComponents = (plugin) => {
+    const names = new Set();
+    for (const [slotId, configs] of Object.entries(plugin.slots || {})) {
+        if (!Array.isArray(configs))
+            continue;
+        for (const config of configs) {
+            if (slotId === 'entities') {
+                const components = config.components;
+                if (components?.list)
+                    names.add(components.list);
+                if (components?.detail)
+                    names.add(components.detail);
+                if (components?.create)
+                    names.add(components.create);
+            }
+            else if (typeof config.component === 'string') {
+                names.add(config.component);
+            }
+        }
+    }
+    return [...names];
+};
+export function preparePluginAssets(plugins, log, options = {}) {
+    const { devMode = false } = options;
+    const routes = new Map();
+    const devCacheControl = 'no-cache, no-store, must-revalidate';
+    const validPlugins = plugins.filter((p) => {
+        if (!PLUGIN_NAME_RE.test(p.name)) {
+            log.warn(`Skipping admin-ui plugin with invalid name: "${p.name}"`);
+            return false;
+        }
+        return true;
+    });
+    const seenNames = new Set();
+    for (const plugin of validPlugins) {
+        if (seenNames.has(plugin.name)) {
+            log.warn(`Duplicate admin-ui plugin name "${plugin.name}": later entries override earlier ones`);
+        }
+        seenNames.add(plugin.name);
+    }
+    if (validPlugins.length > 0) {
+        const pluginList = validPlugins
+            .map((p) => `${p.name}${p.version ? `@${p.version}` : ''}`)
+            .join(', ');
+        log.info(`Loading ${validPlugins.length} admin-ui plugin(s): ${pluginList}`);
+    }
+    const resolvedBundlePaths = new Map();
+    const pluginBundles = new Map();
+    for (const plugin of validPlugins) {
+        try {
+            const bundlePath = resolve(plugin.bundlePath);
+            const content = readFileSync(bundlePath, 'utf-8');
+            resolvedBundlePaths.set(plugin.name, bundlePath);
+            pluginBundles.set(plugin.name, { content, hash: contentHash(content) });
+        }
+        catch (err) {
+            log.warn(`Failed to read bundle for plugin "${plugin.name}" at ${plugin.bundlePath}: ${err.message}`);
+        }
+    }
+    const pluginsWithBundles = validPlugins.filter((p) => pluginBundles.has(p.name));
+    for (const plugin of pluginsWithBundles) {
+        const exportNames = parseBundleExports(pluginBundles.get(plugin.name).content);
+        if (!exportNames)
+            continue;
+        const missing = collectReferencedComponents(plugin).filter((name) => !exportNames.has(name));
+        if (missing.length > 0) {
+            log.warn(`admin-ui plugin "${plugin.name}" references component(s) not exported by its bundle: ${missing.join(', ')}. Exported: ${[...exportNames].join(', ')}`);
+        }
+    }
+    const bundleMtimes = new Map();
+    const bundleHashes = new Map();
+    for (const [name, bundle] of pluginBundles) {
+        bundleHashes.set(name, bundle.hash);
+        try {
+            bundleMtimes.set(name, statSync(resolvedBundlePaths.get(name)).mtimeMs);
+        }
+        catch {
+        }
+    }
+    const refreshBundleHash = (name) => {
+        const bundlePath = resolvedBundlePaths.get(name);
+        try {
+            const currentMtime = statSync(bundlePath).mtimeMs;
+            const cachedMtime = bundleMtimes.get(name);
+            if (cachedMtime !== undefined && cachedMtime === currentMtime) {
+                return bundleHashes.get(name);
+            }
+            const hash = contentHash(readFileSync(bundlePath, 'utf-8'));
+            bundleMtimes.set(name, currentMtime);
+            bundleHashes.set(name, hash);
+            return hash;
+        }
+        catch {
+            return bundleHashes.get(name) ?? pluginBundles.get(name).hash;
+        }
+    };
+    const buildManifestJSON = () => JSON.stringify(pluginsWithBundles.map((plugin) => ({
+        ...Object.fromEntries(Object.entries(plugin).filter(([k]) => k !== 'bundlePath')),
+        bundleUrl: `/admin-plugins/${plugin.name}.js?v=${devMode ? refreshBundleHash(plugin.name) : pluginBundles.get(plugin.name).hash}`,
+    })));
+    if (devMode) {
+        routes.set('/admin-ui-plugins.json', {
+            content: buildManifestJSON,
+            contentType: 'application/json',
+            cacheControl: devCacheControl,
+        });
+    }
+    else {
+        const manifestJSON = buildManifestJSON();
+        routes.set('/admin-ui-plugins.json', {
+            content: manifestJSON,
+            contentType: 'application/json',
+            cacheControl: 'public, max-age=0, must-revalidate',
+            etag: `"${contentHash(manifestJSON)}"`,
+        });
+    }
+    for (const plugin of pluginsWithBundles) {
+        const bundlePath = resolvedBundlePaths.get(plugin.name);
+        if (devMode) {
+            routes.set(`/admin-plugins/${plugin.name}.js`, {
+                content: () => readFileSync(bundlePath, 'utf-8'),
+                contentType: 'application/javascript',
+                cacheControl: devCacheControl,
+            });
+        }
+        else {
+            const { content } = pluginBundles.get(plugin.name);
+            routes.set(`/admin-plugins/${plugin.name}.js`, {
+                content,
+                contentType: 'application/javascript',
+                cacheControl: IMMUTABLE_CACHE,
+            });
+        }
+    }
+    return { routes, validPlugins };
+}

package/lib/chat/generateImageHandler.d.ts

@@ -2,11 +2,277 @@ import type * as aiTypes from 'ai';
 declare const generateImageHandler: (req: any) => ({ model, uploadUrl, }: {
     model: aiTypes.ImageModel;
     uploadUrl?: string;
-}) => aiTypes.Tool<{
-    prompt: string;
-    size?: "512x512" | "768x768" | "1024x1024" | "512x896" | "640x1120" | "768x1344" | "1024x1792" | "896x512" | "1120x640" | "1344x768" | "1792x1024" | undefined;
-}, string | {
-    imageUrl: any;
-    prompt: string;
-}>;
+}) => ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: aiTypes.Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            prompt: any;
+            size?: string | undefined;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type?: undefined | "function";
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    description?: string | ((options: {
+        context: NoInfer<import("@ai-sdk/provider-utils").Context>;
+        experimental_sandbox?: aiTypes.Experimental_SandboxSession;
+    }) => string) | undefined;
+    strict?: boolean;
+    inputExamples?: {
+        input: NoInfer<{
+            prompt: any;
+            size?: string | undefined;
+        }>;
+    }[] | undefined;
+    id?: never;
+    isProviderExecuted?: never;
+    args?: never;
+    supportsDeferredResults?: never;
+} & {
+    type: "dynamic";
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: false;
+    supportsDeferredResults?: never;
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+}) | ({
+    title?: string;
+    providerOptions?: import("@ai-sdk/provider-utils").ProviderOptions;
+    metadata?: import("@ai-sdk/provider").JSONObject;
+    inputSchema: aiTypes.FlexibleSchema<{
+        prompt: any;
+        size?: string | undefined;
+    }>;
+    contextSchema?: aiTypes.FlexibleSchema<import("@ai-sdk/provider-utils").Context> | undefined;
+    needsApproval?: boolean | import("@ai-sdk/provider-utils").ToolNeedsApprovalFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>> | undefined;
+    onInputStart?: ((options: aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputDelta?: ((options: {
+        inputTextDelta: string;
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    onInputAvailable?: ((options: {
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+    } & aiTypes.ToolExecutionOptions<NoInfer<import("@ai-sdk/provider-utils").Context>>) => void | PromiseLike<void>) | undefined;
+    toModelOutput?: ((options: {
+        toolCallId: string;
+        input: {
+            prompt: any;
+            size?: string | undefined;
+        };
+        output: NoInfer<string | {
+            imageUrl: any;
+            prompt: any;
+        }>;
+    }) => import("@ai-sdk/provider-utils").ToolResultOutput | PromiseLike<import("@ai-sdk/provider-utils").ToolResultOutput>) | undefined;
+} & {
+    outputSchema?: aiTypes.FlexibleSchema<string | {
+        imageUrl: any;
+        prompt: any;
+    }> | undefined;
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+} & {
+    type: "provider";
+    id: `${string}.${string}`;
+    args: Record<string, unknown>;
+    description?: never;
+    strict?: never;
+    inputExamples?: never;
+} & {
+    isProviderExecuted: true;
+    supportsDeferredResults?: boolean;
+} & {
+    execute: aiTypes.ToolExecuteFunction<{
+        prompt: any;
+        size?: string | undefined;
+    }, string | {
+        imageUrl: any;
+        prompt: any;
+    }, NoInfer<import("@ai-sdk/provider-utils").Context>>;
+});
 export default generateImageHandler;

package/lib/createGraphQLServer.js

@@ -1,5 +1,7 @@
 import { createLogger } from '@unchainedshop/logger';
 import { createYoga, createSchema, } from 'graphql-yoga';
+import { useEngine } from '@envelop/core';
+import { parse, validate, specifiedRules, execute, subscribe } from 'graphql';
 const logger = createLogger('unchained:api');
 export default async (options) => {
     const schema = 'schema' in options
@@ -15,6 +17,10 @@ export default async (options) => {
             return ctx.req?.unchainedContext;
         },
         ...options,
+        plugins: [
+            useEngine({ parse, validate, specifiedRules, execute, subscribe }),
+            ...(options.plugins ?? []),
+        ],
     });
     return server;
 };

package/lib/express/createMCPMiddleware.js

@@ -31,13 +31,15 @@ const handlePostRequest = async (req, res) => {
             });
             return;
         }
+        Object.assign(transports[sessionId].context, req.unchainedContext);
         transport = transports[sessionId].transport;
     }
     else if (!sessionId && isInitializeRequest(req.body)) {
+        const contextHolder = req.unchainedContext;
         transport = new StreamableHTTPServerTransport({
             sessionIdGenerator: () => crypto.randomUUID(),
             onsessioninitialized: (sessionId) => {
-                transports[sessionId] = { transport, userId: currentUserId };
+                transports[sessionId] = { transport, userId: currentUserId, context: contextHolder };
             },
         });
         transport.onclose = () => {
@@ -45,12 +47,12 @@ const handlePostRequest = async (req, res) => {
                 delete transports[transport.sessionId];
             }
         };
-        const roles = req.unchainedContext.user?.roles || [];
+        const roles = contextHolder.user?.roles || [];
         const { default: initMCPServer } = await import("../mcp/index.js");
         const server = initMCPServer(new McpServer({
             name: 'Unchained MCP Server',
             version: '1.0.0',
-        }), req.unchainedContext, roles);
+        }), contextHolder, roles);
         await server.connect(transport);
     }
     else {
@@ -74,6 +76,7 @@ const handleSessionRequest = async (req, res) => {
         res.status(400).send('Invalid or missing session ID');
         return;
     }
+    Object.assign(transports[sessionId].context, req.unchainedContext);
     const transport = transports[sessionId].transport;
     await transport.handleRequest(req, res);
 };

package/lib/fastify/mcpHandler.js

@@ -45,13 +45,15 @@ const mcpHandler = async (req, res) => {
                         id: null,
                     }));
                 }
+                Object.assign(transports[sessionId].context, req.unchainedContext);
                 transport = transports[sessionId].transport;
             }
             else if (!sessionId && isInitializeRequest(req.body)) {
+                const contextHolder = req.unchainedContext;
                 transport = new StreamableHTTPServerTransport({
                     sessionIdGenerator: () => crypto.randomUUID(),
                     onsessioninitialized: (sessionId) => {
-                        transports[sessionId] = { transport, userId: currentUserId };
+                        transports[sessionId] = { transport, userId: currentUserId, context: contextHolder };
                     },
                 });
                 transport.onclose = () => {
@@ -64,7 +66,7 @@ const mcpHandler = async (req, res) => {
                 const server = initMCPServer(new McpServer({
                     name: 'Unchained MCP Server',
                     version: '1.0.0',
-                }), req.unchainedContext, roles);
+                }), contextHolder, roles);
                 await server.connect(transport);
             }
             else {
@@ -85,6 +87,7 @@ const mcpHandler = async (req, res) => {
             if (!sessionId || !transports[sessionId] || transports[sessionId].userId !== currentUserId) {
                 return res.status(400).send('Invalid or missing session ID');
             }
+            Object.assign(transports[sessionId].context, req.unchainedContext);
             const transport = transports[sessionId].transport;
             await transport.handleRequest(req.raw, res.raw);
             return res;

package/lib/mcp/tools/filter/handlers/createFilter.js

@@ -1,16 +1,14 @@
-import { FilterDirector } from '@unchainedshop/core';
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function createFilter(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filter, texts } = params;
     const { key, type, options = [] } = filter;
-    const newFilter = await modules.filters.create({
+    const newFilter = await services.filters.createFilter({
         key,
         type,
         options,
         isActive: true,
     });
-    await FilterDirector.invalidateProductIdCache(newFilter, context);
     if (texts && texts.length > 0) {
         await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
     }

package/lib/mcp/tools/filter/handlers/createFilterOption.js

@@ -1,16 +1,14 @@
-import { FilterDirector } from '@unchainedshop/core';
 import { FilterNotFoundError } from "../../../../errors.js";
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function createFilterOption(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filterId, option, optionTexts } = params;
     if (!(await modules.filters.filterExists({ filterId }))) {
         throw new FilterNotFoundError({ filterId });
     }
-    const newOption = await modules.filters.createFilterOption(filterId, { value: option });
+    const newOption = await services.filters.createFilterOption(filterId, { value: option });
     if (!newOption)
         return { filter: null };
-    await FilterDirector.invalidateProductIdCache(newOption, context);
     if (optionTexts && optionTexts.length > 0) {
         await modules.filters.texts.updateTexts({ filterId, filterOptionValue: option }, optionTexts);
     }

package/lib/mcp/tools/filter/handlers/removeFilterOption.js

@@ -1,19 +1,17 @@
-import { FilterDirector } from '@unchainedshop/core';
 import { FilterNotFoundError } from "../../../../errors.js";
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function removeFilterOption(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filterId, option } = params;
     if (!(await modules.filters.filterExists({ filterId }))) {
         throw new FilterNotFoundError({ filterId });
     }
-    const removedFilterOption = await modules.filters.removeFilterOption({
+    const removedFilterOption = await services.filters.removeFilterOption({
         filterId,
         filterOptionValue: option,
     });
     if (!removedFilterOption)
         return { filter: null };
-    await FilterDirector.invalidateProductIdCache(removedFilterOption, context);
     const normalizedFilter = await getNormalizedFilterDetails(filterId, context);
     return { filter: normalizedFilter };
 }

package/lib/mcp/tools/filter/handlers/updateFilter.js

@@ -1,12 +1,12 @@
 import { FilterNotFoundError } from "../../../../errors.js";
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function updateFilter(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filterId, updateData } = params;
     if (!(await modules.filters.filterExists({ filterId }))) {
         throw new FilterNotFoundError({ filterId });
     }
-    await modules.filters.update(filterId, updateData);
+    await services.filters.updateFilter(filterId, updateData);
     const normalizedFilter = await getNormalizedFilterDetails(filterId, context);
     return { filter: normalizedFilter };
 }

package/lib/mcp/tools/quotation/index.js

@@ -1,4 +1,4 @@
 import { quotationManagement, QuotationManagementSchema } from "./quotationManagement.js";
 export const registerQuotationTools = (server, context) => {
-    server.tool('quotation_management', 'Unified quotation management system. Supports: LIST (get quotations with filters and pagination), GET (single quotation by ID), COUNT (count quotations), REQUEST (create new quotation request for a product), VERIFY (verify a REQUESTED quotation), MAKE_PROPOSAL (create proposal for PROCESSING quotation), REJECT (reject any quotation except FULFILLED). Quotations go through lifecycle: REQUESTED → PROCESSING → PROPOSED → FULFILLED/REJECTED.', QuotationManagementSchema, async (params) => quotationManagement(context, params));
+    server.tool('quotation_management', 'Unified quotation management system. Supports: LIST (get quotations with filters and pagination), GET (single quotation by ID), COUNT (count quotations), VERIFY (verify a REQUESTED quotation), MAKE_PROPOSAL (create proposal for PROCESSING quotation), REJECT (reject any quotation except FULFILLED). Quotations go through lifecycle: REQUESTED → PROCESSING → PROPOSED → FULFILLED/REJECTED.', QuotationManagementSchema, async (params) => quotationManagement(context, params));
 };

package/lib/mcp/utils/sharedSchemas.d.ts

@@ -73,6 +73,7 @@ export declare function createMcpResponse(response: any): {
     }[];
 };
 export declare function createMcpErrorResponse(action: string, error: Error): {
+    isError: boolean;
     content: {
         type: "text";
         text: string;

package/lib/mcp/utils/sharedSchemas.js

@@ -88,6 +88,7 @@ export function createMcpResponse(response) {
 }
 export function createMcpErrorResponse(action, error) {
     return {
+        isError: true,
         content: [
             {
                 type: 'text',

package/lib/resolvers/mutations/bookmarks/createBookmark.d.ts

@@ -1,6 +1,6 @@
 import type { Context } from '../../../context.ts';
 export default function createBookmark(root: never, { productId, userId, meta }: {
     productId: string;
-    userId: string;
+    userId?: string;
     meta?: any;
 }, { modules, userId: currentUserId }: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-bookmarks").Bookmark> | null>;

package/lib/resolvers/mutations/bookmarks/createBookmark.js

@@ -1,7 +1,8 @@
 import { log } from '@unchainedshop/logger';
 import { BookmarkAlreadyExistsError, InvalidIdError, ProductNotFoundError } from "../../../errors.js";
 export default async function createBookmark(root, { productId, userId, meta }, { modules, userId: currentUserId }) {
-    log(`mutation createBookmark for ${userId}`, {
+    const targetUserId = userId || currentUserId;
+    log(`mutation createBookmark for ${targetUserId}`, {
         productId,
         userId: currentUserId,
     });
@@ -11,13 +12,13 @@ export default async function createBookmark(root, { productId, userId, meta },
         throw new ProductNotFoundError({ productId });
     const [bookmark] = await modules.bookmarks.findBookmarks({
         productId,
-        userId,
+        userId: targetUserId,
         meta,
     });
     if (bookmark)
         throw new BookmarkAlreadyExistsError({ bookmarkId: bookmark._id });
     const bookmarkId = await modules.bookmarks.create({
-        userId,
+        userId: targetUserId,
         productId,
         meta,
     });

package/lib/resolvers/mutations/filters/createFilter.js

@@ -1,12 +1,11 @@
 import { log } from '@unchainedshop/logger';
-import { FilterDirector } from '@unchainedshop/core';
+import {} from '@unchainedshop/core';
 import { DuplicateFilterKeyError } from "../../../errors.js";
 export default async function createFilter(root, { filter, texts }, context) {
-    const { modules, userId } = context;
+    const { modules, services, userId } = context;
     log('mutation createFilter', { userId });
     try {
-        const newFilter = await modules.filters.create(filter);
-        await FilterDirector.invalidateProductIdCache(newFilter, context);
+        const newFilter = await services.filters.createFilter(filter);
         if (texts) {
             await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
         }

package/lib/resolvers/mutations/filters/createFilterOption.d.ts

@@ -4,4 +4,4 @@ export default function createFilterOption(root: never, params: {
     filterId: string;
     option: string;
     texts?: FilterInputText[];
-}, context: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-filters").Filter> | null>;
+}, context: Context): Promise<import("@unchainedshop/core-filters").Filter | null>;

package/lib/resolvers/mutations/filters/createFilterOption.js

@@ -1,16 +1,15 @@
 import { log } from '@unchainedshop/logger';
-import { FilterDirector } from '@unchainedshop/core';
+import {} from '@unchainedshop/core';
 import { FilterNotFoundError, InvalidIdError } from "../../../errors.js";
 export default async function createFilterOption(root, params, context) {
-    const { modules, userId } = context;
+    const { modules, services, userId } = context;
     const { filterId, option, texts } = params;
     log(`mutation createFilterOption ${filterId}`, { userId });
     if (!filterId)
         throw new InvalidIdError({ filterId });
     if (!(await modules.filters.filterExists({ filterId })))
         throw new FilterNotFoundError({ filterId });
-    const filter = await modules.filters.createFilterOption(filterId, { value: option });
-    await FilterDirector.invalidateProductIdCache(filter, context);
+    const filter = await services.filters.createFilterOption(filterId, { value: option });
     if (texts) {
         await modules.filters.texts.updateTexts({ filterId, filterOptionValue: option }, texts);
     }

package/lib/resolvers/mutations/filters/removeFilterOption.d.ts

@@ -2,4 +2,4 @@ import type { Context } from '../../../context.ts';
 export default function removeFilterOption(root: never, { filterId, filterOptionValue }: {
     filterId: string;
     filterOptionValue: string;
-}, context: Context): Promise<import("mongodb").WithId<import("@unchainedshop/core-filters").Filter> | null>;
+}, context: Context): Promise<import("@unchainedshop/core-filters").Filter | null>;

package/lib/resolvers/mutations/filters/removeFilterOption.js

@@ -1,17 +1,11 @@
 import { log } from '@unchainedshop/logger';
 import { FilterNotFoundError, InvalidIdError } from "../../../errors.js";
-import { FilterDirector } from '@unchainedshop/core';
 export default async function removeFilterOption(root, { filterId, filterOptionValue }, context) {
-    const { modules, userId } = context;
+    const { modules, services, userId } = context;
     log(`mutation removeFilterOption ${filterId}`, { userId });
     if (!filterId || !filterOptionValue)
         throw new InvalidIdError({ filterId, filterOptionValue });
     if (!(await modules.filters.filterExists({ filterId })))
         throw new FilterNotFoundError({ filterId });
-    const filter = await modules.filters.removeFilterOption({
-        filterId,
-        filterOptionValue,
-    });
-    await FilterDirector.invalidateProductIdCache(filter, context);
-    return filter;
+    return services.filters.removeFilterOption({ filterId, filterOptionValue });
 }

package/lib/resolvers/mutations/filters/updateFilter.d.ts

@@ -3,4 +3,4 @@ import type { Context } from '../../../context.ts';
 export default function updateFilter(root: never, { filter, filterId }: {
     filter: Filter;
     filterId: string;
-}, context: Context): Promise<import("mongodb").WithId<Filter> | null>;
+}, context: Context): Promise<Filter | null>;

package/lib/resolvers/mutations/filters/updateFilter.js

@@ -1,14 +1,11 @@
 import { log } from '@unchainedshop/logger';
 import { FilterNotFoundError, InvalidIdError } from "../../../errors.js";
-import { FilterDirector } from '@unchainedshop/core';
 export default async function updateFilter(root, { filter, filterId }, context) {
-    const { modules, userId } = context;
+    const { modules, services, userId } = context;
     log(`mutation updateFilter ${filterId}`, { userId });
     if (!filterId)
         throw new InvalidIdError({ filterId });
     if (!(await modules.filters.filterExists({ filterId })))
         throw new FilterNotFoundError({ filterId });
-    const updatedFilter = await modules.filters.update(filterId, filter);
-    await FilterDirector.invalidateProductIdCache(updatedFilter, context);
-    return updatedFilter;
+    return services.filters.updateFilter(filterId, filter);
 }

package/lib/resolvers/scalars/LowerCaseString.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLScalarType } from 'graphql';
-declare const LowerCaseString: GraphQLScalarType<string | null, any>;
+declare const LowerCaseString: GraphQLScalarType<string, any>;
 export default LowerCaseString;

package/lib/resolvers/scalars/index.d.ts

@@ -1,4 +1,4 @@
 declare const _default: {
-    LowerCaseString: import("graphql").GraphQLScalarType<string | null, any>;
+    LowerCaseString: import("graphql").GraphQLScalarType<string, any>;
 };
 export default _default;

package/lib/resolvers/type/index.d.ts

@@ -623,6 +623,10 @@ declare const types: {
         isExpired: (obj: import("@unchainedshop/core-quotations").Quotation, { referenceDate }: {
             referenceDate: Date;
         }, { modules }: import("../../context.ts").Context) => boolean;
+        price: (obj: import("@unchainedshop/core-quotations").Quotation) => {
+            amount: number;
+            currencyCode: string;
+        } | null;
         product: (obj: import("@unchainedshop/core-quotations").Quotation, _: never, { loaders }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-products").Product>;
         status: (obj: import("@unchainedshop/core-quotations").Quotation, _: never, { modules }: import("../../context.ts").Context) => import("@unchainedshop/core-quotations").QuotationStatus;
         user: (obj: import("@unchainedshop/core-quotations").Quotation, _: never, { loaders }: import("../../context.ts").Context) => Promise<import("@unchainedshop/core-users").User>;

package/lib/resolvers/type/quotation-types.d.ts

@@ -6,6 +6,10 @@ export declare const Quotation: {
     isExpired: (obj: QuotationType, { referenceDate }: {
         referenceDate: Date;
     }, { modules }: Context) => boolean;
+    price: (obj: QuotationType) => {
+        amount: number;
+        currencyCode: string;
+    } | null;
     product: (obj: QuotationType, _: never, { loaders }: Context) => Promise<import("@unchainedshop/core-products").Product>;
     status: (obj: QuotationType, _: never, { modules }: Context) => import("@unchainedshop/core-quotations").QuotationStatus;
     user: (obj: QuotationType, _: never, { loaders }: Context) => Promise<import("@unchainedshop/core-users").User>;

package/lib/resolvers/type/quotation-types.js

@@ -2,6 +2,7 @@ export const Quotation = {
     country: async (obj, _, { loaders }) => obj.countryCode ? loaders.countryLoader.load({ isoCode: obj.countryCode }) : null,
     currency: async (obj, _, { loaders }) => obj.currencyCode ? loaders.currencyLoader.load({ isoCode: obj.currencyCode }) : null,
     isExpired: (obj, { referenceDate }, { modules }) => modules.quotations.isExpired(obj, { referenceDate }),
+    price: (obj) => obj.price != null && obj.currencyCode ? { amount: obj.price, currencyCode: obj.currencyCode } : null,
     product: async (obj, _, { loaders }) => {
         const product = await loaders.productLoader.load({
             productId: obj.productId,

package/lib/roles/loggedIn.js

@@ -171,6 +171,7 @@ export const loggedIn = (role, actions) => {
     role.allow(actions.reviewProduct, () => true);
     role.allow(actions.updateProductReview, isOwnedProductReview);
     role.allow(actions.requestQuotation, () => true);
+    role.allow(actions.viewQuotation, isOwnedQuotation);
     role.allow(actions.answerQuotation, isOwnedQuotation);
     role.allow(actions.manageBookmarks, isOwnedBookmark);
     role.allow(actions.createBookmark, isOwnBookmarkUser);

package/lib/schema/types/quotation.js

@@ -57,6 +57,11 @@ export default [
       country: Country
       currency: Currency
       configuration: [ProductConfigurationParameter!]
+
+      """
+      Proposed unit price (minor units of the quotation's currency), set when the quotation reaches PROPOSED
+      """
+      price: Price
     }
   `,
 ];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unchainedshop/api",
   "description": "GraphQL API layer for the Unchained Engine with Express/Fastify adapters and MCP server",
-  "version": "4.8.18",
+  "version": "4.8.20",
   "main": "lib/api-index.js",
   "types": "lib/api-index.d.ts",
   "type": "module",
@@ -60,13 +60,14 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "peerDependencies": {
-    "@ai-sdk/mcp": "^1",
+    "@ai-sdk/mcp": "^2.0.29",
+    "graphql": ">= 16.14 < 18",
     "@fastify/cookie": ">= 11 < 12",
     "@fastify/multipart": ">= 9 < 11",
     "@fastify/session": ">= 11 < 12",
-    "@fastify/static": ">= 9 < 10",
+    "@fastify/static": ">= 10.1.3 < 11",
     "@modelcontextprotocol/sdk": ">= 1 < 2",
-    "ai": ">= 6 < 7",
+    "ai": ">= 7 < 8",
     "express": ">= 5 < 6",
     "express-session": ">= 1.18 < 2",
     "fastify": ">= 5.2 < 6",
@@ -116,6 +117,7 @@
     }
   },
   "dependencies": {
+    "@envelop/core": "^5.6.0",
     "@unchainedshop/core": "^4.8.12",
     "@unchainedshop/events": "^4.8.12",
     "@unchainedshop/logger": "^4.8.12",
@@ -123,25 +125,26 @@
     "@unchainedshop/utils": "^4.8.12",
     "dataloader": "^2.2.3",
     "expiry-map": "^2.0.0",
-    "graphql-scalars": "^1.24.2",
+    "graphql-scalars": "^2.0.0",
     "mime": ">= 4 < 5",
     "p-memoize": "^8.0.0",
     "zod": "^3.25.76 || ^4"
   },
   "devDependencies": {
-    "@ai-sdk/mcp": "^1.0.5",
+    "@ai-sdk/mcp": "^2.0.34",
     "@fastify/cookie": "^11.0.2",
-    "@fastify/multipart": "^10.0.0",
+    "@fastify/multipart": "^10.1.1",
     "@fastify/session": "^11.1.0",
-    "@fastify/static": "^9.0.0",
+    "@fastify/static": "^10.1.3",
     "@modelcontextprotocol/sdk": "^1.15.1",
     "@types/express": "^5.0.3",
     "@types/express-session": "^1.18.2",
-    "@types/node": "^25.0.0",
-    "ai": "^6.0.14",
+    "@types/node": "^26.2.0",
+    "ai": "^7.0.73",
     "express": "^5.1.0",
     "express-session": "^1.18.1",
-    "fastify": "^5.4.0",
+    "fastify": "^5.12.1",
+    "graphql": "^17.0.2",
     "multer": "^2.0.1",
     "passport": "^0.7.0",
     "typescript": "^5.8.3"