anyapi-mcp-server 1.1.1

package/build/query-suggestions.js

@@ -0,0 +1,138 @@
+import { isScalarType, isObjectType, isListType, isNonNullType, } from "graphql";
+const MAX_DEPTH = 2;
+const MAX_FIELDS_PER_LEVEL = 8;
+function unwrapType(type) {
+    if (isNonNullType(type))
+        return type.ofType;
+    return type;
+}
+function getScalarFieldNames(type) {
+    const fields = type.getFields();
+    return Object.keys(fields).filter((name) => {
+        const fieldType = unwrapType(fields[name].type);
+        return isScalarType(fieldType);
+    });
+}
+function buildDepthLimitedQuery(type, maxDepth, depth = 0) {
+    if (depth > maxDepth)
+        return null;
+    const fields = type.getFields();
+    const parts = [];
+    let count = 0;
+    for (const [name, field] of Object.entries(fields)) {
+        if (count >= MAX_FIELDS_PER_LEVEL)
+            break;
+        const fieldType = unwrapType(field.type);
+        if (isScalarType(fieldType)) {
+            parts.push(name);
+            count++;
+        }
+        else if (isObjectType(fieldType) && depth < maxDepth) {
+            const nested = buildDepthLimitedQuery(fieldType, maxDepth, depth + 1);
+            if (nested) {
+                parts.push(`${name} ${nested}`);
+                count++;
+            }
+        }
+        else if (isListType(fieldType)) {
+            const elementType = unwrapType(fieldType.ofType);
+            if (isScalarType(elementType)) {
+                parts.push(name);
+                count++;
+            }
+            else if (isObjectType(elementType) && depth < maxDepth) {
+                const nested = buildDepthLimitedQuery(elementType, maxDepth, depth + 1);
+                if (nested) {
+                    parts.push(`${name} ${nested}`);
+                    count++;
+                }
+            }
+        }
+    }
+    return parts.length > 0 ? `{ ${parts.join(" ")} }` : null;
+}
+export function generateSuggestions(schema) {
+    const suggestions = [];
+    const queryType = schema.getQueryType();
+    if (!queryType)
+        return suggestions;
+    const fields = queryType.getFields();
+    const fieldNames = Object.keys(fields);
+    // Suggestion 1: All scalar fields at root
+    const scalarFields = fieldNames.filter((name) => {
+        const type = unwrapType(fields[name].type);
+        return isScalarType(type);
+    });
+    if (scalarFields.length > 0) {
+        const selected = scalarFields.slice(0, MAX_FIELDS_PER_LEVEL);
+        suggestions.push({
+            name: "All top-level scalar fields",
+            query: `{ ${selected.join(" ")} }`,
+            description: `Returns ${selected.join(", ")}`,
+        });
+    }
+    // Suggestion 2: For each list field, suggest with basic subfields
+    for (const [name, field] of Object.entries(fields)) {
+        const type = unwrapType(field.type);
+        if (isListType(type)) {
+            const elementType = unwrapType(type.ofType);
+            if (isObjectType(elementType)) {
+                const subfields = getScalarFieldNames(elementType).slice(0, MAX_FIELDS_PER_LEVEL);
+                if (subfields.length > 0) {
+                    suggestions.push({
+                        name: `List ${name} with basic fields`,
+                        query: `{ ${name} { ${subfields.join(" ")} } }`,
+                        description: `Fetches ${subfields.join(", ")} for each item in ${name}`,
+                    });
+                }
+            }
+        }
+    }
+    // Suggestion 3: Array response pattern (items + _count)
+    if (fields["items"] && fields["_count"]) {
+        const itemsType = unwrapType(fields["items"].type);
+        if (isListType(itemsType)) {
+            const elementType = unwrapType(itemsType.ofType);
+            if (isObjectType(elementType)) {
+                const subfields = getScalarFieldNames(elementType).slice(0, 6);
+                if (subfields.length > 0) {
+                    suggestions.push({
+                        name: "Items with count",
+                        query: `{ items { ${subfields.join(" ")} } _count }`,
+                        description: `Array response: fetches ${subfields.join(", ")} with total count`,
+                    });
+                }
+            }
+        }
+    }
+    // Suggestion 4: Full depth-2 query
+    const depth2Query = buildDepthLimitedQuery(queryType, MAX_DEPTH);
+    if (depth2Query) {
+        suggestions.push({
+            name: "Full query (depth 2)",
+            query: depth2Query,
+            description: "All fields up to 2 levels deep, including nested objects",
+        });
+    }
+    // Suggestion 5: Mutation queries
+    const mutationType = schema.getMutationType();
+    if (mutationType) {
+        const mutFields = mutationType.getFields();
+        for (const [mutName, mutField] of Object.entries(mutFields)) {
+            const returnType = unwrapType(mutField.type);
+            let returnFields = "value";
+            if (isObjectType(returnType)) {
+                const scalars = getScalarFieldNames(returnType).slice(0, 6);
+                if (scalars.length > 0)
+                    returnFields = scalars.join(" ");
+            }
+            const hasArgs = mutField.args.length > 0;
+            suggestions.push({
+                name: `Mutation: ${mutName}`,
+                query: `mutation { ${mutName}${hasArgs ? "(input: { ... })" : ""} { ${returnFields} } }`,
+                description: `Write operation returning ${returnFields}`,
+            });
+        }
+    }
+    return suggestions;
+}

