@nocobase/plugin-mcp-server 2.1.0-alpha.13 → 2.1.0-alpha.14

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v3/helpers/util.ts

@@ -1,224 +0,0 @@
-export namespace util {
-  type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
-
-  export type isAny<T> = 0 extends 1 & T ? true : false;
-  export const assertEqual = <A, B>(_: AssertEqual<A, B>): void => {};
-  export function assertIs<T>(_arg: T): void {}
-  export function assertNever(_x: never): never {
-    throw new Error();
-  }
-
-  export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-  export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
-  export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-  export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-  export type InexactPartial<T> = { [k in keyof T]?: T[k] | undefined };
-  export const arrayToEnum = <T extends string, U extends [T, ...T[]]>(items: U): { [k in U[number]]: k } => {
-    const obj: any = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
-  };
-
-  export const getValidEnumValues = (obj: any): any[] => {
-    const validKeys = objectKeys(obj).filter((k: any) => typeof obj[obj[k]] !== "number");
-    const filtered: any = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
-    }
-    return objectValues(filtered);
-  };
-
-  export const objectValues = (obj: any): any[] => {
-    return objectKeys(obj).map(function (e) {
-      return obj[e];
-    });
-  };
-
-  export const objectKeys: ObjectConstructor["keys"] =
-    typeof Object.keys === "function" // eslint-disable-line ban/ban
-      ? (obj: any) => Object.keys(obj) // eslint-disable-line ban/ban
-      : (object: any) => {
-          const keys = [];
-          for (const key in object) {
-            if (Object.prototype.hasOwnProperty.call(object, key)) {
-              keys.push(key);
-            }
-          }
-          return keys;
-        };
-
-  export const find = <T>(arr: T[], checker: (arg: T) => any): T | undefined => {
-    for (const item of arr) {
-      if (checker(item)) return item;
-    }
-    return undefined;
-  };
-
-  export type identity<T> = objectUtil.identity<T>;
-  export type flatten<T> = objectUtil.flatten<T>;
-
-  export type noUndefined<T> = T extends undefined ? never : T;
-
-  export const isInteger: NumberConstructor["isInteger"] =
-    typeof Number.isInteger === "function"
-      ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
-      : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
-
-  export function joinValues<T extends any[]>(array: T, separator = " | "): string {
-    return array.map((val) => (typeof val === "string" ? `'${val}'` : val)).join(separator);
-  }
-
-  export const jsonStringifyReplacer = (_: string, value: any): any => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  };
-}
-
-export namespace objectUtil {
-  export type MergeShapes<U, V> =
-    // fast path when there is no keys overlap
-    keyof U & keyof V extends never
-      ? U & V
-      : {
-          [k in Exclude<keyof U, keyof V>]: U[k];
-        } & V;
-
-  type optionalKeys<T extends object> = {
-    [k in keyof T]: undefined extends T[k] ? k : never;
-  }[keyof T];
-  type requiredKeys<T extends object> = {
-    [k in keyof T]: undefined extends T[k] ? never : k;
-  }[keyof T];
-  export type addQuestionMarks<T extends object, _O = any> = {
-    [K in requiredKeys<T>]: T[K];
-  } & {
-    [K in optionalKeys<T>]?: T[K];
-  } & { [k in keyof T]?: unknown };
-
-  export type identity<T> = T;
-  export type flatten<T> = identity<{ [k in keyof T]: T[k] }>;
-
-  export type noNeverKeys<T> = {
-    [k in keyof T]: [T[k]] extends [never] ? never : k;
-  }[keyof T];
-
-  export type noNever<T> = identity<{
-    [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
-  }>;
-
-  export const mergeShapes = <U, T>(first: U, second: T): T & U => {
-    return {
-      ...first,
-      ...second, // second overwrites first
-    };
-  };
-
-  export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never // fast path when there is no keys overlap
-    ? A & B
-    : {
-        [K in keyof A as K extends keyof B ? never : K]: A[K];
-      } & {
-        [K in keyof B]: B[K];
-      };
-}
-
-export const ZodParsedType: {
-  string: "string";
-  nan: "nan";
-  number: "number";
-  integer: "integer";
-  float: "float";
-  boolean: "boolean";
-  date: "date";
-  bigint: "bigint";
-  symbol: "symbol";
-  function: "function";
-  undefined: "undefined";
-  null: "null";
-  array: "array";
-  object: "object";
-  unknown: "unknown";
-  promise: "promise";
-  void: "void";
-  never: "never";
-  map: "map";
-  set: "set";
-} = util.arrayToEnum([
-  "string",
-  "nan",
-  "number",
-  "integer",
-  "float",
-  "boolean",
-  "date",
-  "bigint",
-  "symbol",
-  "function",
-  "undefined",
-  "null",
-  "array",
-  "object",
-  "unknown",
-  "promise",
-  "void",
-  "never",
-  "map",
-  "set",
-]);
-
-export type ZodParsedType = keyof typeof ZodParsedType;
-
-export const getParsedType = (data: any): ZodParsedType => {
-  const t = typeof data;
-
-  switch (t) {
-    case "undefined":
-      return ZodParsedType.undefined;
-
-    case "string":
-      return ZodParsedType.string;
-
-    case "number":
-      return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
-
-    case "boolean":
-      return ZodParsedType.boolean;
-
-    case "function":
-      return ZodParsedType.function;
-
-    case "bigint":
-      return ZodParsedType.bigint;
-
-    case "symbol":
-      return ZodParsedType.symbol;
-
-    case "object":
-      if (Array.isArray(data)) {
-        return ZodParsedType.array;
-      }
-      if (data === null) {
-        return ZodParsedType.null;
-      }
-      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
-        return ZodParsedType.promise;
-      }
-      if (typeof Map !== "undefined" && data instanceof Map) {
-        return ZodParsedType.map;
-      }
-      if (typeof Set !== "undefined" && data instanceof Set) {
-        return ZodParsedType.set;
-      }
-      if (typeof Date !== "undefined" && data instanceof Date) {
-        return ZodParsedType.date;
-      }
-      return ZodParsedType.object;
-
-    default:
-      return ZodParsedType.unknown;
-  }
-};

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v3/index.ts

