hono-takibi 0.9.99992 → 0.9.99994

package/README.md

@@ -486,6 +486,11 @@ export default defineConfig({
 
   mock: {
     output: './src/mock.ts',
+    useExamples: true,
+    locale: 'en',
+    delay: false,
+    arrayMin: 1,
+    arrayMax: 10,
   },
 
   docs: {

package/dist/config/index.d.ts

@@ -280,6 +280,14 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodObject<{
   }, z.core.$strip>>>;
   mock: z.ZodExactOptional<z.ZodReadonly<z.ZodObject<{
     output: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    useExamples: z.ZodExactOptional<z.ZodBoolean>;
+    locale: z.ZodExactOptional<z.ZodString>;
+    delay: z.ZodExactOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<false>, z.ZodReadonly<z.ZodObject<{
+      min: z.ZodNumber;
+      max: z.ZodNumber;
+    }, z.core.$strip>>]>>;
+    arrayMin: z.ZodExactOptional<z.ZodNumber>;
+    arrayMax: z.ZodExactOptional<z.ZodNumber>;
   }, z.core.$strip>>>;
   docs: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     output: z.ZodTemplateLiteral<`${string}.md`>;
@@ -565,6 +573,14 @@ declare function parseConfig(config: unknown): {
     }>;
     mock?: Readonly<{
       output: string;
+      useExamples?: boolean;
+      locale?: string;
+      delay?: number | false | Readonly<{
+        min: number;
+        max: number;
+      }>;
+      arrayMin?: number;
+      arrayMax?: number;
     }>;
     docs?: Readonly<{
       output: `${string}.md`;
@@ -852,6 +868,14 @@ declare function readConfig(): Promise<{
     }>;
     mock?: Readonly<{
       output: string;
+      useExamples?: boolean;
+      locale?: string;
+      delay?: number | false | Readonly<{
+        min: number;
+        max: number;
+      }>;
+      arrayMin?: number;
+      arrayMax?: number;
     }>;
     docs?: Readonly<{
       output: `${string}.md`;
@@ -1136,6 +1160,14 @@ declare function defineConfig(config: z.input<typeof ConfigSchema>): Readonly<{
   }>;
   mock?: Readonly<{
     output: string;
+    useExamples?: boolean;
+    locale?: string;
+    delay?: number | false | Readonly<{
+      min: number;
+      max: number;
+    }>;
+    arrayMin?: number;
+    arrayMax?: number;
   }>;
   docs?: Readonly<{
     output: `${string}.md`;

package/dist/config/index.js

@@ -148,7 +148,21 @@ const ConfigSchema = z.object({
 			"bun"
 		]).default("vitest").exactOptional()
 	}).readonly().exactOptional(),
-	mock: z.object({ output: FileOutputSchema }).readonly().exactOptional(),
+	mock: z.object({
+		output: FileOutputSchema,
+		useExamples: z.boolean().exactOptional(),
+		locale: z.string().regex(/^[A-Za-z_]{1,40}$/, { error: "Invalid faker locale. Use a code like 'ja', 'en', or 'zh_CN'." }).exactOptional(),
+		delay: z.union([
+			z.number().int().nonnegative().max(6e4),
+			z.literal(false),
+			z.object({
+				min: z.number().int().nonnegative().max(6e4),
+				max: z.number().int().nonnegative().max(6e4)
+			}).readonly().refine((v) => v.min <= v.max, { message: "delay.min must be <= delay.max. Swap the values or remove one." })
+		]).exactOptional(),
+		arrayMin: z.number().int().nonnegative().max(1e3).exactOptional(),
+		arrayMax: z.number().int().nonnegative().max(1e3).exactOptional()
+	}).readonly().refine((v) => v.arrayMin === void 0 || v.arrayMax === void 0 || v.arrayMin <= v.arrayMax, { message: "arrayMin must be <= arrayMax. Swap the values or remove one." }).exactOptional(),
 	docs: z.discriminatedUnion("curl", [z.object({
 		output: z.templateLiteral([z.string().min(1), z.enum([".md"])], { error: "must be .md file" }),
 		curl: z.literal(true),

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { readConfig } from "./config/index.js";
 import { r as setFormatOptions } from "./emit-CFR63U4L.js";
-import { n as parseOpenAPI, r as takibi, t as makeJob } from "./shared-DRGflwP5.js";
+import { n as parseOpenAPI, r as takibi, t as makeJob } from "./shared-n3ZMLfl9.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 //#region src/cli/index.ts

package/dist/{shared-DRGflwP5.js → shared-n3ZMLfl9.js}

@@ -514,7 +514,7 @@ const FORMAT_TO_FAKER = {
 	gender: "faker.person.gender()",
 	bic: "faker.finance.bic()",
 	iban: "faker.finance.iban()",
-	binary: "new Blob([faker.string.alphanumeric(100)])",
+	binary: "new File([faker.string.alphanumeric(100)], faker.system.fileName())",
 	byte: "btoa(faker.string.alphanumeric(10))",
 	int32: "faker.number.int({ min: -2147483648, max: 2147483647 })",
 	int64: "faker.number.bigInt({ min: 0n, max: 9007199254740991n })",
@@ -594,6 +594,19 @@ function numericFaker(schema, range) {
 		`fractionDigits: ${fractionDigits}`
 	]).join(", ")} })`;
 }
+function resolveRef(schema, schemas) {
+	if (!schema.$ref) return schema;
+	const name = schema.$ref.split("/").at(-1);
+	return (name ? schemas?.[name] : void 0) ?? schema;
+}
+function isKnownScalar(schema, schemas) {
+	const resolved = resolveRef(schema, schemas);
+	if (resolved.enum || resolved.const !== void 0) return true;
+	if (resolved.properties || resolved.type === "object") return false;
+	if (resolved.allOf && resolved.allOf.length > 0) return resolved.allOf.every((s) => isKnownScalar(s, schemas));
+	if (resolved.oneOf || resolved.anyOf || resolved.type === "array") return false;
+	return typeof resolved.type === "string";
+}
 function schemaToFaker(schema, propertyName, options = {}) {
 	if (options.useExamples && schema.example !== void 0) return JSON.stringify(schema.example);
 	if (schema.const !== void 0) return `${JSON.stringify(schema.const)} as const`;
@@ -602,7 +615,9 @@ function schemaToFaker(schema, propertyName, options = {}) {
 	if (schema.type === "array" && schema.items) {
 		const itemSchema = Array.isArray(schema.items) ? schema.items[0] : schema.items;
 		if (!itemSchema) return "[]";
-		return `Array.from({ length: faker.number.int({ min: 1, max: 5 }) }, () => (${schemaToFaker(itemSchema, void 0, options)}))`;
+		const itemFaker = schemaToFaker(itemSchema, void 0, options);
+		const min = schema.minItems ?? options.arrayMin ?? 1;
+		return `Array.from({ length: faker.number.int({ min: ${min}, max: ${schema.maxItems ?? options.arrayMax ?? Math.max(min, 10)} }) }, () => (${itemFaker}))`;
 	}
 	const renderProps = (properties, required) => {
 		const requiredSet = new Set(required || []);
@@ -616,8 +631,19 @@ function schemaToFaker(schema, propertyName, options = {}) {
 	if (schema.type === "object" && schema.properties) return `{ ${renderProps(schema.properties, schema.required)} }`;
 	if (schema.type === "object" && !schema.properties && schema.additionalProperties) return "{}";
 	if (schema.allOf && schema.allOf.length > 0) {
-		const merged = schema.allOf.map((s) => schemaToFaker(s, propertyName, options)).map((m) => `...${m}`).join(", ");
-		if (schema.properties) return `{ ${merged}, ${renderProps(schema.properties, schema.required)} }`;
+		if (!schema.properties && schema.allOf.every((s) => isKnownScalar(s, options.schemas))) {
+			const [only] = schema.allOf;
+			if (schema.allOf.length === 1 && only) return schemaToFaker(only, propertyName, options);
+			return schemaToFaker(schema.allOf.map((s) => resolveRef(s, options.schemas)).reduce((acc, s) => ({
+				...acc,
+				...s
+			}), {}), propertyName, options);
+		}
+		const merged = schema.allOf.filter((s) => !isKnownScalar(s, options.schemas)).map((s) => `...${schemaToFaker(s, propertyName, options)}`).join(", ");
+		if (schema.properties) {
+			const props = renderProps(schema.properties, schema.required);
+			return merged.length > 0 ? `{ ${merged}, ${props} }` : `{ ${props} }`;
+		}
 		return `{ ${merged} }`;
 	}
 	const union = schema.oneOf && schema.oneOf.length > 0 ? schema.oneOf : schema.anyOf && schema.anyOf.length > 0 ? schema.anyOf : void 0;
@@ -631,7 +657,8 @@ function schemaToFaker(schema, propertyName, options = {}) {
 	if (schema.type && typeof schema.type === "string" && TYPE_TO_FAKER[schema.type]) {
 		if (schema.type === "string") {
 			if (schema.pattern) return `faker.helpers.fromRegExp(/${escapeRegexLiteral(schema.pattern)}/)`;
-			return `faker.string.alpha({ length: { min: ${schema.minLength ?? 5}, max: ${schema.maxLength ?? 20} } })`;
+			const min = schema.minLength ?? 5;
+			return `faker.string.alpha({ length: { min: ${min}, max: ${schema.maxLength ?? Math.max(min, 20)} } })`;
 		}
 		if (schema.type === "integer" || schema.type === "number") return numericFaker(schema, numericRange(schema, schema.type === "integer"));
 		return TYPE_TO_FAKER[schema.type];
@@ -710,11 +737,40 @@ function detectCircularSchemas$1(schemas) {
 	}
 	return circular;
 }
-function makeMockFunction(name, schema, schemas, isCircular) {
-	const mockBody = schemaToFaker(schema, void 0, { schemas });
+function collectSchemaRefs$1(node, refs) {
+	if (Array.isArray(node)) {
+		for (const item of node) collectSchemaRefs$1(item, refs);
+		return refs;
+	}
+	if (node !== null && typeof node === "object") for (const [key, value] of Object.entries(node)) if (key === "$ref" && typeof value === "string" && value.includes("/components/schemas/")) {
+		const name = value.split("/").at(-1);
+		if (name) refs.add(name);
+	} else collectSchemaRefs$1(value, refs);
+	return refs;
+}
+function schemaClosure(roots, schemas) {
+	const used = /* @__PURE__ */ new Set();
+	const stack = [...roots];
+	while (stack.length > 0) {
+		const name = stack.pop();
+		if (name === void 0 || used.has(name)) continue;
+		used.add(name);
+		const schema = schemas[name];
+		if (schema) {
+			for (const ref of collectSchemaRefs$1(schema, /* @__PURE__ */ new Set())) if (!used.has(ref)) stack.push(ref);
+		}
+	}
+	return used;
+}
+function makeMockFunction(name, schema, schemas, isCircular, fakerOptions) {
+	const mockBody = schemaToFaker(schema, void 0, {
+		schemas,
+		...fakerOptions
+	});
 	const returnType = isCircular ? ": any" : "";
 	const sanitized = name.replace(/\./g, "");
-	return `function mock${sanitized}()${returnType}{return ${schema["x-brand"] ? `${mockBody} as z.infer<typeof ${sanitized}Schema>` : mockBody}}`;
+	const schemaConst = toIdentifierPascalCase(ensureSuffix(name, "Schema"));
+	return `function mock${sanitized}()${returnType}{return ${schema["x-brand"] ? `${mockBody} as z.infer<typeof ${schemaConst}>` : mockBody}}`;
 }
 function extractSecurityInfo(opSecurity, globalSecurity, securitySchemes) {
 	return (opSecurity ?? globalSecurity ?? []).flatMap((secDef) => Object.keys(secDef).flatMap((schemeName) => {
@@ -834,16 +890,46 @@ function makeAuthCheck(security, has401) {
 	if (authChecks.length === 0) return "";
 	return `if(!(${authChecks.join(" || ")})){return c.json({ message: 'Unauthorized' }, 401)}`;
 }
-function makeHandlerBody(statusCode, jsonSchema, textSchema, schemas, allRefs) {
+function extractMediaExample(media, components) {
+	if (media.example !== void 0) return media.example;
+	if (!media.examples) return void 0;
+	const first = Object.values(media.examples)[0];
+	if (!first) return void 0;
+	if ("$ref" in first && typeof first.$ref === "string") {
+		const name = first.$ref.split("/").at(-1);
+		const resolved = name ? components?.examples?.[name] : void 0;
+		return resolved && "value" in resolved ? resolved.value : void 0;
+	}
+	return "value" in first ? first.value : void 0;
+}
+function makeHandlerBody(args) {
+	const { statusCode, jsonSchema, textSchema, schemas, fakerOptions, allRefs, exampleValue, exampleCast } = args;
+	if (exampleValue !== void 0) {
+		const cast = exampleCast ? ` as z.infer<typeof ${exampleCast}>` : "";
+		return `return c.json(${JSON.stringify(exampleValue)}${cast}, ${statusCode})`;
+	}
 	if (jsonSchema) {
 		collectRefs(jsonSchema, allRefs);
-		return `return c.json(${schemaToFaker(jsonSchema, void 0, { schemas })}, ${statusCode})`;
+		return `return c.json(${schemaToFaker(jsonSchema, void 0, {
+			schemas,
+			...fakerOptions
+		})}, ${statusCode})`;
 	}
-	if (textSchema) return `return c.text(${schemaToFaker(textSchema, void 0, { schemas })}, ${statusCode})`;
+	if (textSchema) return `return c.text(${schemaToFaker(textSchema, void 0, {
+		schemas,
+		...fakerOptions
+	})}, ${statusCode})`;
 	if (statusCode === 204) return `return new Response(null, { status: 204 })`;
 	return `return c.body(null, ${statusCode})`;
 }
+function delayMiddlewareCode(delay) {
+	const ms = typeof delay === "number" ? `${delay}` : typeof delay === "object" && delay !== null ? `faker.number.int({ min: ${delay.min}, max: ${delay.max} })` : void 0;
+	if (ms === void 0) return "";
+	return `\n\napp.use(async (_c, next) => {\n  await new Promise((resolve) => setTimeout(resolve, ${ms}))\n  await next()\n})`;
+}
 function makeMock(openapi, basePath, options = {}) {
+	const { useExamples: useExamplesOption, locale, delay, readonly: readonlyOption, ...fakerOptions } = options;
+	const useExamples = useExamplesOption ?? true;
 	const filteredOpenapi = filterToJsonContentTypes(openapi);
 	const paths = filteredOpenapi.paths;
 	const schemas = openapi.components?.schemas ?? {};
@@ -860,7 +946,19 @@ function makeMock(openapi, basePath, options = {}) {
 		const successResponse = success?.response;
 		const jsonMedia = successResponse?.content?.["application/json"];
 		const textMedia = successResponse?.content?.["text/plain"];
-		const handlerBody = makeHandlerBody(statusCode, jsonMedia && isMediaWithSchema(jsonMedia) ? jsonMedia.schema : void 0, textMedia && isMediaWithSchema(textMedia) ? textMedia.schema : void 0, schemas, allRefs);
+		const jsonSchema = jsonMedia && isMediaWithSchema(jsonMedia) ? jsonMedia.schema : void 0;
+		const textSchema = textMedia && isMediaWithSchema(textMedia) ? textMedia.schema : void 0;
+		const exampleValue = useExamples && jsonMedia ? extractMediaExample(jsonMedia, openapi.components) : void 0;
+		const handlerBody = makeHandlerBody({
+			statusCode,
+			jsonSchema,
+			textSchema,
+			schemas,
+			fakerOptions,
+			allRefs,
+			exampleValue,
+			exampleCast: exampleValue !== void 0 && jsonSchema?.$ref ? toIdentifierPascalCase(ensureSuffix(jsonSchema.$ref.split("/").at(-1) ?? "", "Schema")) : void 0
+		});
 		const authCheck = makeAuthCheck(security, operation.responses?.[String(401)] !== void 0);
 		const handler = `const ${routeId}RouteHandler: RouteHandler<typeof ${routeId}Route> = async (${handlerBody.includes("c.") || authCheck !== "" ? "c" : "_c"}) => {${authCheck}${handlerBody}}`;
 		return [{
@@ -879,8 +977,23 @@ function makeMock(openapi, basePath, options = {}) {
 	for (const ref of allRefs) collectAllDependencies(ref, schemas, allDeps);
 	const sortedRefs = topologicalSort(allDeps, schemas);
 	const circularSchemas = detectCircularSchemas$1(schemas);
-	const mockFunctions = sortedRefs.filter((refName) => schemas[refName]).map((refName) => makeMockFunction(refName, schemas[refName], schemas, circularSchemas.has(refName)));
-	const components = openapi.components ? componentsCode(openapi.components, {
+	const mockFunctions = sortedRefs.filter((refName) => schemas[refName]).map((refName) => makeMockFunction(refName, schemas[refName], schemas, circularSchemas.has(refName), fakerOptions));
+	const rootRefs = collectSchemaRefs$1(filteredOpenapi.paths, /* @__PURE__ */ new Set());
+	if (openapi.components) {
+		collectSchemaRefs$1(openapi.components.responses, rootRefs);
+		collectSchemaRefs$1(openapi.components.parameters, rootRefs);
+		collectSchemaRefs$1(openapi.components.requestBodies, rootRefs);
+		collectSchemaRefs$1(openapi.components.headers, rootRefs);
+		collectSchemaRefs$1(openapi.components.callbacks, rootRefs);
+		collectSchemaRefs$1(openapi.components.pathItems, rootRefs);
+		collectSchemaRefs$1(openapi.components.links, rootRefs);
+	}
+	const usedSchemaNames = schemaClosure(rootRefs, schemas);
+	const filteredComponents = openapi.components ? {
+		...openapi.components,
+		schemas: Object.fromEntries(Object.entries(schemas).filter(([name]) => usedSchemaNames.has(name)))
+	} : void 0;
+	const components = filteredComponents ? componentsCode(filteredComponents, {
 		exportSchemasTypes: false,
 		exportSchemas: false,
 		exportParametersTypes: false,
@@ -896,14 +1009,16 @@ function makeMock(openapi, basePath, options = {}) {
 		exportPathItems: false,
 		exportMediaTypes: false,
 		exportMediaTypesTypes: false,
-		...options.readonly !== void 0 ? { readonly: options.readonly } : {}
+		...readonlyOption !== void 0 ? { readonly: readonlyOption } : {}
 	}) : "";
-	const routes = routeCode(filteredOpenapi, options.readonly);
+	const routes = routeCode(filteredOpenapi, readonlyOption);
 	const appSetup = routeMetas.map(({ routeId }) => `.openapi(${routeId}Route, ${routeId}RouteHandler)`).join("");
 	const handlersJoined = handlers.join("\n\n");
+	const needsCookieImport = handlersJoined.includes("getCookie(c,");
 	const imports = `import { OpenAPIHono, createRoute, z, type RouteHandler } from '@hono/zod-openapi'
-import { faker } from '@faker-js/faker'${handlersJoined.includes("getCookie(c,") ? `\nimport { getCookie } from 'hono/cookie'` : ""}`;
-	const appCode = `const app = new OpenAPIHono()${basePath !== "/" ? `.basePath('${basePath}')` : ""}
+${locale ? `import { faker } from '@faker-js/faker/locale/${locale}'` : `import { faker } from '@faker-js/faker'`}${needsCookieImport ? `\nimport { getCookie } from 'hono/cookie'` : ""}`;
+	const delayMiddleware = delayMiddlewareCode(delay);
+	const appCode = `const app = new OpenAPIHono()${basePath !== "/" ? `.basePath('${basePath}')` : ""}${delayMiddleware}
 
 export const api = app${appSetup}
 
@@ -919,8 +1034,8 @@ export default app`;
 }
 //#endregion
 //#region src/core/mock/index.ts
-async function mock(openAPI, output, basePath, readonly) {
-	const emitResult = await emit(makeMock(openAPI, basePath, readonly !== void 0 ? { readonly } : {}), path.dirname(output), output);
+async function mock(openAPI, output, basePath, options = {}) {
+	const emitResult = await emit(makeMock(openAPI, basePath, options), path.dirname(output), output);
 	if (!emitResult.ok) return {
 		ok: false,
 		error: emitResult.error
@@ -2765,7 +2880,10 @@ function makeJob(openAPI, config) {
 			name: "mock",
 			output: config.mock.output,
 			split: false,
-			run: (output) => mock(openAPI, output, config.basePath, config.readonly)
+			run: (output) => mock(openAPI, output, config.basePath, {
+				...config.mock,
+				...config.readonly !== void 0 ? { readonly: config.readonly } : {}
+			})
 		} : void 0,
 		config.docs ? {
 			name: "docs",

package/dist/vite-plugin/index.js

@@ -1,7 +1,7 @@
 import { parseConfig } from "../config/index.js";
 import { r as setFormatOptions } from "../emit-CFR63U4L.js";
 import { f as isRecord } from "../guard-zvkMUVYD.js";
-import { n as parseOpenAPI, t as makeJob } from "../shared-DRGflwP5.js";
+import { n as parseOpenAPI, t as makeJob } from "../shared-n3ZMLfl9.js";
 import path from "node:path";
 import fsp from "node:fs/promises";
 //#region src/vite-plugin/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-takibi",
-  "version": "0.9.99992",
+  "version": "0.9.99994",
   "description": "Hono Takibi is a code generator from OpenAPI to @hono/zod-openapi",
   "keywords": [
     "hono",
@@ -63,7 +63,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^26.0.0",
+    "@types/node": "^26.0.1",
     "@typespec/http": "^1.13.0",
     "@typespec/rest": "^0.83.0",
     "@typespec/versioning": "^0.83.0",