@letoribo/mcp-graphql-enhanced 3.9.1 → 3.9.2

package/dist/index.js

@@ -10,7 +10,6 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const language_1 = require("graphql/language");
 const zod_1 = __importDefault(require("zod"));
 const graphiql_js_1 = require("./helpers/graphiql.js");
-const graphql_1 = require("graphql");
 // Helper imports
 const deprecation_js_1 = require("./helpers/deprecation.js");
 const introspection_js_1 = require("./helpers/introspection.js");
@@ -25,7 +24,7 @@ const getVersion = () => {
         return pkg.version;
     }
     catch {
-        return "3.9.0";
+        return "3.9.2";
     }
 };
 (0, deprecation_js_1.checkDeprecatedArguments)();
@@ -128,62 +127,76 @@ async function performUpdate(force) {
     isUpdating = true;
     const startTime = Date.now();
     try {
-        const endpoints = env.ENDPOINT.split(',').map(url => url.trim());
-        console.error(`[SYNC] Initializing broadcast to ${endpoints.length} nodes...`);
-        const results = await Promise.allSettled(endpoints.map(async (url) => {
-            const response = await fetch(url, {
-                method: "POST",
-                headers: { "Content-Type": "application/json", ...env.HEADERS },
-                body: JSON.stringify({ query: (0, graphql_1.getIntrospectionQuery)() }),
-                signal: AbortSignal.timeout(10000)
-            });
-            if (!response.ok)
-                throw new Error(`HTTP Error ${response.status}`);
-            const result = await response.json();
-            if (!result.data)
-                throw new Error("Empty introspection data");
-            const schema = (0, graphql_1.buildClientSchema)(result.data);
-            schema._originUrl = url;
-            return { url, schema };
-        }));
-        const successful = results
-            .filter((r) => r.status === 'fulfilled')
-            .map(r => r.value);
-        const failures = results
-            .filter((r) => r.status === 'rejected')
-            .map(r => r.reason.message);
-        if (successful.length === 0) {
-            throw new Error(`Federation failed. All nodes unreachable: ${failures.join(', ')}`);
+        const { buildClientSchema, getIntrospectionQuery, printSchema, buildASTSchema, parse: gqlParse, isObjectType } = require("graphql");
+        let tempSchemas = [];
+        // --- FETCHING LOGIC: LOCAL SDL OR REMOTE BROADCAST ---
+        if (env.SCHEMA) {
+            let sdl;
+            if (env.SCHEMA.startsWith("http")) {
+                const response = await fetch(env.SCHEMA);
+                if (!response.ok)
+                    throw new Error(`Remote_SDL_Fetch_Failed: ${response.statusText}`);
+                sdl = await response.text();
+            }
+            else {
+                sdl = await (0, introspection_js_1.introspectLocalSchema)(env.SCHEMA);
+            }
+            tempSchemas = [buildASTSchema(gqlParse(sdl))];
         }
-        // Update cache with all discovered schemas
-        cachedSchemas = successful.map(s => s.schema);
-        cachedSchemaObject = cachedSchemas[0]; // Baseline schema
-        cachedSDL = (0, graphql_1.printSchema)(cachedSchemaObject);
-        // Generate Node Manifest for AI reasoning (Full data, no slices)
-        global.nodeManifest = successful.map(node => {
-            const typeMap = node.schema.getTypeMap();
-            const domainTypes = Object.keys(typeMap).filter(name => {
-                const type = typeMap[name];
-                return !name.startsWith('__') && !(0, graphql_1.isScalarType)(type);
-            });
-            return {
-                endpoint: node.url,
-                availableMutations: Object.keys(node.schema.getMutationType()?.getFields() || {}),
-                domainEntities: domainTypes
-            };
+        else {
+            const endpoints = env.ENDPOINT.split(',').map(url => url.trim());
+            const results = await Promise.all(endpoints.map(async (url) => {
+                try {
+                    const response = await fetch(url, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json", ...env.HEADERS },
+                        body: JSON.stringify({ query: getIntrospectionQuery() }),
+                    });
+                    if (!response.ok)
+                        return null;
+                    const result = await response.json();
+                    return result.data ? buildClientSchema(result.data) : null;
+                }
+                catch (e) {
+                    console.error(`[SYNC-WARN] Failed to reach ${url}`);
+                    return null;
+                }
+            }));
+            tempSchemas = results.filter((s) => s !== null);
+        }
+        if (tempSchemas.length === 0) {
+            throw new Error("No valid schemas could be retrieved.");
+        }
+        // Use the primary schema for the UI/Metadata context
+        cachedSchemaObject = tempSchemas[0];
+        const currentSDL = printSchema(cachedSchemaObject);
+        const typeMap = cachedSchemaObject.getTypeMap();
+        const businessTypes = Object.keys(typeMap).filter(typeName => {
+            const type = typeMap[typeName];
+            return !typeName.startsWith('__') &&
+                !['Query', 'Mutation', 'Subscription'].includes(typeName) &&
+                isObjectType(type);
         });
-        const uniqueTypeCount = new Set(cachedSchemas.flatMap(s => Object.keys(s.getTypeMap()))).size;
-        const duration = ((Date.now() - startTime) / 1000).toFixed(2);
-        return `✅ FEDERATION SYNCED: ${successful.length} active nodes, ${uniqueTypeCount} unique types discovered in ${duration}s.`;
+        if (currentSDL !== cachedSDL) {
+            cachedSDL = currentSDL;
+            const duration = ((Date.now() - startTime) / 1000).toFixed(2);
+            const sourceInfo = env.SCHEMA ? 'SDL File' : `${tempSchemas.length} Active Nodes`;
+            return [
+                `✨ SCHEMA EVOLVED (${duration}s)`,
+                `📊 Source: ${sourceInfo}`,
+                `🧬 Types: ${businessTypes.length}`,
+                `---`,
+                `The bridge has updated the graph model.`
+            ].join('\n');
+        }
+        return `✅ Status: Schema stable (${businessTypes.length} types).`;
     }
     catch (error) {
         console.error(`[CRITICAL] Sync failure: ${error.message}`);
-        schemaLoadError = error;
-        return `❌ SYNC ERROR: ${error.message}`;
+        throw error;
     }
     finally {
         isUpdating = false;
-        updatePromise = null;
     }
 }
 // --- TOOLS IMPLEMENTATION ---
@@ -337,23 +350,45 @@ async function handleHttpRequest(req, res) {
         return;
     }
     const url = new URL(req.url || '', `http://${req.headers.host}`);
+    // Render GraphiQL UI
     if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/graphiql')) {
         res.writeHead(200, { 'Content-Type': 'text/html' });
         return res.end((0, graphiql_js_1.renderGraphiQL)(`http://localhost:${env.MCP_PORT}/mcp`, env.HEADERS));
     }
+    // Process MCP/GraphQL requests
     if (url.pathname === '/mcp' && req.method === 'POST') {
         let body = '';
         req.on('data', chunk => { body += chunk; });
         req.on('end', async () => {
+            let requestId = null;
             try {
                 const payload = JSON.parse(body);
+                // Handle raw GraphQL queries sent directly to /mcp without JSON-RPC structure
+                if (!payload.method && payload.query) {
+                    const handler = toolHandlers.get("query-graphql");
+                    if (handler) {
+                        const mcpResult = await handler({
+                            query: payload.query,
+                            variables: payload.variables
+                        });
+                        const parsed = JSON.parse(mcpResult.content[0].text);
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        const graphQLResponse = parsed.data ? parsed : { data: parsed };
+                        return res.end(JSON.stringify(graphQLResponse));
+                    }
+                }
                 const { method, id, params } = payload;
+                requestId = id;
                 const target = (method === "call-tool" || method === "tools/call") ? params.name : method;
                 const args = (method === "call-tool" || method === "tools/call") ? params.arguments : params;
                 const handler = toolHandlers.get(target);
                 if (!handler) {
                     res.writeHead(404);
-                    return res.end(JSON.stringify({ error: { code: -32601, message: "Method not found" } }));
+                    return res.end(JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: requestId,
+                        error: { code: -32601, message: `Method ${target} not found` }
+                    }));
                 }
                 const result = await handler(args);
                 res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -361,7 +396,11 @@ async function handleHttpRequest(req, res) {
             }
             catch (e) {
                 res.writeHead(500);
-                res.end(JSON.stringify({ error: { message: e.message } }));
+                res.end(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: requestId,
+                    error: { message: e.message }
+                }));
             }
         });
         return;

package/package.json

@@ -50,5 +50,5 @@
 		"tsx": "^4.21.0",
 		"typescript": "5.8.3"
 	},
-	"version": "3.9.1"
+	"version": "3.9.2"
 }