hono-takibi 0.8.8 → 0.9.1

package/README.md

@@ -146,7 +146,7 @@ If you use a `.tsp` TypeSpec file, you must set up the TypeSpec environment and
 
 ```ts
 import { defineConfig } from 'vite'
-import HonoTakibiVite from './src/vite-plugin'
+import HonoTakibiVite from 'hono-takibi/vite-plugin'
 
 export default defineConfig({
   plugins: [

package/dist/cli/index.js

@@ -1,5 +1,9 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { config } from '../config/index.js';
+import { rpc } from '../core/rpc.js';
+import { takibi } from '../core/takibi.js';
 import { parseCli } from '../utils/index.js';
-import { takibi } from './takibi.js';
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
 Options:
@@ -47,23 +51,48 @@ export async function honoTakibi() {
     const isHelpRequested = (args) => {
         return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
     };
+    /** help */
     if (isHelpRequested(args)) {
         return {
             ok: true,
             value: HELP_TEXT,
         };
     }
-    const cliResult = parseCli(args);
-    if (!cliResult.ok) {
-        return { ok: false, error: cliResult.error };
+    const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
+    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);
+        if (!takibiResult.ok) {
+            return { ok: false, error: takibiResult.error };
+        }
+        return {
+            ok: true,
+            value: takibiResult.value,
+        };
     }
-    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) {
+    const configResult = await config();
+    if (!configResult.ok) {
+        return { ok: false, error: configResult.error };
+    }
+    const c = configResult.value;
+    const takibiResult = c['hono-takibi']
+        ? await takibi(c['hono-takibi']?.input, c['hono-takibi']?.output, c['hono-takibi']?.exportSchema ?? false, c['hono-takibi']?.exportType ?? false, false, // template
+        false)
+        : undefined;
+    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;
+    if (rpcResult && !rpcResult.ok) {
+        return { ok: false, error: rpcResult.error };
+    }
+    const results = [takibiResult?.value, rpcResult?.value].filter((v) => Boolean(v));
     return {
         ok: true,
-        value: takibiResult.value,
+        value: results.join('\n'),
     };
 }

package/dist/config/index.d.ts

@@ -0,0 +1,22 @@
+type Config = {
+    'hono-takibi'?: {
+        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+        output: `${string}.ts`;
+        exportType?: boolean;
+        exportSchema?: boolean;
+    };
+    rpc?: {
+        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+        output: `${string}.ts`;
+        import: string;
+    };
+};
+export declare function config(): Promise<{
+    ok: true;
+    value: Config;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function defineConfig(config: Config): Config;
+export {};

package/dist/config/index.js

@@ -0,0 +1,23 @@
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { register } from 'tsx/esm/api';
+export async function config() {
+    const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
+    // if (!existsSync(abs)) {
+    //   return { ok: false, error: `Config not found: ${abs}` }
+    // }
+    register();
+    try {
+        const mod = await import(pathToFileURL(abs).href);
+        if (!('default' in mod)) {
+            return { ok: false, error: 'Config must export default object' };
+        }
+        return { ok: true, value: mod.default };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+export function defineConfig(config) {
+    return config;
+}

package/dist/core/rpc.d.ts

@@ -0,0 +1,7 @@
+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;
+}>;

package/dist/core/rpc.js

@@ -0,0 +1,28 @@
+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) {
+    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));
+    if (!honoRpcResult.ok) {
+        return { ok: false, error: honoRpcResult.error };
+    }
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return { ok: false, error: mkdirResult.error };
+    }
+    const writeResult = await writeFile(output, honoRpcResult.value);
+    if (!writeResult.ok) {
+        return { ok: false, error: writeResult.error };
+    }
+    return {
+        ok: true,
+        value: `Generated RPC code written to ${output}`,
+    };
+}

package/dist/{cli → core}/takibi.js

@@ -2,9 +2,9 @@ import path from 'node:path';
 import { fmt } from '../format/index.js';
 import { mkdir, readdir, writeFile } from '../fsp/index.js';
 import { app } from '../generator/zod-openapi-hono/app/index.js';
-import { zodOpenapiHonoHandler } from '../generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js';
 import zodOpenAPIHono from '../generator/zod-openapi-hono/openapi/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
+import { groupHandlersByFileName, methodPath } from '../utils/index.js';
 /**
  * Generates TypeScript code from an OpenAPI spec and optional templates.
  *
@@ -70,6 +70,7 @@ export async function takibi(input, output, exportSchema, exportType, template,
     if (!writeResult.ok) {
         return { ok: false, error: writeResult.error };
     }
+    /** template */
     if (template && output.includes('/')) {
         const appResult = await fmt(app(openAPI, output, basePath));
         if (!appResult.ok) {
@@ -97,3 +98,65 @@ export async function takibi(input, output, exportSchema, exportType, template,
         value: `Generated code written to ${output}`,
     };
 }
+/**
+ * Generates route handler files for a Hono app using Zod and OpenAPI.
+ *
+ * @param openapi - The OpenAPI specification object.
+ * @param output - The output directory or file path for generated handlers.
+ * @param test - Whether to generate corresponding empty test files.
+ * @returns A `Result` indicating success or error with message.
+ */
+async function zodOpenapiHonoHandler(openapi, output, test) {
+    const paths = openapi.paths;
+    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 rawSegment = path.replace(/^\/+/, '').split('/')[0] ?? '';
+            const pathName = (rawSegment === '' ? 'index' : rawSegment)
+                .replace(/\{([^}]+)\}/g, '$1')
+                .replace(/[^0-9A-Za-z._-]/g, '_')
+                .replace(/^[._-]+|[._-]+$/g, '')
+                .replace(/__+/g, '_')
+                .replace(/[-._](\w)/g, (_, c) => c.toUpperCase());
+            const fileName = pathName.length === 0 ? 'indexHandler.ts' : `${pathName}Handler.ts`;
+            const testFileName = pathName.length === 0 ? 'indexHandler.test.ts' : `${pathName}Handler.test.ts`;
+            handlers.push({
+                fileName,
+                testFileName,
+                routeHandlerContents: [routeHandlerContent],
+                routeNames: [`${methodPath(method, path)}Route`],
+            });
+        }
+    }
+    const mergedHandlers = groupHandlersByFileName(handlers);
+    for (const handler of mergedHandlers) {
+        const dirPath = output?.replace(/\/[^/]+\.ts$/, '');
+        const handlerPath = dirPath === 'index.ts' ? 'handlers' : `${dirPath}/handlers`;
+        const mkdirResult = await mkdir(handlerPath);
+        if (!mkdirResult.ok) {
+            return { ok: false, error: mkdirResult.error };
+        }
+        const routeTypes = handler.routeNames.map((routeName) => `${routeName}`).join(', ');
+        const match = output?.match(/[^/]+\.ts$/);
+        const matchPath = match ? match[0] : '';
+        const path = output === '.' || output === './' ? output : `../${matchPath}`;
+        const importRouteTypes = routeTypes ? `import type { ${routeTypes} } from '${path}';` : '';
+        const importStatements = `import type { RouteHandler } from '@hono/zod-openapi'\n${importRouteTypes}`;
+        const fileContent = `${importStatements}\n\n${handler.routeHandlerContents.join('\n\n')}`;
+        const formatCode = await fmt(fileContent);
+        if (!formatCode.ok) {
+            return { ok: false, error: formatCode.error };
+        }
+        const writeResult = await writeFile(`${handlerPath}/${handler.fileName}`, formatCode.value);
+        if (!writeResult.ok)
+            writeResult;
+        if (test) {
+            const writeResult = await writeFile(`${handlerPath}/${handler.testFileName}`, '');
+            if (!writeResult.ok) {
+                return { ok: false, error: writeResult.error };
+            }
+        }
+    }
+    return { ok: true, value: undefined };
+}

package/dist/format/index.js

@@ -7,13 +7,13 @@ import { format } from 'prettier';
  */
 export async function fmt(code) {
     try {
-        const formatted = await format(code, {
+        const result = await format(code, {
             parser: 'typescript',
             printWidth: 100,
             singleQuote: true,
             semi: false,
         });
-        return { ok: true, value: formatted };
+        return { ok: true, value: result };
     }
     catch (e) {
         return {

package/dist/fsp/index.js

@@ -29,7 +29,6 @@ export async function mkdir(dir) {
 export async function readdir(dir) {
     try {
         const files = await fsp.readdir(dir);
-        // return ok(files)
         return { ok: true, value: files };
     }
     catch (e) {

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

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

package/dist/generator/rpc/index.js

@@ -0,0 +1,338 @@
+import { methodPath } from '../../utils/index.js';
+/* ─────────────────────────────── Guards ─────────────────────────────── */
+/** Narrow to generic object records */
+const isRecord = (v) => typeof v === 'object' && v !== null;
+/** Narrow to OpenAPI paths object (shallow structural check) */
+const isOpenAPIPaths = (v) => {
+    if (!isRecord(v))
+        return false;
+    for (const k in v)
+        if (!isRecord(v[k]))
+            return false;
+    return true;
+};
+/** 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 */
+const esc = (s) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+/**
+ * Convert an OpenAPI path to a client access chain.
+ * examples:
+ *  '/'                 -> ".index"
+ *  '/hono-x'           -> "['hono-x']"
+ *  '/posts/hono/{id}'  -> ".posts.hono[':id']"
+ */
+const formatPath = (path) => {
+    const segs = (path === '/' ? ['index'] : path.replace(/^\/+/, '').split('/')).filter(Boolean);
+    return segs
+        .map((seg) => seg.startsWith('{') && seg.endsWith('}')
+        ? `[':${seg.slice(1, -1)}']`
+        : isValidIdent(seg)
+            ? `.${seg}`
+            : `['${esc(seg)}']`)
+        .join('');
+};
+/** 'type' to normalized list for uniform checks */
+const isJSONTypeName = (s) => typeof s === 'string' &&
+    (s === 'object' ||
+        s === 'array' ||
+        s === 'string' ||
+        s === 'number' ||
+        s === 'integer' ||
+        s === 'boolean' ||
+        s === 'null');
+const toTypeArray = (t) => {
+    if (isJSONTypeName(t))
+        return [t];
+    if (Array.isArray(t))
+        return t.filter(isJSONTypeName);
+    return [];
+};
+/** Build literal union from enum values (kept compact) */
+const literalFromEnum = (vals) => {
+    const toLit = (v) => typeof v === 'string'
+        ? `'${v.replace(/'/g, "\\'")}'`
+        : typeof v === 'number' || typeof v === 'boolean'
+            ? String(v)
+            : v === null
+                ? 'null'
+                : 'unknown';
+    return vals.map(toLit).join('|');
+};
+/** Create a $ref resolver for #/components/schemas/... */
+const createResolveRef = (schemas) => (ref) => {
+    if (!ref)
+        return undefined;
+    const m = ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (!m)
+        return undefined;
+    const target = schemas[m[1]];
+    return isSchema(target) ? target : undefined;
+};
+/** Create a Schema->TypeScript type printer (single instance, recursive-safe) */
+const createTsTypeFromSchema = (resolveRef) => {
+    const tt = (schema, seen = new Set()) => {
+        if (!schema)
+            return 'unknown';
+        // $ref resolution
+        if (schema.$ref) {
+            const tgt = resolveRef(schema.$ref);
+            return tt(tgt, seen);
+        }
+        // recursion guard
+        if (seen.has(schema))
+            return 'unknown';
+        const nextSeen = new Set(seen);
+        nextSeen.add(schema);
+        // combinators
+        if (Array.isArray(schema.oneOf) && schema.oneOf.length)
+            return schema.oneOf.map((s) => tt(s, nextSeen)).join('|') || 'unknown';
+        if (Array.isArray(schema.anyOf) && schema.anyOf.length)
+            return schema.anyOf.map((s) => tt(s, nextSeen)).join('|') || 'unknown';
+        if (Array.isArray(schema.allOf) && schema.allOf.length)
+            return schema.allOf.map((s) => tt(s, nextSeen)).join('&') || 'unknown';
+        // enum
+        if (Array.isArray(schema.enum) && schema.enum.length) {
+            const base = literalFromEnum(schema.enum);
+            return schema.nullable ? `${base}|null` : base;
+        }
+        const types = toTypeArray(schema.type);
+        // array
+        if (types.includes('array')) {
+            const inner = tt(isSchema(schema.items) ? schema.items : undefined, nextSeen);
+            const core = `${inner}[]`;
+            return schema.nullable ? `${core}|null` : core;
+        }
+        // object
+        if (types.includes('object')) {
+            const req = new Set(Array.isArray(schema.required) ? schema.required : []);
+            const props = schema.properties ?? {};
+            const fields = Object.entries(props).map(([k, v]) => {
+                const opt = req.has(k) ? '' : '?';
+                const child = isSchema(v) ? v : undefined;
+                return `${k}${opt}:${tt(child, nextSeen)}`;
+            });
+            const ap = schema.additionalProperties;
+            const addl = ap === true
+                ? '[key:string]:unknown'
+                : isSchema(ap)
+                    ? `[key:string]:${tt(ap, nextSeen)}`
+                    : '';
+            const members = [...fields, addl].filter(Boolean).join(',');
+            const core = `{${members}}`;
+            return schema.nullable ? `${core}|null` : core;
+        }
+        // primitives
+        if (types.length === 0)
+            return schema.nullable ? 'unknown|null' : 'unknown';
+        const prim = types
+            .map((t) => (t === 'integer' ? 'number' : t === 'null' ? 'null' : t))
+            .join('|');
+        return schema.nullable ? `${prim}|null` : prim;
+    };
+    return tt;
+};
+const isRefObject = (v) => isRecord(v) && typeof v.$ref === 'string';
+const isParameterObject = (v) => {
+    if (!isRecord(v))
+        return false;
+    if (typeof v.name !== 'string')
+        return false;
+    const pos = v.in;
+    return pos === 'path' || pos === 'query' || pos === 'header' || pos === 'cookie';
+};
+/** Extract components/parameters name from a ref-like value */
+const refParamName = (refLike) => {
+    const ref = typeof refLike === 'string' ? refLike : isRefObject(refLike) ? refLike.$ref : undefined;
+    const m = ref?.match(/^#\/components\/parameters\/(.+)$/);
+    return m ? m[1] : undefined;
+};
+/** Build a resolver that returns normalized ParameterLike (resolving $ref) */
+const createResolveParameter = (componentsParameters) => (p) => {
+    if (isParameterObject(p))
+        return p;
+    const name = refParamName(p);
+    const cand = name ? componentsParameters[name] : undefined;
+    return isParameterObject(cand) ? cand : undefined;
+};
+/** Convert raw parameters array into ParameterLike[] */
+const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr)
+    ? arr.reduce((acc, x) => {
+        const r = resolveParam(x);
+        if (r)
+            acc.push(r);
+        return acc;
+    }, [])
+    : [];
+const isOperationLike = (v) => isRecord(v) && 'responses' in v;
+const HTTP_METHODS = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace',
+];
+/** Extract the first suitable schema from requestBody.content by priority order */
+const pickBodySchema = (op) => {
+    const rb = op.requestBody;
+    if (!isRecord(rb))
+        return undefined;
+    const content = rb.content;
+    if (!isRecord(content))
+        return undefined;
+    const order = [
+        'application/json',
+        'application/*+json',
+        'application/xml',
+        'application/x-www-form-urlencoded',
+        'multipart/form-data',
+        'application/octet-stream',
+    ];
+    for (const k of order) {
+        const media = isRecord(content[k]) ? content[k] : undefined;
+        if (isRecord(media) && 'schema' in media && isSchema(media.schema)) {
+            return media.schema;
+        }
+    }
+    return undefined;
+};
+/* ─────────────────────────────── Args builders ─────────────────────────────── */
+/** Build TS type for params arg (compact formatting) */
+const createBuildParamsType = (tsTypeFromSchema) => (pathParams, queryParams) => {
+    const parts = [];
+    if (pathParams.length) {
+        const inner = pathParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',');
+        parts.push(`path:{${inner}}`);
+    }
+    if (queryParams.length) {
+        const inner = queryParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',');
+        parts.push(`query:{${inner}}`);
+    }
+    return parts.length ? `{${parts.join(',')}}` : '';
+};
+/** Build function argument signature */
+const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
+    ? `params:${paramsType}, body:${bodyType}`
+    : paramsType
+        ? `params:${paramsType}`
+        : bodyType
+            ? `body:${bodyType}`
+            : '';
+/** Build one query key:value piece with integer-to-string rules */
+const buildQueryPiece = (p) => {
+    const types = toTypeArray(p.schema?.type);
+    const isArr = types.includes('array');
+    const itemsInt = isArr && isSchema(p.schema?.items) && toTypeArray(p.schema?.items?.type).includes('integer');
+    const isInt = types.includes('integer');
+    const rhs = itemsInt
+        ? `(params.query.${p.name}??[]).map((v:unknown)=>String(v))`
+        : isInt
+            ? `String(params.query.${p.name})`
+            : `params.query.${p.name}`;
+    return `${p.name}:${rhs}`;
+};
+/** Build client call argument object (compact formatting) */
+const buildClientArgs = (pathParams, queryParams, hasBody) => {
+    const pieces = [];
+    if (pathParams.length) {
+        const inner = pathParams.map((p) => `${p.name}:params.path.${p.name}`).join(',');
+        pieces.push(`param:{${inner}}`);
+    }
+    if (queryParams.length) {
+        const inner = queryParams.map(buildQueryPiece).join(',');
+        pieces.push(`query:{${inner}}`);
+    }
+    if (hasBody)
+        pieces.push('json:body');
+    return pieces.length ? `{${pieces.join(',')}}` : '';
+};
+/* ─────────────────────────────── Single-operation generator ─────────────────────────────── */
+const generateOperationCode = (path, method, item, deps) => {
+    const op = item[method];
+    if (!isOperationLike(op))
+        return '';
+    const funcName = methodPath(method, path);
+    const clientAccess = formatPath(path);
+    const pathLevelParams = deps.toParameterLikes(item.parameters);
+    const opParams = deps.toParameterLikes(op.parameters);
+    const allParams = [...pathLevelParams, ...opParams];
+    const pathParams = allParams.filter((p) => p.in === 'path');
+    const queryParams = allParams.filter((p) => p.in === 'query');
+    const bodySchema = pickBodySchema(op);
+    const hasBody = bodySchema !== undefined;
+    const bodyType = hasBody ? deps.tsTypeFromSchema(bodySchema) : null;
+    const buildParamsType = createBuildParamsType(deps.tsTypeFromSchema);
+    const paramsType = buildParamsType(pathParams, queryParams);
+    const argSig = buildArgSignature(paramsType, bodyType);
+    const clientArgs = buildClientArgs(pathParams, queryParams, hasBody);
+    const call = clientArgs
+        ? `${deps.client}${clientAccess}.$${method}(${clientArgs})`
+        : `${deps.client}${clientAccess}.$${method}()`;
+    const summary = typeof op.summary === 'string' ? op.summary : '';
+    const description = typeof op.description === 'string' ? op.description : '';
+    return ('/**\n' +
+        (summary ? ` * ${summary}\n *\n` : '') +
+        (description ? ` * ${description}\n *\n` : '') +
+        ` * ${method.toUpperCase()} ${path}\n` +
+        ' */\n' +
+        `export async function ${funcName}(${argSig}) {\n` +
+        `  return await ${call}\n` +
+        '}');
+};
+/* ─────────────────────────────── Entry ─────────────────────────────── */
+export function honoRpc(openapi, importCode) {
+    const client = 'client';
+    const out = [];
+    // import header (kept as-is, then a blank line if present)
+    const header = (() => {
+        const s = (importCode ?? '').trim();
+        return s.length ? `${s}\n\n` : '';
+    })();
+    // paths guard
+    const pathsMaybe = openapi.paths;
+    if (!isOpenAPIPaths(pathsMaybe))
+        return header;
+    // schema & parameter resolvers
+    const schemas = openapi.components?.schemas ?? {};
+    const resolveRef = createResolveRef(schemas);
+    const tsTypeFromSchema = createTsTypeFromSchema(resolveRef);
+    const componentsParameters = openapi.components?.parameters ?? {};
+    const resolveParameter = createResolveParameter(componentsParameters);
+    const toParameterLikes = createToParameterLikes(resolveParameter);
+    // iterate path items & operations
+    for (const path in pathsMaybe) {
+        const rawItem = pathsMaybe[path];
+        if (!isRecord(rawItem))
+            continue;
+        const pathItem = {
+            parameters: rawItem.parameters,
+            get: isOperationLike(rawItem.get) ? rawItem.get : undefined,
+            put: isOperationLike(rawItem.put) ? rawItem.put : undefined,
+            post: isOperationLike(rawItem.post) ? rawItem.post : undefined,
+            delete: isOperationLike(rawItem.delete) ? rawItem.delete : undefined,
+            options: isOperationLike(rawItem.options) ? rawItem.options : undefined,
+            head: isOperationLike(rawItem.head) ? rawItem.head : undefined,
+            patch: isOperationLike(rawItem.patch) ? rawItem.patch : undefined,
+            trace: isOperationLike(rawItem.trace) ? rawItem.trace : undefined,
+        };
+        for (const method of HTTP_METHODS) {
+            const code = generateOperationCode(path, method, pathItem, {
+                client,
+                tsTypeFromSchema,
+                toParameterLikes,
+            });
+            if (code)
+                out.push(code);
+        }
+    }
+    // final string (compact; Prettier will handle formatting as configured)
+    return header + out.join('\n\n') + (out.length ? '\n' : '');
+}

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

