@kubb/agent 5.0.0-alpha.35 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/plugin-faker/dist/fakerGenerator-BztogaeO.js

@@ -0,0 +1,200 @@
+import "./chunk--u3MIqq1.js";
+import { t as Faker } from "./components-BkBIov4R.js";
+import { SchemaGenerator, schemaKeywords } from "@kubb/plugin-oas";
+import { pluginTsName } from "@kubb/plugin-ts";
+import { useMode, usePluginManager } from "@kubb/core/hooks";
+import { createReactGenerator } from "@kubb/plugin-oas/generators";
+import { useOas, useOperationManager, useSchemaManager } from "@kubb/plugin-oas/hooks";
+import { applyParamsCasing, getBanner, getFooter, getImports, isParameterSchema } from "@kubb/plugin-oas/utils";
+import { File } from "@kubb/react-fabric";
+import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#region src/generators/fakerGenerator.tsx
+const fakerGenerator = createReactGenerator({
+	name: "faker",
+	Operation({ operation, generator, plugin }) {
+		const { options, options: { dateParser, regexGenerator, seed, mapper } } = plugin;
+		const mode = useMode();
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const { getSchemas, getFile, getGroup } = useOperationManager(generator);
+		const schemaManager = useSchemaManager();
+		const file = getFile(operation);
+		const schemas = getSchemas(operation);
+		const schemaGenerator = new SchemaGenerator(options, {
+			fabric: generator.context.fabric,
+			oas,
+			plugin,
+			events: generator.context.events,
+			pluginManager,
+			mode,
+			override: options.override
+		});
+		const operationSchemas = [
+			schemas.pathParams,
+			schemas.queryParams,
+			schemas.headerParams,
+			schemas.statusCodes,
+			schemas.request,
+			schemas.response
+		].flat().filter((x) => Boolean(x));
+		const mapOperationSchema = ({ name, schema, description, ...options }) => {
+			const transformedSchema = isParameterSchema(name) && plugin.options.paramsCasing ? applyParamsCasing(schema, plugin.options.paramsCasing) : schema;
+			const tree = schemaGenerator.parse({
+				schema: transformedSchema,
+				name,
+				parentName: null
+			});
+			const imports = getImports(tree);
+			const group = options.operation ? getGroup(options.operation) : void 0;
+			const faker = {
+				name: schemaManager.getName(name, { type: "function" }),
+				file: schemaManager.getFile(name)
+			};
+			const type = {
+				name: schemaManager.getName(name, {
+					type: "type",
+					pluginKey: [pluginTsName]
+				}),
+				file: schemaManager.getFile(options.operationName || name, {
+					pluginKey: [pluginTsName],
+					group
+				})
+			};
+			const canOverride = tree.some(({ keyword }) => keyword === schemaKeywords.array || keyword === schemaKeywords.and || keyword === schemaKeywords.object || keyword === schemaKeywords.union || keyword === schemaKeywords.tuple || keyword === schemaKeywords.enum || keyword === schemaKeywords.ref);
+			return /* @__PURE__ */ jsxs(Fragment, { children: [
+				canOverride && /* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					root: file.path,
+					path: type.file.path,
+					name: [type.name]
+				}),
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					imp.path,
+					imp.name,
+					imp.isTypeOnly
+				].join("-"))),
+				/* @__PURE__ */ jsx(Faker, {
+					name: faker.name,
+					typeName: type.name,
+					description,
+					tree,
+					regexGenerator,
+					dateParser,
+					mapper,
+					seed,
+					canOverride
+				})
+			] });
+		};
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: file.baseName,
+			path: file.path,
+			meta: file.meta,
+			banner: getBanner({
+				oas,
+				output: plugin.options.output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output: plugin.options.output
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["faker"],
+					path: "@faker-js/faker"
+				}),
+				regexGenerator === "randexp" && /* @__PURE__ */ jsx(File.Import, {
+					name: "RandExp",
+					path: "randexp"
+				}),
+				dateParser !== "faker" && /* @__PURE__ */ jsx(File.Import, {
+					path: dateParser,
+					name: dateParser
+				}),
+				operationSchemas.map(mapOperationSchema)
+			]
+		});
+	},
+	Schema({ schema, plugin }) {
+		const { getName, getFile } = useSchemaManager();
+		const { options: { output, dateParser, regexGenerator, seed, mapper } } = plugin;
+		const pluginManager = usePluginManager();
+		const oas = useOas();
+		const imports = getImports(schema.tree);
+		const faker = {
+			name: getName(schema.name, { type: "function" }),
+			file: getFile(schema.name)
+		};
+		const type = {
+			name: getName(schema.name, {
+				type: "type",
+				pluginKey: [pluginTsName]
+			}),
+			file: getFile(schema.name, { pluginKey: [pluginTsName] })
+		};
+		const canOverride = schema.tree.some(({ keyword }) => keyword === schemaKeywords.array || keyword === schemaKeywords.and || keyword === schemaKeywords.object || keyword === schemaKeywords.union || keyword === schemaKeywords.tuple || keyword === schemaKeywords.ref || keyword === schemaKeywords.enum || keyword === schemaKeywords.string || keyword === schemaKeywords.integer || keyword === schemaKeywords.number);
+		return /* @__PURE__ */ jsxs(File, {
+			baseName: faker.file.baseName,
+			path: faker.file.path,
+			meta: faker.file.meta,
+			banner: getBanner({
+				oas,
+				output,
+				config: pluginManager.config
+			}),
+			footer: getFooter({
+				oas,
+				output
+			}),
+			children: [
+				/* @__PURE__ */ jsx(File.Import, {
+					name: ["faker"],
+					path: "@faker-js/faker"
+				}),
+				regexGenerator === "randexp" && /* @__PURE__ */ jsx(File.Import, {
+					name: "RandExp",
+					path: "randexp"
+				}),
+				dateParser !== "faker" && /* @__PURE__ */ jsx(File.Import, {
+					path: dateParser,
+					name: dateParser
+				}),
+				/* @__PURE__ */ jsx(File.Import, {
+					isTypeOnly: true,
+					root: faker.file.path,
+					path: type.file.path,
+					name: [type.name]
+				}),
+				imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
+					root: faker.file.path,
+					path: imp.path,
+					name: imp.name
+				}, [
+					imp.path,
+					imp.name,
+					imp.isTypeOnly
+				].join("-"))),
+				/* @__PURE__ */ jsx(Faker, {
+					name: faker.name,
+					typeName: type.name,
+					description: schema.value.description,
+					tree: schema.tree,
+					regexGenerator,
+					dateParser,
+					mapper,
+					seed,
+					canOverride
+				})
+			]
+		});
+	}
+});
+//#endregion
+export { fakerGenerator as t };
+
+//# sourceMappingURL=fakerGenerator-BztogaeO.js.map

