build

src/lib/mcp_tool_convert.ts

@@ -1,11 +1,5 @@
-// mcp_tool_convert.ts
 import _ from "lodash";
 
-/**
- * ============================
- *  Types
- * ============================
- */
 interface McpTool {
     name: string;
     description: string;
@@ -17,16 +11,11 @@ interface McpTool {
         tag?: string;
         deprecated?: boolean;
         summary?: string;
-        parameters?: any[];
     };
 }
 
 /**
- * ============================
+ * Convert OpenAPI 3.x JSON spec into MCP-compatible tool definitions.
- *  Public: convertOpenApiToMcpTools
- * ============================
- * Convert OpenAPI 3.x spec → MCP Tools
- * - filterTag : match against operation tags
  */
 export function convertOpenApiToMcpTools(openApiJson: any, filterTag: string): McpTool[] {
     const tools: McpTool[] = [];
@@ -37,38 +26,37 @@ export function convertOpenApiToMcpTools(openApiJson: any, filterTag: string): M
     }
 
     const paths = openApiJson.paths || {};
+    
     if (Object.keys(paths).length === 0) {
         console.warn("No paths found in OpenAPI spec");
         return tools;
     }
 
-    for (const [path, methods] of Object.entries<any>(paths)) {
+    for (const [path, methods] of Object.entries(paths)) {
+        if (!path || typeof path !== "string") continue;
+
         if (!methods || typeof methods !== "object") continue;
 
         for (const [method, operation] of Object.entries<any>(methods)) {
-            const valid = ["get", "post", "put", "delete", "patch", "head", "options"];
+            const validMethods = ["get", "post", "put", "delete", "patch", "head", "options"];
-            if (!valid.includes(method.toLowerCase())) continue;
+            if (!validMethods.includes(method.toLowerCase())) continue;
 
             if (!operation || typeof operation !== "object") continue;
 
-            const tags = Array.isArray(operation.tags) ? operation.tags : [];
+            const tags: string[] = Array.isArray(operation.tags) ? operation.tags : [];
 
-            // Tag filter
+            if (!tags.length || !tags.some(t => 
-            if (
+                typeof t === "string" && t.toLowerCase().includes(filterTag)
-                filterTag &&
+            )) continue;
-                (!tags.length ||
-                    !tags.some((t: string) =>
-                        t?.toLowerCase().includes(filterTag.toLowerCase())
-                    ))
-            ) {
-                continue;
-            }
 
             try {
                 const tool = createToolFromOperation(path, method, operation, tags);
-                if (tool) tools.push(tool);
+                if (tool) {
-            } catch (err) {
+                    tools.push(tool);
-                console.error(`Error building tool for ${method.toUpperCase()} ${path}`, err);
+                }
+            } catch (error) {
+                console.error(`Error creating tool for ${method.toUpperCase()} ${path}:`, error);
+                continue;
             }
         }
     }
@@ -77,9 +65,7 @@ export function convertOpenApiToMcpTools(openApiJson: any, filterTag: string): M
 }
 
 /**
- * ============================
+ * Buat MCP tool dari operation OpenAPI
- *  Build Tool from Operation
- * ============================
  */
 function createToolFromOperation(
     path: string,
@@ -87,11 +73,12 @@ function createToolFromOperation(
     operation: any,
     tags: string[]
 ): McpTool | null {
-    const rawName = _.snakeCase(operation.operationId || `${method}_${path}`) || "unnamed_tool";
+    try {
+        const rawName = _.snakeCase(`${operation.operationId}` || `${method}_${path}`) || "unnamed_tool";
         const name = cleanToolName(rawName);
 
-    if (name === "unnamed_tool") {
+        if (!name || name === "unnamed_tool") {
-        console.warn(`Invalid tool name: ${method} ${path}`);
+            console.warn(`Invalid tool name for ${method} ${path}`);
             return null;
         }
 
@@ -100,45 +87,14 @@ function createToolFromOperation(
             operation.summary ||
             `Execute ${method.toUpperCase()} ${path}`;
 
-    // Build executor parameter array
+        // ✅ Extract schema berdasarkan method
-    const parameters: any[] = [];
+        let schema;
-
+        if (method.toLowerCase() === "get") {
-    if (Array.isArray(operation.parameters)) {
+            // ✅ Untuk GET, ambil dari parameters (query/path)
-        for (const p of operation.parameters) {
-            if (!p || typeof p !== "object") continue;
-
-            parameters.push({
-                name: p.name,
-                in: p.in,
-                required: !!p.required,
-                description: p.description,
-                schema: p.schema || { type: "string" },
-            });
-        }
-    }
-
-    // Synthetic requestBody param
-    if (operation.requestBody?.content) {
-        const schema = extractPreferredContentSchema(operation.requestBody.content);
-
-        parameters.push({
-            name: "body",
-            in: "requestBody",
-            required: !!operation.requestBody.required,
-            schema: schema || { type: "object" },
-            description: operation.requestBody.description || "Request body",
-        });
-    }
-
-    // Build input schema
-    let schema: any = null;
-
-    const lower = method.toLowerCase();
-    if (["get", "delete", "head"].includes(lower)) {
             schema = extractParametersSchema(operation.parameters || []);
         } else {
-        schema = extractRequestBodySchema(operation) ||
+            // ✅ Untuk POST/PUT/etc, ambil dari requestBody
-                 extractParametersSchema(operation.parameters || []);
+            schema = extractRequestBodySchema(operation);
         }
         
         const inputSchema = createInputSchema(schema);
@@ -153,99 +109,140 @@ function createToolFromOperation(
                 tag: tags[0],
                 deprecated: operation.deprecated || false,
                 summary: operation.summary,
-            parameters,
             },
             inputSchema,
         };
+    } catch (error) {
+        console.error(`Failed to create tool from operation:`, error);
+        return null;
+    }
+}
+
+/**
+ * Extract schema dari parameters (untuk GET requests)
+ */
+function extractParametersSchema(parameters: any[]): any {
+    if (!Array.isArray(parameters) || parameters.length === 0) {
+        return null;
+    }
+
+    const properties: any = {};
+    const required: string[] = [];
+
+    for (const param of parameters) {
+        if (!param || typeof param !== "object") continue;
+
+        // ✅ Support path, query, dan header parameters
+        if (["path", "query", "header"].includes(param.in)) {
+            const paramName = param.name;
+            if (!paramName || typeof paramName !== "string") continue;
+
+            properties[paramName] = {
+                type: param.schema?.type || "string",
+                description: param.description || `${param.in} parameter: ${paramName}`,
+            };
+
+            // ✅ Copy field tambahan dari schema
+            if (param.schema) {
+                const allowedFields = ["examples", "example", "default", "enum", "pattern", "minLength", "maxLength", "minimum", "maximum", "format"];
+                for (const field of allowedFields) {
+                    if (param.schema[field] !== undefined) {
+                        properties[paramName][field] = param.schema[field];
+                    }
+                }
+            }
+
+            if (param.required === true) {
+                required.push(paramName);
+            }
+        }
+    }
+
+    if (Object.keys(properties).length === 0) {
+        return null;
+    }
+
+    return {
+        type: "object",
+        properties,
+        required,
+    };
 }
 
 /**
- * ============================
+ * Extract schema dari requestBody (untuk POST/PUT/etc requests)
- *  Extract Preferred Content Schema
- * ============================
  */
-function extractPreferredContentSchema(content: any): any {
+function extractRequestBodySchema(operation: any): any {
-    if (!content) return null;
+    if (!operation.requestBody?.content) {
+        return null;
+    }
 
-    const preferred = [
+    const content = operation.requestBody.content;
+
+    const contentTypes = [
         "application/json",
         "multipart/form-data",
         "application/x-www-form-urlencoded",
         "text/plain",
     ];
 
-    for (const type of preferred) {
+    for (const contentType of contentTypes) {
-        if (content[type]?.schema) return content[type].schema;
+        if (content[contentType]?.schema) {
+            return content[contentType].schema;
+        }
     }
 
-    const first = Object.values<any>(content)[0];
+    for (const [_, value] of Object.entries<any>(content)) {
-    return first?.schema || null;
+        if (value?.schema) {
+            return value.schema;
+        }
+    }
+
+    return null;
 }
 
 /**
- * ============================
+ * Buat input schema yang valid untuk MCP
- *  Extract Parameter Schema (GET/DELETE)
- * ============================
- */
-function extractParametersSchema(parameters: any[]): any | null {
-    if (!parameters.length) return null;
-
-    const properties: any = {};
-    const required: string[] = [];
-
-    for (const param of parameters) {
-        if (!["path", "query", "header"].includes(param.in)) continue;
-
-        const name = param.name;
-        if (!name) continue;
-
-        const schema = param.schema || { type: "string" };
-
-        properties[name] = {
-            type: schema.type || "string",
-            description: param.description || `${param.in} parameter: ${name}`,
-            ...extractSchemaDetails(schema),
-        };
-
-        if (param.required) required.push(name);
-    }
-
-    if (!Object.keys(properties).length) return null;
-
-    return { type: "object", properties, required };
-}
-
-/**
- * ============================
- *  Extract RequestBody Schema
- * ============================
- */
-function extractRequestBodySchema(operation: any): any | null {
-    return extractPreferredContentSchema(operation?.requestBody?.content);
-}
-
-/**
- * ============================
- *  Create MCP Input Schema
- * ============================
  */
 function createInputSchema(schema: any): any {
+    const defaultSchema = {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+    };
+
     if (!schema || typeof schema !== "object") {
-        return { type: "object", properties: {}, additionalProperties: false };
+        return defaultSchema;
     }
 
+    try {
         const properties: any = {};
-    const required: string[] = Array.isArray(schema.required) ? [...schema.required] : [];
+        const required: string[] = [];
+        const originalRequired = Array.isArray(schema.required) ? schema.required : [];
 
-    if (schema.properties) {
+        if (schema.properties && typeof schema.properties === "object") {
             for (const [key, prop] of Object.entries<any>(schema.properties)) {
-            const cleaned = cleanProperty(prop);
+                if (!key || typeof key !== "string") continue;
-            if (cleaned) properties[key] = cleaned;
-        }
-    }
 
-    if (schema.type === "array" && schema.items) {
+                try {
-        properties.items = cleanProperty(schema.items) || { type: "string" };
+                    const cleanProp = cleanProperty(prop);
+                    if (cleanProp) {
+                        properties[key] = cleanProp;
+
+                        // ✅ PERBAIKAN: Check optional flag dengan benar
+                        const isOptional = prop?.optional === true || prop?.optional === "true";
+                        const isInRequired = originalRequired.includes(key);
+                        
+                        // ✅ Hanya masukkan ke required jika memang required DAN bukan optional
+                        if (isInRequired && !isOptional) {
+                            required.push(key);
+                        }
+                    }
+                } catch (error) {
+                    console.error(`Error cleaning property ${key}:`, error);
+                    continue;
+                }
+            }
         }
 
         return {
@@ -254,50 +251,26 @@ function createInputSchema(schema: any): any {
             required,
             additionalProperties: false,
         };
+    } catch (error) {
+        console.error("Error creating input schema:", error);
+        return defaultSchema;
+    }
 }
 
 /**
- * ============================
+ * Bersihkan property dari field custom
- *  Clean Individual Schema Property
- * ============================
  */
 function cleanProperty(prop: any): any | null {
-    if (!prop || typeof prop !== "object") return { type: "string" };
+    if (!prop || typeof prop !== "object") {
-
+        return { type: "string" };
-    const out: any = { type: prop.type || "string" };
-
-    Object.assign(out, extractSchemaDetails(prop));
-
-    if (prop.properties) {
-        out.properties = {};
-        for (const [k, v] of Object.entries<any>(prop.properties)) {
-            const cleaned = cleanProperty(v);
-            if (cleaned) out.properties[k] = cleaned;
     }
 
-        if (Array.isArray(prop.required)) {
+    try {
-            out.required = prop.required.filter((r: any) => typeof r === "string");
+        const cleaned: any = {
-        }
+            type: prop.type || "string",
-    }
+        };
 
-    if (prop.items) {
+        const allowedFields = [
-        out.items = cleanProperty(prop.items);
-    }
-
-    if (Array.isArray(prop.oneOf)) out.oneOf = prop.oneOf.map(cleanProperty);
-    if (Array.isArray(prop.anyOf)) out.anyOf = prop.anyOf.map(cleanProperty);
-    if (Array.isArray(prop.allOf)) out.allOf = prop.allOf.map(cleanProperty);
-
-    return out;
-}
-
-/**
- * ============================
- *  Extract Allowed Schema Fields
- * ============================
- */
-function extractSchemaDetails(schema: any) {
-    const allowed = [
             "description",
             "examples",
             "example",
@@ -314,48 +287,94 @@ function extractSchemaDetails(schema: any) {
             "exclusiveMaximum",
         ];
 
-    const out: any = {};
+        for (const field of allowedFields) {
-    for (const f of allowed) {
+            if (prop[field] !== undefined && prop[field] !== null) {
-        if (schema[f] !== undefined) out[f] = schema[f];
+                cleaned[field] = prop[field];
+            }
+        }
+
+        if (prop.properties && typeof prop.properties === "object") {
+            cleaned.properties = {};
+            for (const [key, value] of Object.entries(prop.properties)) {
+                const cleanedNested = cleanProperty(value);
+                if (cleanedNested) {
+                    cleaned.properties[key] = cleanedNested;
+                }
+            }
+            
+            if (Array.isArray(prop.required)) {
+                cleaned.required = prop.required.filter((r: any) => typeof r === "string");
+            }
+        }
+
+        if (prop.items) {
+            cleaned.items = cleanProperty(prop.items);
+        }
+
+        if (Array.isArray(prop.oneOf)) {
+            cleaned.oneOf = prop.oneOf.map(cleanProperty).filter(Boolean);
+        }
+        if (Array.isArray(prop.anyOf)) {
+            cleaned.anyOf = prop.anyOf.map(cleanProperty).filter(Boolean);
+        }
+        if (Array.isArray(prop.allOf)) {
+            cleaned.allOf = prop.allOf.map(cleanProperty).filter(Boolean);
+        }
+
+        return cleaned;
+    } catch (error) {
+        console.error("Error cleaning property:", error);
+        return null;
     }
-    return out;
 }
 
 /**
- * ============================
+ * Bersihkan nama tool
- *  Clean tool name safely
- * ============================
  */
-function cleanToolName(value: string): string {
+function cleanToolName(name: string): string {
-    if (!value) return "unnamed_tool";
+    if (!name || typeof name !== "string") {
+        return "unnamed_tool";
+    }
 
-    return value
+    try {
+        return name
             .replace(/[{}]/g, "")
             .replace(/[^a-zA-Z0-9_]/g, "_")
             .replace(/_+/g, "_")
             .replace(/^_|_$/g, "")
-        .toLowerCase() || "unnamed_tool";
+            // ❗️ METHOD PREFIX TIDAK DIHAPUS LAGI (agar tidak duplicate)
+            .toLowerCase()
+            || "unnamed_tool";
+    } catch (error) {
+        console.error("Error cleaning tool name:", error);
+        return "unnamed_tool";
+    }
 }
 
+
 /**
- * ============================
+ * Ambil OpenAPI JSON dari endpoint dan konversi ke tools MCP
- *  Public: getMcpTools
- * ============================
  */
 export async function getMcpTools(url: string, filterTag: string): Promise<McpTool[]> {
     try {
-        console.log(`Fetching OpenAPI spec: ${url}`);
         
-        const res = await fetch(url);
+        console.log(`Fetching OpenAPI spec from: ${url}`);
-        if (!res.ok) throw new Error(`HTTP ${res.status}`);
 
-        const json = await res.json();
+        const response = await fetch(url);
-        const tools = convertOpenApiToMcpTools(json, filterTag);
+        
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+
+        const openApiJson = await response.json();
+        const tools = convertOpenApiToMcpTools(openApiJson, filterTag);
+        
+        console.log(`✅ Successfully generated ${tools.length} MCP tools`);
         
-        console.log(`Generated ${tools.length} MCP tools`);
         return tools;
-    } catch (err) {
+    } catch (error) {
-        console.error("Error fetching MCP Tools:", err);
+        console.error("Error fetching MCP tools:", error);
-        throw err;
+        throw error;
     }
 }
+

src/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-openapi-mcp-server",
-  "version": "1.1.29",
+  "version": "1.1.30",
   "keywords": [
     "n8n",
     "n8n-nodes"