@kubb/plugin-mcp 4.20.2 → 4.20.5

package/dist/index-RsNfvceH.d.cts

@@ -0,0 +1,549 @@
+import { KubbFile } from "@kubb/fabric-core/types";
+import { BaseGenerator, Config, FileMetaBase, Group, KubbEvents, Output, Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from "@kubb/core";
+import * as oas_normalize_lib_types0 from "oas-normalize/lib/types";
+import BaseOas from "oas";
+import { Operation } from "oas/operation";
+import { DiscriminatorObject, HttpMethods, OASDocument, SchemaObject } from "oas/types";
+import { Fabric } from "@kubb/react-fabric";
+import { FabricReactNode } from "@kubb/react-fabric/types";
+
+//#region rolldown:runtime
+//#endregion
+//#region ../oas/src/types.d.ts
+type contentType = 'application/json' | (string & {});
+type SchemaObject$1 = SchemaObject & {
+  'x-nullable'?: boolean;
+  $ref?: string;
+};
+type HttpMethod = HttpMethods;
+type Document = OASDocument;
+type Operation$1 = Operation;
+type DiscriminatorObject$1 = DiscriminatorObject;
+//#endregion
+//#region ../oas/src/Oas.d.ts
+type OasOptions = {
+  contentType?: contentType;
+  discriminator?: 'strict' | 'inherit';
+  /**
+   * Resolve name collisions when schemas from different components share the same name (case-insensitive).
+   * @default false
+   */
+  collisionDetection?: boolean;
+};
+declare class Oas extends BaseOas {
+  #private;
+  document: Document;
+  constructor(document: Document);
+  setOptions(options: OasOptions): void;
+  get options(): OasOptions;
+  get<T = unknown>($ref: string): T | null;
+  getKey($ref: string): string | undefined;
+  set($ref: string, value: unknown): false | undefined;
+  getDiscriminator(schema: SchemaObject$1 | null): DiscriminatorObject$1 | null;
+  dereferenceWithRef<T = unknown>(schema?: T): T;
+  getResponseSchema(operation: Operation$1, statusCode: string | number): SchemaObject$1;
+  getRequestSchema(operation: Operation$1): SchemaObject$1 | undefined;
+  getParametersSchema(operation: Operation$1, inKey: 'path' | 'query' | 'header'): SchemaObject$1 | null;
+  validate(): Promise<oas_normalize_lib_types0.ValidationResult>;
+  flattenSchema(schema: SchemaObject$1 | null): SchemaObject$1 | null;
+  /**
+   * Get schemas from OpenAPI components (schemas, responses, requestBodies).
+   * Returns schemas in dependency order along with name mapping for collision resolution.
+   */
+  getSchemas(options?: {
+    contentType?: contentType;
+    includes?: Array<'schemas' | 'responses' | 'requestBodies'>;
+    collisionDetection?: boolean;
+  }): {
+    schemas: Record<string, SchemaObject$1>;
+    nameMapping: Map<string, string>;
+  };
+}
+//#endregion
+//#region ../core/src/utils/AsyncEventEmitter.d.ts
+declare class AsyncEventEmitter<TEvents extends Record<string, any>> {
+  #private;
+  constructor(maxListener?: number);
+  emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArgs: TEvents[TEventName]): Promise<void>;
+  on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+  onOnce<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArgs: TEvents[TEventName]) => void): void;
+  off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+  removeAll(): void;
+}
+//#endregion
+//#region ../core/src/types.d.ts
+declare global {
+  namespace Kubb {
+    interface PluginContext {}
+  }
+}
+/**
+ * Config used in `kubb.config.ts`
+ *
+ * @example
+ * import { defineConfig } from '@kubb/core'
+ * export default defineConfig({
+ * ...
+ * })
+ */
+//#endregion
+//#region ../plugin-oas/src/types.d.ts
+type GetOasOptions = {
+  validate?: boolean;
+};
+type Context$2 = {
+  getOas(options?: GetOasOptions): Promise<Oas>;
+  getBaseURL(): Promise<string | undefined>;
+};
+declare global {
+  namespace Kubb {
+    interface PluginContext extends Context$2 {}
+  }
+}
+type ResolvePathOptions = {
+  pluginKey?: Plugin['key'];
+  group?: {
+    tag?: string;
+    path?: string;
+  };
+  type?: ResolveNameParams['type'];
+};
+/**
+ * `propertyName` is the ref name + resolved with the nameResolver
+ *  @example import { Pet } from './Pet'
+ *
+ * `originalName` is the original name used(in PascalCase), only used to remove duplicates
+ *
+ * `pluginKey` can be used to override the current plugin being used, handy when you want to import a type/schema out of another plugin
+ * @example import a type(plugin-ts) for a mock file(swagger-faker)
+ */
+type Ref = {
+  propertyName: string;
+  originalName: string;
+  path: KubbFile.Path;
+  pluginKey?: Plugin['key'];
+};
+type Refs = Record<string, Ref>;
+type OperationSchema = {
+  /**
+   * Converted name, contains already `PathParams`, `QueryParams`, ...
+   */
+  name: string;
+  schema: SchemaObject$1;
+  operation?: Operation$1;
+  /**
+   * OperationName in PascalCase, only being used in OperationGenerator
+   */
+  operationName: string;
+  description?: string;
+  statusCode?: number;
+  keys?: string[];
+  keysToOmit?: string[];
+  withData?: boolean;
+};
+type OperationSchemas = {
+  pathParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  queryParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  headerParams?: OperationSchema & {
+    keysToOmit?: never;
+  };
+  request?: OperationSchema;
+  response: OperationSchema;
+  responses: Array<OperationSchema>;
+  statusCodes?: Array<OperationSchema>;
+  errors?: Array<OperationSchema>;
+};
+type ByTag = {
+  type: 'tag';
+  pattern: string | RegExp;
+};
+type ByOperationId = {
+  type: 'operationId';
+  pattern: string | RegExp;
+};
+type ByPath = {
+  type: 'path';
+  pattern: string | RegExp;
+};
+type ByMethod = {
+  type: 'method';
+  pattern: HttpMethod | RegExp;
+};
+type BySchemaName = {
+  type: 'schemaName';
+  pattern: string | RegExp;
+};
+type ByContentType = {
+  type: 'contentType';
+  pattern: string | RegExp;
+};
+type Exclude$1 = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Include = ByTag | ByOperationId | ByPath | ByMethod | ByContentType;
+type Override<TOptions> = (ByTag | ByOperationId | ByPath | ByMethod | BySchemaName | ByContentType) & {
+  options: Partial<TOptions>;
+};
+//#endregion
+//#region ../plugin-oas/src/OperationGenerator.d.ts
+type Context$1<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  exclude: Array<Exclude$1> | undefined;
+  include: Array<Include> | undefined;
+  override: Array<Override<TOptions>> | undefined;
+  contentType: contentType | undefined;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  UNSTABLE_NAMING?: true;
+};
+declare class OperationGenerator<TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context$1<TPluginOptions['resolvedOptions'], TPluginOptions>> {
+  #private;
+  getOptions(operation: Operation$1, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']>;
+  getSchemas(operation: Operation$1, {
+    resolveName
+  }?: {
+    resolveName?: (name: string) => string;
+  }): OperationSchemas;
+  getOperations(): Promise<Array<{
+    path: string;
+    method: HttpMethod;
+    operation: Operation$1;
+  }>>;
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/SchemaMapper.d.ts
+type SchemaKeywordMapper = {
+  object: {
+    keyword: 'object';
+    args: {
+      properties: {
+        [x: string]: Schema[];
+      };
+      additionalProperties: Schema[];
+      patternProperties?: Record<string, Schema[]>;
+      strict?: boolean;
+    };
+  };
+  url: {
+    keyword: 'url';
+  };
+  readOnly: {
+    keyword: 'readOnly';
+  };
+  writeOnly: {
+    keyword: 'writeOnly';
+  };
+  uuid: {
+    keyword: 'uuid';
+  };
+  email: {
+    keyword: 'email';
+  };
+  firstName: {
+    keyword: 'firstName';
+  };
+  lastName: {
+    keyword: 'lastName';
+  };
+  phone: {
+    keyword: 'phone';
+  };
+  password: {
+    keyword: 'password';
+  };
+  date: {
+    keyword: 'date';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  time: {
+    keyword: 'time';
+    args: {
+      type?: 'date' | 'string';
+    };
+  };
+  datetime: {
+    keyword: 'datetime';
+    args: {
+      offset?: boolean;
+      local?: boolean;
+    };
+  };
+  tuple: {
+    keyword: 'tuple';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      rest?: Schema;
+    };
+  };
+  array: {
+    keyword: 'array';
+    args: {
+      items: Schema[];
+      min?: number;
+      max?: number;
+      unique?: boolean;
+    };
+  };
+  enum: {
+    keyword: 'enum';
+    args: {
+      name: string;
+      typeName: string;
+      asConst: boolean;
+      items: Array<{
+        name: string | number;
+        format: 'string' | 'number' | 'boolean';
+        value?: string | number | boolean;
+      }>;
+    };
+  };
+  and: {
+    keyword: 'and';
+    args: Schema[];
+  };
+  const: {
+    keyword: 'const';
+    args: {
+      name: string | number;
+      format: 'string' | 'number' | 'boolean';
+      value?: string | number | boolean;
+    };
+  };
+  union: {
+    keyword: 'union';
+    args: Schema[];
+  };
+  ref: {
+    keyword: 'ref';
+    args: {
+      name: string;
+      $ref: string;
+      /**
+       * Full qualified path.
+       */
+      path: KubbFile.Path;
+      /**
+       * When true `File.Import` is used.
+       * When false a reference is used inside the current file.
+       */
+      isImportable: boolean;
+    };
+  };
+  matches: {
+    keyword: 'matches';
+    args?: string;
+  };
+  boolean: {
+    keyword: 'boolean';
+  };
+  default: {
+    keyword: 'default';
+    args: string | number | boolean;
+  };
+  string: {
+    keyword: 'string';
+  };
+  integer: {
+    keyword: 'integer';
+  };
+  number: {
+    keyword: 'number';
+  };
+  max: {
+    keyword: 'max';
+    args: number;
+  };
+  min: {
+    keyword: 'min';
+    args: number;
+  };
+  exclusiveMaximum: {
+    keyword: 'exclusiveMaximum';
+    args: number;
+  };
+  exclusiveMinimum: {
+    keyword: 'exclusiveMinimum';
+    args: number;
+  };
+  describe: {
+    keyword: 'describe';
+    args: string;
+  };
+  example: {
+    keyword: 'example';
+    args: string;
+  };
+  deprecated: {
+    keyword: 'deprecated';
+  };
+  optional: {
+    keyword: 'optional';
+  };
+  undefined: {
+    keyword: 'undefined';
+  };
+  nullish: {
+    keyword: 'nullish';
+  };
+  nullable: {
+    keyword: 'nullable';
+  };
+  null: {
+    keyword: 'null';
+  };
+  any: {
+    keyword: 'any';
+  };
+  unknown: {
+    keyword: 'unknown';
+  };
+  void: {
+    keyword: 'void';
+  };
+  blob: {
+    keyword: 'blob';
+  };
+  schema: {
+    keyword: 'schema';
+    args: {
+      type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object';
+      format?: string;
+    };
+  };
+  name: {
+    keyword: 'name';
+    args: string;
+  };
+  catchall: {
+    keyword: 'catchall';
+  };
+  interface: {
+    keyword: 'interface';
+  };
+};
+type Schema = {
+  keyword: string;
+} | SchemaKeywordMapper[keyof SchemaKeywordMapper];
+//#endregion
+//#region ../plugin-oas/src/SchemaGenerator.d.ts
+type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
+  fabric: Fabric;
+  oas: Oas;
+  pluginManager: PluginManager;
+  events?: AsyncEventEmitter<KubbEvents>;
+  /**
+   * Current plugin
+   */
+  plugin: Plugin<TPluginOptions>;
+  mode: KubbFile.Mode;
+  include?: Array<'schemas' | 'responses' | 'requestBodies'>;
+  override: Array<Override<TOptions>> | undefined;
+  contentType?: contentType;
+  output?: string;
+};
+type SchemaGeneratorOptions = {
+  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date';
+  unknownType: 'any' | 'unknown' | 'void';
+  emptySchemaType: 'any' | 'unknown' | 'void';
+  enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral';
+  enumSuffix?: string;
+  /**
+   * @deprecated Will be removed in v5. Use `collisionDetection: true` instead to prevent enum name collisions.
+   * When `collisionDetection` is enabled, the rootName-based approach eliminates the need for numeric suffixes.
+   * @internal
+   */
+  usedEnumNames?: Record<string, number>;
+  mapper?: Record<string, string>;
+  typed?: boolean;
+  transformers: {
+    /**
+     * Customize the names based on the type that is provided by the plugin.
+     */
+    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string;
+    /**
+     * Receive schema and name(propertyName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (schemaProps: SchemaProps$1, defaultSchemas: Schema[]) => Array<Schema> | undefined;
+  };
+};
+type SchemaProps$1 = {
+  schema: SchemaObject$1 | null;
+  name: string | null;
+  parentName: string | null;
+  rootName?: string | null;
+};
+declare class SchemaGenerator<TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
+  #private;
+  refs: Refs;
+  /**
+   * Creates a type node from a given schema.
+   * Delegates to getBaseTypeFromSchema internally and
+   * optionally adds a union with null.
+   */
+  parse(props: SchemaProps$1): Schema[];
+  static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]>;
+  static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined;
+  static combineObjects(tree: Schema[] | undefined): Schema[];
+  build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>>;
+}
+//#endregion
+//#region ../plugin-oas/src/generators/createReactGenerator.d.ts
+type ReactGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'react';
+  Operations: (props: OperationsProps<TOptions>) => FabricReactNode;
+  Operation: (props: OperationProps<TOptions>) => FabricReactNode;
+  Schema: (props: SchemaProps<TOptions>) => FabricReactNode;
+};
+//#endregion
+//#region ../plugin-oas/src/generators/types.d.ts
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operations: Array<Operation$1>;
+};
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<OperationGenerator<TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  operation: Operation$1;
+};
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+  config: Config;
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>;
+  plugin: Plugin<TOptions>;
+  schema: {
+    name: string;
+    tree: Array<Schema>;
+    value: SchemaObject$1;
+  };
+};
+type Generator<TOptions extends PluginFactoryOptions> = CoreGenerator<TOptions> | ReactGenerator<TOptions>;
+//#endregion
+//#region ../plugin-oas/src/generators/createGenerator.d.ts
+type CoreGenerator<TOptions extends PluginFactoryOptions> = {
+  name: string;
+  type: 'core';
+  operations: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>;
+  operation: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>;
+  schema: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>;
+};
+//#endregion
+export { OperationSchemas as a, Oas as c, Include as i, contentType as l, ReactGenerator as n, Override as o, Exclude$1 as r, ResolvePathOptions as s, Generator as t, __name as u };
+//# sourceMappingURL=index-RsNfvceH.d.cts.map

