hono-takibi 0.9.60 → 0.9.70

package/README.md

@@ -230,30 +230,6 @@ That’s it — set `input`, choose one of the two patterns, and (optionally) ad
 
 ![](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/vite/hono-takibi-vite.gif)
 
-
-## AI Prompt Example
-
-```sh
-Generate one **OpenAPI 3.x+** YAML (prefer **3.1.0**).
-
-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`.
-
-Fill, then generate:
-- title / version / tags
-- resources & fields
-- ops per resource: create / get / search / update / delete
-
-**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.**

package/dist/cli/index.d.ts

@@ -1,33 +1,38 @@
 /**
- * CLI entry point for `hono-takibi`.
+ * Main CLI entry point for hono-takibi.
  *
- * Executes the CLI flow: parse args → optional help → validate options → run generator (`takibi`) → return result.
+ * 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 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"]
+ *   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
  * ```
  *
- * **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: `/`)
- * - `-h, --help`           Show help and exit
+ * @returns Promise resolving to success with output message or error
  *
- * @returns A Result-like object:
- * - `{ ok: true, value: string }` with either help text or generation message
- * - `{ ok: false, error: string }` on validation or generation errors
+ * @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;

package/dist/cli/index.js

@@ -1,118 +1,206 @@
+/**
+ * CLI module for hono-takibi.
+ *
+ * Provides the main entry point for the CLI tool that converts OpenAPI
+ * specifications to Hono routes with Zod validation.
+ *
+ * ```mermaid
+ * flowchart TD
+ *   A["honoTakibi()"] --> B{"--help or -h?"}
+ *   B -->|Yes| C["Return HELP_TEXT"]
+ *   B -->|No| D{"hono-takibi.config.ts exists?"}
+ *   D -->|No| E["Parse CLI args"]
+ *   D -->|Yes| F["Load config file"]
+ *   E --> G["parseOpenAPI(input)"]
+ *   F --> G
+ *   G --> H["takibi() + components"]
+ *   H --> I["Return success/error"]
+ * ```
+ *
+ * @module cli
+ */
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { config } from '../config/index.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 { honoRpcWithSWR } from '../generator/swr/index.js'
+import { loadConfig } 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';
-/**
- * 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:
-  --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: /)
-  -h, --help           display help for command`;
+  --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`;
 /**
- * CLI entry point for `hono-takibi`.
+ * Main CLI entry point for hono-takibi.
  *
- * Executes the CLI flow: parse args → optional help → validate options → run generator (`takibi`) → return result.
+ * 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 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"]
+ *   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
  * ```
  *
- * **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: `/`)
- * - `-h, --help`           Show help and exit
+ * @returns Promise resolving to success with output message or error
  *
- * @returns A Result-like object:
- * - `{ ok: true, value: string }` with either help text or generation message
- * - `{ ok: false, error: string }` on validation or generation errors
+ * @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 async function honoTakibi() {
-    /** 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');
-    };
-    /** help */
-    if (isHelpRequested(args)) {
-        return {
-            ok: true,
-            value: HELP_TEXT,
-        };
+    if (args.length === 1 && (args[0] === '--help' || args[0] === '-h')) {
+        return { ok: true, value: HELP_TEXT };
     }
     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)
             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);
+        const { input, output, template, test, basePath, componentsOptions } = cli;
+        const openAPIResult = await parseOpenAPI(input);
+        if (!openAPIResult.ok)
+            return { ok: false, error: openAPIResult.error };
+        const openAPI = openAPIResult.value;
+        const takibiResult = await takibi(openAPI, output, template, test, basePath, componentsOptions);
         if (!takibiResult.ok)
             return { ok: false, error: takibiResult.error };
-        return {
-            ok: true,
-            value: takibiResult.value,
-        };
-    }
-    /** If config file exists, parse config file */
-    const configResult = await config();
-    if (!configResult.ok) {
-        return { ok: false, error: configResult.error };
+        return { ok: true, value: takibiResult.value };
     }
