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

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/lib/pointer.ts

@@ -1,327 +0,0 @@
-import type { ParserOptions } from "./options.js";
-
-import $Ref from "./ref.js";
-import * as url from "./util/url.js";
-import { JSONParserError, InvalidPointerError, MissingPointerError, isHandledError } from "./util/errors.js";
-import type { JSONSchema } from "./types";
-
-const slashes = /\//g;
-const tildes = /~/g;
-const escapedSlash = /~1/g;
-const escapedTilde = /~0/g;
-
-const safeDecodeURIComponent = (encodedURIComponent: string): string => {
-  try {
-    return decodeURIComponent(encodedURIComponent);
-  } catch {
-    return encodedURIComponent;
-  }
-};
-
-/**
- * This class represents a single JSON pointer and its resolved value.
- *
- * @param $ref
- * @param path
- * @param [friendlyPath] - The original user-specified path (used for error messages)
- * @class
- */
-class Pointer<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * The {@link $Ref} object that contains this {@link Pointer} object.
-   */
-  $ref: $Ref<S, O>;
-
-  /**
-   * The file path or URL, containing the JSON pointer in the hash.
-   * This path is relative to the path of the main JSON schema file.
-   */
-  path: string;
-
-  /**
-   * The original path or URL, used for error messages.
-   */
-  originalPath: string;
-
-  /**
-   * The value of the JSON pointer.
-   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
-   */
-
-  value: any;
-  /**
-   * Indicates whether the pointer references itself.
-   */
-  circular: boolean;
-  /**
-   * The number of indirect references that were traversed to resolve the value.
-   * Resolving a single pointer may require resolving multiple $Refs.
-   */
-  indirections: number;
-
-  constructor($ref: $Ref<S, O>, path: string, friendlyPath?: string) {
-    this.$ref = $ref;
-
-    this.path = path;
-
-    this.originalPath = friendlyPath || path;
-
-    this.value = undefined;
-
-    this.circular = false;
-
-    this.indirections = 0;
-  }
-
-  /**
-   * Resolves the value of a nested property within the given object.
-   *
-   * @param obj - The object that will be crawled
-   * @param options
-   * @param pathFromRoot - the path of place that initiated resolving
-   *
-   * @returns
-   * Returns a JSON pointer whose {@link Pointer#value} is the resolved value.
-   * If resolving this value required resolving other JSON references, then
-   * the {@link Pointer#$ref} and {@link Pointer#path} will reflect the resolution path
-   * of the resolved value.
-   */
-  resolve(obj: S, options?: O, pathFromRoot?: string) {
-    const tokens = Pointer.parse(this.path, this.originalPath);
-
-    // Crawl the object, one token at a time
-    this.value = unwrapOrThrow(obj);
-
-    for (let i = 0; i < tokens.length; i++) {
-      if (resolveIf$Ref(this, options, pathFromRoot)) {
-        // The $ref path has changed, so append the remaining tokens to the path
-        this.path = Pointer.join(this.path, tokens.slice(i));
-      }
-
-      if (typeof this.value === "object" && this.value !== null && !isRootPath(pathFromRoot) && "$ref" in this.value) {
-        return this;
-      }
-
-      const token = tokens[i];
-      if (this.value[token] === undefined || (this.value[token] === null && i === tokens.length - 1)) {
-        // one final case is if the entry itself includes slashes, and was parsed out as a token - we can join the remaining tokens and try again
-        let didFindSubstringSlashMatch = false;
-        for (let j = tokens.length - 1; j > i; j--) {
-          const joinedToken = tokens.slice(i, j + 1).join("/");
-          if (this.value[joinedToken] !== undefined) {
-            this.value = this.value[joinedToken];
-            i = j;
-            didFindSubstringSlashMatch = true;
-            break;
-          }
-        }
-        if (didFindSubstringSlashMatch) {
-          continue;
-        }
-
-        this.value = null;
-        throw new MissingPointerError(token, decodeURI(this.originalPath));
-      } else {
-        this.value = this.value[token];
-      }
-    }
-
-    // Resolve the final value
-    if (!this.value || (this.value.$ref && url.resolve(this.path, this.value.$ref) !== pathFromRoot)) {
-      resolveIf$Ref(this, options, pathFromRoot);
-    }
-
-    return this;
-  }
-
-  /**
-   * Sets the value of a nested property within the given object.
-   *
-   * @param obj - The object that will be crawled
-   * @param value - the value to assign
-   * @param options
-   *
-   * @returns
-   * Returns the modified object, or an entirely new object if the entire object is overwritten.
-   */
-  set(obj: S, value: any, options?: O) {
-    const tokens = Pointer.parse(this.path);
-    let token;
-
-    if (tokens.length === 0) {
-      // There are no tokens, replace the entire object with the new value
-      this.value = value;
-      return value;
-    }
-
-    // Crawl the object, one token at a time
-    this.value = unwrapOrThrow(obj);
-
-    for (let i = 0; i < tokens.length - 1; i++) {
-      resolveIf$Ref(this, options);
-
-      token = tokens[i];
-      if (this.value && this.value[token] !== undefined) {
-        // The token exists
-        this.value = this.value[token];
-      } else {
-        // The token doesn't exist, so create it
-        this.value = setValue(this, token, {});
-      }
-    }
-
-    // Set the value of the final token
-    resolveIf$Ref(this, options);
-    token = tokens[tokens.length - 1];
-    setValue(this, token, value);
-
-    // Return the updated object
-    return obj;
-  }
-
-  /**
-   * Parses a JSON pointer (or a path containing a JSON pointer in the hash)
-   * and returns an array of the pointer's tokens.
-   * (e.g. "schema.json#/definitions/person/name" => ["definitions", "person", "name"])
-   *
-   * The pointer is parsed according to RFC 6901
-   * {@link https://tools.ietf.org/html/rfc6901#section-3}
-   *
-   * @param path
-   * @param [originalPath]
-   * @returns
-   */
-  static parse(path: string, originalPath?: string): string[] {
-    // Get the JSON pointer from the path's hash
-    const pointer = url.getHash(path).substring(1);
-
-    // If there's no pointer, then there are no tokens,
-    // so return an empty array
-    if (!pointer) {
-      return [];
-    }
-
-    // Split into an array
-    const split = pointer.split("/");
-
-    // Decode each part, according to RFC 6901
-    for (let i = 0; i < split.length; i++) {
-      split[i] = safeDecodeURIComponent(split[i].replace(escapedSlash, "/").replace(escapedTilde, "~"));
-    }
-
-    if (split[0] !== "") {
-      throw new InvalidPointerError(split, originalPath === undefined ? path : originalPath);
-    }
-
-    return split.slice(1);
-  }
-
-  /**
-   * Creates a JSON pointer path, by joining one or more tokens to a base path.
-   *
-   * @param base - The base path (e.g. "schema.json#/definitions/person")
-   * @param tokens - The token(s) to append (e.g. ["name", "first"])
-   * @returns
-   */
-  static join(base: string, tokens: string | string[]) {
-    // Ensure that the base path contains a hash
-    if (base.indexOf("#") === -1) {
-      base += "#";
-    }
-
-    // Append each token to the base path
-    tokens = Array.isArray(tokens) ? tokens : [tokens];
-    for (let i = 0; i < tokens.length; i++) {
-      const token = tokens[i];
-      // Encode the token, according to RFC 6901
-      base += "/" + encodeURIComponent(token.replace(tildes, "~0").replace(slashes, "~1"));
-    }
-
-    return base;
-  }
-}
-
-/**
- * If the given pointer's {@link Pointer#value} is a JSON reference,
- * then the reference is resolved and {@link Pointer#value} is replaced with the resolved value.
- * In addition, {@link Pointer#path} and {@link Pointer#$ref} are updated to reflect the
- * resolution path of the new value.
- *
- * @param pointer
- * @param options
- * @param [pathFromRoot] - the path of place that initiated resolving
- * @returns - Returns `true` if the resolution path changed
- */
-function resolveIf$Ref(pointer: any, options: any, pathFromRoot?: any) {
-  // Is the value a JSON reference? (and allowed?)
-
-  if ($Ref.isAllowed$Ref(pointer.value, options)) {
-    const $refPath = url.resolve(pointer.path, pointer.value.$ref);
-
-    if ($refPath === pointer.path && !isRootPath(pathFromRoot)) {
-      // The value is a reference to itself, so there's nothing to do.
-      pointer.circular = true;
-    } else {
-      const resolved = pointer.$ref.$refs._resolve($refPath, pointer.path, options);
-      if (resolved === null) {
-        return false;
-      }
-
-      pointer.indirections += resolved.indirections + 1;
-
-      if ($Ref.isExtended$Ref(pointer.value)) {
-        // This JSON reference "extends" the resolved value, rather than simply pointing to it.
-        // So the resolved path does NOT change.  Just the value does.
-        pointer.value = $Ref.dereference(pointer.value, resolved.value);
-        return false;
-      } else {
-        // Resolve the reference
-        pointer.$ref = resolved.$ref;
-        pointer.path = resolved.path;
-        pointer.value = resolved.value;
-      }
-
-      return true;
-    }
-  }
-  return undefined;
-}
-export default Pointer;
-
-/**
- * Sets the specified token value of the {@link Pointer#value}.
- *
- * The token is evaluated according to RFC 6901.
- * {@link https://tools.ietf.org/html/rfc6901#section-4}
- *
- * @param pointer - The JSON Pointer whose value will be modified
- * @param token - A JSON Pointer token that indicates how to modify `obj`
- * @param value - The value to assign
- * @returns - Returns the assigned value
- */
-function setValue(pointer: any, token: any, value: any) {
-  if (pointer.value && typeof pointer.value === "object") {
-    if (token === "-" && Array.isArray(pointer.value)) {
-      pointer.value.push(value);
-    } else {
-      pointer.value[token] = value;
-    }
-  } else {
-    throw new JSONParserError(
-      `Error assigning $ref pointer "${pointer.path}". \nCannot set "${token}" of a non-object.`,
-    );
-  }
-  return value;
-}
-
-function unwrapOrThrow(value: any) {
-  if (isHandledError(value)) {
-    throw value;
-  }
-
-  return value;
-}
-
-function isRootPath(pathFromRoot: any): boolean {
-  return typeof pathFromRoot == "string" && Pointer.parse(pathFromRoot).length == 0;
-}

