hono-takibi 0.9.40 → 0.9.51

package/dist/core/takibi.js

@@ -4,7 +4,7 @@ import { mkdir, readdir, writeFile } from '../fsp/index.js';
 import { app } from '../generator/zod-openapi-hono/app/index.js';
 import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-import { groupHandlersByFileName, isHttpMethod, methodPath } from '../utils/index.js';
+import { isHttpMethod, methodPath } from '../utils/index.js';
 /**
  * Generates TypeScript code from an OpenAPI spec and optional templates.
  *
@@ -81,14 +81,14 @@ export async function takibi(input, output, exportSchema, exportType, template,
         if (!readdirResult.ok) {
             return { ok: false, error: readdirResult.error };
         }
-        const target = path.join(dir, readdirResult.value.includes('index.ts') ? 'main.ts' : 'index.ts');
+        const target = path.join(dir, 'index.ts');
         const writeResult = await writeFile(target, appResult.value);
         if (!writeResult.ok) {
             return { ok: false, error: writeResult.error };
         }
-        const handlerResult = await zodOpenapiHonoHandler(openAPI, output, test);
-        if (!handlerResult.ok) {
-            return { ok: false, error: handlerResult.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' };
     }
@@ -107,57 +107,98 @@ export async function takibi(input, output, exportSchema, exportType, template,
  */
 async function zodOpenapiHonoHandler(openapi, output, test) {
     const paths = openapi.paths;
-    const handlers = [];
-    for (const [path, pathItem] of Object.entries(paths)) {
-        for (const [method] of Object.entries(pathItem)) {
-            if (!isHttpMethod(method))
-                continue;
-            const routeHandlerContent = `export const ${methodPath(method, path)}RouteHandler:RouteHandler<typeof ${methodPath(method, path)}Route>=async(c)=>{}`;
-            const rawSegment = path.replace(/^\/+/, '').split('/')[0] ?? '';
-            const pathName = (rawSegment === '' ? 'index' : rawSegment)
-                .replace(/\{([^}]+)\}/g, '$1')
-                .replace(/[^0-9A-Za-z._-]/g, '_')
-                .replace(/^[._-]+|[._-]+$/g, '')
-                .replace(/__+/g, '_')
-                .replace(/[-._](\w)/g, (_, c) => c.toUpperCase());
-            const fileName = pathName.length === 0 ? 'indexHandler.ts' : `${pathName}Handler.ts`;
-            const testFileName = pathName.length === 0 ? 'indexHandler.test.ts' : `${pathName}Handler.test.ts`;
-            handlers.push({
-                fileName,
-                testFileName,
-                routeHandlerContents: [routeHandlerContent],
-                routeNames: [`${methodPath(method, path)}Route`],
-            });
-        }
-    }
-    const mergedHandlers = groupHandlersByFileName(handlers);
+    const handlers = Object.entries(paths).flatMap(([p, pathItem]) => Object.entries(pathItem)
+        .filter(([m]) => isHttpMethod(m))
+        .map(([method]) => {
+        const routeId = methodPath(method, p);
+        const routeHandlerContent = `export const ${routeId}RouteHandler:RouteHandler<typeof ${routeId}Route>=async(c)=>{}`;
+        const rawSegment = p.replace(/^\/+/, '').split('/')[0] ?? '';
+        const sanitized = rawSegment
+            .replace(/\{([^}]+)\}/g, '$1')
+            .replace(/[^0-9A-Za-z._-]/g, '_')
+            .replace(/^[._-]+|[._-]+$/g, '')
+            .replace(/__+/g, '_')
+            .replace(/[-._](\w)/g, (_, c) => c.toUpperCase());
+        const pathName = sanitized === '' ? '__root' : sanitized;
+        const fileName = `${pathName}.ts`;
+        const testFileName = `${pathName}.test.ts`;
+        return {
+            fileName,
+            testFileName,
+            routeHandlerContents: [routeHandlerContent],
+            routeNames: [`${routeId}Route`],
+        };
+    }));
+    const mergedHandlers = Array.from(handlers
+        .reduce((map, h) => {
+        const prev = map.get(h.fileName);
+        const next = prev
+            ? {
+                fileName: h.fileName,
+                testFileName: h.testFileName,
+                routeHandlerContents: [...prev.routeHandlerContents, ...h.routeHandlerContents],
+                routeNames: Array.from(new Set([...prev.routeNames, ...h.routeNames])),
+            }
+            : {
+                fileName: h.fileName,
+                testFileName: h.testFileName,
+                routeHandlerContents: [...h.routeHandlerContents],
+                routeNames: [...h.routeNames],
+            };
+        map.set(h.fileName, next);
+        return map;
+    }, new Map())
+        .values());
+    const isDot = output === '.' || output === './';
+    const baseDir = isDot ? '.' : (output.match(/^(.*)\/[^/]+\.ts$/)?.[1] ?? '.');
+    const handlerPath = baseDir === '.' ? 'handlers' : `${baseDir}/handlers`;
+    const routeEntryBasename = output.match(/[^/]+\.ts$/)?.[0] ?? 'index.ts';
+    const importFrom = `../${routeEntryBasename.replace(/\.ts$/, '')}`;
+    const mkdirResult = await mkdir(handlerPath);
+    if (!mkdirResult.ok)
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
     for (const handler of mergedHandlers) {
-        const dirPath = output?.replace(/\/[^/]+\.ts$/, '');
-        const handlerPath = dirPath === 'index.ts' ? 'handlers' : `${dirPath}/handlers`;
-        const mkdirResult = await mkdir(handlerPath);
-        if (!mkdirResult.ok) {
-            return { ok: false, error: mkdirResult.error };
-        }
-        const routeTypes = handler.routeNames.map((routeName) => `${routeName}`).join(', ');
-        const match = output?.match(/[^/]+\.ts$/);
-        const matchPath = match ? match[0] : '';
-        const path = output === '.' || output === './' ? output : `../${matchPath}`;
-        const importRouteTypes = routeTypes ? `import type { ${routeTypes} } from '${path}';` : '';
+        const routeTypes = Array.from(new Set(handler.routeNames)).join(', ');
+        const importRouteTypes = routeTypes ? `import type { ${routeTypes} } from '${importFrom}';` : '';
         const importStatements = `import type { RouteHandler } from '@hono/zod-openapi'\n${importRouteTypes}`;
         const fileContent = `${importStatements}\n\n${handler.routeHandlerContents.join('\n\n')}`;
-        const formatCode = await fmt(fileContent);
-        if (!formatCode.ok) {
-            return { ok: false, error: formatCode.error };
-        }
-        const writeResult = await writeFile(`${handlerPath}/${handler.fileName}`, formatCode.value);
+        const fmtResult = await fmt(fileContent);
+        if (!fmtResult.ok)
+            return {
+                ok: false,
+                error: fmtResult.error,
+            };
+        const writeResult = await writeFile(`${handlerPath}/${handler.fileName}`, fmtResult.value);
         if (!writeResult.ok)
-            writeResult;
+            return {
+                ok: false,
+                error: writeResult.error,
+            };
         if (test) {
             const writeResult = await writeFile(`${handlerPath}/${handler.testFileName}`, '');
-            if (!writeResult.ok) {
-                return { ok: false, error: writeResult.error };
-            }
+            if (!writeResult.ok)
+                return {
+                    ok: false,
+                    error: writeResult.error,
+                };
         }
     }