-    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)
-        : undefined;
+    const loadConfigResult = await loadConfig();
+    if (!loadConfigResult.ok)
+        return { ok: false, error: loadConfigResult.error };
+    const config = loadConfigResult.value;
+    const openAPIResult = await parseOpenAPI(config.input);
+    if (!openAPIResult.ok)
+        return { ok: false, error: openAPIResult.error };
+    const openAPI = openAPIResult.value;
+    const [takibiResult, schemaResult, parameterResult, headersResult, examplesResult, linksResult, callbacksResult, securitySchemesResult, requestBodiesResult, responsesResult, routeResult, typeResult, rpcResult,] = await Promise.all([
+        config['zod-openapi']?.output
+            ? takibi(openAPI, config['zod-openapi'].output, false, false, '/', {
+                exportSchemasTypes: config['zod-openapi'].exportSchemasTypes ?? false,
+                exportSchemas: config['zod-openapi'].exportSchemas ?? false,
+                exportParametersTypes: config['zod-openapi'].exportParametersTypes ?? false,
+                exportParameters: config['zod-openapi'].exportParameters ?? false,
+                exportSecuritySchemes: config['zod-openapi'].exportSecuritySchemes ?? false,
+                exportRequestBodies: config['zod-openapi'].exportRequestBodies ?? false,
+                exportResponses: config['zod-openapi'].exportResponses ?? false,
+                exportHeadersTypes: config['zod-openapi'].exportHeadersTypes ?? false,
+                exportHeaders: config['zod-openapi'].exportHeaders ?? false,
+                exportExamples: config['zod-openapi'].exportExamples ?? false,
+                exportLinks: config['zod-openapi'].exportLinks ?? false,
+                exportCallbacks: config['zod-openapi'].exportCallbacks ?? false,
+            })
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.schemas
+            ? schemas(openAPI.components?.schemas, config['zod-openapi']?.components?.schemas?.output, config['zod-openapi']?.components?.schemas?.split ?? false, config['zod-openapi']?.components?.schemas?.exportTypes ?? false)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.parameters
+            ? parameters(openAPI.components?.parameters, config['zod-openapi']?.components?.parameters?.output, config['zod-openapi']?.components?.parameters?.split ?? false, config['zod-openapi']?.components?.parameters?.exportTypes ?? false, config['zod-openapi']?.components)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.headers
+            ? headers(openAPI.components?.headers, config['zod-openapi']?.components?.headers?.output, config['zod-openapi']?.components?.headers?.split ?? false, config['zod-openapi']?.components?.headers?.exportTypes ?? false, config['zod-openapi']?.components)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.examples
+            ? examples(openAPI.components?.examples, config['zod-openapi']?.components?.examples?.output, config['zod-openapi']?.components?.examples?.split ?? false)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.links
+            ? links(openAPI.components?.links, config['zod-openapi']?.components?.links?.output, config['zod-openapi']?.components?.links?.split ?? false)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.callbacks
+            ? callbacks(openAPI.components?.callbacks, config['zod-openapi']?.components?.callbacks?.output, config['zod-openapi']?.components?.callbacks?.split ?? false)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.securitySchemes
+            ? securitySchemes(openAPI.components?.securitySchemes, config['zod-openapi']?.components?.securitySchemes?.output, config['zod-openapi']?.components?.securitySchemes?.split ?? false)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.requestBodies
+            ? requestBodies(openAPI.components?.requestBodies, config['zod-openapi']?.components?.requestBodies?.output, config['zod-openapi']?.components?.requestBodies?.split ?? false, config['zod-openapi']?.components)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.components?.responses
+            ? responses(openAPI.components?.responses, config['zod-openapi']?.components?.responses?.output, config['zod-openapi']?.components?.responses?.split ?? false, config['zod-openapi']?.components)
+            : Promise.resolve(undefined),
+        config['zod-openapi']?.routes
+            ? route(openAPI, config['zod-openapi'].routes, config['zod-openapi'].components)
+            : Promise.resolve(undefined),
+        config.type ? type(openAPI, config.type.output) : Promise.resolve(undefined),
+        config.rpc
+            ? rpc(openAPI, config.rpc.output, config.rpc.import, config.rpc.split ?? false)
+            : Promise.resolve(undefined),
+    ]);
     if (takibiResult && !takibiResult.ok)
         return { ok: false, error: takibiResult.error };
