hono-takibi 0.9.99992 → 0.9.99993

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-DC4zuL9A.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 //#region src/cli/index.ts

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

@@ -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`;
@@ -616,8 +629,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;
@@ -710,11 +734,37 @@ function detectCircularSchemas$1(schemas) {
 	}
 	return circular;
 }
+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) {
 	const mockBody = schemaToFaker(schema, void 0, { schemas });
 	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,7 +884,67 @@ 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;
+}
+const PAGE_PARAM_NAMES = [
+	"page",
+	"pageNumber",
+	"page_number"
+];
+const OFFSET_PARAM_NAMES = ["offset", "skip"];
+const ROWS_PARAM_NAMES = [
+	"rows",
+	"limit",
+	"perPage",
+	"per_page",
+	"pageSize",
+	"page_size",
+	"size",
+	"take"
+];
+function detectPagination(operation) {
+	if (operation["x-pagination"] !== true) return void 0;
+	const queryParams = (operation.parameters ?? []).filter((p) => "in" in p && p.in === "query");
+	const rows = queryParams.find((p) => ROWS_PARAM_NAMES.includes(p.name));
+	if (!rows) return void 0;
+	const pageParam = queryParams.find((p) => PAGE_PARAM_NAMES.includes(p.name));
+	const offsetParam = pageParam ? void 0 : queryParams.find((p) => OFFSET_PARAM_NAMES.includes(p.name));
+	const cursor = pageParam ?? offsetParam;
+	if (!cursor) return void 0;
+	const defaultRows = typeof rows.schema?.default === "number" ? rows.schema.default : 20;
+	return {
+		rowsParam: rows.name,
+		cursorParam: cursor.name,
+		offsetStyle: offsetParam !== void 0,
+		defaultRows
+	};
+}
+function makeHandlerBody(args) {
+	const { statusCode, jsonSchema, textSchema, schemas, allRefs, exampleValue, exampleCast, pagination } = args;
+	if (exampleValue !== void 0) {
+		const cast = exampleCast ? ` as z.infer<typeof ${exampleCast}>` : "";
+		return `return c.json(${JSON.stringify(exampleValue)}${cast}, ${statusCode})`;
+	}
+	if (pagination && jsonSchema?.type === "array" && jsonSchema.items) {
+		collectRefs(jsonSchema, allRefs);
+		const itemFaker = schemaToFaker(Array.isArray(jsonSchema.items) ? jsonSchema.items[0] : jsonSchema.items, void 0, { schemas });
+		const startExpr = pagination.offsetStyle ? `const start = query.${pagination.cursorParam} ?? 0` : `const page = query.${pagination.cursorParam} ?? 1\nconst start = (page - 1) * rows`;
+		return `const query = c.req.valid('query')
+const rows = query.${pagination.rowsParam} ?? ${pagination.defaultRows}
+${startExpr}
+const items = Array.from({ length: ${pagination.totalConst} }, () => (${itemFaker}))
+return c.json(items.slice(start, start + rows), ${statusCode})`;
+	}
 	if (jsonSchema) {
 		collectRefs(jsonSchema, allRefs);
 		return `return c.json(${schemaToFaker(jsonSchema, void 0, { schemas })}, ${statusCode})`;
@@ -860,7 +970,26 @@ 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 = jsonMedia ? extractMediaExample(jsonMedia, openapi.components) : void 0;
+		const exampleCast = exampleValue !== void 0 && jsonSchema?.$ref ? toIdentifierPascalCase(ensureSuffix(jsonSchema.$ref.split("/").at(-1) ?? "", "Schema")) : void 0;
+		const pag = detectPagination(operation);
+		const pagination = pag && exampleValue === void 0 && jsonSchema?.type === "array" && jsonSchema.items ? {
+			totalConst: `${routeId}Total`,
+			...pag
+		} : void 0;
+		const handlerBody = makeHandlerBody({
+			statusCode,
+			jsonSchema,
+			textSchema,
+			schemas,
+			allRefs,
+			exampleValue,
+			exampleCast,
+			pagination
+		});
+		const paginationDecl = pagination ? `const ${pagination.totalConst} = faker.number.int({ min: 0, max: ${Math.min(pagination.defaultRows * 3, 3e3)} })` : "";
 		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 [{
@@ -870,17 +999,34 @@ function makeMock(openapi, basePath, options = {}) {
 				path: p,
 				requiresAuth
 			},
-			handler
+			handler,
+			paginationDecl
 		}];
 	}));
 	const routeMetas = processed.map(({ entry }) => entry);
 	const handlers = processed.map(({ handler }) => handler);
+	const paginationDecls = processed.flatMap(({ paginationDecl }) => paginationDecl.length > 0 ? [paginationDecl] : []);
 	const allDeps = /* @__PURE__ */ new Set();
 	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 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,
@@ -913,6 +1059,7 @@ export default app`;
 		components,
 		routes,
 		mockFunctions.join("\n\n"),
+		paginationDecls.join("\n"),
 		handlersJoined,
 		appCode
 	].filter((s) => s.length > 0).join("\n\n");

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-DC4zuL9A.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.99993",
   "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",