+    const sorted = mergedHandlers.map((h) => h.fileName).sort();
+    const exports = sorted.map((h) => `export * from './${h}'`).join('\n');
+    const fmtResult = await fmt(exports);
+    if (!fmtResult.ok)
+        return {
+            ok: false,
+            error: fmtResult.error,
+        };
+    const writeResult = await writeFile(`${handlerPath}/index.ts`, fmtResult.value);
+    if (!writeResult.ok)
+        return {
+            ok: false,
+            error: writeResult.error,
+        };
     return { ok: true, value: undefined };
 }

package/dist/generator/zod-openapi-hono/app/index.js

@@ -1,6 +1,5 @@
 import { docs } from '../../../helper/docs.js';
-import { getRouteMaps } from '../../../helper/get-route-maps.js';
-import { getHandlerImports, importHandlers, importMap, importRoutes, registerComponent, } from '../../../utils/index.js';
+import { isHttpMethod, methodPath, registerComponent } from '../../../utils/index.js';
 /**
  * Generates a Hono app with OpenAPI and Swagger UI integration.
  *
@@ -10,7 +9,27 @@ import { getHandlerImports, importHandlers, importMap, importRoutes, registerCom
  * @returns The generated application code as a string.
  */
 export function app(openapi, output, basePath) {
+    const getRouteMaps = (openapi) => {
+        const paths = openapi.paths;
+        const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
+            return Object.entries(pathItem).flatMap(([method]) => {
+                if (!isHttpMethod(method))
+                    return [];
+                return {
+                    routeName: `${methodPath(method, path)}Route`,
+                    handlerName: `${methodPath(method, path)}RouteHandler`,
+                    path,
+                };
+            });
+        });
+        return routeMappings;
+    };
     const routeMappings = getRouteMaps(openapi);
