hono-takibi 0.9.70 → 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).
+### Config Reference
 
----
-
-## Single‑file
-
-One file. Set top‑level `output` (don’t define `schema`/`route`).
+All available options are shown below. In practice, use only the options you need.
 
 ```ts
+// hono-takibi.config.ts
 import { defineConfig } from 'hono-takibi/config'
 
 export default defineConfig({
   input: 'openapi.yaml',
   'zod-openapi': {
     output: './src/index.ts',
-    exportSchema: true,
-    exportType: true,
+    exportSchemas: true,
+    exportSchemasTypes: true,
+    exportParameters: true,
+    exportParametersTypes: true,
+    exportSecuritySchemes: true,
+    exportRequestBodies: true,
+    exportResponses: true,
+    exportHeaders: true,
+    exportHeadersTypes: true,
+    exportExamples: true,
+    exportLinks: true,
+    exportCallbacks: true,
+    routes: {
+      output: './src/routes',
+      split: true,
+    },
+    components: {
+      schemas: {
+        output: './src/schemas',
+        exportTypes: true,
+        split: true,
+        import: '../schemas',
+      },
+      parameters: {
+        output: './src/parameters',
+        exportTypes: true,
+        split: true,
+        import: '../parameters',
+      },
+      securitySchemes: {
+        output: './src/securitySchemes',
+        split: true,
+        import: '../securitySchemes',
+      },
+      requestBodies: {
+        output: './src/requestBodies',
+        split: true,
+        import: '../requestBodies',
+      },
+      responses: {
+        output: './src/responses',
+        split: true,
+        import: '../responses',
+      },
+      headers: {
+        output: './src/headers',
+        exportTypes: true,
+        split: true,
+        import: '../headers',
+      },
+      examples: {
+        output: './src/examples',
+        split: true,
+        import: '../examples',
+      },
+      links: {
+        output: './src/links',
+        split: true,
+        import: '../links',
+      },
+      callbacks: {
+        output: './src/callbacks',
+        split: true,
+        import: '../callbacks',
+      },
+    },
+  },
+  type: {
+    output: './src/types.ts',
+  },
+  rpc: {
+    output: './src/rpc',
+    import: '../client',
+    split: true,
   },
 })
 ```
 
+## Essentials
+
+* Put **`hono-takibi.config.ts`** at repo root.
+* Default‑export with `defineConfig(...)`.
+* `input`: **`openapi.yaml`** (recommended), or `*.json` / `*.tsp`.
+
+> **About `split`**
+>
+> * `split: true` → `output` is a **directory**; many files + `index.ts`.
+> * `split` **omitted** or `false` → `output` is a **single `*.ts` file** (one file only).
+
 ---
 
-## Schemas & Routes
+## Single‑file
 
-Define **both** `schema` and `route` (don’t set top‑level `output`).
+One file. Set top‑level `output` (don't define `components`/`routes`).
 
 ```ts
 import { defineConfig } from 'hono-takibi/config'
@@ -158,13 +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`)

package/dist/core/rpc/index.js

@@ -40,9 +40,9 @@ const isValidIdent = (s) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(s);
  *
  * Rules:
  * - '/' -> '.index'
- * - Single segment with valid identifier -> dot notation: '/pet' -> '.pet'
- * - All other cases -> each segment becomes bracket access: '/files/upload' -> "['files']['upload']"
- * - Path params converted: '/files/{fileId}' -> "['files'][':fileId']"
+ * - Valid identifiers use dot notation: '/users' -> '.users'
+ * - Invalid identifiers use bracket notation: '/:id' -> "[':id']"
+ * - Path params converted: '/files/{fileId}' -> ".files[':fileId']"
  */
 const formatPath = (p) => {
     if (p === '/')
@@ -50,12 +50,8 @@ const formatPath = (p) => {
     const segs = p.replace(/^\/+/, '').split('/').filter(Boolean);
     // Convert {param} to :param
     const honoSegs = segs.map((seg) => seg.startsWith('{') && seg.endsWith('}') ? `:${seg.slice(1, -1)}` : seg);
-    // Single segment with valid identifier: use dot notation
-    if (honoSegs.length === 1 && isValidIdent(honoSegs[0])) {
-        return `.${honoSegs[0]}`;
-    }
-    // All other cases: each segment becomes separate bracket access
-    return honoSegs.map((seg) => `['${esc(seg)}']`).join('');
+    // Use dot notation for valid identifiers, bracket for others
+    return honoSegs.map((seg) => (isValidIdent(seg) ? `.${seg}` : `['${esc(seg)}']`)).join('');
 };
 const isRefObject = (v) => isRecord(v) && typeof v.$ref === 'string';
 const isParameterObject = (v) => {
@@ -354,18 +350,19 @@ const generateOperationCode = (pathStr, method, item, deps) => {
         headerParams.length > 0 ||
         cookieParams.length > 0 ||
         hasBody;
-    // Use unified path format for both type and runtime
-    const hasBracket = pathAccess.includes('[');
-    const methodAccess = hasBracket ? `['$${method}']` : `.$${method}`;
+    // Always use dot notation for method access
+    const methodAccess = `.$${method}`;
     // Generate argument type directly from OpenAPI instead of using InferRequestType
     const argType = generateArgType(pathParams, queryParams, headerParams, cookieParams, allBodyInfo, deps.componentsSchemas);
     // options is always a separate parameter
     // If there are required args (params, query, body, etc.), args is required
-    // If no args, use args?: {} | undefined
+    // If no args, omit args parameter entirely
     const argSig = hasArgs
         ? `args: ${argType}, options?: ClientRequestOptions`
-        : 'args?: {} | undefined, options?: ClientRequestOptions';
-    const call = `${deps.client}${pathAccess}${methodAccess}(args, options)`;
+        : 'options?: ClientRequestOptions';
+    const call = hasArgs
+        ? `${deps.client}${pathAccess}${methodAccess}(args, options)`
+        : `${deps.client}${pathAccess}${methodAccess}(undefined, options)`;
     const summary = typeof op.summary === 'string' ? op.summary : '';
     const description = typeof op.description === 'string' ? op.description : '';
     const docs = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.9.70",
+  "version": "0.9.71",
   "type": "module",
   "license": "MIT",
   "keywords": [