@@ -1,4 +0,0 @@
-import * as z from "./external.js";
-export * from "./external.js";
-export { z };
-export default z;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v3/locales/en.ts

@@ -1,124 +0,0 @@
-import { type ZodErrorMap, ZodIssueCode } from "../ZodError.js";
-import { util, ZodParsedType } from "../helpers/util.js";
-
-const errorMap: ZodErrorMap = (issue, _ctx) => {
-  let message: string;
-  switch (issue.code) {
-    case ZodIssueCode.invalid_type:
-      if (issue.received === ZodParsedType.undefined) {
-        message = "Required";
-      } else {
-        message = `Expected ${issue.expected}, received ${issue.received}`;
-      }
-      break;
-    case ZodIssueCode.invalid_literal:
-      message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
-      break;
-    case ZodIssueCode.unrecognized_keys:
-      message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
-      break;
-    case ZodIssueCode.invalid_union:
-      message = `Invalid input`;
-      break;
-    case ZodIssueCode.invalid_union_discriminator:
-      message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
-      break;
-    case ZodIssueCode.invalid_enum_value:
-      message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
-      break;
-    case ZodIssueCode.invalid_arguments:
-      message = `Invalid function arguments`;
-      break;
-    case ZodIssueCode.invalid_return_type:
-      message = `Invalid function return type`;
-      break;
-    case ZodIssueCode.invalid_date:
-      message = `Invalid date`;
-      break;
-    case ZodIssueCode.invalid_string:
-      if (typeof issue.validation === "object") {
-        if ("includes" in issue.validation) {
-          message = `Invalid input: must include "${issue.validation.includes}"`;
-
-          if (typeof issue.validation.position === "number") {
-            message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
-          }
-        } else if ("startsWith" in issue.validation) {
-          message = `Invalid input: must start with "${issue.validation.startsWith}"`;
-        } else if ("endsWith" in issue.validation) {
-          message = `Invalid input: must end with "${issue.validation.endsWith}"`;
-        } else {
-          util.assertNever(issue.validation);
-        }
-      } else if (issue.validation !== "regex") {
-        message = `Invalid ${issue.validation}`;
-      } else {
-        message = "Invalid";
-      }
-      break;
-    case ZodIssueCode.too_small:
-      if (issue.type === "array")
-        message = `Array must contain ${
-          issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`
-        } ${issue.minimum} element(s)`;
-      else if (issue.type === "string")
-        message = `String must contain ${
-          issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`
-        } ${issue.minimum} character(s)`;
-      else if (issue.type === "number")
-        message = `Number must be ${
-          issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `
-        }${issue.minimum}`;
-      else if (issue.type === "bigint")
-        message = `Number must be ${
-          issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `
-        }${issue.minimum}`;
-      else if (issue.type === "date")
-        message = `Date must be ${
-          issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `
-        }${new Date(Number(issue.minimum))}`;
-      else message = "Invalid input";
-      break;
-    case ZodIssueCode.too_big:
-      if (issue.type === "array")
-        message = `Array must contain ${
-          issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`
-        } ${issue.maximum} element(s)`;
-      else if (issue.type === "string")
-        message = `String must contain ${
-          issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`
-        } ${issue.maximum} character(s)`;
-      else if (issue.type === "number")
-        message = `Number must be ${
-          issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`
-        } ${issue.maximum}`;
-      else if (issue.type === "bigint")
-        message = `BigInt must be ${
-          issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`
-        } ${issue.maximum}`;
-      else if (issue.type === "date")
-        message = `Date must be ${
-          issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`
-        } ${new Date(Number(issue.maximum))}`;
-      else message = "Invalid input";
-      break;
-    case ZodIssueCode.custom:
-      message = `Invalid input`;
-      break;
-    case ZodIssueCode.invalid_intersection_types:
-      message = `Intersection results could not be merged`;
-      break;
-    case ZodIssueCode.not_multiple_of:
-      message = `Number must be a multiple of ${issue.multipleOf}`;
-      break;
-    case ZodIssueCode.not_finite:
-      message = "Number must be finite";
-      break;
-    default:
-      message = _ctx.defaultError;
-      util.assertNever(issue);
-  }
-  return { message };
-};
-
-export default errorMap;

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v3/standard-schema.ts