package/dist/index.d.cts

@@ -1,9 +1,10 @@
-import { h as __name, m as UserPluginWithLifeCycle } from "./index-CGe1JmIp.cjs";
-import { n as PluginMcp, t as Options } from "./types-1i7hEdhc.cjs";
+import { u as __name } from "./index-RsNfvceH.cjs";
+import { n as PluginMcp, t as Options } from "./types-CALFhXwx.cjs";
+import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts
 declare const pluginMcpName = "plugin-mcp";
-declare const pluginMcp: (options?: Options | undefined) => UserPluginWithLifeCycle<PluginMcp>;
+declare const pluginMcp: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginMcp>;
 //#endregion
 export { type PluginMcp, pluginMcp, pluginMcpName };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { m as UserPluginWithLifeCycle } from "./index-D9FArzes.js";
-import { n as PluginMcp, t as Options } from "./types-BpFIHuV_.js";
+import "./index-DNBGPN7Z.js";
+import { n as PluginMcp, t as Options } from "./types-BXH4nmYX.js";
+import * as _kubb_core0 from "@kubb/core";
 
 //#region src/plugin.d.ts
 declare const pluginMcpName = "plugin-mcp";
-declare const pluginMcp: (options?: Options | undefined) => UserPluginWithLifeCycle<PluginMcp>;
+declare const pluginMcp: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginMcp>;
 //#endregion
 export { type PluginMcp, pluginMcp, pluginMcpName };
 //# sourceMappingURL=index.d.ts.map

