hono-takibi 0.9.70 → 0.9.72

package/README.md

@@ -91,66 +91,142 @@ export const getRoute = createRoute({
 
 ### Options
 
-basic
-
 ```bash
 Options:
-  --export-type        export TypeScript type aliases
-  --export-schema      export Zod schema objects
-  --template           generate app file and handler stubs
-  --test               generate empty *.test.ts files
-  --base-path <path>   api prefix (default: /)
+  --export-schemas-types      export schemas types
+  --export-schemas            export schemas
+  --export-parameters-types   export parameters types
+  --export-parameters         export parameters
+  --export-security-schemes   export securitySchemes
+  --export-request-bodies     export requestBodies
+  --export-responses          export responses
+  --export-headers-types      export headers types
+  --export-headers            export headers
+  --export-examples           export examples
+  --export-links              export links
+  --export-callbacks          export callbacks
+  --template                  generate app file and handler stubs
+  --test                      generate empty *.test.ts files
+  --base-path <path>          api prefix (default: /)
+  -h, --help                  display help for command
 ```
 
-template
-
-> **⚠️** When using the `--template` option, you must specify a valid directory path. Ensure the directory exists before executing the 
-
 ### Example
 
 ```bash
-npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts --export-type --export-schema --template --base-path '/api/v1'
+npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts --export-schemas --export-schemas-types --template --base-path '/api/v1'
 ```
 
 ## Configuration File (`hono-takibi.config.ts`)
 
 Config used by both the CLI and the Vite plugin.
 
-## Essentials
-
-* Put **`hono-takibi.config.ts`** at repo root.
-* Default‑export with `defineConfig(...)`.
-* `input`: **`openapi.yaml`** (recommended), or `*.json` / `*.tsp`.
-
-> **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).
+### Config Reference
 
----
-
-## Single‑file
-
-One file. Set top‑level `output` (don’t define `schema`/`route`).
+All available options are shown below. In practice, use only the options you need.
 
 ```ts
+// hono-takibi.config.ts
 import { defineConfig } from 'hono-takibi/config'
 
 export default defineConfig({
   input: 'openapi.yaml',
   'zod-openapi': {
     output: './src/index.ts',
-    exportSchema: true,
-    exportType: true,
+    exportSchemas: true,
+    exportSchemasTypes: true,
+    exportParameters: true,
+    exportParametersTypes: true,
+    exportSecuritySchemes: true,
+    exportRequestBodies: true,
+    exportResponses: true,
+    exportHeaders: true,
+    exportHeadersTypes: true,
+    exportExamples: true,
+    exportLinks: true,
+    exportCallbacks: true,
+    routes: {
+      output: './src/routes',
+      split: true,
+    },
+    components: {
+      schemas: {
+        output: './src/schemas',
+        exportTypes: true,
+        split: true,
+        import: '../schemas',
+      },
+      parameters: {
+        output: './src/parameters',
+        exportTypes: true,
+        split: true,
+        import: '../parameters',
+      },
+      securitySchemes: {
+        output: './src/securitySchemes',
+        split: true,
+        import: '../securitySchemes',
+      },
+      requestBodies: {
+        output: './src/requestBodies',
+        split: true,
+        import: '../requestBodies',
+      },
+      responses: {
+        output: './src/responses',
+        split: true,
+        import: '../responses',
+      },
+      headers: {
+        output: './src/headers',
+        exportTypes: true,
+        split: true,
+        import: '../headers',
+      },
+      examples: {
+        output: './src/examples',
+        split: true,
+        import: '../examples',
+      },
+      links: {
+        output: './src/links',
+        split: true,
+        import: '../links',
+      },
+      callbacks: {
+        output: './src/callbacks',
+        split: true,
+        import: '../callbacks',
+      },
+    },
+  },
+  type: {
+    output: './src/types.ts',
+  },
+  rpc: {
+    output: './src/rpc',
+    import: '../client',
+    split: true,
   },
 })
 ```
 
+## Essentials
+
+* Put **`hono-takibi.config.ts`** at repo root.
+* Default‑export with `defineConfig(...)`.
+* `input`: **`openapi.yaml`** (recommended), or `*.json` / `*.tsp`.
+
+> **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).
+
 ---
 
