hono-takibi 0.9.71 → 0.9.73

package/README.md

@@ -111,8 +111,6 @@ Options:
   -h, --help                  display help for command
 ```
 
-> **⚠️** When using the `--template` option, you must specify a valid directory path. Ensure the directory exists before executing.
-
 ### Example
 
 ```bash

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:/);
+            }
+        });
+    });
+}

package/dist/core/components/examples.js

@@ -2,13 +2,21 @@
  * Example component generation module.
  *
  * Handles generation of JSON exports from OpenAPI example components
- * with support for split mode.
+ * with support for split mode and $ref resolution.
  *
  * @module core/components/examples
  */
 import path from 'node:path';
 import { makeExportConst } from '../../helper/code.js';
-import { core, makeExports } from '../../helper/index.js';
+import { core, makeRef } from '../../helper/index.js';
+import { ensureSuffix, lowerFirst, toIdentifierPascalCase } from '../../utils/index.js';
+/**
+ * Type guard for $ref property.
+ *
+ * @param val - Value to check
+ * @returns True if value has $ref property
+ */
+const hasRef = (val) => typeof val === 'object' && val !== null && '$ref' in val && typeof val.$ref === 'string';
 /**
  * Generates example component files.
  *
@@ -42,10 +50,38 @@ export async function examples(examples, output, split) {
     if (keys.length === 0)
         return { ok: true, value: 'No examples found' };
     if (split) {
-        const exportsResult = await makeExports(examples, 'Example', output);
-        if (!exportsResult.ok)
-            return { ok: false, error: exportsResult.error };
-        return { ok: true, value: exportsResult.value };
+        const outDir = output.replace(/\.ts$/, '');
+        // Generate index.ts with sorted exports
+        const indexCode = `${keys
+            .sort()
+            .map((v) => `export * from './${lowerFirst(v)}.ts'`)
+            .join('\n')}\n`;
+        const results = await Promise.all([
+            ...keys.map((key) => {
+                const v = examples[key];
+                const name = toIdentifierPascalCase(ensureSuffix(key, 'Example'));
+                const filePath = path.join(outDir, `${lowerFirst(key)}.ts`);
+                // Handle $ref references: generate import + re-export
+                if (hasRef(v)) {
+                    const refName = makeRef(v.$ref);
+                    const refKey = v.$ref.split('/').at(-1) ?? '';
+                    const importPath = `./${lowerFirst(refKey)}.ts`;
+                    const body = `import { ${refName} } from '${importPath}'\n\nexport const ${name} = ${refName}\n`;
+                    return core(body, path.dirname(filePath), filePath);
+                }
+                // Inline value: generate JSON export
+                const body = `export const ${name} = ${JSON.stringify(v)}\n`;
+                return core(body, path.dirname(filePath), filePath);
+            }),
+            core(indexCode, path.dirname(path.join(outDir, 'index.ts')), path.join(outDir, 'index.ts')),
+        ]);
+        const firstError = results.find((r) => !r.ok);
+        if (firstError)
+            return firstError;
+        return {
+            ok: true,
+            value: `Generated Example code written to ${outDir}/*.ts (index.ts included)`,
+        };
     }
     const code = makeExportConst(examples, 'Example');
     const coreResult = await core(code, path.dirname(output), output);

package/dist/core/components/headers.js

@@ -59,8 +59,8 @@ export async function headers(headers, output, split, exportType, components) {
             core(makeBarell(headers), outDir, path.join(outDir, 'index.ts')),
         ]);
         const firstError = allResults.find((r) => !r.ok);
-        if (firstError && !firstError.ok)
-            return { ok: false, error: firstError.error };
+        if (firstError)
+            return firstError;
         return {
             ok: true,
             value: `Generated headers code written to ${outDir}/*.ts (index.ts included)`,

package/dist/core/components/parameters.js

@@ -59,8 +59,8 @@ export async function parameters(parameters, output, split, exportType, componen
             core(makeBarell(parameters), outDir, path.join(outDir, 'index.ts')),
         ]);
         const firstError = allResults.find((r) => !r.ok);
-        if (firstError && !firstError.ok)
-            return { ok: false, error: firstError.error };
+        if (firstError)
+            return firstError;
         return {
             ok: true,
             value: `Generated parameters code written to ${outDir}/*.ts (index.ts included)`,

package/dist/core/components/requestBodies.js

@@ -56,8 +56,8 @@ export async function requestBodies(requestBodies, output, split, components) {
             core(makeBarell(requestBodies), outDir, path.join(outDir, 'index.ts')),
         ]);
         const firstError = allResults.find((r) => !r.ok);
-        if (firstError && !firstError.ok)
-            return { ok: false, error: firstError.error };
+        if (firstError)
+            return firstError;
         return {
             ok: true,
             value: `Generated requestBodies code written to ${outDir}/*.ts (index.ts included)`,

package/dist/core/components/responses.js

@@ -56,8 +56,8 @@ export async function responses(responses, output, split, components) {
             core(makeBarell(responses), outDir, path.join(outDir, 'index.ts')),
         ]);
         const firstError = allResults.find((r) => !r.ok);
-        if (firstError && !firstError.ok)
-            return { ok: false, error: firstError.error };
+        if (firstError)
+            return firstError;
         return {
             ok: true,
             value: `Generated responses code written to ${outDir}/*.ts (index.ts included)`,

package/dist/core/components/schemas.js

@@ -57,8 +57,8 @@ export async function schemas(schemas, output, split, exportType) {
             core(makeBarell(schemas), path.dirname(`${outDir}/index.ts`), `${outDir}/index.ts`),
         ]);
         const firstError = allResults.find((r) => !r.ok);
-        if (firstError && !firstError.ok)
-            return { ok: false, error: firstError.error };
+        if (firstError)
+            return firstError;
         return {
             ok: true,
             value: `Generated schema code written to ${outDir}/*.ts (index.ts included)`,