hono-takibi 0.9.26 → 0.9.30

package/README.md

@@ -33,31 +33,6 @@ If you have OpenAPI specifications, Hono Takibi automates the conversion process
 npx hono-takibi path/to/input.{yaml,json,tsp} -o path/to/output.ts
 ```
 
-## CLI
-
-### 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: /)
-```
-
-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'
-```
-
 input:
 
 ```yaml
@@ -112,6 +87,31 @@ export const getRoute = createRoute({
 
 ![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/demo/hono-takibi.gif)
 
+## CLI
+
+### 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: /)
+```
+
+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'
+```
+
 ## HonoTakibiVite
 
 ### Automatic Code Regeneration & HMR

package/dist/cli/index.d.ts

@@ -5,17 +5,16 @@
  *
  * ```mermaid
  * flowchart TD
- *   A["Start honoTakibi()"] --> B["args = process.argv.slice(2)"]
- *   B --> C{"isHelpRequested(args) ?"}
- *   C -->|Yes| D["return { ok:true, value: HELP_TEXT }"]
- *   C -->|No| E["cliResult = parseCli(args)"]
- *   E --> F{"cliResult.ok ?"}
- *   F -->|No| G["return { ok:false, error: cliResult.error }"]
- *   F -->|Yes| H["cli = cliResult.value"]
- *   H --> I["takibiResult = await takibi(cli.input, cli.output, ...options)"]
- *   I --> J{"takibiResult.ok ?"}
- *   J -->|No| K["return { ok:false, error: takibiResult.error }"]
- *   J -->|Yes| L["return { ok:true, value: takibiResult.value }"]
+ *   A["Start honoTakibi"] --> B["Parse args"]
+ *   B --> C{"Help requested?"}
+ *   C -- Yes --> D["Return help text"]
+ *   C -- No --> E["parseCli(args)"]
+ *   E --> F{"cliResult.ok?"}
+ *   F -- No --> G["Return parse error"]
+ *   F -- Yes --> H["Run takibi"]
+ *   H --> I{"takibi.ok?"}
+ *   I -- No --> J["Return takibi error"]
+ *   I -- Yes --> K["Return success message"]
  * ```
  *
  * **Options**

package/dist/cli/index.js

@@ -1,13 +1,16 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { config } from '../config/index.js';
-import { core } from '../core/core.js';
 import { route } from '../core/route.js';
+import { rpc } from '../core/rpc.js';
 import { schema } from '../core/schema.js';
 import { takibi } from '../core/takibi.js';
-import { rpc } from '../generator/rpc/index.js';
 // import { honoRpcWithSWR } from '../generator/swr/index.js'
 import { parseCli } from '../utils/index.js';
+/**
+ * CLI usage help text shown when `-h`/`--help` is provided.
+ * Kept as a single template for easy updates and snapshot stability.
+ */
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
 Options:
@@ -24,17 +27,16 @@ Options:
  *
  * ```mermaid
  * flowchart TD
- *   A["Start honoTakibi()"] --> B["args = process.argv.slice(2)"]
- *   B --> C{"isHelpRequested(args) ?"}
- *   C -->|Yes| D["return { ok:true, value: HELP_TEXT }"]
- *   C -->|No| E["cliResult = parseCli(args)"]
- *   E --> F{"cliResult.ok ?"}
- *   F -->|No| G["return { ok:false, error: cliResult.error }"]
- *   F -->|Yes| H["cli = cliResult.value"]
- *   H --> I["takibiResult = await takibi(cli.input, cli.output, ...options)"]
- *   I --> J{"takibiResult.ok ?"}
- *   J -->|No| K["return { ok:false, error: takibiResult.error }"]
- *   J -->|Yes| L["return { ok:true, value: takibiResult.value }"]
+ *   A["Start honoTakibi"] --> B["Parse args"]
+ *   B --> C{"Help requested?"}
+ *   C -- Yes --> D["Return help text"]
+ *   C -- No --> E["parseCli(args)"]
+ *   E --> F{"cliResult.ok?"}
+ *   F -- No --> G["Return parse error"]
+ *   F -- Yes --> H["Run takibi"]
+ *   H --> I{"takibi.ok?"}
+ *   I -- No --> J["Return takibi error"]
+ *   I -- Yes --> K["Return success message"]
  * ```
  *
  * **Options**
@@ -50,7 +52,7 @@ Options:
  * - `{ ok: false, error: string }` on validation or generation errors
  */
 export async function honoTakibi() {
-    // Slice the arguments to remove the first two (node and script path)
+    /** Slice the arguments to remove the first two (node and script path) */
     const args = process.argv.slice(2);
     const isHelpRequested = (args) => {
         return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
@@ -63,11 +65,11 @@ export async function honoTakibi() {
         };
     }
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
+    /** If config file does not exist, parse CLI arguments */
     if (!existsSync(abs)) {
         const cliResult = parseCli(args);
-        if (!cliResult.ok) {
+        if (!cliResult.ok)
             return { ok: false, error: cliResult.error };
-        }
         const cli = cliResult.value;
         const takibiResult = await takibi(cli.input, cli.output, cli.exportSchema ?? false, cli.exportType ?? false, cli.template ?? false, cli.test ?? false, cli.basePath);
         if (!takibiResult.ok) {
@@ -78,11 +80,13 @@ export async function honoTakibi() {
             value: takibiResult.value,
         };
     }
+    /** If config file exists, parse config file */
     const configResult = await config();
     if (!configResult.ok) {
         return { ok: false, error: configResult.error };
     }
     const c = configResult.value;
+    /** takibi */
     const takibiResult = c['zod-openapi']?.output
         ? await takibi(c.input, c['zod-openapi']?.output, c['zod-openapi']?.exportSchema ?? false, c['zod-openapi']?.exportType ?? false, false, // template
         false)
@@ -90,38 +94,27 @@ export async function honoTakibi() {
     if (takibiResult && !takibiResult.ok) {
         return { ok: false, error: takibiResult.error };
     }
-    // schema
+    /** schema */
     const schemaResult = c['zod-openapi']?.schema
         ? await schema(c.input, c['zod-openapi'].schema.output, c['zod-openapi'].schema.exportType ?? false, c['zod-openapi']?.schema.split ?? false)
         : undefined;
     if (schemaResult && !schemaResult.ok) {
         return { ok: false, error: schemaResult.error };
     }
-    // route
+    /** route */
     const routeResult = c['zod-openapi']?.route
         ? await route(c.input, c['zod-openapi'].route.output, c['zod-openapi'].route.import, c['zod-openapi'].route.split ?? false)
         : undefined;
     if (routeResult && !routeResult.ok) {
         return { ok: false, error: routeResult.error };
     }
+    /** rpc */
     const rpcResult = c.rpc
-        ? await core(c.input, c.rpc.output, c.rpc.import, 'Generated RPC code written to', rpc)
+        ? await rpc(c.input, c.rpc.output, c.rpc.import, c.rpc.split ?? false)
         : undefined;
     if (rpcResult && !rpcResult.ok) {
         return { ok: false, error: rpcResult.error };
     }
-    // const swrResult = c.swr
-    //   ? await core(
-    //       c.swr.input,
-    //       c.swr.output,
-    //       c.swr.import,
-    //       'Generated SWR code written to',
-    //       honoRpcWithSWR,
-    //     )
-    //   : undefined
-    // if (swrResult && !swrResult.ok) {
-    //   return { ok: false, error: swrResult.error }
-    // }
     const results = [takibiResult?.value, rpcResult?.value].filter((v) => Boolean(v));
     return {
         ok: true,

package/dist/config/index.d.ts

@@ -16,8 +16,9 @@ type Config = {
         };
     };
     readonly rpc?: {
-        readonly output: `${string}.ts`;
+        readonly output: string | `${string}.ts`;
         readonly import: string;
+        readonly split?: boolean;
     };
 };
 export declare function config(): Promise<{
@@ -27,5 +28,10 @@ export declare function config(): Promise<{
     readonly ok: false;
     readonly error: string;
 }>;
+/**
+ * Helper to define a config with full type completion.
+ *
+ * @see config
+ */
 export declare function defineConfig(c: Config): Config;
 export {};

package/dist/config/index.js

@@ -2,149 +2,32 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { register } from 'tsx/esm/api';
-const isYamlOrJsonOrTsp = (i) => typeof i === 'string' && (i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp'));
-const isTs = (o) => typeof o === 'string' && o.endsWith('.ts');
+import { parseConfig } from '../utils/index.js';
 export async function config() {
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
     if (!existsSync(abs))
         return { ok: false, error: `Config not found: ${abs}` };
     try {
         register();
-        const mod = await import(pathToFileURL(abs).href);
-        if (!('default' in mod)) {
+        const url = pathToFileURL(abs).href;
+        const mod = await import(/* @vite-ignore */ url);
+        if (!('default' in mod) || mod.default === undefined) {
             return { ok: false, error: 'Config must export default object' };
         }
-        if (mod.default) {
-            // input
-            if (!isYamlOrJsonOrTsp(mod.default.input)) {
-                return {
-                    ok: false,
-                    error: `Invalid input format for zod-openapi: ${String(mod.default.input)}`,
-                };
-            }
-            // zod-openapi
-            const zo = mod.default['zod-openapi'];
-            if (zo) {
-                // boolean flags
-                if (zo.exportSchema !== undefined && typeof zo.exportSchema !== 'boolean') {
-                    return {
-                        ok: false,
-                        error: `Invalid exportSchema format for zod-openapi: ${String(zo.exportSchema)}`,
-                    };
-                }
-                if (zo.exportType !== undefined && typeof zo.exportType !== 'boolean') {
-                    return {
-                        ok: false,
-                        error: `Invalid exportType format for zod-openapi: ${String(zo.exportType)}`,
-                    };
-                }
-                const hasSchema = zo.schema !== undefined;
-                const hasRoute = zo.route !== undefined;
-                if (hasSchema || hasRoute) {
-                    if (Object.hasOwn(zo, 'output')) {
-                        return {
-                            ok: false,
-                            error: "Invalid config: When using 'zod-openapi.schema' or 'zod-openapi.route', do NOT set 'zod-openapi.output'.",
-                        };
-                    }
-                }
-                else {
-                    if (!isTs(zo.output)) {
-                        return {
-                            ok: false,
-                            error: `Invalid output format for zod-openapi: ${String(zo.output)}`,
-                        };
-                    }
-                }
-                if (hasSchema) {
-                    const s = zo.schema;
-                    if (!s)
-                        return { ok: false, error: 'Invalid config: zod-openapi.schema is undefined' };
-                    if (s.split !== undefined && typeof s.split !== 'boolean') {
-                        return {
-                            ok: false,
-                            error: `Invalid schema split format for zod-openapi: ${String(s.split)}`,
-                        };
-                    }
-                    if (typeof s.output !== 'string') {
-                        return { ok: false, error: `Invalid schema output path: ${String(s.output)}` };
-                    }
-                    if (s.split === true) {
-                        if (isTs(s.output)) {
-                            return {
-                                ok: false,
-                                error: `Invalid schema output path for split mode (must be a directory, not .ts): ${s.output}`,
-                            };
-                        }
-                    }
-                    else {
-                        if (!isTs(s.output)) {
-                            return {
-                                ok: false,
-                                error: `Invalid schema output path for non-split mode (must be .ts file): ${s.output}`,
-                            };
-                        }
-                    }
-                    if (s.exportType !== undefined && typeof s.exportType !== 'boolean') {
-                        return {
-                            ok: false,
-                            error: `Invalid schema exportType format for zod-openapi: ${String(s.exportType)}`,
-                        };
-                    }
-                }
-                if (hasRoute) {
-                    const r = zo.route;
-                    if (!r)
-                        return { ok: false, error: 'Invalid config: zod-openapi.route is undefined' };
-                    if (typeof r.import !== 'string') {
-                        return {
-                            ok: false,
-                            error: `Invalid route import format for zod-openapi: ${String(r.import)}`,
-                        };
-                    }
-                    if (r.split !== undefined && typeof r.split !== 'boolean') {
-                        return {
-                            ok: false,
-                            error: `Invalid route split format for zod-openapi: ${String(r.split)}`,
-                        };
-                    }
-                    if (typeof r.output !== 'string') {
-                        return { ok: false, error: `Invalid route output path: ${String(r.output)}` };
-                    }
-                    if (r.split === true) {
-                        if (isTs(r.output)) {
-                            return {
-                                ok: false,
-                                error: `Invalid route output path for split mode (must be a directory, not .ts): ${r.output}`,
-                            };
-                        }
-                    }
-                    else {
-                        if (!isTs(r.output)) {
-                            return {
-                                ok: false,
-                                error: `Invalid route output path for non-split mode (must be .ts file): ${r.output}`,
-                            };
-                        }
-                    }
-                }
-            }
-            const rpc = mod.default.rpc;
-            if (rpc) {
-                if (!isTs(rpc.output)) {
-                    return { ok: false, error: `Invalid output format for rpc: ${String(rpc.output)}` };
-                }
-                if (typeof rpc.import !== 'string') {
-                    return { ok: false, error: `Invalid import format for rpc: ${String(rpc.import)}` };
-                }
-            }
-        }
-        return { ok: true, value: mod.default };
+        const result = parseConfig(mod.default);
+        if (!result.ok)
+            return { ok: false, error: result.error };
+        return { ok: true, value: result.value };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
+/**
+ * Helper to define a config with full type completion.
+ *
+ * @see config
+ */
 export function defineConfig(c) {
     return c;
 }

package/dist/core/route.js

@@ -35,16 +35,16 @@ export async function route(input, output, importPath, split) {
         const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
         const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
         const finalSrc = [importHono, importSchemas, '\n', routesSrc].filter(Boolean).join('\n');
-        const fmtCode = await fmt(finalSrc);
-        if (!fmtCode.ok)
-            return { ok: false, error: fmtCode.error };
-        const mk = await mkdir(path.dirname(output));
-        if (!mk.ok)
-            return { ok: false, error: mk.error };
-        const wr = await writeFile(output, fmtCode.value);
-        return wr.ok
+        const fmtResult = await fmt(finalSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(output, fmtResult.value);
+        return writeResult.ok
             ? { ok: true, value: `Generated route code written to ${output}` }
-            : { ok: false, error: wr.error };
+            : { ok: false, error: writeResult.error };
     }
     const outDir = output.replace(/\.ts$/, '');
     const blocks = extractRouteBlocks(routesSrc);
@@ -54,16 +54,16 @@ export async function route(input, output, importPath, split) {
         const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
         const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
         const finalSrc = [importHono, importSchemas, '\n', routesSrc].filter(Boolean).join('\n');
-        const fmtCode = await fmt(finalSrc);
-        if (!fmtCode.ok)
-            return { ok: false, error: fmtCode.error };
-        const mk = await mkdir(path.dirname(output));
-        if (!mk.ok)
-            return { ok: false, error: mk.error };
-        const wr = await writeFile(output, fmtCode.value);
-        return wr.ok
+        const fmtResult = await fmt(finalSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(output, fmtResult.value);
+        return writeResult.ok
             ? { ok: true, value: `Generated route code written to ${output}` }
-            : { ok: false, error: wr.error };
+            : { ok: false, error: writeResult.error };
     }
     for (const { name, block } of blocks) {
         const includeZ = block.includes('z.');
@@ -71,26 +71,29 @@ export async function route(input, output, importPath, split) {
         const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
         const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
         const fileSrc = [importHono, importSchemas, '\n', block, ''].filter(Boolean).join('\n');
-        const fmtCode = await fmt(fileSrc);
-        if (!fmtCode.ok)
-            return { ok: false, error: fmtCode.error };
+        const fmtResult = await fmt(fileSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
         const filePath = `${outDir}/${lowerFirst(name)}.ts`;
-        const mk = await mkdir(path.dirname(filePath));
-        if (!mk.ok)
-            return { ok: false, error: mk.error };
-        const wr = await writeFile(filePath, fmtCode.value);
-        if (!wr.ok)
-            return { ok: false, error: wr.error };
+        const mkdirResult = await mkdir(path.dirname(filePath));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(filePath, fmtResult.value);
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
     }
-    const indexBody = `${blocks.map(({ name }) => `export * from './${lowerFirst(name)}'`).join('\n')}\n`;
-    const indexFmt = await fmt(indexBody);
-    if (!indexFmt.ok)
-        return { ok: false, error: indexFmt.error };
-    const mkIndex = await mkdir(path.dirname(`${outDir}/index.ts`));
-    if (!mkIndex.ok)
-        return { ok: false, error: mkIndex.error };
-    const wrIndex = await writeFile(`${outDir}/index.ts`, indexFmt.value);
-    if (!wrIndex.ok)
-        return { ok: false, error: wrIndex.error };
+    const indexBody = `${blocks
+        .sort()
+        .map(({ name }) => `export * from './${lowerFirst(name)}'`)
+        .join('\n')}\n`;
+    const fmtResult = await fmt(indexBody);
+    if (!fmtResult.ok)
+        return { ok: false, error: fmtResult.error };
+    const mkdirResult = await mkdir(path.dirname(`${outDir}/index.ts`));
+    if (!mkdirResult.ok)
+        return { ok: false, error: mkdirResult.error };
+    const writeResult = await writeFile(`${outDir}/index.ts`, fmtResult.value);
+    if (!writeResult.ok)
+        return { ok: false, error: writeResult.error };
     return { ok: true, value: `Generated route code written to ${outDir}/*.ts (index.ts included)` };
 }

package/dist/core/rpc.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generate RPC client wrappers from an OpenAPI/TypeSpec source.
+ *
+ * - When `split=true`, writes one file per RPC function under `output` (directory) and an `index.ts` barrel.
+ * - Otherwise, emits a single `.ts` file at `output`.
+ */
+export declare function rpc(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: string | `${string}.ts`, importPath: string, split?: boolean): Promise<{
+    readonly ok: true;
+    readonly value: string;
+} | {
+    readonly ok: false;
+    readonly error: string;
+}>;