@kubb/plugin-faker 5.0.0-beta.99 → 5.0.0

package/dist/index.cjs

@@ -580,8 +580,9 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
 	})();
 	const { dataType, returnType: resolvedReturnType } = resolveFakerTypeUsage(node, typeName, canOverride);
 	if (!useGenericOverride) {
+		const dataParamName = /\bdata\b/.test(fakerTextWithOverride) ? "data" : "_data";
 		const params = (0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
-			name: /\bdata\b/.test(fakerTextWithOverride) ? "data" : "_data",
+			name: dataParamName,
 			type: dataType,
 			optional: true
 		})] });
@@ -605,7 +606,7 @@ function Faker({ node, description, name, typeName, printer, seed, canOverride }
 	const functionSignature = `${description ? `/**\n   * @description ${jsStringEscape(description)}\n   */\n  ` : ""}export function ${name}<TData extends Partial<${typeName}> = object>(data?: TData)`;
 	const seedCode = seed ? `faker.seed(${JSON.stringify(seed)})\n  ` : "";
 	const { cyclicSchemas, schemaName } = printer.options;
-	const functionBody = node.type === "object" && !!cyclicSchemas && (node.properties ?? []).some((p) => kubb_kit.ast.containsCircularRef(p.schema, {
+	const functionBody = node.type === "object" && !!cyclicSchemas && (node.properties ?? []).some((p) => (0, kubb_kit.containsCircularRef)(p.schema, {
 		circularSchemas: cyclicSchemas,
 		excludeName: schemaName
 	})) ? `{
@@ -651,6 +652,45 @@ function dedupeParams(params) {
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
+* Builds the `ResolverFileParams` every operation generator passes to
+* `resolver.file`: a file named `name`, tagged by the operation's first
+* tag (or `'default'`), at the operation's path. Centralizes the entry object
+* that was repeated at dozens of call sites across the client and query plugins.
+*
+* @example
+* ```ts
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
+* ```
+*/
+function operationFileEntry(node, name, extname = ".ts") {
+	return {
+		name,
+		extname,
+		tag: node.tags[0] ?? "default",
+		path: node.path
+	};
+}
+/**
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
+* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* same dependency for the same operation in one pass (a query plugin's several hook generators, the
+* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
+*
+* @example Cache `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveDependencyOperationFile(options) {
+	const { cache, node, resolver, root, output, group } = options;
+	return cache.ensureItem(`${resolver.pluginName}:operationFile`, () => resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output,
+		group: group ?? void 0
+	}));
+}
+/**
 * Maps a content type to the PascalCase suffix used to name per-content-type variants
 * (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
 */
@@ -698,16 +738,24 @@ function resolveContentTypeVariants(entries, baseName) {
 		};
 	});
 }
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
+* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
+* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
+* same parameters once per plugin.
+*/
 function getOperationParameters(node) {
-	return {
-		path: dedupeParams(node.parameters.filter((param) => param.in === "path").map((param) => isValidVarName(param.name) ? param : {
-			...param,
-			name: camelCase(param.name)
-		})),
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
+		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
 		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
 		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
 		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
 }
 //#endregion
 //#region ../../internals/shared/src/resolver.ts
@@ -839,6 +887,18 @@ function mapSchemaItems(node, transform) {
 }
 //#endregion
 //#region src/printers/printerFaker.ts
+/**
+* Formats that put a whole number inside a `type: 'string'` schema, the way ProtoJSON encodes
+* 64-bit integers, so the mock has to be digits rather than letters.
+*
+* @see https://protobuf.dev/programming-guides/json/#int64-strings
+*/
+const integerFormats = /* @__PURE__ */ new Set([
+	"int32",
+	"int64",
+	"uint64"
+]);
+const maxInt32 = 2147483647;
 const fakerKeywordMapper = {
 	any: () => "undefined",
 	unknown: () => "undefined",
@@ -856,6 +916,10 @@ const fakerKeywordMapper = {
 		return "faker.number.int()";
 	},
 	bigint: () => "faker.number.bigInt()",
+	integerString: (format) => {
+		if (format === "int32") return `faker.number.int({ max: ${maxInt32} }).toString()`;
+		return "faker.number.bigInt().toString()";
+	},
 	string: (min, max) => {
 		if (max !== void 0 && min !== void 0) return `faker.string.alpha({ length: { min: ${min}, max: ${max} } })`;
 		if (max !== void 0) return `faker.string.alpha({ length: ${max} })`;
@@ -955,6 +1019,7 @@ const printerFaker = kubb_kit.ast.createPrinter((options) => {
 			null: () => fakerKeywordMapper.null(),
 			string(node) {
 				if (node.pattern) return fakerKeywordMapper.matches(node.pattern, this.options.regexGenerator);
+				if (node.format && integerFormats.has(node.format)) return fakerKeywordMapper.integerString(node.format);
 				return fakerKeywordMapper.string(node.min, node.max);
 			},
 			email: () => fakerKeywordMapper.email(),
@@ -1031,7 +1096,7 @@ const printerFaker = kubb_kit.ast.createPrinter((options) => {
 						typeName: this.options.typeName ? indexedTypeName(this.options.typeName, property.name, this.options.nestedInUnion) : void 0,
 						nestedInObject: true
 					}) ?? "undefined";
-					if (cyclicSchemas && kubb_kit.ast.containsCircularRef(property.schema, {
+					if (cyclicSchemas && (0, kubb_kit.containsCircularRef)(property.schema, {
 						circularSchemas: cyclicSchemas,
 						excludeName: this.options.schemaName
 					})) return `get ${objectKey(property.name)}() { const _value = ${value}; Object.defineProperty(this, ${JSON.stringify(property.name)}, { value: _value, configurable: true, writable: true, enumerable: true }); return _value }`;
@@ -1260,14 +1325,13 @@ const fakerGenerator = (0, kubb_kit.defineGenerator)({
 				output,
 				group: group ?? void 0
 			}),
-			typeFile: tsResolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+			typeFile: resolveDependencyOperationFile({
+				cache: ctx.cache,
+				node,
+				resolver: tsResolver,
 				root,
 				output: pluginTs.options?.output ?? output,
-				group: pluginTs.options?.group ?? void 0
+				group: pluginTs.options?.group
 			})
 		};
 		function resolveMockImports(schema) {