@nocobase/plugin-mcp-server 2.1.0-alpha.16 → 2.1.0-alpha.18

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/swagger-parser/lib/options.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const { getJsonSchemaRefParserDefaultOptions } = require("@apidevtools/json-schema-ref-parser");
+const schemaValidator = require("./validators/schema");
+const specValidator = require("./validators/spec");
+
+module.exports = ParserOptions;
+
+
+
+/**
+ * Merges the properties of the source object into the target object.
+ *
+ * @param target - The object that we're populating
+ * @param source - The options that are being merged
+ * @returns
+ */
+function merge (target, source) {
+  if (isMergeable(source)) {
+    // prevent prototype pollution
+    const keys = Object.keys(source).filter((key) => !["__proto__", "constructor", "prototype"].includes(key));
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const sourceSetting = source[key];
+      const targetSetting = target[key];
+
+      if (isMergeable(sourceSetting)) {
+        // It's a nested object, so merge it recursively
+        target[key] = merge(targetSetting || {}, sourceSetting);
+      }
+      else if (sourceSetting !== undefined) {
+        // It's a scalar value, function, or array. No merging necessary. Just overwrite the target value.
+        target[key] = sourceSetting;
+      }
+    }
+  }
+  return target;
+}
+/**
+ * Determines whether the given value can be merged,
+ * or if it is a scalar value that should just override the target value.
+ *
+ * @param val
+ * @returns
+ */
+function isMergeable (val) {
+  return val && typeof val === "object" && !Array.isArray(val) && !(val instanceof RegExp) && !(val instanceof Date);
+}
+
+/**
+ * Options that determine how Swagger APIs are parsed, resolved, dereferenced, and validated.
+ *
+ * @param {object|ParserOptions} [_options] - Overridden options
+ * @class
+ * @augments $RefParserOptions
+ */
+function ParserOptions (_options) {
+  const defaultOptions = getJsonSchemaRefParserDefaultOptions();
+  const options = merge(defaultOptions, ParserOptions.defaults);
+  return merge(options, _options);
+}
+
+ParserOptions.defaults = {
+  /**
+   * Determines how the API definition will be validated.
+   *
+   * You can add additional validators of your own, replace an existing one with
+   * your own implemenation, or disable any validator by setting it to false.
+   */
+  validate: {
+    schema: schemaValidator,
+    spec: specValidator,
+  },
+};

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/swagger-parser/lib/util.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const util = require("util");
+
+exports.format = util.format;
+exports.inherits = util.inherits;
+const parse = (u) => new URL(u);
+
+/**
+ * Regular Expression that matches Swagger path params.
+ */
+exports.swaggerParamRegExp = /\{([^/}]+)}/g;
+
+/**
+ * List of HTTP verbs used for OperationItem as per the Swagger specification
+ */
+const operationsList = ["get", "post", "put", "delete", "patch", "options", "head", "trace"];
+
+/**
+ * This function takes in a Server object, checks if it has relative path
+ * and then fixes it as per the path url
+ *
+ * @param {object} server - The server object to be fixed
+ * @param {string} path - The path (an http/https url) from where the file was downloaded
+ * @returns {object} - The fixed server object
+ */
+function fixServers (server, path) {
+  // Server url starting with "/" tells that it is not an http(s) url
+  if (server.url && server.url.startsWith("/")) {
+    const inUrl = parse(path);
+    const finalUrl = inUrl.protocol + "//" + inUrl.hostname + server.url;
+    server.url = finalUrl;
+    return server;
+  }
+}
+
+/**
+ * This function helps fix the relative servers in the API definition file
+ * be at root, path or operation's level
+ */
+function fixOasRelativeServers (schema, filePath) {
+  if (schema.openapi && (filePath && (filePath.startsWith("http:") || filePath.startsWith("https:")))) {
+    /**
+     * From OpenAPI v3 spec for Server object's url property: "REQUIRED. A URL to the target host.
+     * This URL supports Server Variables and MAY be relative, to indicate that the host location is relative to the location where
+     * the OpenAPI document is being served."
+     * Further, the spec says that "servers" property can show up at root level, in 'Path Item' object or in 'Operation' object.
+     * However, interpretation of the spec says that relative paths for servers should take into account the hostname that
+     * serves the OpenAPI file.
+     */
+    if (schema.servers) {
+      schema.servers.map(server => fixServers(server, filePath)); // Root level servers array's fixup
+    }
+
+    // Path, Operation, or Webhook level servers array's fixup
+    ["paths", "webhooks"].forEach(component => {
+      Object.keys(schema[component] || []).forEach(path => {
+        const pathItem = schema[component][path];
+        Object.keys(pathItem).forEach(opItem => {
+          if (opItem === "servers") {
+            // servers at pathitem level
+            pathItem[opItem].map(server => fixServers(server, filePath));
+          }
+          else if (operationsList.includes(opItem)) {
+            // servers at operation level
+            if (pathItem[opItem].servers) {
+              pathItem[opItem].servers.map(server => fixServers(server, filePath));
+            }
+          }
+        });
+      });
+    });
+  }
+  else {
+    // Do nothing and return
+  }
+}
+
+exports.fixOasRelativeServers = fixOasRelativeServers;

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/swagger-parser/lib/validators/schema.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const util = require("../util");
+const { ono } = require("@jsdevtools/ono");
+const AjvDraft4 = require("ajv-draft-04");
+const Ajv = require("ajv/dist/2020");
+const { openapi } = require("@apidevtools/openapi-schemas");
+
+module.exports = validateSchema;
+
+/**
+ * Validates the given Swagger API against the Swagger 2.0 or OpenAPI 3.0 and 3.1 schemas.
+ *
+ * @param {SwaggerObject} api
+ */
+function validateSchema (api) {
+  let ajv;
+
+  // Choose the appropriate schema (Swagger or OpenAPI)
+  let schema;
+
+  if (api.swagger) {
+    schema = openapi.v2;
+    ajv = initializeAjv();
+  }
+  else {
+    if (api.openapi.startsWith("3.1")) {
+      schema = openapi.v31;
+
+      // There's a bug with Ajv in how it handles `$dynamicRef` in the way that it's used within the 3.1 schema so we
+      // need to do some adhoc workarounds.
+      // https://github.com/OAI/OpenAPI-Specification/issues/2689
+      // https://github.com/ajv-validator/ajv/issues/1573
+      const schemaDynamicRef = schema.$defs.schema;
+      delete schemaDynamicRef.$dynamicAnchor;
+
+      schema.$defs.components.properties.schemas.additionalProperties = schemaDynamicRef;
+      schema.$defs.header.dependentSchemas.schema.properties.schema = schemaDynamicRef;
+      schema.$defs["media-type"].properties.schema = schemaDynamicRef;
+      schema.$defs.parameter.properties.schema = schemaDynamicRef;
+
+      ajv = initializeAjv(false);
+    }
+    else {
+      schema = openapi.v3;
+      ajv = initializeAjv();
+    }
+  }
+
+  // Validate against the schema
+  let isValid = ajv.validate(schema, api);
+  if (!isValid) {
+    let err = ajv.errors;
+    let message = "Swagger schema validation failed.\n" + formatAjvError(err);
+    throw ono.syntax(err, { details: err }, message);
+  }
+}
+
+/**
+ * Determines which version of Ajv to load and prepares it for use.
+ *
+ * @param {bool} draft04
+ * @returns {Ajv}
+ */
+function initializeAjv (draft04 = true) {
+  const opts = {
+    allErrors: true,
+    strict: false,
+    validateFormats: false,
+  };
+
+  if (draft04) {
+    return new AjvDraft4(opts);
+  }
+
+  return new Ajv(opts);
+}
+
+/**
+ * Run through a set of Ajv errors and compile them into an error message string.
+ *
+ * @param {object[]}  errors     - The Ajv errors
+ * @param {string}    [indent]   - The whitespace used to indent the error message
+ * @returns {string}
+ */
+function formatAjvError (errors, indent) {
+  indent = indent || "  ";
+  let message = "";
+  for (let error of errors) {
+    message += util.format(`${indent}#${error.instancePath.length ? error.instancePath : "/"} ${error.message}\n`);
+  }
+  return message;
+}

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/swagger-parser/lib/validators/spec.js