+    const handlerNames = Array.from(new Set(routeMappings.map((m) => m.handlerName))).sort();
+    const handlerImport = handlerNames.length > 0 ? `import { ${handlerNames.join(',')} } from './handlers'` : '';
+    const routeNames = Array.from(new Set(routeMappings.map((m) => m.routeName))).sort();
+    const routeModule = `./${output.replace(/^.*\//, '').replace(/\.ts$/, '')}`;
+    const routesImport = routeNames.length > 0 ? `import { ${routeNames.join(',')} } from '${routeModule}'` : '';
     const path = basePath !== undefined ? `${basePath}/doc` : '/doc';
     const registerComponentCode = openapi.components?.securitySchemes
         ? registerComponent(openapi.components.securitySchemes)
@@ -21,25 +40,33 @@ export function app(openapi, output, basePath) {
     const minor = Number.isFinite(Number(minStr)) ? Number(minStr) : 0;
     const is31Plus = major > 3 || (major === 3 && minor >= 1);
     const doc = is31Plus ? 'doc31' : 'doc';
-    const swagger = `if(process.env.NODE_ENV === 'development'){${registerComponentCode}\napp.${doc}('${'/doc'}',${JSON.stringify(docs(openapi))}).get('/ui',swaggerUI({url:'${path}'}))}`;
-    const sections = [
-        [
-            `import { swaggerUI } from '@hono/swagger-ui'`,
-            `import { OpenAPIHono } from '@hono/zod-openapi'`,
-            importHandlers(getHandlerImports(routeMappings), output).join('\n'),
-            importRoutes(importMap(routeMappings, output)).join(''),
-        ].join('\n'),
-        basePath
-            ? `${'const app = new OpenAPIHono()'}.basePath('${basePath}')`
-            : 'const app = new OpenAPIHono()',
-        `export const api = ${`app${routeMappings
-            .map(({ routeName, handlerName }) => {
-            return `.openapi(${routeName},${handlerName})`;
-        })
-            .join('\n')}`}`,
+    const importSection = [
+        `import { swaggerUI } from '@hono/swagger-ui'`,
+        `import { OpenAPIHono } from '@hono/zod-openapi'`,
+        handlerImport,
+        routesImport,
+    ]
+        .filter(Boolean)
+        .join('\n');
+    const appInit = basePath
+        ? `const app = new OpenAPIHono().basePath('${basePath}')`
+        : 'const app = new OpenAPIHono()';
+    const apiInit = '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('\n');
+    const swagger = `if(process.env.NODE_ENV === 'development'){` +
+        `${registerComponentCode}\n` +
+        `app.${doc}('/doc',${JSON.stringify(docs(openapi))})` +
+        `.get('/ui',swaggerUI({url:'${path}'}))` +
+        '}';
+    return [
+        importSection,
+        appInit,
+        apiInit,
         swagger,
         'export type AddType = typeof api',
         'export default app',
-    ];
-    return sections.join('\n\n');
+    ].join('\n\n');
 }

package/dist/helper/index.d.ts

@@ -1,5 +1,4 @@
 export { docs } from './docs.js';
-export { getRouteMaps } from './get-route-maps.js';
 export { propertiesSchema } from './properties-schema.js';
 export { resolveSchemasDependencies } from './resolve-schemas-dependencies.js';
 export { wrap } from './wrap.js';

package/dist/helper/index.js

@@ -1,5 +1,4 @@
 export { docs } from './docs.js';
-export { getRouteMaps } from './get-route-maps.js';
 export { propertiesSchema } from './properties-schema.js';
 export { resolveSchemasDependencies } from './resolve-schemas-dependencies.js';
 export { wrap } from './wrap.js';

package/dist/utils/index.d.ts