package/.output/server/node_modules/@kubb/plugin-faker/dist/index.js

@@ -0,0 +1,141 @@
+import "./chunk--u3MIqq1.js";
+import { t as fakerGenerator } from "./fakerGenerator-BztogaeO.js";
+import path from "node:path";
+import { definePlugin, getBarrelFiles, getMode } from "@kubb/core";
+import { OperationGenerator, SchemaGenerator, pluginOasName } from "@kubb/plugin-oas";
+import { pluginTsName } from "@kubb/plugin-ts";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region src/plugin.ts
+const pluginFakerName = "plugin-faker";
+const pluginFaker = definePlugin((options) => {
+	const { output = {
+		path: "mocks",
+		barrelType: "named"
+	}, seed, group, exclude = [], include, override = [], transformers = {}, mapper = {}, unknownType = "any", emptySchemaType = unknownType, dateType = "string", integerType = "number", dateParser = "faker", generators = [fakerGenerator].filter(Boolean), regexGenerator = "faker", paramsCasing, contentType } = options;
+	return {
+		name: pluginFakerName,
+		options: {
+			output,
+			transformers,
+			seed,
+			dateType,
+			integerType,
+			unknownType,
+			emptySchemaType,
+			dateParser,
+			mapper,
+			override,
+			regexGenerator,
+			paramsCasing,
+			group,
+			usedEnumNames: {}
+		},
+		pre: [pluginOasName, pluginTsName],
+		resolvePath(baseName, pathMode, options) {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			if ((pathMode ?? getMode(path.resolve(root, output.path))) === "single")
+ /**
+			* when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
+			* Other plugins then need to call addOrAppend instead of just add from the fileManager class
+			*/
+			return path.resolve(root, output.path);
+			if (group && (options?.group?.path || options?.group?.tag)) {
+				const groupName = group?.name ? group.name : (ctx) => {
+					if (group?.type === "path") return `${ctx.group.split("/")[1]}`;
+					return `${camelCase(ctx.group)}Controller`;
+				};
+				return path.resolve(root, output.path, groupName({ group: group.type === "path" ? options.group.path : options.group.tag }), baseName);
+			}
+			return path.resolve(root, output.path, baseName);
+		},
+		resolveName(name, type) {
+			const resolvedName = camelCase(name, {
+				prefix: type ? "create" : void 0,
+				isFile: type === "file"
+			});
+			if (type) return transformers?.name?.(resolvedName, type) || resolvedName;
+			return resolvedName;
+		},
+		async install() {
+			const root = path.resolve(this.config.root, this.config.output.path);
+			const mode = getMode(path.resolve(root, output.path));
+			const oas = await this.getOas();
+			const schemaFiles = await new SchemaGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				include: void 0,
+				override,
+				mode,
+				output: output.path
+			}).build(...generators);
+			await this.upsertFile(...schemaFiles);
+			const operationFiles = await new OperationGenerator(this.plugin.options, {
+				fabric: this.fabric,
+				oas,
+				pluginManager: this.pluginManager,
+				events: this.events,
+				plugin: this.plugin,
+				contentType,
+				exclude,
+				include,
+				override,
+				mode
+			}).build(...generators);
+			await this.upsertFile(...operationFiles);
+			const barrelFiles = await getBarrelFiles(this.fabric.files, {
+				type: output.barrelType ?? "named",
+				root,
+				output,
+				meta: { pluginKey: this.plugin.key }
+			});
+			await this.upsertFile(...barrelFiles);
+		}
+	};
+});
+//#endregion
+export { pluginFaker, pluginFakerName };
+
+//# sourceMappingURL=index.js.map