@@ -1,113 +0,0 @@
-/**
- * The Standard Schema interface.
- */
-export type StandardSchemaV1<Input = unknown, Output = Input> = {
-  /**
-   * The Standard Schema properties.
-   */
-  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-};
-
-export declare namespace StandardSchemaV1 {
-  /**
-   * The Standard Schema properties interface.
-   */
-  export interface Props<Input = unknown, Output = Input> {
-    /**
-     * The version number of the standard.
-     */
-    readonly version: 1;
-    /**
-     * The vendor name of the schema library.
-     */
-    readonly vendor: string;
-    /**
-     * Validates unknown input values.
-     */
-    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-    /**
-     * Inferred types associated with the schema.
-     */
-    readonly types?: Types<Input, Output> | undefined;
-  }
-
-  /**
-   * The result interface of the validate function.
-   */
-  export type Result<Output> = SuccessResult<Output> | FailureResult;
-
-  /**
-   * The result interface if validation succeeds.
-   */
-  export interface SuccessResult<Output> {
-    /**
-     * The typed output value.
-     */
-    readonly value: Output;
-    /**
-     * The non-existent issues.
-     */
-    readonly issues?: undefined;
-  }
-
-  /**
-   * The result interface if validation fails.
-   */
-  export interface FailureResult {
-    /**
-     * The issues of failed validation.
-     */
-    readonly issues: ReadonlyArray<Issue>;
-  }
-
-  /**
-   * The issue interface of the failure output.
-   */
-  export interface Issue {
-    /**
-     * The error message of the issue.
-     */
-    readonly message: string;
-    /**
-     * The path of the issue, if any.
-     */
-    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-  }
-
-  /**
-   * The path segment interface of the issue.
-   */
-  export interface PathSegment {
-    /**
-     * The key representing a path segment.
-     */
-    readonly key: PropertyKey;
-  }
-
-  /**
-   * The Standard Schema types interface.
-   */
-  export interface Types<Input = unknown, Output = Input> {
-    /**
-     * The input type of the schema.
-     */
-    readonly input: Input;
-    /**
-     * The output type of the schema.
-     */
-    readonly output: Output;
-  }
-
-  /**
-   * Infers the input type of a Standard Schema.
-   */
-  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-
-  /**
-   * Infers the output type of a Standard Schema.
-   */
-  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-
-  // biome-ignore lint/complexity/noUselessEmptyExport: needed for granular visibility control of TS namespace
-  export {};
-}

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v3/tests/Mocker.ts