package/build/response-cache.js

@@ -0,0 +1,39 @@
+const DEFAULT_TTL_MS = 30_000;
+const cache = new Map();
+export function buildCacheKey(method, pathTemplate, params, body, extraHeaders) {
+    const parts = [method, pathTemplate];
+    if (params && Object.keys(params).length > 0) {
+        parts.push(JSON.stringify(params, Object.keys(params).sort()));
+    }
+    if (body && Object.keys(body).length > 0) {
+        parts.push(JSON.stringify(body, Object.keys(body).sort()));
+    }
+    if (extraHeaders && Object.keys(extraHeaders).length > 0) {
+        parts.push(JSON.stringify(extraHeaders, Object.keys(extraHeaders).sort()));
+    }
+    return parts.join("|");
+}
+export function getCached(key) {
+    const entry = cache.get(key);
+    if (!entry)
+        return undefined;
+    if (Date.now() > entry.expiresAt) {
+        cache.delete(key);
+        return undefined;
+    }
+    return entry.data;
+}
+export function setCache(key, data, ttlMs = DEFAULT_TTL_MS) {
+    cache.set(key, { data, expiresAt: Date.now() + ttlMs });
+}
+export function evictExpired() {
+    const now = Date.now();
+    for (const [key, entry] of cache) {
+        if (now > entry.expiresAt) {
+            cache.delete(key);
+        }
+    }
+}
+export function clearCache() {
+    cache.clear();
+}

package/build/response-parser.js

@@ -0,0 +1,80 @@
+import { XMLParser } from "fast-xml-parser";
+const xmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_",
+    textNodeName: "#text",
+});
+export function parseResponse(contentType, body) {
+    const ct = (contentType ?? "").toLowerCase();
+    if (ct.includes("application/json") || ct.includes("+json")) {
+        return JSON.parse(body);
+    }
+    if (ct.includes("xml") || ct.includes("+xml")) {
+        return xmlParser.parse(body);
+    }
+    if (ct.includes("text/csv") || ct.includes("application/csv")) {
+        return parseCsv(body);
+    }
+    // Try JSON parse for responses without content-type
+    if (!ct || ct.includes("text/plain")) {
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            // Not JSON, wrap as text
+        }
+    }
+    return { _type: "text", content: body };
+}
+function parseCsv(csv) {
+    const lines = csv.split("\n").filter((line) => line.trim().length > 0);
+    if (lines.length === 0)
+        return [];
+    const headers = parseCsvLine(lines[0]);
+    const rows = [];
+    for (let i = 1; i < lines.length; i++) {
+        const values = parseCsvLine(lines[i]);
+        const row = {};
+        for (let j = 0; j < headers.length; j++) {
+            row[headers[j]] = values[j] ?? "";
+        }
+        rows.push(row);
+    }
+    return rows;
+}
+function parseCsvLine(line) {
+    const fields = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (inQuotes) {
+            if (char === '"') {
+                if (line[i + 1] === '"') {
+                    current += '"';
+                    i++;
+                }
+                else {
+                    inQuotes = false;
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        else {
+            if (char === '"') {
+                inQuotes = true;
+            }
+            else if (char === ",") {
+                fields.push(current.trim());
+                current = "";
+            }
+            else {
+                current += char;
+            }
+        }
+    }
+    fields.push(current.trim());
+    return fields;
+}

package/build/retry.js

@@ -0,0 +1,53 @@
+const DEFAULT_OPTIONS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 10_000,
+};
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+export class RetryableError extends Error {
+    status;
+    retryAfterMs;
+    constructor(message, status, retryAfterMs) {
+        super(message);
+        this.status = status;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "RetryableError";
+    }
+}
+export function isRetryableStatus(status) {
+    return RETRYABLE_STATUSES.has(status);
+}
+function isRetryable(error) {
+    if (error instanceof RetryableError)
+        return true;
+    if (error instanceof TypeError)
+        return true;
+    return false;
+}
+function computeDelay(attempt, options, retryAfterMs) {
+    if (retryAfterMs !== undefined) {
+        return Math.min(retryAfterMs, options.maxDelayMs);
+    }
+    const exponential = options.baseDelayMs * Math.pow(2, attempt);
+    const jitter = Math.random() * options.baseDelayMs;
+    return Math.min(exponential + jitter, options.maxDelayMs);
+}
+export async function withRetry(fn, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    let lastError;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= opts.maxRetries || !isRetryable(error)) {
+                throw error;
+            }
+            const retryAfterMs = error instanceof RetryableError ? error.retryAfterMs : undefined;
+            const delay = computeDelay(attempt, opts, retryAfterMs);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw lastError;
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "anyapi-mcp-server",
+  "version": "1.1.1",
+  "description": "A universal MCP server that connects any REST API (via OpenAPI spec) to AI assistants, with GraphQL-style field selection and automatic schema inference.",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "openapi",
+    "rest-api",
+    "ai",
+    "graphql",
+    "claude",
+    "cursor",
+    "llm"
+  ],
+  "bin": {
+    "anyapi-mcp": "./build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "fast-xml-parser": "^5.3.5",
+    "graphql": "^16.10.0",
+    "js-yaml": "^4.1.0",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}