@@ -108,28 +108,6 @@ export declare function normalizeTypes(t?: 'string' | 'number' | 'integer' | 'da
     'string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null',
     ...('string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null')[]
 ]): ("string" | "number" | "boolean" | "object" | "integer" | "date" | "array" | "null")[];
-/**
- * Generates import statements for route handler modules.
- *
- * ```mermaid
- * graph TD
- *   A[Start importRoutes] --> B[Init result list]
- *   B --> C[Iterate entries]
- *   C --> D[Make unique names]
- *   D --> E[Normalize path if needed]
- *   E --> F[Build import line]
- *   F --> G[Append to result list]
- *   G --> H[More entries]
- *   H -->|Yes| C
- *   H -->|No| I[Return result list]
- * ```
- *
- * @param importsMap - Map of file paths to exported identifiers.
- * @returns Array of import statements.
- */
-export declare function importRoutes(importsMap: {
-    [importPath: `${string}.ts`]: readonly string[];
-}): readonly string[];
 /**
  * Generates registration code for OpenAPI `securitySchemes`.
  *
@@ -158,116 +136,6 @@ export declare function registerComponent(securitySchemes: {
         bearerFormat?: string;
     };
 }): string;
-/**
- * Generates an import map that associates route names with their corresponding import file path.
- *
- * This is useful for dynamically constructing import statements in code generation,
- * ensuring that each route is grouped under its appropriate file.
- *
- * ```mermaid
- * graph TD
- *   A[Start importMap] --> B[Initialize empty map]
- *   B --> C[Iterate routeMappings]
- *   C --> D[Extract output file name]
- *   D --> E[Check if map has key]
- *   E --> F[Create array if missing]
- *   F --> G[Add route name to array]
- *   G --> H[More routeMappings]
- *   H --> C
- *   C --> I[Return importsMap]
- * ```
- *
- * @param routeMappings - An array of route mapping objects containing route name, handler name, and path.
- * @param output - The output TypeScript file name (e.g., 'user.ts'). Used to determine the import path.
- * @returns A record where each key is an import path (e.g., 'user.ts') and the value is an array of route names imported from that path.
- */
-export declare function importMap(routeMappings: {
-    readonly routeName: string;
-    readonly handlerName: string;
-    readonly path: string;
-}[], output: `${string}.ts`): {
-    [importPath: `${string}.ts`]: readonly string[];
-};
-/**
- * Generates import statements for handler functions.
- *
- * ```mermaid
- * graph TD
- *   A[Start importHandlers] --> B[Init empty list]
- *   B --> C[Iterate handlerImportsMap]
- *   C --> D[Make unique handler names]
- *   D --> E[Get dir path from output]
- *   E --> F[Set handler path base]
- *   F --> G[Build import statement]
- *   G --> H[Append to list]
- *   H --> I[More entries]
- *   I --> C
- *   C --> J[Return list]
- * ```
- *
- * @param handlerImportsMap - A map from file names to handler names.
- * @param output - The output file path (e.g., 'api.ts').
- * @returns An array of import statement strings.
- */
-export declare function importHandlers(handlerImportsMap: {
-    [fileName: string]: readonly string[];
-}, output: `${string}.ts`): readonly string[];
-/**
- * Groups route handlers by file name.
- *
- * ```mermaid
- * graph TD
- *   A[Start groupHandlersByFileName] --> B[Create empty map]
- *   B --> C[Iterate handlers]
- *   C --> D[Find existing entry by file name]
- *   D --> E[Merge contents and route names]
- *   E --> F[Set merged entry back to map]
- *   F --> G[More handlers]
- *   G --> C
- *   C --> H[Return map values as array]
- * ```
- *
- * @param handlers - An array of route handler definitions including file name, test file name, contents, and route names.
- * @returns A deduplicated array of grouped handler definitions per file.
- */
-export declare function groupHandlersByFileName(handlers: {
-    readonly fileName: `${string}.ts`;
-    readonly testFileName: `${string}.ts`;
-    readonly routeHandlerContents: readonly string[];
-    readonly routeNames: readonly string[];
-}[]): {
-    readonly fileName: `${string}.ts`;
-    readonly testFileName: `${string}.ts`;
-    readonly routeHandlerContents: readonly string[];
-    readonly routeNames: readonly string[];
-}[];
-/**
- * Generates a map of handler file names to handler names.
- *
- * ```mermaid
- * graph TD
- *   A[Start getHandlerImports] --> B[Init empty map]
- *   B --> C[Iterate handler maps]
- *   C --> D[Take first path segment]
- *   D --> E[Sanitize segment to path name]
- *   E --> F[Make file name or index handler]
- *   F --> G[Ensure array exists in map]
- *   G --> H[Append handler name]
- *   H --> I[More items]
- *   I --> C
- *   C --> J[Return map]
- * ```
- *
- * @param handlerMaps - Array of route mappings including route name, handler name, and path.
- * @returns A map where keys are handler file names and values are arrays of handler names.
- */
-export declare function getHandlerImports(handlerMaps: {
-    readonly routeName: string;
-    readonly handlerName: string;
-    readonly path: string;
-}[]): {
-    [fileName: `${string}.ts`]: readonly string[];
-};
 /**
  * Checks if a value is a non-null object (e.g., a potential `$ref` object).
  *
@@ -411,25 +279,10 @@ export declare function createRoute(args: {
 }): string;
 /**
  * Generates an array of Zod validator strings from OpenAPI parameter objects.
- *
- * ```mermaid
- * graph TD
- *   A[Start requestParamsArray] --> B[Collect non empty sections]
- *   B --> C[Iterate sections]
- *   C --> D[Build z object string from entries]
- *   D --> E[If section is path rename to params]
- *   E --> F[Push section colon z object string]
- *   F --> G[Continue loop]
- *   G --> H[Filter out null values]
- *   H --> I[Return array of strings]
- * ```
- *
  * @param parameters - An object containing `query`, `path`, and `header` parameters.
  * @returns An array of strings like `'query:z.object({...})'` or `'params:z.object({...})'`.
  */