-    /** 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 */
-    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 (parameterResult && !parameterResult.ok)
+        return { ok: false, error: parameterResult.error };
+    if (headersResult && !headersResult.ok)
+        return { ok: false, error: headersResult.error };
+    if (examplesResult && !examplesResult.ok)
+        return { ok: false, error: examplesResult.error };
+    if (linksResult && !linksResult.ok)
+        return { ok: false, error: linksResult.error };
+    if (callbacksResult && !callbacksResult.ok)
+        return { ok: false, error: callbacksResult.error };
+    if (securitySchemesResult && !securitySchemesResult.ok)
+        return { ok: false, error: securitySchemesResult.error };
+    if (requestBodiesResult && !requestBodiesResult.ok)
+        return { ok: false, error: requestBodiesResult.error };
+    if (responsesResult && !responsesResult.ok)
+        return { ok: false, error: responsesResult.error };
     if (routeResult && !routeResult.ok)
         return { ok: false, error: routeResult.error };
-    /** rpc */
-    const rpcResult = c.rpc
-        ? await rpc(c.input, c.rpc.output, c.rpc.import, c.rpc.split ?? false)
-        : undefined;
+    if (typeResult && !typeResult.ok)
+        return { ok: false, error: typeResult.error };
     if (rpcResult && !rpcResult.ok)
         return { ok: false, error: rpcResult.error };
-    const results = [takibiResult?.value, rpcResult?.value].filter((v) => Boolean(v));
-    return {
-        ok: true,
-        value: results.join('\n'),
-    };
+    const results = [
+        takibiResult?.value,
+        schemaResult?.value,
+        parameterResult?.value,
+        headersResult?.value,
+        examplesResult?.value,
+        linksResult?.value,
+        callbacksResult?.value,
+        securitySchemesResult?.value,
+        requestBodiesResult?.value,
+        responsesResult?.value,
+        routeResult?.value,
+        typeResult?.value,
+        rpcResult?.value,
+    ].filter((v) => v !== undefined);
+    return { ok: true, value: results.join('\n') };
 }

package/dist/config/index.d.ts

@@ -2,26 +2,90 @@ type Config = {
     readonly input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
     readonly 'zod-openapi'?: {
         readonly output?: `${string}.ts`;
-        readonly exportType?: boolean;
-        readonly exportSchema?: boolean;
-        readonly schema?: {
+        readonly exportSchemas?: boolean;
+        readonly exportSchemasTypes?: boolean;
+        readonly exportParameters?: boolean;
+        readonly exportParametersTypes?: boolean;
+        readonly exportSecuritySchemes?: boolean;
+        readonly exportRequestBodies?: boolean;
+        readonly exportResponses?: boolean;
+        readonly exportHeaders?: boolean;
+        readonly exportHeadersTypes?: boolean;
+        readonly exportExamples?: boolean;
+        readonly exportLinks?: boolean;
+        readonly exportCallbacks?: boolean;
+        readonly routes?: {
             readonly output: string | `${string}.ts`;
-            readonly exportType?: boolean;
             readonly split?: boolean;
         };
-        readonly route?: {
-            readonly output: string | `${string}.ts`;
-            readonly import: string;
-            readonly split?: boolean;
+        readonly components?: {
+            readonly schemas?: {
+                readonly output: string | `${string}.ts`;
+                readonly exportTypes?: boolean;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly parameters?: {
+                readonly output: string | `${string}.ts`;
+                readonly exportTypes?: boolean;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly securitySchemes?: {
+                readonly output: string | `${string}.ts`;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly requestBodies?: {
+                readonly output: string | `${string}.ts`;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly responses?: {
+                readonly output: string | `${string}.ts`;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly headers?: {
+                readonly output: string | `${string}.ts`;
+                readonly exportTypes?: boolean;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly examples?: {
+                readonly output: string | `${string}.ts`;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly links?: {
+                readonly output: string | `${string}.ts`;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
+            readonly callbacks?: {
+                readonly output: string | `${string}.ts`;
+                readonly split?: boolean;
+                readonly import?: string;
+            };
         };
     };
+    readonly type?: {
+        readonly output: `${string}.ts`;
+    };
     readonly rpc?: {
         readonly output: string | `${string}.ts`;
         readonly import: string;
         readonly split?: boolean;
     };
 };
-export declare function config(): Promise<{
+export declare function parseConfig(config: Config): {
+    readonly ok: true;
+    readonly value: Config;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+export declare function loadConfig(): Promise<{
     readonly ok: true;
     readonly value: Config;
 } | {
@@ -33,5 +97,5 @@ export declare function config(): Promise<{
  *
  * @see config
  */
-export declare function defineConfig(c: Config): Config;
+export declare function defineConfig(config: Config): Config;
 export {};