@@ -1,4 +1,4 @@
-import { createRoute, escapeStringLiteral, routeName } from '../../../../utils/index.js';
+import { createRoute, escapeStringLiteral, methodPath } from '../../../../utils/index.js';
 import { requestParameter } from './params/index.js';
 import { response } from './response/index.js';
 /**
@@ -19,7 +19,7 @@ export function route(path, method, operation) {
     const tagList = tags ? JSON.stringify(tags) : '[]';
     const requestParams = requestParameter(parameters, requestBody);
     const create_args = {
-        routeName: routeName(method, path),
+        routeName: `${methodPath(method, path)}Route`,
         tags: tags ? `tags:${tagList},` : '',
         method: `method:'${method}',`,
         path: `path:'${path}',`,

package/dist/generator/zod-to-openapi/index.js

@@ -6,18 +6,16 @@ import { integer } from './z/integer.js';
 import { number } from './z/number.js';
 import { object } from './z/object.js';
 import { string } from './z/string.js';
-// Test run
-// pnpm vitest run ./src/generator/zod-to-openapi/index.test.ts
 export function zodToOpenAPI(schema, paramName, paramIn) {
     if (schema === undefined)
         throw new Error('hono-takibi: only #/components/schemas/* is supported');
-    // ref
-    if (schema.$ref) {
+    /** ref */
+    if (schema.$ref !== undefined) {
         return wrap(refSchema(schema.$ref), schema, paramName, paramIn);
     }
     /* combinators */