package/.output/server/node_modules/@kubb/plugin-faker/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@kubb/plugin-faker",
+  "version": "4.37.2",
+  "description": "Faker.js data generator plugin for Kubb, creating realistic mock data from OpenAPI specifications for development and testing.",
+  "keywords": [
+    "faker",
+    "faker.js",
+    "fakerjs",
+    "mock-data",
+    "mocks",
+    "data-generation",
+    "fixtures",
+    "testing",
+    "development",
+    "typescript",
+    "openapi",
+    "swagger",
+    "oas",
+    "code-generator",
+    "codegen",
+    "plugins",
+    "kubb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-faker"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
+  "dependencies": {
+    "@kubb/react-fabric": "0.14.0",
+    "@kubb/core": "4.37.2",
+    "@kubb/oas": "4.37.2",
+    "@kubb/plugin-oas": "4.37.2",
+    "@kubb/plugin-ts": "4.37.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "devDependencies": {
+    "@internals/utils": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown && size-limit",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --fix --unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsdown --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/.output/server/node_modules/@kubb/plugin-mcp/dist/Server-H3SwqhwF.js

@@ -0,0 +1,178 @@
+import "./chunk--u3MIqq1.js";
+import { isOptional } from "@kubb/plugin-oas/utils";
+import { Const, File, FunctionParams } from "@kubb/react-fabric";
+import { jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region src/components/Server.tsx
+function zodExprFromOasSchema(schema) {
+	const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+	const baseType = types.find((t) => t && t !== "null");
+	const isNullableType = types.includes("null");
+	let expr;
+	if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+		expr = `z.enum([${schema.enum.map((v) => JSON.stringify(v)).join(", ")}])`;
+		if (isNullableType) expr = `${expr}.nullable()`;
+		return expr;
+	}
+	switch (baseType) {
+		case "integer":
+			expr = "z.coerce.number()";
+			break;
+		case "number":
+			expr = "z.number()";
+			break;
+		case "boolean":
+			expr = "z.boolean()";
+			break;
+		case "array":
+			expr = "z.array(z.unknown())";
+			break;
+		default: expr = "z.string()";
+	}
+	if (isNullableType) expr = `${expr}.nullable()`;
+	return expr;
+}
+function getParams({ schemas, paramsCasing }) {
+	const pathParamProperties = schemas.pathParams?.schema?.properties ?? {};
+	const requiredFields = Array.isArray(schemas.pathParams?.schema?.required) ? schemas.pathParams.schema.required : [];
+	const pathParamEntries = Object.entries(pathParamProperties).reduce((acc, [originalKey, propSchema]) => {
+		const key = paramsCasing === "camelcase" || !isValidVarName(originalKey) ? camelCase(originalKey) : originalKey;
+		acc[key] = {
+			value: zodExprFromOasSchema(propSchema),
+			optional: !requiredFields.includes(originalKey)
+		};
+		return acc;
+	}, {});
+	return FunctionParams.factory({ data: {
+		mode: "object",
+		children: {
+			...pathParamEntries,
+			data: schemas.request?.name ? {
+				value: schemas.request?.name,
+				optional: isOptional(schemas.request?.schema)
+			} : void 0,
+			params: schemas.queryParams?.name ? {
+				value: schemas.queryParams?.name,
+				optional: isOptional(schemas.queryParams?.schema)
+			} : void 0,
+			headers: schemas.headerParams?.name ? {
+				value: schemas.headerParams?.name,
+				optional: isOptional(schemas.headerParams?.schema)
+			} : void 0
+		}
+	} });
+}
+function Server({ name, serverName, serverVersion, paramsCasing, operations }) {
+	return /* @__PURE__ */ jsxs(File.Source, {
+		name,
+		isExportable: true,
+		isIndexable: true,
+		children: [
+			/* @__PURE__ */ jsx(Const, {
+				name: "server",
+				export: true,
+				children: `
+          new McpServer({
+  name: '${serverName}',
+  version: '${serverVersion}',
+})
+          `
+			}),
+			operations.map(({ tool, mcp, zod }) => {
+				const paramsClient = getParams({
+					schemas: zod.schemas,
+					paramsCasing
+				});
+				const outputSchema = zod.schemas.response?.name;
+				const config = [
+					tool.title ? `title: ${JSON.stringify(tool.title)}` : null,
+					`description: ${JSON.stringify(tool.description)}`,
+					outputSchema ? `outputSchema: { data: ${outputSchema} }` : null
+				].filter(Boolean).join(",\n  ");
+				if (zod.schemas.request?.name || zod.schemas.headerParams?.name || zod.schemas.queryParams?.name || zod.schemas.pathParams?.name) return `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+  inputSchema: ${paramsClient.toObjectValue()},
+}, async (${paramsClient.toObject()}) => {
+  return ${mcp.name}(${paramsClient.toObject()})
+})
+          `;
+				return `
+server.registerTool(${JSON.stringify(tool.name)}, {
+  ${config},
+}, async () => {
+  return ${mcp.name}(${paramsClient.toObject()})
+})
+          `;
+			}).filter(Boolean),
+			`
+export async function startServer() {
+  try {
+    const transport = new StdioServerTransport()
+    await server.connect(transport)
+
+  } catch (error) {
+    console.error('Failed to start server:', error)
+    process.exit(1)
+  }
+}
+`
+		]
+	});
+}
+//#endregion
+export { camelCase as n, Server as t };
+
+//# sourceMappingURL=Server-H3SwqhwF.js.map

package/.output/server/node_modules/@kubb/plugin-mcp/dist/chunk--u3MIqq1.js

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+export { __name as t };