@@ -0,0 +1,352 @@
+"use strict";
+
+const util = require("../util");
+const { ono } = require("@jsdevtools/ono");
+const swaggerMethods = require("@apidevtools/swagger-methods");
+const primitiveTypes = ["array", "boolean", "integer", "number", "string"];
+const schemaTypes = ["array", "boolean", "integer", "number", "string", "object", "null", undefined];
+
+module.exports = validateSpec;
+
+/**
+ * Validates parts of the Swagger 2.0 spec that aren't covered by the Swagger 2.0 JSON Schema.
+ *
+ * @param {SwaggerObject} api
+ */
+function validateSpec (api) {
+  if (api.openapi) {
+    // We don't (yet) support validating against the OpenAPI spec
+    return;
+  }
+
+  let paths = Object.keys(api.paths || {});
+  let operationIds = [];
+  for (let pathName of paths) {
+    let path = api.paths[pathName];
+    let pathId = "/paths" + pathName;
+
+    if (path && pathName.indexOf("/") === 0) {
+      validatePath(api, path, pathId, operationIds);
+    }
+  }
+
+  let definitions = Object.keys(api.definitions || {});
+  for (let definitionName of definitions) {
+    let definition = api.definitions[definitionName];
+    let definitionId = "/definitions/" + definitionName;
+    validateRequiredPropertiesExist(definition, definitionId);
+  }
+}
+
+/**
+ * Validates the given path.
+ *
+ * @param {SwaggerObject} api           - The entire Swagger API object
+ * @param {object}        path          - A Path object, from the Swagger API
+ * @param {string}        pathId        - A value that uniquely identifies the path
+ * @param {string}        operationIds  - An array of collected operationIds found in other paths
+ */
+function validatePath (api, path, pathId, operationIds) {
+  for (let operationName of swaggerMethods) {
+    let operation = path[operationName];
+    let operationId = pathId + "/" + operationName;
+
+    if (operation) {
+      let declaredOperationId = operation.operationId;
+      if (declaredOperationId) {
+        if (operationIds.indexOf(declaredOperationId) === -1) {
+          operationIds.push(declaredOperationId);
+        }
+        else {
+          throw ono.syntax(`Validation failed. Duplicate operation id '${declaredOperationId}'`);
+        }
+      }
+      validateParameters(api, path, pathId, operation, operationId);
+
+      let responses = Object.keys(operation.responses || {});
+      for (let responseName of responses) {
+        let response = operation.responses[responseName];
+        let responseId = operationId + "/responses/" + responseName;
+        validateResponse(responseName, (response || {}), responseId);
+      }
+    }
+  }
+}
+
+/**
+ * Validates the parameters for the given operation.
+ *
+ * @param {SwaggerObject} api           - The entire Swagger API object
+ * @param {object}        path          - A Path object, from the Swagger API
+ * @param {string}        pathId        - A value that uniquely identifies the path
+ * @param {object}        operation     - An Operation object, from the Swagger API
+ * @param {string}        operationId   - A value that uniquely identifies the operation
+ */
+function validateParameters (api, path, pathId, operation, operationId) {
+  let pathParams = path.parameters || [];
+  let operationParams = operation.parameters || [];
+
+  // Check for duplicate path parameters
+  try {
+    checkForDuplicates(pathParams);
+  }
+  catch (e) {
+    throw ono.syntax(e, `Validation failed. ${pathId} has duplicate parameters`);
+  }
+
+  // Check for duplicate operation parameters
+  try {
+    checkForDuplicates(operationParams);
+  }
+  catch (e) {
+    throw ono.syntax(e, `Validation failed. ${operationId} has duplicate parameters`);
+  }
+
+  // Combine the path and operation parameters,
+  // with the operation params taking precedence over the path params
+  let params = pathParams.reduce((combinedParams, value) => {
+    let duplicate = combinedParams.some((param) => {
+      return param.in === value.in && param.name === value.name;
+    });
+    if (!duplicate) {
+      combinedParams.push(value);
+    }
+    return combinedParams;
+  }, operationParams.slice());
+
+  validateBodyParameters(params, operationId);
+  validatePathParameters(params, pathId, operationId);
+  validateParameterTypes(params, api, operation, operationId);
+}
+
+/**
+ * Validates body and formData parameters for the given operation.
+ *
+ * @param   {object[]}  params       -  An array of Parameter objects
+ * @param   {string}    operationId  -  A value that uniquely identifies the operation
+ */
+function validateBodyParameters (params, operationId) {
+  let bodyParams = params.filter((param) => { return param.in === "body"; });
+  let formParams = params.filter((param) => { return param.in === "formData"; });
+
+  // There can only be one "body" parameter
+  if (bodyParams.length > 1) {
+    throw ono.syntax(
+      `Validation failed. ${operationId} has ${bodyParams.length} body parameters. Only one is allowed.`,
+    );
+  }
+  else if (bodyParams.length > 0 && formParams.length > 0) {
+    // "body" params and "formData" params are mutually exclusive
+    throw ono.syntax(
+      `Validation failed. ${operationId} has body parameters and formData parameters. Only one or the other is allowed.`,
+    );
+  }
+}
+
+/**
+ * Validates path parameters for the given path.
+ *
+ * @param   {object[]}  params        - An array of Parameter objects
+ * @param   {string}    pathId        - A value that uniquely identifies the path
+ * @param   {string}    operationId   - A value that uniquely identifies the operation
+ */
+function validatePathParameters (params, pathId, operationId) {
+  // Find all {placeholders} in the path string
+  let placeholders = pathId.match(util.swaggerParamRegExp) || [];
+
+  // Check for duplicates
+  for (let i = 0; i < placeholders.length; i++) {
+    for (let j = i + 1; j < placeholders.length; j++) {
+      if (placeholders[i] === placeholders[j]) {
+        throw ono.syntax(
+          `Validation failed. ${operationId} has multiple path placeholders named ${placeholders[i]}`);
+      }
+    }
+  }
+
+  params = params.filter((param) => { return param.in === "path"; });
+
+  for (let param of params) {
+    if (param.required !== true) {
+      throw ono.syntax(
+        "Validation failed. Path parameters cannot be optional. " +
+        `Set required=true for the "${param.name}" parameter at ${operationId}`,
+      );
+    }
+    let match = placeholders.indexOf("{" + param.name + "}");
+    if (match === -1) {
+      throw ono.syntax(
+        `Validation failed. ${operationId} has a path parameter named "${param.name}", ` +
+        `but there is no corresponding {${param.name}} in the path string`
+      );
+    }
+    placeholders.splice(match, 1);
+  }
+
+  if (placeholders.length > 0) {
+    throw ono.syntax(`Validation failed. ${operationId} is missing path parameter(s) for ${placeholders}`);
+  }
+}
+
+/**
+ * Validates data types of parameters for the given operation.
+ *
+ * @param   {object[]}  params       -  An array of Parameter objects
+ * @param   {object}    api          -  The entire Swagger API object
+ * @param   {object}    operation    -  An Operation object, from the Swagger API
+ * @param   {string}    operationId  -  A value that uniquely identifies the operation
+ */
+function validateParameterTypes (params, api, operation, operationId) {
+  for (let param of params) {
+    let parameterId = operationId + "/parameters/" + param.name;
+    let schema, validTypes;
+
+    switch (param.in) {
+      case "body":
+        schema = param.schema;
+        validTypes = schemaTypes;
+        break;
+      case "formData":
+        schema = param;
+        validTypes = primitiveTypes.concat("file");
+        break;
+      default:
+        schema = param;
+        validTypes = primitiveTypes;
+    }
+
+    validateSchema(schema, parameterId, validTypes);
+    validateRequiredPropertiesExist(schema, parameterId);
+
+    if (schema.type === "file") {
+      // "file" params must consume at least one of these MIME types
+      let formData = /multipart\/(.*\+)?form-data/;
+      let urlEncoded = /application\/(.*\+)?x-www-form-urlencoded/;
+
+      let consumes = operation.consumes || api.consumes || [];
+
+      let hasValidMimeType = consumes.some((consume) => {
+        return formData.test(consume) || urlEncoded.test(consume);
+      });
+
+      if (!hasValidMimeType) {
+        throw ono.syntax(
+          `Validation failed. ${operationId} has a file parameter, so it must consume multipart/form-data ` +
+          "or application/x-www-form-urlencoded",
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Checks the given parameter list for duplicates, and throws an error if found.
+ *
+ * @param   {object[]}  params  - An array of Parameter objects
+ */
+function checkForDuplicates (params) {
+  for (let i = 0; i < params.length - 1; i++) {
+    let outer = params[i];
+    for (let j = i + 1; j < params.length; j++) {
+      let inner = params[j];
+      if (outer.name === inner.name && outer.in === inner.in) {
+        throw ono.syntax(`Validation failed. Found multiple ${outer.in} parameters named "${outer.name}"`);
+      }
+    }
+  }
+}
+
+/**
+ * Validates the given response object.
+ *
+ * @param   {string}    code        -  The HTTP response code (or "default")
+ * @param   {object}    response    -  A Response object, from the Swagger API
+ * @param   {string}    responseId  -  A value that uniquely identifies the response
+ */
+function validateResponse (code, response, responseId) {
+  if (code !== "default" && (code < 100 || code > 599)) {
+    throw ono.syntax(`Validation failed. ${responseId} has an invalid response code (${code})`);
+  }
+
+  let headers = Object.keys(response.headers || {});
+  for (let headerName of headers) {
+    let header = response.headers[headerName];
+    let headerId = responseId + "/headers/" + headerName;
+    validateSchema(header, headerId, primitiveTypes);
+  }
+
+  if (response.schema) {
+    let validTypes = schemaTypes.concat("file");
+    if (validTypes.indexOf(response.schema.type) === -1) {
+      throw ono.syntax(
+        `Validation failed. ${responseId} has an invalid response schema type (${response.schema.type})`);
+    }
+    else {
+      validateSchema(response.schema, responseId + "/schema", validTypes);
+    }
+  }
+}
+
+/**
+ * Validates the given Swagger schema object.
+ *
+ * @param {object}    schema      - A Schema object, from the Swagger API
+ * @param {string}    schemaId    - A value that uniquely identifies the schema object
+ * @param {string[]}  validTypes  - An array of the allowed schema types
+ */
+function validateSchema (schema, schemaId, validTypes) {
+  if (validTypes.indexOf(schema.type) === -1) {
+    throw ono.syntax(
+      `Validation failed. ${schemaId} has an invalid type (${schema.type})`);
+  }
+
+  if (schema.type === "array" && !schema.items) {
+    throw ono.syntax(`Validation failed. ${schemaId} is an array, so it must include an "items" schema`);
+  }
+}
+
+/**
+ * Validates that the declared properties of the given Swagger schema object actually exist.
+ *
+ * @param {object}    schema      - A Schema object, from the Swagger API
+ * @param {string}    schemaId    - A value that uniquely identifies the schema object
+ */
+function validateRequiredPropertiesExist (schema, schemaId) {
+  /**
+   * Recursively collects all properties of the schema and its ancestors. They are added to the props object.
+   */
+  function collectProperties (schemaObj, props) {
+    if (schemaObj.properties) {
+      for (let property in schemaObj.properties) {
+        if (schemaObj.properties.hasOwnProperty(property)) {
+          props[property] = schemaObj.properties[property];
+        }
+      }
+    }
+    if (schemaObj.allOf) {
+      for (let parent of schemaObj.allOf) {
+        collectProperties(parent, props);
+      }
+    }
+  }
+
+  // The "required" keyword is only applicable for objects
+  if (Array.isArray(schema.type) && !schema.type.includes("object")) {
+    return;
+  }
+  else if (!Array.isArray(schema.type) && schema.type !== "object") {
+    return;
+  }
+
+  if (schema.required && Array.isArray(schema.required)) {
+    let props = {};
+    collectProperties(schema, props);
+    for (let requiredProperty of schema.required) {
+      if (!props[requiredProperty]) {
+        throw ono.syntax(
+          `Validation failed. Property '${requiredProperty}' listed as required but does not exist in '${schemaId}'`
+        );
+      }
+    }
+  }
+}

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/swagger-parser/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@apidevtools/swagger-parser",
+  "version": "10.1.1",
+  "description": "Swagger 2.0 and OpenAPI 3.0 parser and validator for Node and browsers",
+  "keywords": [
+    "swagger",
+    "openapi",
+    "open-api",
+    "json",
+    "yaml",
+    "parse",
+    "parser",
+    "validate",
+    "validator",
+    "validation",
+    "spec",
+    "specification",
+    "schema",
+    "reference",
+    "dereference"
+  ],
+  "author": {
+    "name": "James Messinger",
+    "url": "https://jamesmessinger.com"
+  },
+  "homepage": "https://apitools.dev/swagger-parser/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/APIDevTools/swagger-parser.git"
+  },
+  "license": "MIT",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "clean": "shx rm -rf .nyc_output coverage",
+    "lint": "eslint lib test online/src/js",
+    "lint:fix": "eslint --fix lib test online/src/js",
+    "build": "npm run build:website && npm run build:sass",
+    "build:website": "node build-website.mjs",
+    "build:sass": "sass online/src/scss/style.scss online/css/style.min.css",
+    "test": "npm run test:node && npm run test:typescript && npm run lint",
+    "test:node": "mocha",
+    "test:typescript": "tsc --noEmit --strict --lib esnext,dom test/specs/typescript-definition.spec.ts",
+    "coverage": "npm run coverage:node",
+    "coverage:node": "cross-env QUICK_TEST=true nyc mocha",
+    "upgrade": "npm-check -u && npm audit fix",
+    "bump": "bump --tag --push --all",
+    "--release--cannot upgrade or everything breaks": "npm run upgrade && npm run clean && npm run build && npm test && npm run bump",
+    "release": "npm run clean && npm run build && npm test && npm run bump"
+  },
+  "devDependencies": {
+    "@jsdevtools/host-environment": "^2.1.2",
+    "@jsdevtools/version-bump-prompt": "^6.1.0",
+    "@types/node": "^22.7.5",
+    "chai": "^4",
+    "cross-env": "^7.0.3",
+    "esbuild": "^0.24.0",
+    "esbuild-plugin-polyfill-node": "^0.3.0",
+    "eslint": "^8",
+    "eslint-plugin-jsdoc": "^50.3.1",
+    "js-yaml": "^4.1.0",
+    "mocha": "^10.7.3",
+    "node-fetch": "^2",
+    "npm-check": "^6.0.1",
+    "nyc": "^17.1.0",
+    "openapi-types": "^12.1.3",
+    "sass": "^1.79.4",
+    "shx": "^0.3.4",
+    "sinon": "^19.0.2",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "@apidevtools/json-schema-ref-parser": "11.7.2",
+    "@apidevtools/openapi-schemas": "^2.1.0",
+    "@apidevtools/swagger-methods": "^3.0.2",
+    "@jsdevtools/ono": "^7.1.3",
+    "ajv": "^8.17.1",
+    "ajv-draft-04": "^1.0.0",
+    "call-me-maybe": "^1.0.2"
+  },
+  "peerDependencies": {
+    "openapi-types": ">=7"
+  }
+}