package/dist/node_modules/openapi-mcp-generator/node_modules/@apidevtools/json-schema-ref-parser/lib/ref.ts

@@ -1,298 +0,0 @@
-import Pointer from "./pointer.js";
-import type { JSONParserError, MissingPointerError, ParserError, ResolverError } from "./util/errors.js";
-import { InvalidPointerError, isHandledError, normalizeError } from "./util/errors.js";
-import { safePointerToPath, stripHash, getHash } from "./util/url.js";
-import type $Refs from "./refs.js";
-import type { ParserOptions } from "./options.js";
-import type { JSONSchema } from "./types";
-
-export type $RefError = JSONParserError | ResolverError | ParserError | MissingPointerError;
-
-/**
- * This class represents a single JSON reference and its resolved value.
- *
- * @class
- */
-class $Ref<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>> {
-  /**
-   * The file path or URL of the referenced file.
-   * This path is relative to the path of the main JSON schema file.
-   *
-   * This path does NOT contain document fragments (JSON pointers). It always references an ENTIRE file.
-   * Use methods such as {@link $Ref#get}, {@link $Ref#resolve}, and {@link $Ref#exists} to get
-   * specific JSON pointers within the file.
-   *
-   * @type {string}
-   */
-  path: undefined | string;
-
-  /**
-   * The resolved value of the JSON reference.
-   * Can be any JSON type, not just objects. Unknown file types are represented as Buffers (byte arrays).
-   *
-   * @type {?*}
-   */
-  value: any;
-
-  /**
-   * The {@link $Refs} object that contains this {@link $Ref} object.
-   *
-   * @type {$Refs}
-   */
-  $refs: $Refs<S, O>;
-
-  /**
-   * Indicates the type of {@link $Ref#path} (e.g. "file", "http", etc.)
-   */
-  pathType: string | unknown;
-
-  /**
-   * List of all errors. Undefined if no errors.
-   */
-  errors: Array<$RefError> = [];
-
-  constructor($refs: $Refs<S, O>) {
-    this.$refs = $refs;
-  }
-
-  /**
-   * Pushes an error to errors array.
-   *
-   * @param err - The error to be pushed
-   * @returns
-   */
-  addError(err: $RefError) {
-    if (this.errors === undefined) {
-      this.errors = [];
-    }
-
-    const existingErrors = this.errors.map(({ footprint }: any) => footprint);
-
-    // the path has been almost certainly set at this point,
-    // but just in case something went wrong, normalizeError injects path if necessary
-    // moreover, certain errors might point at the same spot, so filter them out to reduce noise
-    if ("errors" in err && Array.isArray(err.errors)) {
-      this.errors.push(
-        ...err.errors.map(normalizeError).filter(({ footprint }: any) => !existingErrors.includes(footprint)),
-      );
-    } else if (!("footprint" in err) || !existingErrors.includes(err.footprint)) {
-      this.errors.push(normalizeError(err));
-    }
-  }
-
-  /**
-   * Determines whether the given JSON reference exists within this {@link $Ref#value}.
-   *
-   * @param path - The full path being resolved, optionally with a JSON pointer in the hash
-   * @param options
-   * @returns
-   */
-  exists(path: string, options?: O) {
-    try {
-      this.resolve(path, options);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Resolves the given JSON reference within this {@link $Ref#value} and returns the resolved value.
-   *
-   * @param path - The full path being resolved, optionally with a JSON pointer in the hash
-   * @param options
-   * @returns - Returns the resolved value
-   */
-  get(path: string, options?: O) {
-    return this.resolve(path, options)?.value;
-  }
-
-  /**
-   * Resolves the given JSON reference within this {@link $Ref#value}.
-   *
-   * @param path - The full path being resolved, optionally with a JSON pointer in the hash
-   * @param options
-   * @param friendlyPath - The original user-specified path (used for error messages)
-   * @param pathFromRoot - The path of `obj` from the schema root
-   * @returns
-   */
-  resolve(path: string, options?: O, friendlyPath?: string, pathFromRoot?: string) {
-    const pointer = new Pointer<S, O>(this, path, friendlyPath);
-    try {
-      return pointer.resolve(this.value, options, pathFromRoot);
-    } catch (err: any) {
-      if (!options || !options.continueOnError || !isHandledError(err)) {
-        throw err;
-      }
-
-      if (err.path === null) {
-        err.path = safePointerToPath(getHash(pathFromRoot));
-      }
-
-      if (err instanceof InvalidPointerError) {
-        err.source = decodeURI(stripHash(pathFromRoot));
-      }
-
-      this.addError(err);
-      return null;
-    }
-  }
-
-  /**
-   * Sets the value of a nested property within this {@link $Ref#value}.
-   * If the property, or any of its parents don't exist, they will be created.
-   *
-   * @param path - The full path of the property to set, optionally with a JSON pointer in the hash
-   * @param value - The value to assign
-   */
-  set(path: string, value: any) {
-    const pointer = new Pointer(this, path);
-    this.value = pointer.set(this.value, value);
-  }
-
-  /**
-   * Determines whether the given value is a JSON reference.
-   *
-   * @param value - The value to inspect
-   * @returns
-   */
-  static is$Ref(value: unknown): value is { $ref: string; length?: number } {
-    return (
-      Boolean(value) &&
-      typeof value === "object" &&
-      value !== null &&
-      "$ref" in value &&
-      typeof value.$ref === "string" &&
-      value.$ref.length > 0
-    );
-  }
-
-  /**
-   * Determines whether the given value is an external JSON reference.
-   *
-   * @param value - The value to inspect
-   * @returns
-   */
-  static isExternal$Ref(value: unknown): boolean {
-    return $Ref.is$Ref(value) && value.$ref![0] !== "#";
-  }
-
-  /**
-   * Determines whether the given value is a JSON reference, and whether it is allowed by the options.
-   * For example, if it references an external file, then options.resolve.external must be true.
-   *
-   * @param value - The value to inspect
-   * @param options
-   * @returns
-   */
-  static isAllowed$Ref<S extends object = JSONSchema>(value: unknown, options?: ParserOptions<S>) {
-    if (this.is$Ref(value)) {
-      if (value.$ref.substring(0, 2) === "#/" || value.$ref === "#") {
-        // It's a JSON Pointer reference, which is always allowed
-        return true;
-      } else if (value.$ref[0] !== "#" && (!options || options.resolve?.external)) {
-        // It's an external reference, which is allowed by the options
-        return true;
-      }
-    }
-    return undefined;
-  }
-
-  /**
-   * Determines whether the given value is a JSON reference that "extends" its resolved value.
-   * That is, it has extra properties (in addition to "$ref"), so rather than simply pointing to
-   * an existing value, this $ref actually creates a NEW value that is a shallow copy of the resolved
-   * value, plus the extra properties.
-   *
-   * @example: {
-     person: {
-       properties: {
-         firstName: { type: string }
-         lastName: { type: string }
-       }
-     }
-     employee: {
-       properties: {
-         $ref: #/person/properties
-         salary: { type: number }
-       }
-     }
-   }
-   *  In this example, "employee" is an extended $ref, since it extends "person" with an additional
-   *  property (salary).  The result is a NEW value that looks like this:
-   *
-   *  {
-   *    properties: {
-   *      firstName: { type: string }
-   *      lastName: { type: string }
-   *      salary: { type: number }
-   *    }
-   *  }
-   *
-   * @param value - The value to inspect
-   * @returns
-   */
-  static isExtended$Ref(value: unknown) {
-    return $Ref.is$Ref(value) && Object.keys(value).length > 1;
-  }
-
-  /**
-   * Returns the resolved value of a JSON Reference.
-   * If necessary, the resolved value is merged with the JSON Reference to create a new object
-   *
-   * @example: {
-  person: {
-    properties: {
-      firstName: { type: string }
-      lastName: { type: string }
-    }
-  }
-  employee: {
-    properties: {
-      $ref: #/person/properties
-      salary: { type: number }
-    }
-  }
-  } When "person" and "employee" are merged, you end up with the following object:
-   *
-   *  {
-   *    properties: {
-   *      firstName: { type: string }
-   *      lastName: { type: string }
-   *      salary: { type: number }
-   *    }
-   *  }
-   *
-   * @param $ref - The JSON reference object (the one with the "$ref" property)
-   * @param resolvedValue - The resolved value, which can be any type
-   * @returns - Returns the dereferenced value
-   */
-  static dereference<S extends object = JSONSchema, O extends ParserOptions<S> = ParserOptions<S>>(
-    $ref: $Ref<S, O>,
-    resolvedValue: S,
-  ): S {
-    if (resolvedValue && typeof resolvedValue === "object" && $Ref.isExtended$Ref($ref)) {
-      const merged = {};
-      for (const key of Object.keys($ref)) {
-        if (key !== "$ref") {
-          // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
-          merged[key] = $ref[key];
-        }
-      }
-
-      for (const key of Object.keys(resolvedValue)) {
-        if (!(key in merged)) {
-          // @ts-expect-error TS(7053): Element implicitly has an 'any' type because expre... Remove this comment to see the full error message
-          merged[key] = resolvedValue[key];
-        }
-      }
-
-      return merged as S;
-    } else {
-      // Completely replace the original reference with the resolved value
-      return resolvedValue;
-    }
-  }
-}
-
-export default $Ref;