hono-takibi 0.9.30 → 0.9.51

package/README.md

@@ -112,101 +112,152 @@ template
 npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts --export-type --export-schema --template --base-path '/api/v1'
 ```
 
-## HonoTakibiVite
+## Configuration File (`hono-takibi.config.ts`)
 
-### Automatic Code Regeneration & HMR
+Config used by both the CLI and the Vite plugin.
 
-With **HonoTakibiVite**, saving your OpenAPI spec while the Vite dev server is running instantly regenerates the code.
+## Essentials
 
-### OpenAPI Schema Requirements
+* Put **`hono-takibi.config.ts`** at repo root.
+* Default‑export with `defineConfig(...)`.
+* `input`: **`openapi.yaml`** (recommended), or `*.json` / `*.tsp`.
 
-- Your OpenAPI definition must include **only the `#/components/schemas/` section**.
-- It must be fully compliant with **OpenAPI 3.0 or later (e.g., 3.0 or 3.1)**.
-- Do **not** include `paths`, `tags`, or any other OpenAPI sections.
+> **About `split`**
+>
+> * `split: true` → `output` is a **directory**; many files + `index.ts`.
+> * `split` **omitted** or `false` → `output` is a **single `*.ts` file** (one file only).
 
-### Supported Input Formats
+---
 
-You may specify the input file in one of the following formats:
+## Single‑file
 
-- `.yaml` — OpenAPI YAML (schemas only)
-- `.json` — OpenAPI JSON (schemas only)
-- `.tsp` — TypeSpec source file
+One file. Set top‑level `output` (don’t define `schema`/`route`).
 
-### TypeSpec Setup (if using `.tsp`)
+```ts
+import { defineConfig } from 'hono-takibi/config'
 
-If you use a `.tsp` TypeSpec file, you must set up the TypeSpec environment and install required libraries:
+export default defineConfig({
+  input: 'openapi.yaml',
+  'zod-openapi': {
+    output: './src/index.ts',
+    exportSchema: true,
+    exportType: true,
+  },
+})
+```
 
-- @typespec/http
-- @typespec/rest
-- ...other
+---
 
-### Example
+## Schemas & Routes
 
-`vite.config.ts`
+Define **both** `schema` and `route` (don’t set top‑level `output`).
 
 ```ts
-import { defineConfig } from 'vite'
-import { HonoTakibiVite } from 'hono-takibi/vite-plugin'
+import { defineConfig } from 'hono-takibi/config'
 
 export default defineConfig({
-  plugins: [
-    HonoTakibiVite({
-      input: 'main.tsp',
-      output: 'index.ts',
-      exportType: true,
-      exportSchema: true,
-    }),
-  ],
+  input: 'openapi.yaml',
+  'zod-openapi': {
+    // split ON → outputs are directories
+    schema: { output: './src/schemas', split: true },
+    route: { output: './src/routes', import: '../schemas', split: true },
+
+    // split OFF example (one file each):
+    // schema: { output: './src/schemas/index.ts' },
+    // route: { output: './src/routes/index.ts', import: '../schemas' },
+  },
 })
 ```
 
-### Demo
+---
 
-![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/vite/hono-takibi-vite.gif)
+## RPC (optional)
 
+Works with either pattern.
 
-## With AI Prompt
+* `split: true` → `output` is a **directory**; many files + `index.ts`.
+* `split` **omitted** or `false` → `output` is **one `*.ts` file**.
 
-### Sample Prompt — Schemas-Only Extractor (OpenAPI 3+)
+**Example (split: true)**
 
-A copy‑and‑paste prompt for **any LLM** that extracts **only** the contents of `#/components/schemas/` from an OpenAPI document.
+```ts
+import { defineConfig } from 'hono-takibi/config'
+
+export default defineConfig({
+  input: 'openapi.yaml',
+  'zod-openapi': { output: './src/index.ts', exportSchema: true, exportType: true },
+  rpc: { output: './src/rpc', import: '../client', split: true },
+})
+```
 
-## Prompt　Example
+**Example (single file; split omitted/false)**
 
