@nocobase/plugin-mcp-server 2.1.0-alpha.19 → 2.1.0-alpha.21

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

@@ -1,74 +0,0 @@
-"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

@@ -1,79 +0,0 @@
-"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

@@ -1,93 +0,0 @@
-"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

@@ -1,352 +0,0 @@
-"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

@@ -1,87 +0,0 @@
-{
-  "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"
-  }
-}