hono-takibi 0.9.52 → 0.9.61

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { route } from '../core/route.js';
 import { rpc } from '../core/rpc.js';
 import { schema } from '../core/schema.js';
 import { takibi } from '../core/takibi.js';
+import { type } from '../core/type.js';
 // import { honoRpcWithSWR } from '../generator/swr/index.js'
 import { parseCli } from '../utils/index.js';
 /**
@@ -104,13 +105,17 @@ export async function honoTakibi() {
         : undefined;
     if (routeResult && !routeResult.ok)
         return { ok: false, error: routeResult.error };
+    /** type */
+    const typeResult = c.type ? await type(c.input, c.type.output) : undefined;
+    if (typeResult && !typeResult.ok)
+        return { ok: false, error: typeResult.error };
     /** rpc */
     const rpcResult = c.rpc
         ? await rpc(c.input, c.rpc.output, c.rpc.import, c.rpc.split ?? false)
         : undefined;
     if (rpcResult && !rpcResult.ok)
         return { ok: false, error: rpcResult.error };
-    const results = [takibiResult?.value, rpcResult?.value].filter((v) => Boolean(v));
+    const results = [takibiResult?.value, typeResult?.value, rpcResult?.value].filter((v) => v !== undefined);
     return {
         ok: true,
         value: results.join('\n'),

package/dist/config/index.d.ts

@@ -15,6 +15,9 @@ type Config = {
             readonly split?: boolean;
         };
     };
+    readonly type?: {
+        readonly output: `${string}.ts`;
+    };
     readonly rpc?: {
         readonly output: string | `${string}.ts`;
         readonly import: string;

package/dist/core/route.js

@@ -41,9 +41,9 @@ export async function route(input, output, importPath, split) {
         if (!mkdirResult.ok)
             return { ok: false, error: mkdirResult.error };
         const writeResult = await writeFile(output, fmtResult.value);
-        return writeResult.ok
-            ? { ok: true, value: `Generated route code written to ${output}` }
-            : { ok: false, error: writeResult.error };
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+        return { ok: true, value: `Generated route code written to ${output}` };
     }
     const outDir = output.replace(/\.ts$/, '');
     const blocks = extractRouteBlocks(routesSrc);
@@ -60,9 +60,9 @@ export async function route(input, output, importPath, split) {
         if (!mkdirResult.ok)
             return { ok: false, error: mkdirResult.error };
         const writeResult = await writeFile(output, fmtResult.value);
-        return writeResult.ok
-            ? { ok: true, value: `Generated route code written to ${output}` }
-            : { ok: false, error: writeResult.error };
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+        return { ok: true, value: `Generated route code written to ${output}` };
     }
     for (const { name, block } of blocks) {
         const includeZ = block.includes('z.');

package/dist/core/rpc.js

@@ -139,14 +139,7 @@ const createResolveParameter = (componentsParameters) => (p) => {
     const cand = name ? componentsParameters[name] : undefined;
     return isParameterObject(cand) ? cand : undefined;
 };
-const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr)
-    ? arr.reduce((acc, x) => {
-        const r = resolveParam(x);
-        if (r)
-            acc.push(r);
-        return acc;
-    }, [])
-    : [];
+const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr) ? arr.map((x) => resolveParam(x)).filter((param) => param !== undefined) : [];
 const isOperationLike = (v) => isRecord(v) && 'responses' in v;
 const HTTP_METHODS = [
     'get',
@@ -183,16 +176,14 @@ const pickBodySchema = (op) => {
 };
 /* ─────────────────────────────── Args builders ─────────────────────────────── */
 const createBuildParamsType = (tsTypeFromSchema) => (pathParams, queryParams) => {
-    const parts = [];
-    if (pathParams.length) {
-        const inner = pathParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',');
-        parts.push(`path:{${inner}}`);
-    }
-    if (queryParams.length) {
-        const inner = queryParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',');
-        parts.push(`query:{${inner}}`);
-    }
-    return parts.length ? `{${parts.join(',')}}` : '';
+    const pathPart = pathParams.length === 0
+        ? []
+        : [`path:{${pathParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',')}}`];
+    const queryPart = queryParams.length === 0
+        ? []
+        : [`query:{${queryParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',')}}`];
+    const parts = [...pathPart, ...queryPart];
+    return parts.length === 0 ? '' : `{${parts.join(',')}}`;
 };
 const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
     ? `params:${paramsType},body:${bodyType}`
