hono-takibi 0.9.61 → 0.9.71

package/README.md

@@ -91,66 +91,144 @@ 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 
+> **⚠️** When using the `--template` option, you must specify a valid directory path. Ensure the directory exists before executing.
 
 ### 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).
-
----
-
-## Single‑file
+### Config Reference
 
-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 +236,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 +252,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`)
@@ -230,30 +290,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,123 +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 { type } from '../core/type.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 };
-    /** type */
-    const typeResult = c.type ? await type(c.input, c.type.output) : undefined;
     if (typeResult && !typeResult.ok)
         return { ok: false, error: typeResult.error };
-    /** rpc */
-    const rpcResult = c.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 results = [takibiResult?.value, typeResult?.value, rpcResult?.value].filter((v) => v !== undefined);
-    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') };
 }