-```md
-You are a **Schemas‑Only Extractor** for OpenAPI 3+.
+```ts
+import { defineConfig } from 'hono-takibi/config'
+
+export default defineConfig({
+  input: 'openapi.yaml',
+  'zod-openapi': { output: './src/index.ts', exportSchema: true, exportType: true },
+  rpc: { output: './src/rpc/index.ts', import: '../client' },
+})
+```
+
+---
+
+## Vite Plugin (`honoTakibiVite`)
+
+Auto‑regenerates on changes and reloads dev server.
+
+```ts
+// vite.config.ts
+import { honoTakibiVite } from 'hono-takibi/vite-plugin'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  plugins: [honoTakibiVite()],
+})
+```
+
+**What it does**
+
+* **Watches**: the config, your `input`, and nearby `**/*.{yaml,json,tsp}`.
+* **Generates** outputs per your config (single‑file or split, plus `rpc`).
+* **Cleans** old generated files safely when paths or `split` change.
+
+That’s it — set `input`, choose one of the two patterns, and (optionally) add `rpc`. ✅
+
+### Demo (Vite + HMR)
+
+![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/vite/hono-takibi-vite.gif)
 
-## 1. Version
-- Accept files that start with `openapi: "3.0.0"` or newer.
-- Otherwise reply with: `Unsupported OpenAPI version (must be 3.0+).`
 
-## 2. Scope
-- Look **only** inside `#/components/schemas/`. Ignore everything else.
-- `$ref` must also point inside that section.
+## AI Prompt Example
 
-## 3. Schemas section present?
-- If `components.schemas` is missing, reply with: `Missing '#/components/schemas/' section. Cannot proceed.`
+```sh
+Generate one **OpenAPI 3.x+** YAML (prefer **3.1.0**).
 
-## 4. File type
-- Accept **.yaml**, **.json**, or **.tsp** files.
-- Otherwise reply with: `Unsupported input file extension.`
+Rules:
+- Use only `components.schemas` (no other `components`).
+- Never include `parameters:`.
+- No path params; all inputs in `requestBody` (`application/json`) with `$ref: '#/components/schemas/*'`.
+- All responses use `application/json` with `$ref: '#/components/schemas/*'`.
+- POST-only action routes: `/resource/create|get|search|update|delete`.
+- No inline schemas in `paths`.
 
-## Format tips
-- `format: uuid` usually means **UUID v4**.
-- Other accepted identifiers include `uuidv6`, `uuidv7`, `ulid`, `cuid`, etc.
-- With **hono‑takibi**, you can generate **Zod schemas** directly from a custom OpenAPI file.
+Fill, then generate:
+- title / version / tags
+- resources & fields
+- ops per resource: create / get / search / update / delete
 
-## What the LLM should do
-1. Validate the file with the four rules above.
-2. If it passes, output **only** the YAML/JSON fragment under `#/components/schemas/` (preserve indentation).
-3. Otherwise, output the exact error message above—nothing more.
+**Output format (strict):**
+- Return a **single fenced code block** labeled `yaml` that contains **only** the YAML.
+- No text before or after the code block.
 ```
 
 ### ⚠️ WARNING: Potential Breaking Changes Without Notice
 
 **This package is in active development and may introduce breaking changes without prior notice.**
 Specifically:
-- Query parameter coercion behavior may change
 - Schema generation logic might be updated
 - Output code structure could be modified
 - Example value handling might be altered

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/dist/vite-plugin/index.d.ts

@@ -1 +1 @@
-export declare function HonoTakibiVite(): any;
+export declare function honoTakibiVite(): any;

package/dist/vite-plugin/index.js

@@ -397,7 +397,7 @@ const outputDirsFromConf = (c) => {
  * Plugin (return `any`, no `let`)
  * ────────────────────────────────────────────────────────────── */
 // biome-ignore lint: plugin
-export function HonoTakibiVite() {
+export function honoTakibiVite() {
     const state = { current: null };
     const absConfig = path.resolve(process.cwd(), 'hono-takibi.config.ts');
     const run = async () => {

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.30",
+  "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;
-}