@@ -203,14 +194,11 @@ const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
             : '';
 /** pass path/query as-is (keep numbers/arrays) */
 const buildClientArgs = (pathParams, queryParams, hasBody) => {
-    const pieces = [];
-    if (pathParams.length)
-        pieces.push('param:params.path');
-    if (queryParams.length)
-        pieces.push('query:params.query');
-    if (hasBody)
-        pieces.push('json:body');
-    return pieces.length ? `{${pieces.join(',')}}` : '';
+    const paramPiece = pathParams.length ? ['param:params.path'] : [];
+    const queryPiece = queryParams.length ? ['query:params.query'] : [];
+    const bodyPiece = hasBody ? ['json:body'] : [];
+    const pieces = [...paramPiece, ...queryPiece, ...bodyPiece];
+    return pieces.length === 0 ? '' : `{${pieces.join(',')}}`;
 };
 /* ─────────────────────────────── Single-operation generator ─────────────────────────────── */
 const generateOperationCode = (pathStr, method, item, deps) => {
@@ -246,6 +234,25 @@ const generateOperationCode = (pathStr, method, item, deps) => {
     const func = `export async function ${funcName}(${argSig}){return await ${call}}`;
     return `${docs}\n${func}`;
 };
+const buildOperationCodes = (paths, deps) => Object.entries(paths)
+    .filter((entry) => isRecord(entry[1]))
+    .flatMap(([p, rawItem]) => {
+    const pathItem = {
+        parameters: rawItem.parameters,
+        get: isOperationLike(rawItem.get) ? rawItem.get : undefined,
+        put: isOperationLike(rawItem.put) ? rawItem.put : undefined,
+        post: isOperationLike(rawItem.post) ? rawItem.post : undefined,
+        delete: isOperationLike(rawItem.delete) ? rawItem.delete : undefined,
+        options: isOperationLike(rawItem.options) ? rawItem.options : undefined,
+        head: isOperationLike(rawItem.head) ? rawItem.head : undefined,
+        patch: isOperationLike(rawItem.patch) ? rawItem.patch : undefined,
+        trace: isOperationLike(rawItem.trace) ? rawItem.trace : undefined,
+    };
+    return HTTP_METHODS.map((method) => {
+        const code = generateOperationCode(p, method, pathItem, deps);
+        return code ? { funcName: methodPath(method, p), code } : null;
+    }).filter((item) => item !== null);
+});
 /* ─────────────────────────────── Split ─────────────────────────────── */
 const resolveSplitOutDir = (output) => {
     const looksLikeFile = output.endsWith('.ts');
@@ -268,7 +275,6 @@ export async function rpc(input, output, importPath, split) {
     const client = 'client';
     const s = `import { client } from '${importPath}'`;
     const header = s.length ? `${s}\n\n` : '';
-    const combinedOut = [];
     const pathsMaybe = openAPI.paths;
     if (!isOpenAPIPaths(pathsMaybe)) {
         return { ok: false, error: 'Invalid OpenAPI paths' };
@@ -279,60 +285,19 @@ export async function rpc(input, output, importPath, split) {
     const componentsParameters = openAPI.components?.parameters ?? {};
     const resolveParameter = createResolveParameter(componentsParameters);
     const toParameterLikes = createToParameterLikes(resolveParameter);
-    // Split-mode: prepare an index file exports collector.
-    const splitExports = new Set();
-    // Iterate paths and generate per-operation code
-    for (const p in pathsMaybe) {
-        const rawItem = pathsMaybe[p];
-        if (!isRecord(rawItem))
-            continue;
-        const pathItem = {
-            parameters: rawItem.parameters,
-            get: isOperationLike(rawItem.get) ? rawItem.get : undefined,
-            put: isOperationLike(rawItem.put) ? rawItem.put : undefined,
-            post: isOperationLike(rawItem.post) ? rawItem.post : undefined,
-            delete: isOperationLike(rawItem.delete) ? rawItem.delete : undefined,
-            options: isOperationLike(rawItem.options) ? rawItem.options : undefined,
-            head: isOperationLike(rawItem.head) ? rawItem.head : undefined,
-            patch: isOperationLike(rawItem.patch) ? rawItem.patch : undefined,
-            trace: isOperationLike(rawItem.trace) ? rawItem.trace : undefined,
-        };
-        for (const method of HTTP_METHODS) {
-            const code = generateOperationCode(p, method, pathItem, {
-                client,
-                tsTypeFromSchema,
-                toParameterLikes,
-            });
-            if (!code)
-                continue;
-            if (split) {
-                // One file per RPC function: <funcName>.ts
-                const funcName = methodPath(method, p);
-                const fileSrc = `${header}${code}\n`;
-                const fmtResult = await fmt(fileSrc);
-                if (!fmtResult.ok)
-                    return { ok: false, error: fmtResult.error };
-                const { outDir } = resolveSplitOutDir(output);
-                const filePath = path.join(outDir, `${funcName}.ts`);
-                const mkdirResult = await mkdir(path.dirname(filePath));
-                if (!mkdirResult.ok)
-                    return { ok: false, error: mkdirResult.error };
-                const writeResult = await writeFile(filePath, fmtResult.value);
-                if (!writeResult.ok)
-                    return { ok: false, error: writeResult.error };
-                splitExports.add(`export * from './${funcName}'`);
-            }
-            else {
-                combinedOut.push(code);
-            }
-        }
-    }
+    const deps = {
+        client,
+        tsTypeFromSchema,
+        toParameterLikes,
+    };
+    const operationCodes = buildOperationCodes(pathsMaybe, deps);
     // Non-split: write single file
     if (!split) {
         const mkdirResult = await mkdir(path.dirname(output));
         if (!mkdirResult.ok)
             return { ok: false, error: mkdirResult.error };
-        const code = `${header}${combinedOut.join('\n\n')}${combinedOut.length ? '\n' : ''}`;
+        const body = operationCodes.map(({ code }) => code).join('\n\n');
+        const code = `${header}${body}${operationCodes.length ? '\n' : ''}`;
         const fmtResult = await fmt(code);
         if (!fmtResult.ok)
             return { ok: false, error: fmtResult.error };
@@ -341,9 +306,23 @@ export async function rpc(input, output, importPath, split) {
             return { ok: false, error: writeResult.error };
         return { ok: true, value: `Generated rpc code written to ${output}` };
     }
-    // Split: write index.ts (barrel)
+    // Split: write each file + index.ts (barrel)
     const { outDir, indexPath } = resolveSplitOutDir(output);
-    const index = `${Array.from(splitExports).sort().join('\n')}\n`;
+    for (const { funcName, code } of operationCodes) {
+        const fileSrc = `${header}${code}\n`;
+        const fmtResult = await fmt(fileSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const filePath = path.join(outDir, `${funcName}.ts`);
+        const mkdirResult = await mkdir(path.dirname(filePath));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(filePath, fmtResult.value);
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+    }
+    const exportLines = Array.from(new Set(operationCodes.map(({ funcName }) => `export * from './${funcName}'`))).sort();
+    const index = `${exportLines.join('\n')}\n`;
     const fmtResult = await fmt(index);
     if (!fmtResult.ok)
         return { ok: false, error: fmtResult.error };
@@ -353,5 +332,8 @@ export async function rpc(input, output, importPath, split) {
     const writeResult = await writeFile(indexPath, fmtResult.value);
     if (!writeResult.ok)
         return { ok: false, error: writeResult.error };
-    return { ok: true, value: `Generated rpc code written to ${outDir}/*.ts (index.ts included)` };
+    return {
+        ok: true,
+        value: `Generated rpc code written to ${outDir}/*.ts (index.ts included)`,
+    };
 }

package/dist/core/takibi.d.ts

@@ -30,9 +30,9 @@
  *   Y --> Z["writeResult2 = writeFile(target, appResult.value)"]
  *   Z --> ZA{"writeResult2.ok ?"}
  *   ZA -->|No| ZB["return { ok:false, error: writeResult2.error }"]
- *   ZA -->|Yes| ZC["handlerResult = zodOpenapiHonoHandler(openAPI, output, test)"]
- *   ZC --> ZD{"handlerResult.ok ?"}
- *   ZD -->|No| ZE["return { ok:false, error: handlerResult.error }"]
+ *   ZA -->|Yes| ZC["zodOpenAPIHonoHandlerResult = zodOpenAPIHonoHandler(openAPI, output, test)"]
+ *   ZC --> ZD{"zodOpenAPIHonoHandlerResult.ok ?"}
+ *   ZD -->|No| ZE["return { ok:false, error: zodOpenAPIHonoHandlerResult.error }"]
  *   ZD -->|Yes| ZF["return { ok:true, value: 'Generated code and template files written' }"]
  * ```
  *

package/dist/core/takibi.js

@@ -37,9 +37,9 @@ import { isHttpMethod, methodPath } from '../utils/index.js';
  *   Y --> Z["writeResult2 = writeFile(target, appResult.value)"]
  *   Z --> ZA{"writeResult2.ok ?"}
  *   ZA -->|No| ZB["return { ok:false, error: writeResult2.error }"]
- *   ZA -->|Yes| ZC["handlerResult = zodOpenapiHonoHandler(openAPI, output, test)"]
- *   ZC --> ZD{"handlerResult.ok ?"}
- *   ZD -->|No| ZE["return { ok:false, error: handlerResult.error }"]
+ *   ZA -->|Yes| ZC["zodOpenAPIHonoHandlerResult = zodOpenAPIHonoHandler(openAPI, output, test)"]
+ *   ZC --> ZD{"zodOpenAPIHonoHandlerResult.ok ?"}
+ *   ZD -->|No| ZE["return { ok:false, error: zodOpenAPIHonoHandlerResult.error }"]
  *   ZD -->|Yes| ZF["return { ok:true, value: 'Generated code and template files written' }"]
  * ```
  *
@@ -53,41 +53,46 @@ import { isHttpMethod, methodPath } from '../utils/index.js';
  * @returns A `Result` containing a success message or an error string.
  */
 export async function takibi(input, output, exportSchema, exportType, template, test, basePath) {
-    const openAPIResult = await parseOpenAPI(input);
-    if (!openAPIResult.ok)
-        return { ok: false, error: openAPIResult.error };
-    const openAPI = openAPIResult.value;
-    const honoResult = await fmt(zodOpenAPIHono(openAPI, exportSchema, exportType));
-    if (!honoResult.ok)
-        return { ok: false, error: honoResult.error };
-    const mkdirResult = await mkdir(path.dirname(output));
-    if (!mkdirResult.ok)
-        return { ok: false, error: mkdirResult.error };
-    const writeResult = await writeFile(output, honoResult.value);
-    if (!writeResult.ok)
-        return { ok: false, error: writeResult.error };
-    /** template */
-    if (template && output.includes('/')) {
-        const appResult = await fmt(app(openAPI, output, basePath));
-        if (!appResult.ok)
-            return { ok: false, error: appResult.error };
-        const dir = path.dirname(output);
-        const readdirResult = await readdir(dir);
-        if (!readdirResult.ok)
-            return { ok: false, error: readdirResult.error };
-        const target = path.join(dir, 'index.ts');
-        const writeResult = await writeFile(target, appResult.value);
+    try {
+        const openAPIResult = await parseOpenAPI(input);
+        if (!openAPIResult.ok)
+            return { ok: false, error: openAPIResult.error };
+        const openAPI = openAPIResult.value;
+        const honoResult = await fmt(zodOpenAPIHono(openAPI, exportSchema, exportType));
+        if (!honoResult.ok)
+            return { ok: false, error: honoResult.error };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(output, honoResult.value);
         if (!writeResult.ok)
             return { ok: false, error: writeResult.error };
-        const zodOpenapiHonoHandlerResult = await zodOpenapiHonoHandler(openAPI, output, test);
-        if (!zodOpenapiHonoHandlerResult.ok)
-            return { ok: false, error: zodOpenapiHonoHandlerResult.error };
-        return { ok: true, value: 'Generated code and template files written' };
+        /** template */
+        if (template && output.includes('/')) {
+            const appResult = await fmt(app(openAPI, output, basePath));
+            if (!appResult.ok)
+                return { ok: false, error: appResult.error };
+            const dir = path.dirname(output);
+            const readdirResult = await readdir(dir);
+            if (!readdirResult.ok)
+                return { ok: false, error: readdirResult.error };
+            const target = path.join(dir, 'index.ts');
+            const writeResult = await writeFile(target, appResult.value);
+            if (!writeResult.ok)
+                return { ok: false, error: writeResult.error };
+            const zodOpenAPIHonoHandlerResult = await zodOpenAPIHonoHandler(openAPI, output, test);
+            if (!zodOpenAPIHonoHandlerResult.ok)
+                return { ok: false, error: zodOpenAPIHonoHandlerResult.error };
+            return { ok: true, value: 'Generated code and template files written' };
+        }
+        return {
+            ok: true,
+            value: `Generated code written to ${output}`,
+        };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
-    return {
-        ok: true,
-        value: `Generated code written to ${output}`,
-    };
 }
 /**
  * Generates route handler files for a Hono app using Zod and OpenAPI.
@@ -97,7 +102,7 @@ export async function takibi(input, output, exportSchema, exportType, template,
  * @param test - Whether to generate corresponding empty test files.
  * @returns A `Result` indicating success or error with message.
  */
-async function zodOpenapiHonoHandler(openapi, output, test) {
+async function zodOpenAPIHonoHandler(openapi, output, test) {
     const paths = openapi.paths;
     const handlers = Object.entries(paths).flatMap(([p, pathItem]) => Object.entries(pathItem)
         .filter(([m]) => isHttpMethod(m))

package/dist/core/type.d.ts

@@ -0,0 +1,7 @@
+export declare function type(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`): Promise<{
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/core/type.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { fmt } from '../format/index.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/index.js';
+import { parseOpenAPI } from '../openapi/index.js';
+import { isHttpMethod, methodPath } from '../utils/index.js';
+export async function type(input, output) {
+    try {
+        const openAPIResult = await parseOpenAPI(input);
+        if (!openAPIResult.ok)
+            return { ok: false, error: openAPIResult.error };
+        const openAPI = openAPIResult.value;
+        const hono = zodOpenAPIHono(openAPI, false, false);
+        const paths = openAPI.paths;
+        const routes = Object.entries(paths).flatMap(([p, pathItem]) => Object.entries(pathItem)
+            .filter(([m]) => isHttpMethod(m))
+            .map(([method]) => {
+            const routeId = methodPath(method, p);
+            return `export const ${routeId}RouteHandler:RouteHandler<typeof ${routeId}Route>=async(c)=>{}`;
+        }));
+        const getRouteMaps = (openapi) => {
+            const openapiPaths = openapi.paths;
+            const routeMappings = Object.entries(openapiPaths).flatMap(([path, pathItem]) => {
+                return Object.entries(pathItem).flatMap(([method]) => {
+                    if (!isHttpMethod(method)) {
+                        return [];
+                    }
+                    const base = methodPath(method, path);
+                    return {
+                        routeName: `${base}Route`,
+                        handlerName: `${base}RouteHandler`,
+                        path,
+                    };
+                });
+            });
+            return routeMappings;
+        };
+        const routeMappings = getRouteMaps(openAPI);
+        const appInit = 'export const api = app' +
+            routeMappings
+                .sort((a, b) => (a.routeName < b.routeName ? -1 : a.routeName > b.routeName ? 1 : 0))
+                .map(({ routeName, handlerName }) => `.openapi(${routeName},${handlerName})`)
+                .join('');
+        const code = `import { OpenAPIHono, type RouteHandler } from '@hono/zod-openapi'\n${hono}\nconst app = new OpenAPIHono()\n${routes.join('\n')}\n${appInit}\nexport type AddType = typeof api`;
+        const honoType = apiType(code);
+        if (honoType === undefined)
+            return { ok: false, error: 'not generated type' };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const type = `declare const routes:\n${honoType}\nexport default routes`;
+        const fmtResult = await fmt(type);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const writeResult = await writeFile(output, fmtResult.value);
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+        return {
+            ok: true,
+            value: `Generated type code written to ${output}`,
+        };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function apiType(code) {
+    const VIRTUAL_FILE_NAME = 'virtual.ts';
+    const compilerOptions = {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        strict: true,
+    };
+    const sourceFile = ts.createSourceFile(VIRTUAL_FILE_NAME, code, compilerOptions.target ?? ts.ScriptTarget.ESNext);
+    const host = ts.createCompilerHost(compilerOptions);
+    const originalGetSourceFile = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        if (fileName === VIRTUAL_FILE_NAME)
+            return sourceFile;
+        return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    };
+    const program = ts.createProgram([VIRTUAL_FILE_NAME], compilerOptions, host);
+    const checker = program.getTypeChecker();
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol)
+        return undefined;
+    const apiSymbol = checker.getExportsOfModule(moduleSymbol).find((s) => s.getName() === 'api');
+    if (!apiSymbol)
+        return undefined;
+    const type = checker.getTypeOfSymbolAtLocation(apiSymbol, sourceFile);
+    return checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation |
+        ts.TypeFormatFlags.UseFullyQualifiedType |
+        ts.TypeFormatFlags.WriteTypeArgumentsOfSignature);
+}

package/dist/generator/zod-openapi-hono/openapi/route/params/request-parameter.js

@@ -16,18 +16,16 @@ import { paramsObject } from './index.js';
  */
 export function requestParameter(parameters, body) {
     // Early return if no parameters or content
-    if (!(parameters || body?.content)) {
+    if (!(parameters || body?.content))
         return '';
-    }
     const requestBodyContentTypes = Object.keys(body?.content || {});
     const params = parameters
         ? (() => {
             const paramsObj = paramsObject(parameters);
             const requestParamsArr = requestParamsArray(paramsObj);
-            if (requestParamsArr.length) {
-                // params
+            // params
+            if (requestParamsArr.length)
                 return `request:{${requestParamsArr.join(',')}},`;
-            }
             return '';
         })()
         : '';
@@ -42,9 +40,8 @@ export function requestParameter(parameters, body) {
         const required = body.required ?? false;
         const [firstSchema] = uniqueSchemas.values();
         const requestBodyCode = requestBody(required, body.content, firstSchema);
-        if (params) {
+        if (params)
             return params.replace('request:{', `request:{${requestBodyCode}`);
-        }
         return `request:{${requestBodyCode}},`;
     }
     return params;

package/dist/generator/zod-openapi-hono/openapi/route/request/body/index.js

@@ -11,21 +11,12 @@ export function requestBody(required, content, schema) {
     const contentTypes = Object.keys(content);
     if (contentTypes.length === 0)
         return '';
-    // check duplication
     const isUniqueSchema = isUniqueContentSchema(contentTypes, content);
-    // all duplication same schema
-    if (isUniqueSchema) {
-        const contentParts = [];
-        for (const contentType of contentTypes) {
-            // z.date() → z.coerce.date()
-            if (schema.includes('z.date()')) {
-                contentParts.push(`'${contentType}':{schema:z.coerce.${schema.replace('z.', '')}}`);
-            }
-            else {
-                contentParts.push(`'${contentType}':{schema:${schema}}`);
-            }
-        }
-        return `body:{required:${required},content:{${contentParts.join(',')}}},`;
-    }
-    return '';
+    if (!isUniqueSchema)
+        return '';
+    // if z.date() → z.coerce.date()
+    const contentParts = contentTypes
+        .map((contentType) => `'${contentType}':{schema:${schema.includes('z.date()') ? `z.coerce.${schema.replace('z.', '')}` : schema}}`)
+        .join(',');
+    return `body:{required:${required},content:{${contentParts}}},`;
 }

package/dist/generator/zod-openapi-hono/openapi/route/response/index.js

@@ -12,53 +12,14 @@ import { zodToOpenAPI } from '../../../../zod-to-openapi/index.js';
  * - Deduplicates content types if all share the same schema.
  * - Escapes all descriptions safely for inline code.
  */
-// export function response(responses: Responses): string {
-//   // 1. get response codes (200, 404, etc.)
-//   const responseCodes = Object.keys(responses)
-//   // 2. processing for each response code
-//   const responseEntries = responseCodes.map((code) => {
-//     const response = responses[code]
-//     // 2.1 no content (description only response)
-//     if (!response.content)
-//       return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',},`
-//     // check duplication
-//     const contentTypes = Object.keys(response.content)
-//     const isUniqueSchema = isUniqueContentSchema(contentTypes, response.content)
-//     // all duplication same schema
-//     if (isUniqueSchema) {
-//       const contentParts: string[] = []
-//       for (const contentType of contentTypes) {
-//         const content = response.content[contentType]
-//         const z = zodToOpenAPI(content.schema)
-//         const examples = content.examples
-//         const exampleString =
-//           examples && Object.keys(examples).length > 0
-//             ? `,examples:{${Object.entries(examples)
-//                 .map(([key, example]) => {
-//                   const parts = []
-//                   if (example.summary) parts.push(`summary:${JSON.stringify(example.summary)}`)
-//                   if (example.value !== undefined)
-//                     parts.push(`value:${JSON.stringify(example.value)}`)
-//                   return `${JSON.stringify(key)}:{${parts.join(',')}}`
-//                 })
-//                 .join(',')}}`
-//             : ''
-//         contentParts.push(`'${contentType}':{schema:${z}${exampleString}}`)
-//       }
-//       return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',content:{${contentParts.join(',')}}},`
-//     }
-//   })
-//   // 3.combine all response definitions
-//   return responseEntries.join('')
-// }
 export function response(responses) {
     // 1. get response codes (200, 404, etc.)
-    const responseEntries = Object.keys(responses).map((code) => {
+    return Object.keys(responses)
+        .map((code) => {
         const res = responses[code];
         const content = res.content;
-        if (!content) {
+        if (!content)
             return `${code}:{description:'${escapeStringLiteral(res.description ?? '')}',},`;
-        }
         const contentTypes = Object.keys(content);
         const isUnique = isUniqueContentSchema(contentTypes, content);
         const sharedZ = isUnique ? zodToOpenAPI(content[contentTypes[0]].schema) : undefined;
@@ -68,19 +29,22 @@ export function response(responses) {
             const examples = media.examples;
             const exampleString = examples && Object.keys(examples).length > 0
                 ? `,examples:{${Object.entries(examples)
-                    .map(([k, v]) => {
-                    const parts = [];
-                    if (v.summary)
-                        parts.push(`summary:${JSON.stringify(v.summary)}`);
-                    if (v.value !== undefined)
-                        parts.push(`value:${JSON.stringify(v.value)}`);
-                    return `${JSON.stringify(k)}:{${parts.join(',')}}`;
+                    .map(([exampleKey, example]) => {
+                    const fields = [
+                        example.summary !== undefined
+                            ? `summary:${JSON.stringify(example.summary)}`
+                            : undefined,
+                        example.value !== undefined
+                            ? `value:${JSON.stringify(example.value)}`
+                            : undefined,
+                    ].filter((field) => field !== undefined);
+                    return `${JSON.stringify(exampleKey)}:{${fields.join(',')}}`;
                 })
                     .join(',')}}`
                 : '';
             return `'${ct}':{schema:${z}${exampleString}}`;
         });
         return `${code}:{description:'${escapeStringLiteral(res.description ?? '')}',content:{${contentParts.join(',')}}},`;
-    });
-    return responseEntries.join('');
+    })
+        .join('');
 }