@@ -1,54 +0,0 @@
-function getRandomInt(max: number) {
-  return Math.floor(Math.random() * Math.floor(max));
-}
-
-const testSymbol = Symbol("test");
-
-export class Mocker {
-  pick = (...args: any[]): any => {
-    return args[getRandomInt(args.length)];
-  };
-
-  get string(): string {
-    return Math.random().toString(36).substring(7);
-  }
-  get number(): number {
-    return Math.random() * 100;
-  }
-  get bigint(): bigint {
-    return BigInt(Math.floor(Math.random() * 10000));
-  }
-  get boolean(): boolean {
-    return Math.random() < 0.5;
-  }
-  get date(): Date {
-    return new Date(Math.floor(Date.now() * Math.random()));
-  }
-  get symbol(): symbol {
-    return testSymbol;
-  }
-  get null(): null {
-    return null;
-  }
-  get undefined(): undefined {
-    return undefined;
-  }
-  get stringOptional(): string | undefined {
-    return this.pick(this.string, this.undefined);
-  }
-  get stringNullable(): string | null {
-    return this.pick(this.string, this.null);
-  }
-  get numberOptional(): number | undefined {
-    return this.pick(this.number, this.undefined);
-  }
-  get numberNullable(): number | null {
-    return this.pick(this.number, this.null);
-  }
-  get booleanOptional(): boolean | undefined {
-    return this.pick(this.boolean, this.undefined);
-  }
-  get booleanNullable(): boolean | null {
-    return this.pick(this.boolean, this.null);
-  }
-}

package/dist/node_modules/@modelcontextprotocol/sdk/node_modules/zod-to-json-schema/node_modules/zod/src/v3/tests/all-errors.test.ts