-    // allOf
-    if (schema.allOf) {
+    /** allOf */
+    if (schema.allOf !== undefined) {
         if (!schema.allOf || schema.allOf.length === 0) {
             return wrap('z.any()', schema, paramName, paramIn);
         }
@@ -49,8 +47,8 @@ export function zodToOpenAPI(schema, paramName, paramIn) {
         const z = `z.intersection(${schemas.join(',')})`;
         return wrap(z, schema, paramName, paramIn);
     }
-    // anyOf
-    if (schema.anyOf) {
+    /* anyOf */
+    if (schema.anyOf !== undefined) {
         if (!schema.anyOf || schema.anyOf.length === 0) {
             return wrap('z.any()', schema, paramName, paramIn);
         }
@@ -60,8 +58,8 @@ export function zodToOpenAPI(schema, paramName, paramIn) {
         const z = `z.union([${schemas.join(',')}])`;
         return wrap(z, schema, paramName, paramIn);
     }
-    // oneOf
-    if (schema.oneOf) {
+    /* oneOf */
+    if (schema.oneOf !== undefined) {
         if (!schema.oneOf || schema.oneOf.length === 0) {
             return wrap('z.any()', schema, paramName, paramIn);
         }
@@ -78,8 +76,8 @@ export function zodToOpenAPI(schema, paramName, paramIn) {
         const z = `z.union([${schemas.join(',')}])`;
         return wrap(z, schema, paramName, paramIn);
     }
-    // not
-    if (schema.not) {
+    /* not */
+    if (schema.not !== undefined) {
         if (typeof schema.not === 'object' && schema.not.type && typeof schema.not.type === 'string') {
             const predicate = `(v) => typeof v !== '${schema.not.type}'`;
             const z = `z.any().refine(${predicate})`;
@@ -93,16 +91,16 @@ export function zodToOpenAPI(schema, paramName, paramIn) {
         }
         return wrap('z.any()', schema, paramName, paramIn);
     }
-    // const
-    if (schema.const) {
+    /* const */
+    if (schema.const !== undefined) {
         const z = `z.literal(${JSON.stringify(schema.const)})`;
         return wrap(z, schema, paramName, paramIn);
     }
     /* enum */
-    if (schema.enum)
+    if (schema.enum !== undefined)
         return wrap(_enum(schema), schema, paramName, paramIn);
     /* properties */
-    if (schema.properties)
+    if (schema.properties !== undefined)
         return wrap(object(schema), schema, paramName, paramIn);
     const t = normalizeTypes(schema.type);
     /* string */

package/dist/helper/get-route-maps.js

@@ -1,4 +1,4 @@
-import { routeName } from '../utils/index.js';
+import { methodPath } from '../utils/index.js';
 /**
  * Extracts route mappings from an OpenAPI specification.
  *
@@ -10,8 +10,8 @@ export function getRouteMaps(openapi) {
     const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
         return Object.entries(pathItem).flatMap(([method]) => {
             return {
-                routeName: routeName(method, path),
-                handlerName: `${routeName(method, path)}Handler`,
+                routeName: `${methodPath(method, path)}Route`,
+                handlerName: `${methodPath(method, path)}RouteHandler`,
                 path,
             };
         });

package/dist/typespec/index.js

@@ -45,7 +45,7 @@ export async function typeSpecToOpenAPI(input) {
     catch (e) {
         return {
             ok: false,
-            error: e instanceof Error ? String(e.message) : String(e),
+            error: e instanceof Error ? e.message : String(e),
         };
     }
 }

package/dist/utils/index.d.ts

@@ -56,7 +56,7 @@ export declare function parseCli(args: readonly string[]): {
 export declare function normalizeTypes(t?: 'string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null' | [
     'string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null',
     ...('string' | 'number' | 'integer' | 'date' | 'boolean' | 'array' | 'object' | 'null')[]
-]): ("string" | "number" | "boolean" | "object" | "integer" | "date" | "array" | "null")[];
+]): ("string" | "number" | "boolean" | "object" | "array" | "integer" | "null" | "date")[];
 /**
  * Generates import statements for route handler modules.
  *
@@ -312,9 +312,9 @@ export declare function refSchema($ref: `#/components/schemas/${string}`): strin
  * @returns A route name string (e.g., 'getUsersIdPostsRoute').
  *
  * @example
- * routeName('get', '/users/{id}/posts') // 'getUsersIdPostsRoute'
+ * methodPath('get', '/users/{id}/posts') // 'getUsersIdPosts'
  */
-export declare function routeName(method: string, path: string): string;
+export declare function methodPath(method: string, path: string): string;
 /**
  * Generates a Hono route definition as a TypeScript export string.
  *

package/dist/utils/index.js

@@ -23,6 +23,7 @@ export function parseCli(args) {
     const input = args[0];
     const oIdx = args.indexOf('-o');
     const output = oIdx !== -1 ? args[oIdx + 1] : undefined;
+    /** yaml or json or tsp */
     const isYamlOrJsonOrTsp = (i) => i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp');
     const isTs = (o) => o.endsWith('.ts');
     const getFlagValue = (args, flag) => {
@@ -376,9 +377,9 @@ export function refSchema($ref) {
  * @returns A route name string (e.g., 'getUsersIdPostsRoute').
  *
  * @example
- * routeName('get', '/users/{id}/posts') // 'getUsersIdPostsRoute'
+ * methodPath('get', '/users/{id}/posts') // 'getUsersIdPosts'
  */
-export function routeName(method, path) {
+export function methodPath(method, path) {
     // 1. api_path: `/user/createWithList`
     // 2. replace(/[\/{}-]/g, ' ') -> ` user createWithList`
     // 3. trim() -> `user createWithList`
@@ -391,7 +392,7 @@ export function routeName(method, path) {
         .split(/\s+/)
         .map((str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`)
         .join('');
-    return `${method}${apiPath}Route`;
+    return apiPath ? `${method}${apiPath}` : `${method}Index`;
 }
 /**
  * Generates a Hono route definition as a TypeScript export string.

package/dist/vite-plugin/index.d.ts

@@ -36,7 +36,6 @@ export default function HonoTakibiVite({ input, output, exportType, exportSchema
     exportSchema?: boolean;
 }): Promise<{
     name: string;
-    apply: string;
     buildStart(): Promise<void>;
     configureServer(server: ViteDevServer): void;
 }>;

package/dist/vite-plugin/index.js

@@ -35,27 +35,29 @@ import { parseOpenAPI } from '../openapi/index.js';
  */
 export default async function HonoTakibiVite({ input, output, exportType = true, exportSchema = true, }) {
     const run = async () => {
-        if (typeof input === 'string' &&
-            ((i) => i.endsWith('.tsp'))(input)) {
-            const spec = await parseOpenAPI(input);
-            if (!spec.ok) {
-                console.error(spec.error);
-                return false;
-            }
-            try {
-                const hono = zodOpenAPIHono(spec.value, exportSchema, exportType);
-                const code = await fmt(hono);
-                if (!code.ok) {
-                    console.error(`${code.error}`);
-                    return false;
-                }
-                await fsp.mkdir(path.dirname(output), { recursive: true });
-                await fsp.writeFile(output, code.value, 'utf-8');
-            }
-            catch (e) {
-                console.error(String(e));
-                throw e;
+        const isYamlOrJsonOrTsp = (i) => i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp');
+        if (!isYamlOrJsonOrTsp(input)) {
+            console.error(`Invalid input file type: ${input}`);
+            return;
+        }
+        const spec = await parseOpenAPI(input);
+        if (!spec.ok) {
+            console.error(spec.error);
+            return;
+        }
+        try {
+            const hono = zodOpenAPIHono(spec.value, exportSchema, exportType);
+            const code = await fmt(hono);
+            if (!code.ok) {
+                console.error(`${code.error}`);
+                return;
             }
+            await fsp.mkdir(path.dirname(output), { recursive: true });
+            await fsp.writeFile(output, code.value, 'utf-8');
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            throw e;
         }
     };
     const debounce = (ms, fn) => {
@@ -74,9 +76,6 @@ export default async function HonoTakibiVite({ input, output, exportType = true,
     const absInput = path.resolve(input);
     return {
         name: 'hono-takibi-vite',
-        // https://vite.dev/guide/api-plugin.html#conditional-application
-        // Only valid when the development server is running.
-        apply: 'serve',
         async buildStart() {
             await run();
         },

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.8.8",
+  "version": "0.9.01",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -32,16 +32,25 @@
       "types": "./dist/vite-plugin/index.d.ts",
       "import": "./dist/vite-plugin/index.js"
     },
+    "./config": {
+      "types": "./dist/generator/config/index.d.ts",
+      "import": "./dist/generator/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"
     }
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.0.0",
     "@typespec/compiler": "^1.3.0",
     "@typespec/openapi3": "^1.3.0",
-    "prettier": "^3.6.2"
+    "prettier": "^3.6.2",
+    "tsx": "^4.20.4"
   },
   "devDependencies": {
     "@hono/zod-openapi": "1.1.0",
@@ -50,7 +59,6 @@
     "@typespec/rest": "^0.73.0",
     "@typespec/versioning": "^0.73.0",
     "@vitest/coverage-v8": "^3.2.4",
-    "tsx": "^4.20.3",
     "typescript": "^5.8.3",
     "vite": "^7.0.6",
     "vitest": "^3.2.4",

package/dist/generator/zod-openapi-hono/handler/zod-openapi-hono-handler.d.ts

@@ -1,16 +0,0 @@
-import type { OpenAPI } from '../../../openapi/index.js';
-/**
- * Generates route handler files for a Hono app using Zod and OpenAPI.
- *
- * @param openapi - The OpenAPI specification object.
- * @param output - The output directory or file path for generated handlers.
- * @param test - Whether to generate corresponding empty test files.
- * @returns A `Result` indicating success or error with message.
- */
-export declare function zodOpenapiHonoHandler(openapi: OpenAPI, output: string, test: boolean): Promise<{
-    ok: true;
-    value: undefined;
-} | {
-    ok: false;
-    error: string;
-}>;

package/dist/generator/zod-openapi-hono/handler/zod-openapi-hono-handler.js

@@ -1,65 +0,0 @@
-import { fmt } from '../../../format/index.js';
-import { mkdir, writeFile } from '../../../fsp/index.js';
-import { groupHandlersByFileName, routeName } from '../../../utils/index.js';
-/**
- * Generates route handler files for a Hono app using Zod and OpenAPI.
- *
- * @param openapi - The OpenAPI specification object.
- * @param output - The output directory or file path for generated handlers.
- * @param test - Whether to generate corresponding empty test files.
- * @returns A `Result` indicating success or error with message.
- */
-export async function zodOpenapiHonoHandler(openapi, output, test) {
-    const paths = openapi.paths;
-    const handlers = [];
-    for (const [path, pathItem] of Object.entries(paths)) {
-        for (const [method] of Object.entries(pathItem)) {
-            const routeHandlerContent = `export const ${routeName(method, path)}Handler:RouteHandler<typeof ${routeName(method, path)}>=async(c)=>{}`;
-            const rawSegment = path.replace(/^\/+/, '').split('/')[0] ?? '';
-            const pathName = (rawSegment === '' ? 'index' : rawSegment)
-                .replace(/\{([^}]+)\}/g, '$1')
-                .replace(/[^0-9A-Za-z._-]/g, '_')
-                .replace(/^[._-]+|[._-]+$/g, '')
-                .replace(/__+/g, '_')
-                .replace(/[-._](\w)/g, (_, c) => c.toUpperCase());
-            const fileName = pathName.length === 0 ? 'indexHandler.ts' : `${pathName}Handler.ts`;
-            const testFileName = pathName.length === 0 ? 'indexHandler.test.ts' : `${pathName}Handler.test.ts`;
-            handlers.push({
-                fileName,
-                testFileName,
-                routeHandlerContents: [routeHandlerContent],
-                routeNames: [routeName(method, path)],
-            });
-        }
-    }
-    const mergedHandlers = groupHandlersByFileName(handlers);
-    for (const handler of mergedHandlers) {
-        const dirPath = output?.replace(/\/[^/]+\.ts$/, '');
-        const handlerPath = dirPath === 'index.ts' ? 'handlers' : `${dirPath}/handlers`;
-        const mkdirResult = await mkdir(handlerPath);
-        if (!mkdirResult.ok) {
-            return { ok: false, error: mkdirResult.error };
-        }
-        const routeTypes = handler.routeNames.map((routeName) => `${routeName}`).join(', ');
-        const match = output?.match(/[^/]+\.ts$/);
-        const matchPath = match ? match[0] : '';
-        const path = output === '.' || output === './' ? output : `../${matchPath}`;
-        const importRouteTypes = routeTypes ? `import type { ${routeTypes} } from '${path}';` : '';
-        const importStatements = `import type { RouteHandler } from '@hono/zod-openapi'\n${importRouteTypes}`;
-        const fileContent = `${importStatements}\n\n${handler.routeHandlerContents.join('\n\n')}`;
-        const formatCode = await fmt(fileContent);
-        if (!formatCode.ok) {
-            return { ok: false, error: formatCode.error };
-        }
-        const writeResult = await writeFile(`${handlerPath}/${handler.fileName}`, formatCode.value);
-        if (!writeResult.ok)
-            writeResult;
-        if (test) {
-            const writeResult = await writeFile(`${handlerPath}/${handler.testFileName}`, '');
-            if (!writeResult.ok) {
-                return { ok: false, error: writeResult.error };
-            }
-        }
-    }
-    return { ok: true, value: undefined };
-}