-export declare function requestParamsArray(parameters: {
-    [section: string]: Record<string, string>;
-}): readonly string[];
+export declare const requestParamsArray: (parameters: Record<string, Record<string, string>>) => readonly string[];
 /**
  * Escapes a string for safe use in TypeScript string literals.
  *

package/dist/utils/index.js

@@ -225,39 +225,6 @@ export function parseCli(args) {
 export function normalizeTypes(t) {
     return t === undefined ? [] : Array.isArray(t) ? t : [t];
 }
-/**
- * Generates import statements for route handler modules.
- *
- * ```mermaid
- * graph TD
- *   A[Start importRoutes] --> B[Init result list]
- *   B --> C[Iterate entries]
- *   C --> D[Make unique names]
- *   D --> E[Normalize path if needed]
- *   E --> F[Build import line]
- *   F --> G[Append to result list]
- *   G --> H[More entries]
- *   H -->|Yes| C
- *   H -->|No| I[Return result list]
- * ```
- *
- * @param importsMap - Map of file paths to exported identifiers.
- * @returns Array of import statements.
- */
-export function importRoutes(importsMap) {
-    const importRoutes = [];
-    for (const [importPath, names] of Object.entries(importsMap)) {
-        const uniqueNames = Array.from(new Set(names));
-        if (importPath.includes('index.ts')) {
-            const normalizedPath = importPath.replace('index.ts', '');
-            importRoutes.push(`import { ${uniqueNames.join(',')} } from './${normalizedPath}'`);
-        }
-        else {
-            importRoutes.push(`import { ${uniqueNames.join(',')} } from './${importPath}'`);
-        }
-    }
-    return importRoutes;
-}
 /**
  * Generates registration code for OpenAPI `securitySchemes`.
  *
@@ -285,152 +252,6 @@ export function registerComponent(securitySchemes) {
     })
         .join('\n');
 }
-/**
- * Generates an import map that associates route names with their corresponding import file path.
- *
- * This is useful for dynamically constructing import statements in code generation,
- * ensuring that each route is grouped under its appropriate file.
- *
- * ```mermaid
- * graph TD
- *   A[Start importMap] --> B[Initialize empty map]
- *   B --> C[Iterate routeMappings]
- *   C --> D[Extract output file name]
- *   D --> E[Check if map has key]
- *   E --> F[Create array if missing]
- *   F --> G[Add route name to array]
- *   G --> H[More routeMappings]
- *   H --> C
- *   C --> I[Return importsMap]
- * ```
- *
- * @param routeMappings - An array of route mapping objects containing route name, handler name, and path.
- * @param output - The output TypeScript file name (e.g., 'user.ts'). Used to determine the import path.
- * @returns A record where each key is an import path (e.g., 'user.ts') and the value is an array of route names imported from that path.
- */
-export function importMap(routeMappings, output) {
-    const importsMap = {};
-    for (const { routeName } of routeMappings) {
-        const match = output.match(/[^/]+\.ts$/);
-        const importPath = match ? match[0] : output;
-        if (!importsMap[importPath]) {
-            importsMap[importPath] = [];
-        }
-        importsMap[importPath].push(routeName);
-    }
-    return importsMap;
-}
-/**
- * Generates import statements for handler functions.
- *
- * ```mermaid
- * graph TD
- *   A[Start importHandlers] --> B[Init empty list]
- *   B --> C[Iterate handlerImportsMap]
- *   C --> D[Make unique handler names]
- *   D --> E[Get dir path from output]
- *   E --> F[Set handler path base]
- *   F --> G[Build import statement]
- *   G --> H[Append to list]
- *   H --> I[More entries]
- *   I --> C
- *   C --> J[Return list]
- * ```
- *
- * @param handlerImportsMap - A map from file names to handler names.
- * @param output - The output file path (e.g., 'api.ts').
- * @returns An array of import statement strings.
- */
-export function importHandlers(handlerImportsMap, output) {
-    const importHandlers = [];
-    for (const [fileName, handlers] of Object.entries(handlerImportsMap)) {
-        const uniqueHandlers = Array.from(new Set(handlers));
-        const replacePath = output?.replace(/\/[^/]+\.ts$/, '');
-        const dirPath = replacePath === undefined ? '.' : replacePath;
-        const handlerPath = 'handlers';
-        if (dirPath === '.') {
-            importHandlers.push(`import { ${uniqueHandlers.join(',')} } from '${handlerPath}/${fileName}'`);
-        }
-        else {
-            importHandlers.push(`import { ${uniqueHandlers.join(',')} } from './${handlerPath}/${fileName}'`);
-        }
-    }
-    return importHandlers;
-}
-/**
- * Groups route handlers by file name.
- *
- * ```mermaid
- * graph TD
- *   A[Start groupHandlersByFileName] --> B[Create empty map]
- *   B --> C[Iterate handlers]
- *   C --> D[Find existing entry by file name]
- *   D --> E[Merge contents and route names]
- *   E --> F[Set merged entry back to map]
- *   F --> G[More handlers]
- *   G --> C
- *   C --> H[Return map values as array]
- * ```
- *
- * @param handlers - An array of route handler definitions including file name, test file name, contents, and route names.
- * @returns A deduplicated array of grouped handler definitions per file.
- */
-export function groupHandlersByFileName(handlers) {
-    return Array.from(handlers
-        .reduce((acc, handler) => {
-        const existing = acc.get(handler.fileName);
-        const mergedHandler = {
-            fileName: handler.fileName,
-            testFileName: handler.testFileName,
-            routeHandlerContents: existing
-                ? [...existing.routeHandlerContents, ...handler.routeHandlerContents]
-                : [...handler.routeHandlerContents],
-            routeNames: existing
-                ? [...existing.routeNames, ...handler.routeNames]
-                : [...handler.routeNames],
-        };
-        return acc.set(handler.fileName, mergedHandler);
-    }, new Map())
-        .values());
-}
-/**
- * Generates a map of handler file names to handler names.
- *
- * ```mermaid
- * graph TD
- *   A[Start getHandlerImports] --> B[Init empty map]
- *   B --> C[Iterate handler maps]
- *   C --> D[Take first path segment]
- *   D --> E[Sanitize segment to path name]
- *   E --> F[Make file name or index handler]
- *   F --> G[Ensure array exists in map]
- *   G --> H[Append handler name]
- *   H --> I[More items]
- *   I --> C
- *   C --> J[Return map]
- * ```
- *
- * @param handlerMaps - Array of route mappings including route name, handler name, and path.
- * @returns A map where keys are handler file names and values are arrays of handler names.
- */
-export function getHandlerImports(handlerMaps) {
-    const getHandlerImports = {};
-    for (const { handlerName, path } of handlerMaps) {
-        const rawSegment = path.replace(/^\/+/, '').split('/')[0] ?? '';
-        const pathName = (rawSegment === '' ? 'index' : rawSegment)
-            .replace(/\{([^}]+)\}/g, '$1')
-            .replace(/[^0-9A-Za-z._-]/g, '_')
-            .replace(/^[._-]+|[._-]+$/g, '')
-            .replace(/__+/g, '_')
-            .replace(/[-._](\w)/g, (_, c) => c.toUpperCase());
-        const fileName = pathName.length === 0 ? 'indexHandler.ts' : `${pathName}Handler.ts`;
-        if (!getHandlerImports[fileName]) {
-            getHandlerImports[fileName] = [];
-        }
-        getHandlerImports[fileName].push(handlerName);
-    }
-    return getHandlerImports;
-}
 /**
  * Checks if a value is a non-null object (e.g., a potential `$ref` object).
  *
@@ -560,7 +381,7 @@ export function methodPath(method, path) {
         .split(/\s+/)
         .map((str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`)
         .join('');
-    return apiPath ? `${method}${apiPath}` : `${method}Index`;
+    return apiPath ? `${method}${apiPath}` : `${method}`;
 }
 /**
  * Generates a Hono route definition as a TypeScript export string.
@@ -602,47 +423,18 @@ export function createRoute(args) {
 }
 /**
  * Generates an array of Zod validator strings from OpenAPI parameter objects.
- *
- * ```mermaid
- * graph TD
- *   A[Start requestParamsArray] --> B[Collect non empty sections]
- *   B --> C[Iterate sections]
- *   C --> D[Build z object string from entries]
- *   D --> E[If section is path rename to params]
- *   E --> F[Push section colon z object string]
- *   F --> G[Continue loop]
- *   G --> H[Filter out null values]
- *   H --> I[Return array of strings]
- * ```
- *
  * @param parameters - An object containing `query`, `path`, and `header` parameters.
  * @returns An array of strings like `'query:z.object({...})'` or `'params:z.object({...})'`.
  */
