hono-takibi 0.9.1 → 0.9.2

package/dist/cli/index.js

@@ -1,8 +1,10 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { config } from '../config/index.js';
-import { rpc } from '../core/rpc.js';
+import core from '../core/core.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';
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
@@ -86,10 +88,24 @@ export async function honoTakibi() {
     if (takibiResult && !takibiResult.ok) {
         return { ok: false, error: takibiResult.error };
     }
-    const rpcResult = c.rpc ? await rpc(c.rpc.input, c.rpc.output, c.rpc.import) : undefined;
+    const rpcResult = c.rpc
+        ? await core(c.rpc.input, c.rpc.output, c.rpc.import, 'Generated RPC code written to', rpc)
+        : 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

@@ -10,6 +10,11 @@ type Config = {
         output: `${string}.ts`;
         import: string;
     };
+    swr?: {
+        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+        output: `${string}.ts`;
+        import: string;
+    };
 };
 export declare function config(): Promise<{
     ok: true;
@@ -18,5 +23,5 @@ export declare function config(): Promise<{
     ok: false;
     error: string;
 }>;
-export declare function defineConfig(config: Config): Config;
+export default function defineConfig(config: Config): Config;
 export {};

package/dist/config/index.js

@@ -18,6 +18,6 @@ export async function config() {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
-export function defineConfig(config) {
+export default function defineConfig(config) {
     return config;
 }

package/dist/core/core.d.ts

@@ -0,0 +1,8 @@
+import { type OpenAPI } from '../openapi/index.js';
+export default function core(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, importCode: string, value: string, fn: (openapi: OpenAPI, importCode: string) => string): Promise<{
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/core/{rpc.js → core.js}

@@ -1,15 +1,14 @@
 import path from 'node:path';
 import { fmt } from '../format/index.js';
 import { mkdir, writeFile } from '../fsp/index.js';
-import { honoRpc } from '../generator/rpc/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-export async function rpc(input, output, importCode) {
+export default async function core(input, output, importCode, value, fn) {
     const openAPIResult = await parseOpenAPI(input);
     if (!openAPIResult.ok) {
         return { ok: false, error: openAPIResult.error };
     }
     const openAPI = openAPIResult.value;
-    const honoRpcResult = await fmt(honoRpc(openAPI, importCode));
+    const honoRpcResult = await fmt(fn(openAPI, importCode));
     if (!honoRpcResult.ok) {
         return { ok: false, error: honoRpcResult.error };
     }
@@ -23,6 +22,6 @@ export async function rpc(input, output, importCode) {
     }
     return {
         ok: true,
-        value: `Generated RPC code written to ${output}`,
+        value: `${value} ${output}`,
     };
 }

package/dist/core/takibi.js

@@ -111,7 +111,7 @@ async function zodOpenapiHonoHandler(openapi, output, test) {
     const handlers = [];
     for (const [path, pathItem] of Object.entries(paths)) {
         for (const [method] of Object.entries(pathItem)) {
-            const routeHandlerContent = `export const ${methodPath(method, path)}RouteHandler:RouteHandler<typeof ${methodPath(method, path)}>=async(c)=>{}`;
+            const routeHandlerContent = `export const ${methodPath(method, path)}RouteHandler:RouteHandler<typeof ${methodPath(method, path)}Route>=async(c)=>{}`;
             const rawSegment = path.replace(/^\/+/, '').split('/')[0] ?? '';
             const pathName = (rawSegment === '' ? 'index' : rawSegment)
                 .replace(/\{([^}]+)\}/g, '$1')

package/dist/generator/rpc/index.d.ts

@@ -1,2 +1,2 @@
 import type { OpenAPI } from '../../openapi/index.js';
-export declare function honoRpc(openapi: OpenAPI, importCode: string): string;
+export default function rpc(openapi: OpenAPI, importCode: string): string;

package/dist/generator/rpc/index.js

@@ -14,8 +14,6 @@ const isOpenAPIPaths = (v) => {
 /** Treat any object as Schema (we rely on downstream field checks) */
 const isSchema = (v) => isRecord(v);
 /* ─────────────────────────────── Formatters ─────────────────────────────── */
-/** Uppercase the first character */
-const upperHead = (s) => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
 /** JS identifier check */
 const isValidIdent = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
 /** Escape single quotes and backslashes for single-quoted strings */
@@ -288,7 +286,7 @@ const generateOperationCode = (path, method, item, deps) => {
         '}');
 };
 /* ─────────────────────────────── Entry ─────────────────────────────── */
-export function honoRpc(openapi, importCode) {
+export default function rpc(openapi, importCode) {
     const client = 'client';
     const out = [];
     // import header (kept as-is, then a blank line if present)

package/dist/generator/swr/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/generator/swr/index.js

@@ -0,0 +1 @@
+export {};

package/dist/generator/zod-openapi-hono/openapi/route/response/index.js

@@ -12,42 +12,75 @@ import { zodToOpenAPI } from '../../../../zod-to-openapi/index.js';
  * - Deduplicates content types if all share the same schema.
  * - Escapes all descriptions safely for inline code.
  */
+// export function response(responses: Responses): string {
+//   // 1. get response codes (200, 404, etc.)
+//   const responseCodes = Object.keys(responses)
+//   // 2. processing for each response code
+//   const responseEntries = responseCodes.map((code) => {
+//     const response = responses[code]
+//     // 2.1 no content (description only response)
+//     if (!response.content)
+//       return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',},`
+//     // check duplication
+//     const contentTypes = Object.keys(response.content)
+//     const isUniqueSchema = isUniqueContentSchema(contentTypes, response.content)
+//     // all duplication same schema
+//     if (isUniqueSchema) {
+//       const contentParts: string[] = []
+//       for (const contentType of contentTypes) {
+//         const content = response.content[contentType]
+//         const z = zodToOpenAPI(content.schema)
+//         const examples = content.examples
+//         const exampleString =
+//           examples && Object.keys(examples).length > 0
+//             ? `,examples:{${Object.entries(examples)
+//                 .map(([key, example]) => {
+//                   const parts = []
+//                   if (example.summary) parts.push(`summary:${JSON.stringify(example.summary)}`)
+//                   if (example.value !== undefined)
+//                     parts.push(`value:${JSON.stringify(example.value)}`)
+//                   return `${JSON.stringify(key)}:{${parts.join(',')}}`
+//                 })
+//                 .join(',')}}`
+//             : ''
+//         contentParts.push(`'${contentType}':{schema:${z}${exampleString}}`)
+//       }
+//       return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',content:{${contentParts.join(',')}}},`
+//     }
+//   })
+//   // 3.combine all response definitions
+//   return responseEntries.join('')
+// }
 export function response(responses) {
     // 1. get response codes (200, 404, etc.)
-    const responseCodes = Object.keys(responses);
-    // 2. processing for each response code
-    const responseEntries = responseCodes.map((code) => {
-        const response = responses[code];
-        // 2.1 no content (description only response)
-        if (!response.content)
-            return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',},`;
-        // check duplication
-        const contentTypes = Object.keys(response.content);
-        const isUniqueSchema = isUniqueContentSchema(contentTypes, response.content);
-        // all duplication same schema
-        if (isUniqueSchema) {
-            const contentParts = [];
-            for (const contentType of contentTypes) {
-                const content = response.content[contentType];
-                const z = zodToOpenAPI(content.schema);
-                const examples = content.examples;
-                const exampleString = examples && Object.keys(examples).length > 0
-                    ? `,examples:{${Object.entries(examples)
-                        .map(([key, example]) => {
-                        const parts = [];
-                        if (example.summary)
-                            parts.push(`summary:${JSON.stringify(example.summary)}`);
-                        if (example.value !== undefined)
-                            parts.push(`value:${JSON.stringify(example.value)}`);
-                        return `${JSON.stringify(key)}:{${parts.join(',')}}`;
-                    })
-                        .join(',')}}`
-                    : '';
-                contentParts.push(`'${contentType}':{schema:${z}${exampleString}}`);
-            }
-            return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',content:{${contentParts.join(',')}}},`;
+    const responseEntries = Object.keys(responses).map((code) => {
+        const res = responses[code];
+        const content = res.content;
+        if (!content) {
+            return `${code}:{description:'${escapeStringLiteral(res.description ?? '')}',},`;
         }
+        const contentTypes = Object.keys(content);
+        const isUnique = isUniqueContentSchema(contentTypes, content);
+        const sharedZ = isUnique ? zodToOpenAPI(content[contentTypes[0]].schema) : undefined;
+        const contentParts = contentTypes.map((ct) => {
+            const media = content[ct];
+            const z = sharedZ ?? zodToOpenAPI(media.schema);
+            const examples = media.examples;
+            const exampleString = examples && Object.keys(examples).length > 0
+                ? `,examples:{${Object.entries(examples)
+                    .map(([k, v]) => {
+                    const parts = [];
+                    if (v.summary)
+                        parts.push(`summary:${JSON.stringify(v.summary)}`);
+                    if (v.value !== undefined)
+                        parts.push(`value:${JSON.stringify(v.value)}`);
+                    return `${JSON.stringify(k)}:{${parts.join(',')}}`;
+                })
+                    .join(',')}}`
+                : '';
+            return `'${ct}':{schema:${z}${exampleString}}`;
+        });
+        return `${code}:{description:'${escapeStringLiteral(res.description ?? '')}',content:{${contentParts.join(',')}}},`;
     });
-    // 3.combine all response definitions
     return responseEntries.join('');
 }

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.01",
+  "version": "0.9.2",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -33,16 +33,20 @@
       "import": "./dist/vite-plugin/index.js"
     },
     "./config": {
-      "types": "./dist/generator/config/index.d.ts",
-      "import": "./dist/generator/config/index.js"
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js"
     },
     "./zod-openapi-hono": {
       "types": "./dist/generator/zod-openapi-hono/openapi/index.d.ts",
       "import": "./dist/generator/zod-openapi-hono/openapi/index.js"
     },
-    "./rpc-beta": {
-      "types": "./dist/core/rpc.d.ts",
-      "import": "./dist/core/rpc.js"
+    "./core": {
+      "types": "./dist/core/core.d.ts",
+      "import": "./dist/core/core.js"
+    },
+    "./rpc": {
+      "types": "./dist/generator/rpc/index.d.ts",
+      "import": "./dist/generator/rpc/index.js"
     }
   },
   "dependencies": {

package/dist/core/rpc.d.ts

@@ -1,7 +0,0 @@
-export declare function rpc(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, importCode: string): Promise<{
-    ok: true;
-    value: string;
-} | {
-    ok: false;
-    error: string;
-}>;