@@ -1,157 +0,0 @@
-// @ts-ignore TS6133
-import { expect, test } from "vitest";
-
-import * as z from "zod/v3";
-import { util } from "../helpers/util.js";
-
-const Test = z.object({
-  f1: z.number(),
-  f2: z.string().optional(),
-  f3: z.string().nullable(),
-  f4: z.array(z.object({ t: z.union([z.string(), z.boolean()]) })),
-});
-type TestFlattenedErrors = z.inferFlattenedErrors<typeof Test, { message: string; code: number }>;
-type TestFormErrors = z.inferFlattenedErrors<typeof Test>;
-
-test("default flattened errors type inference", () => {
-  type TestTypeErrors = {
-    formErrors: string[];
-    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] | undefined };
-  };
-
-  util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);
-  util.assertEqual<z.inferFlattenedErrors<typeof Test, { message: string }>, TestTypeErrors>(false);
-});
-
-test("custom flattened errors type inference", () => {
-  type ErrorType = { message: string; code: number };
-  type TestTypeErrors = {
-    formErrors: ErrorType[];
-    fieldErrors: {
-      [P in keyof z.TypeOf<typeof Test>]?: ErrorType[] | undefined;
-    };
-  };
-
-  util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(false);
-  util.assertEqual<z.inferFlattenedErrors<typeof Test, { message: string; code: number }>, TestTypeErrors>(true);
-  util.assertEqual<z.inferFlattenedErrors<typeof Test, { message: string }>, TestTypeErrors>(false);
-});
-
-test("form errors type inference", () => {
-  type TestTypeErrors = {
-    formErrors: string[];
-    fieldErrors: { [P in keyof z.TypeOf<typeof Test>]?: string[] | undefined };
-  };
-
-  util.assertEqual<z.inferFlattenedErrors<typeof Test>, TestTypeErrors>(true);
-});
-
-test(".flatten() type assertion", () => {
-  const parsed = Test.safeParse({}) as z.SafeParseError<void>;
-  const validFlattenedErrors: TestFlattenedErrors = parsed.error.flatten(() => ({ message: "", code: 0 }));
-  // @ts-expect-error should fail assertion between `TestFlattenedErrors` and unmapped `flatten()`.
-  const invalidFlattenedErrors: TestFlattenedErrors = parsed.error.flatten();
-  const validFormErrors: TestFormErrors = parsed.error.flatten();
-  // @ts-expect-error should fail assertion between `TestFormErrors` and mapped `flatten()`.
-  const invalidFormErrors: TestFormErrors = parsed.error.flatten(() => ({
-    message: "string",
-    code: 0,
-  }));
-
-  [validFlattenedErrors, invalidFlattenedErrors, validFormErrors, invalidFormErrors];
-});
-
-test(".formErrors type assertion", () => {
-  const parsed = Test.safeParse({}) as z.SafeParseError<void>;
-  const validFormErrors: TestFormErrors = parsed.error.formErrors;
-  // @ts-expect-error should fail assertion between `TestFlattenedErrors` and `.formErrors`.
-  const invalidFlattenedErrors: TestFlattenedErrors = parsed.error.formErrors;
-
-  [validFormErrors, invalidFlattenedErrors];
-});
-
-test("all errors", () => {
-  const propertySchema = z.string();
-  const schema = z
-    .object({
-      a: propertySchema,
-      b: propertySchema,
-    })
-    .refine(
-      (val) => {
-        return val.a === val.b;
-      },
-      { message: "Must be equal" }
-    );
-
-  try {
-    schema.parse({
-      a: "asdf",
-      b: "qwer",
-    });
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      expect(error.flatten()).toEqual({
-        formErrors: ["Must be equal"],
-        fieldErrors: {},
-      });
-    }
-  }
-
-  try {
-    schema.parse({
-      a: null,
-      b: null,
-    });
-  } catch (_error) {
-    const error = _error as z.ZodError;
-    expect(error.flatten()).toEqual({
-      formErrors: [],
-      fieldErrors: {
-        a: ["Expected string, received null"],
-        b: ["Expected string, received null"],
-      },
-    });
-
-    expect(error.flatten((iss) => iss.message.toUpperCase())).toEqual({
-      formErrors: [],
-      fieldErrors: {
-        a: ["EXPECTED STRING, RECEIVED NULL"],
-        b: ["EXPECTED STRING, RECEIVED NULL"],
-      },
-    });
-    // Test identity
-
-    expect(error.flatten((i: z.ZodIssue) => i)).toEqual({
-      formErrors: [],
-      fieldErrors: {
-        a: [
-          {
-            code: "invalid_type",
-            expected: "string",
-            message: "Expected string, received null",
-            path: ["a"],
-            received: "null",
-          },
-        ],
-        b: [
-          {
-            code: "invalid_type",
-            expected: "string",
-            message: "Expected string, received null",
-            path: ["b"],
-            received: "null",
-          },
-        ],
-      },
-    });
-    // Test mapping
-    expect(error.flatten((i: z.ZodIssue) => i.message.length)).toEqual({
-      formErrors: [],
-      fieldErrors: {
-        a: ["Expected string, received null".length],
-        b: ["Expected string, received null".length],
-      },
-    });
-  }
-});