-## Schemas & Routes
+## Single‑file
 
-Define **both** `schema` and `route` (don’t set top‑level `output`).
+One file. Set top‑level `output` (don't define `components`/`routes`).
 
 ```ts
 import { defineConfig } from 'hono-takibi/config'
@@ -158,13 +234,9 @@ import { defineConfig } from 'hono-takibi/config'
 export default defineConfig({
   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' },
+    output: './src/index.ts',
+    exportSchemas: true,
+    exportSchemasTypes: true,
   },
 })
 ```
@@ -178,30 +250,16 @@ Works with either pattern.
 * `split: true` → `output` is a **directory**; many files + `index.ts`.
 * `split` **omitted** or `false` → `output` is **one `*.ts` file**.
 
-**Example (split: true)**
-
 ```ts
 import { defineConfig } from 'hono-takibi/config'
 
 export default defineConfig({
   input: 'openapi.yaml',
-  'zod-openapi': { output: './src/index.ts', exportSchema: true, exportType: true },
+  'zod-openapi': { output: './src/index.ts', exportSchemas: true, exportSchemasTypes: true },
   rpc: { output: './src/rpc', import: '../client', split: true },
 })
 ```
 
-**Example (single file; split omitted/false)**
-
-```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`)

package/dist/cli/index.d.ts