-export function requestParamsArray(parameters) {
-    // 1.  define sections to be processed
-    const sections = Object.entries(parameters)
-        .filter(([_, obj]) => obj && Object.keys(obj).length > 0)
-        .map(([section]) => section);
-    // 2. processing of each section
-    return (sections
-        .map((section) => {
-        const obj = parameters[section];
-        // 2.1 process only if object is not empty
-        if (Object.keys(obj).length) {
-            const s = `z.object({${Object.entries(obj)
-                .map(([k, v]) => `${k}:${v}`)
-                .join(',')}})`;
-            // path is params convention
-            if (section === 'path') {
-                return `params:${s}`;
-            }
-            return `${section}:${s}`;
-        }
-        return null;
-    })
-        // 3. exclude null and return only an array of strings
-        .filter((item) => item !== null));
-}
+export const requestParamsArray = (parameters) => Object.entries(parameters)
+    .filter(([, obj]) => obj && Object.keys(obj).length)
+    .map(([section, obj]) => {
+    const name = section === 'path' ? 'params' : section;
+    const fields = Object.entries(obj)
+        .map(([k, v]) => `${k}:${v}`)
+        .join(',');
+    return `${name}:z.object({${fields}})`;
+});
 /**
  * Escapes a string for safe use in TypeScript string literals.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.9.40",
+  "version": "0.9.51",
   "type": "module",
   "license": "MIT",
   "keywords": [

package/dist/helper/get-route-maps.d.ts

@@ -1,12 +0,0 @@
-import type { OpenAPI } from '../openapi/index.js';
-/**
- * Extracts route mappings from an OpenAPI specification.
- *
- * @param openapi - The OpenAPI specification object.
- * @returns An array of route mappings, each with route name, handler name, and path.
- */
-export declare function getRouteMaps(openapi: OpenAPI): {
-    routeName: string;
-    handlerName: string;
-    path: string;
-}[];

package/dist/helper/get-route-maps.js

@@ -1,22 +0,0 @@
-import { isHttpMethod, methodPath } from '../utils/index.js';
-/**
- * Extracts route mappings from an OpenAPI specification.
- *
- * @param openapi - The OpenAPI specification object.
- * @returns An array of route mappings, each with route name, handler name, and path.
- */
-export function getRouteMaps(openapi) {
-    const paths = openapi.paths;
-    const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
-        return Object.entries(pathItem).flatMap(([method]) => {
-            if (!isHttpMethod(method))
-                return [];
-            return {
-                routeName: `${methodPath(method, path)}Route`,
-                handlerName: `${methodPath(method, path)}RouteHandler`,
-                path,
-            };
-        });
-    });
-    return routeMappings;
-}