package/dist/{types-BpFIHuV_.d.ts → types-BXH4nmYX.d.ts}

@@ -1,5 +1,6 @@
 import { t as __name } from "./chunk-eQyhnF5A.js";
-import { c as Oas, d as Output, f as PluginFactoryOptions, i as Include, l as contentType, o as Override, p as ResolveNameParams, r as Exclude, s as ResolvePathOptions, t as Generator, u as Group } from "./index-D9FArzes.js";
+import { c as Oas, i as Include, l as contentType, o as Override, r as Exclude, s as ResolvePathOptions, t as Generator } from "./index-DNBGPN7Z.js";
+import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
 
 //#region ../plugin-client/src/types.d.ts
 type Options$1 = {
@@ -183,4 +184,4 @@ type ResolvedOptions = {
 type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>;
 //#endregion
 export { PluginMcp as n, Options as t };
-//# sourceMappingURL=types-BpFIHuV_.d.ts.map
+//# sourceMappingURL=types-BXH4nmYX.d.ts.map

package/dist/{types-1i7hEdhc.d.cts → types-CALFhXwx.d.cts}

@@ -1,7 +1,7 @@
-import { c as Oas, d as Output, f as PluginFactoryOptions, h as __name, i as Include, l as contentType, o as Override, p as ResolveNameParams, r as Exclude, s as ResolvePathOptions, t as Generator, u as Group } from "./index-CGe1JmIp.cjs";
+import { c as Oas, i as Include, l as contentType, o as Override, r as Exclude, s as ResolvePathOptions, t as Generator, u as __name } from "./index-RsNfvceH.cjs";
+import { Group, Output, PluginFactoryOptions, ResolveNameParams } from "@kubb/core";
 
 //#region ../plugin-client/src/types.d.ts
-
 type Options$1 = {
   /**
    * Specify the export location for the files and define the behavior of the output
@@ -183,4 +183,4 @@ type ResolvedOptions = {
 type PluginMcp = PluginFactoryOptions<'plugin-mcp', Options, ResolvedOptions, never, ResolvePathOptions>;
 //#endregion
 export { PluginMcp as n, Options as t };
-//# sourceMappingURL=types-1i7hEdhc.d.cts.map
+//# sourceMappingURL=types-CALFhXwx.d.cts.map

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@kubb/plugin-mcp",
-  "version": "4.20.2",
-  "description": "Generator mcp",
+  "version": "4.20.5",
+  "description": "Model Context Protocol (MCP) plugin for Kubb, generating MCP-compatible tools and schemas from OpenAPI specifications for AI assistants.",
   "keywords": [
-    "typescript",
-    "plugins",
-    "kubb",
-    "codegen",
     "mcp",
+    "model-context-protocol",
     "ai",
+    "llm",
     "claude",
-    "openapi"
+    "ai-tools",
+    "openapi",
+    "swagger",
+    "typescript",
+    "code-generator",
+    "codegen",
+    "plugins",
+    "kubb"
   ],
   "repository": {
     "type": "git",
@@ -69,13 +74,13 @@
     }
   ],
   "dependencies": {
-    "@kubb/react-fabric": "0.12.7",
-    "@kubb/core": "4.20.2",
-    "@kubb/oas": "4.20.2",
-    "@kubb/plugin-client": "4.20.2",
-    "@kubb/plugin-oas": "4.20.2",
-    "@kubb/plugin-ts": "4.20.2",
-    "@kubb/plugin-zod": "4.20.2"
+    "@kubb/react-fabric": "0.12.10",
+    "@kubb/core": "4.20.5",
+    "@kubb/oas": "4.20.5",
+    "@kubb/plugin-client": "4.20.5",
+    "@kubb/plugin-oas": "4.20.5",
+    "@kubb/plugin-ts": "4.20.5",
+    "@kubb/plugin-zod": "4.20.5"
   },
   "devDependencies": {},
   "engines": {