@@ -1,39 +1,3 @@
-/**
- * Main CLI entry point for hono-takibi.
- *
- * Processes command-line arguments or config file to generate TypeScript
- * code from OpenAPI specifications. Supports both CLI mode and config file mode.
- *
- * ```mermaid
- * flowchart TD
- *   A["Start"] --> B{"Args: --help/-h?"}
- *   B -->|Yes| C["Return help text"]
- *   B -->|No| D{"Config file exists?"}
- *   D -->|No| E["CLI Mode"]
- *   D -->|Yes| F["Config Mode"]
- *   E --> G["parseCli(args)"]
- *   G --> H["parseOpenAPI(input)"]
- *   H --> I["takibi(openAPI, ...)"]
- *   F --> J["config()"]
- *   J --> K["parseOpenAPI(config.input)"]
- *   K --> L["Generate all components"]
- *   L --> M["Return results"]
- *   I --> M
- * ```
- *
- * @returns Promise resolving to success with output message or error
- *
- * @example
- * ```ts
- * // CLI usage
- * const result = await honoTakibi()
- * if (result.ok) {
- *   console.log(result.value) // "Generated code written to routes.ts"
- * } else {
- *   console.error(result.error)
- * }
- * ```
- */
 export declare function honoTakibi(): Promise<{
     readonly ok: true;
     readonly value: string;

package/dist/cli/index.js

@@ -21,10 +21,9 @@
  */
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { loadConfig } from '../config/index.js';
+import { readConfig } from '../config/index.js';
 import { callbacks, examples, headers, links, parameters, requestBodies, responses, route, rpc, schemas, securitySchemes, takibi, type, } from '../core/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-import { parseCli } from '../utils/index.js';
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
 Options:
@@ -80,6 +79,71 @@ Options:
  * }
  * ```
  */
+/**
+ * Parse raw CLI arguments into structured options.
+ *
+ * - Validates `<input>` ends with `.yaml`/`.json`/`.tsp`
+ * - Requires `-o <output.ts>`
+ * - Extracts boolean flags for component exports and templates/tests
+ * - Extracts optional `--base-path <path>`
+ *
+ * ```mermaid
+ * flowchart TD
+ *   A["parseCli(args)"] --> B["Extract input & output (-o)"]
+ *   B --> C{"input endsWith .yaml/.json/.tsp AND output endsWith .ts?"}
+ *   C -->|No| D["return { ok:false, error:'Usage: hono-takibi ...' }"]
+ *   C -->|Yes| E["Read flags (--export-schemas-types, --export-schemas, ..., --template, --test)"]
+ *   E --> F["Read optional --base-path value"]
+ *   F --> G["return { ok:true, value:{ input, output, flags... } }"]
+ * ```
+ *
+ * @param args - Raw CLI arguments (e.g., `process.argv.slice(2)`).
+ * @returns `{ ok:true, value }` on success; `{ ok:false, error }` on invalid usage.
+ */
+function parseCli(args) {
+    const input = args[0];
+    const oIdx = args.indexOf('-o');
+    const output = oIdx !== -1 ? args[oIdx + 1] : undefined;
+    /** yaml or json or tsp */
+    const isYamlOrJsonOrTsp = (i) => i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp');
+    const isTs = (o) => o.endsWith('.ts');
+    const getFlagValue = (args, flag) => {
+        const idx = args.indexOf(flag);
+        if (idx !== -1 && args[idx + 1] && !args[idx + 1].startsWith('-'))
+            return args[idx + 1];
+        return undefined;
+    };
+    if (!(input && output && isYamlOrJsonOrTsp(input) && isTs(output))) {
+        return {
+            ok: false,
+            error: HELP_TEXT,
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            input,
+            output,
+            template: args.includes('--template'),
+            test: args.includes('--test'),
+            basePath: getFlagValue(args, '--base-path') ?? '/', // default: /
+            componentsOptions: {
+                exportSchemas: args.includes('--export-schemas') ?? false,
+                exportSchemasTypes: args.includes('--export-schemas-types') ?? false,
+                exportParameters: args.includes('--export-parameters') ?? false,
+                exportParametersTypes: args.includes('--export-parameters-types') ?? false,
+                exportSecuritySchemes: args.includes('--export-security-schemes') ?? false,
+                exportRequestBodies: args.includes('--export-request-bodies') ?? false,
+                exportResponses: args.includes('--export-responses') ?? false,
+                exportHeaders: args.includes('--export-headers') ?? false,
+                exportHeadersTypes: args.includes('--export-headers-types') ?? false,
+                exportExamples: args.includes('--export-examples') ?? false,
+                exportLinks: args.includes('--export-links') ?? false,
+                exportCallbacks: args.includes('--export-callbacks') ?? false,
+            },
+        },
+    };
+}
 export async function honoTakibi() {
     const args = process.argv.slice(2);
     if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) {
@@ -101,7 +165,7 @@ export async function honoTakibi() {
             return { ok: false, error: takibiResult.error };
         return { ok: true, value: takibiResult.value };
     }
-    const loadConfigResult = await loadConfig();
+    const loadConfigResult = await readConfig();
     if (!loadConfigResult.ok)
         return { ok: false, error: loadConfigResult.error };
     const config = loadConfigResult.value;
@@ -204,3 +268,253 @@ export async function honoTakibi() {
     ].filter((v) => v !== undefined);
     return { ok: true, value: results.join('\n') };
 }
+// Test run
+// pnpm vitest run ./packages/hono-takibi/src/cli/index.ts
+if (import.meta.vitest) {
+    const { describe, it, expect, beforeAll, afterAll } = import.meta.vitest;
+    const fs = await import('node:fs');
+    const openapi = {
+        openapi: '3.1.0',
+        info: {
+            title: 'HonoTakibi',
+            version: 'v1',
+        },
+        tags: [{ name: 'Hono' }, { name: 'HonoX' }, { name: 'ZodOpenAPIHono' }],
+        paths: {
+            '/hono': {
+                get: {
+                    tags: ['Hono'],
+                    summary: 'Hono',
+                    description: 'Hono',
+                    responses: {
+                        '200': {
+                            description: 'OK',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            message: {
+                                                type: 'string',
+                                                example: 'Hono',
+                                            },
+                                        },
+                                        required: ['message'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            '/hono-x': {
+                get: {
+                    tags: ['HonoX'],
+                    summary: 'HonoX',
+                    description: 'HonoX',
+                    responses: {
+                        '200': {
+                            description: 'OK',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            message: {
+                                                type: 'string',
+                                                example: 'HonoX',
+                                            },
+                                        },
+                                        required: ['message'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            '/zod-openapi-hono': {
+                get: {
+                    tags: ['ZodOpenAPIHono'],
+                    summary: 'ZodOpenAPIHono',
+                    description: 'ZodOpenAPIHono',
+                    responses: {
+                        '200': {
+                            description: 'OK',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            message: {
+                                                type: 'string',
+                                                example: 'ZodOpenAPIHono',
+                                            },
+                                        },
+                                        required: ['message'],
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    describe('honoTakibi', () => {
+        beforeAll(() => {
+            process.argv = [
+                '*/*/bin/node',
+                '*/dist/index.js',
+                'openapi.json',
+                '-o',
+                'zod-openapi-hono.ts',
+            ];
+            fs.writeFileSync('openapi.json', JSON.stringify(openapi));
+        });
+        afterAll(() => {
+            fs.rmSync('openapi.json', { force: true });
+            fs.rmSync('zod-openapi-hono.ts', { force: true });
+        });
+        it('honoTakibi generated', async () => {
+            const result = await honoTakibi();
+            expect(result).toEqual({
+                ok: true,
+                value: 'Generated code written to zod-openapi-hono.ts',
+            });
+            const generatedCode = fs.readFileSync('zod-openapi-hono.ts', 'utf-8');
+            const expectedCode = `import { createRoute, z } from '@hono/zod-openapi'
+
+export const getHonoRoute = createRoute({
+  method: 'get',
+  path: '/hono',
+  tags: ['Hono'],
+  summary: 'Hono',
+  description: 'Hono',
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: z
+            .object({ message: z.string().openapi({ example: 'Hono' }) })
+            .openapi({ required: ['message'] }),
+        },
+      },
+    },
+  },
+})
+
+export const getHonoXRoute = createRoute({
+  method: 'get',
+  path: '/hono-x',
+  tags: ['HonoX'],
+  summary: 'HonoX',
+  description: 'HonoX',
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: z
+            .object({ message: z.string().openapi({ example: 'HonoX' }) })
+            .openapi({ required: ['message'] }),
+        },
+      },
+    },
+  },
+})
+
+export const getZodOpenapiHonoRoute = createRoute({
+  method: 'get',
+  path: '/zod-openapi-hono',
+  tags: ['ZodOpenAPIHono'],
+  summary: 'ZodOpenAPIHono',
+  description: 'ZodOpenAPIHono',
+  responses: {
+    200: {
+      description: 'OK',
+      content: {
+        'application/json': {
+          schema: z
+            .object({ message: z.string().openapi({ example: 'ZodOpenAPIHono' }) })
+            .openapi({ required: ['message'] }),
+        },
+      },
+    },
+  },
+})
+`;
+            expect(generatedCode).toBe(expectedCode);
+        });
+    });
+    describe('honoTakibi --help', () => {
+        beforeAll(() => {
+            process.argv = ['*/*/bin/node', '*/dist/index.js', '--help'];
+        });
+        it('honoTakibi help requested --help', async () => {
+            const result = await honoTakibi();
+            expect(result).toStrictEqual({
+                ok: true,
+                value: `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
+
+Options:
+  --export-schemas-types      export schemas types
+  --export-schemas            export schemas
+  --export-parameters-types   export parameters types
+  --export-parameters         export parameters
+  --export-security-schemes   export securitySchemes
+  --export-request-bodies     export requestBodies
+  --export-responses          export responses
+  --export-headers-types      export headers types
+  --export-headers            export headers
+  --export-examples           export examples
+  --export-links              export links
+  --export-callbacks          export callbacks
+  --template                  generate app file and handler stubs
+  --test                      generate empty *.test.ts files
+  --base-path <path>          api prefix (default: /)
+  -h, --help                  display help for command`,
+            });
+        });
+    });
+    describe('honoTakibi -h', () => {
+        beforeAll(() => {
+            process.argv = ['*/*/bin/node', '*/dist/index.js', '-h'];
+        });
+        it('honoTakibi help requested -h', async () => {
+            const result = await honoTakibi();
+            expect(result).toStrictEqual({
+                ok: true,
+                value: `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
+
+Options:
+  --export-schemas-types      export schemas types
+  --export-schemas            export schemas
+  --export-parameters-types   export parameters types
+  --export-parameters         export parameters
+  --export-security-schemes   export securitySchemes
+  --export-request-bodies     export requestBodies
+  --export-responses          export responses
+  --export-headers-types      export headers types
+  --export-headers            export headers
+  --export-examples           export examples
+  --export-links              export links
+  --export-callbacks          export callbacks
+  --template                  generate app file and handler stubs
+  --test                      generate empty *.test.ts files
+  --base-path <path>          api prefix (default: /)
+  -h, --help                  display help for command`,
+            });
+        });
+        describe('honoTakibi missing output', () => {
+            beforeAll(() => {
+                process.argv = ['node', 'dist/index.js', 'openapi.yaml'];
+            });
+            it('should fail if output is not specified', async () => {
+                const result = await honoTakibi();
+                expect(result.ok).toBe(false);
+            });
+        });
+    });
+}

package/dist/config/index.d.ts

@@ -85,7 +85,7 @@ export declare function parseConfig(config: Config): {
     readonly ok: false;
     readonly error: string;
 };
-export declare function loadConfig(): Promise<{
+export declare function readConfig(): Promise<{
     readonly ok: true;
     readonly value: Config;
 } | {

package/dist/config/index.js

@@ -225,7 +225,7 @@ export function parseConfig(config) {
     }
     return { ok: true, value: config };
 }
-export async function loadConfig() {
+export async function readConfig() {
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
     if (!existsSync(abs))
         return { ok: false, error: `Config not found: ${abs}` };
@@ -252,3 +252,64 @@ export async function loadConfig() {
 export function defineConfig(config) {
     return config;
 }
+// Test run
+// pnpm vitest run ./packages/hono-takibi/src/config/index.ts
+if (import.meta.vitest) {
+    const { describe, it, expect, beforeEach, afterEach, vi } = import.meta.vitest;
+    const fs = await import('node:fs');
+    const os = await import('node:os');
+    const path = await import('node:path');
+    describe('loadConfig()', () => {
+        const origCwd = process.cwd();
+        beforeEach(() => {
+            vi.resetModules();
+            const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'hono-takibi-config-ts-'));
+            process.chdir(tmpdir);
+        });
+        afterEach(() => {
+            const cwd = process.cwd();
+            process.chdir(origCwd);
+            fs.rmSync(cwd, { recursive: true, force: true });
+        });
+        it('passes: legacy top-level output mode', async () => {
+            const p = path.join(process.cwd(), 'hono-takibi.config.ts');
+            const c = `
+export default {
+  input: 'openapi.yaml',
+  'zod-openapi': {
+    output: 'routes/index.ts',
+    exportSchemasTypes: true,
+    exportSchemas: true
+  },
+  rpc: {
+    output: 'rpc/index.ts',
+    import: '../client'
+  }
+}
+`;
+            fs.writeFileSync(p, c, 'utf-8');
+            await expect(readConfig()).resolves.toStrictEqual({
+                ok: true,
+                value: {
+                    input: 'openapi.yaml',
+                    'zod-openapi': {
+                        output: 'routes/index.ts',
+                        exportSchemasTypes: true,
+                        exportSchemas: true,
+                    },
+                    rpc: {
+                        output: 'rpc/index.ts',
+                        import: '../client',
+                    },
+                },
+            });
+        });
+        it('fails: config file missing', async () => {
+            const result = await readConfig();
+            expect(result.ok).toBe(false);
+            if (!result.ok) {
+                expect(result.error).toMatch(/Config not found:/);
+            }
+        });
+    });
+}