hono-takibi 0.9.21 → 0.9.23

package/dist/cli/index.js

@@ -5,7 +5,7 @@ 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';
+import { parseCli, parseIO } from '../utils/index.js';
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
 
 Options:
@@ -81,13 +81,21 @@ export async function honoTakibi() {
         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
+    const zodOpenAPIConfigResult = parseIO(c['zod-openapi']);
+    if (!zodOpenAPIConfigResult.ok) {
+        return { ok: false, error: zodOpenAPIConfigResult.error };
+    }
+    const takibiResult = c['zod-openapi']
+        ? await takibi(c['zod-openapi']?.input, c['zod-openapi']?.output, c['zod-openapi']?.exportSchema ?? false, c['zod-openapi']?.exportType ?? false, false, // template
         false)
         : undefined;
     if (takibiResult && !takibiResult.ok) {
         return { ok: false, error: takibiResult.error };
     }
+    const rpcConfigResult = parseIO(c.rpc);
+    if (!rpcConfigResult.ok) {
+        return { ok: false, error: rpcConfigResult.error };
+    }
     const rpcResult = c.rpc
         ? await core(c.rpc.input, c.rpc.output, c.rpc.import, 'Generated RPC code written to', rpc)
         : undefined;

package/dist/config/index.d.ts

@@ -1,5 +1,5 @@
 type Config = {
-    'hono-takibi'?: {
+    'zod-openapi'?: {
         input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
         output: `${string}.ts`;
         exportType?: boolean;
@@ -10,11 +10,6 @@ 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;

package/dist/config/index.js

@@ -9,9 +9,9 @@ export async function config() {
     register();
     try {
         const mod = await import(pathToFileURL(abs).href);
-        if (!('default' in mod)) {
-            return { ok: false, error: 'Config must export default object' };
-        }
+        // if (!('default' in mod)) {
+        //   return { ok: false, error: 'Config must export default object' }
+        // }
         return { ok: true, value: mod.default };
     }
     catch (e) {

package/dist/core/core.js

@@ -8,15 +8,15 @@ export default async function core(input, output, importCode, value, fn) {
         return { ok: false, error: openAPIResult.error };
     }
     const openAPI = openAPIResult.value;
-    const honoRpcResult = await fmt(fn(openAPI, importCode));
-    if (!honoRpcResult.ok) {
-        return { ok: false, error: honoRpcResult.error };
+    const fnResult = await fmt(fn(openAPI, importCode));
+    if (!fnResult.ok) {
+        return { ok: false, error: fnResult.error };
     }
     const mkdirResult = await mkdir(path.dirname(output));
     if (!mkdirResult.ok) {
         return { ok: false, error: mkdirResult.error };
     }
-    const writeResult = await writeFile(output, honoRpcResult.value);
+    const writeResult = await writeFile(output, fnResult.value);
     if (!writeResult.ok) {
         return { ok: false, error: writeResult.error };
     }

package/dist/core/takibi.js

@@ -4,7 +4,7 @@ import { mkdir, readdir, writeFile } from '../fsp/index.js';
 import { app } from '../generator/zod-openapi-hono/app/index.js';
 import zodOpenAPIHono from '../generator/zod-openapi-hono/openapi/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-import { groupHandlersByFileName, methodPath } from '../utils/index.js';
+import { groupHandlersByFileName, isHttpMethod, methodPath } from '../utils/index.js';
 /**
  * Generates TypeScript code from an OpenAPI spec and optional templates.
  *
@@ -109,13 +109,6 @@ export async function takibi(input, output, exportSchema, exportType, template,
 async function zodOpenapiHonoHandler(openapi, output, test) {
     const paths = openapi.paths;
     const handlers = [];
-    const isHttpMethod = (v) => {
-        for (const m of ['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace']) {
-            if (m === v)
-                return true;
-        }
-        return false;
-    };
     for (const [path, pathItem] of Object.entries(paths)) {
         for (const [method] of Object.entries(pathItem)) {
             if (!isHttpMethod(method))

package/dist/generator/rpc/index.js

@@ -1,8 +1,6 @@
 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;
@@ -11,20 +9,11 @@ const isOpenAPIPaths = (v) => {
             return false;
     return true;
 };
-/** Treat any object as Schema (we rely on downstream field checks) */
 const isSchema = (v) => isRecord(v);
 /* ─────────────────────────────── Formatters ─────────────────────────────── */
-/** 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']"
- */
+/** '/'->'.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
@@ -35,7 +24,6 @@ const formatPath = (path) => {
             : `['${esc(seg)}']`)
         .join('');
 };
-/** 'type' to normalized list for uniform checks */
 const isJSONTypeName = (s) => typeof s === 'string' &&
     (s === 'object' ||
         s === 'array' ||
@@ -51,7 +39,6 @@ const toTypeArray = (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, "\\'")}'`
@@ -62,7 +49,6 @@ const literalFromEnum = (vals) => {
                 : 'unknown';
     return vals.map(toLit).join('|');
 };
-/** Create a $ref resolver for #/components/schemas/... */
 const createResolveRef = (schemas) => (ref) => {
     if (!ref)
         return undefined;
@@ -72,60 +58,52 @@ const createResolveRef = (schemas) => (ref) => {
     const target = schemas[m[1]];
     return isSchema(target) ? target : undefined;
 };
-/** Create a Schema->TypeScript type printer (single instance, recursive-safe) */
+/** TS type printer (handles $ref / enums / combinators / additionalProperties / nullable) */
 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
+        const next = new Set(seen);
+        next.add(schema);
         if (Array.isArray(schema.oneOf) && schema.oneOf.length)
-            return schema.oneOf.map((s) => tt(s, nextSeen)).join('|') || 'unknown';
+            return schema.oneOf.map((s) => tt(s, next)).join('|') || 'unknown';
         if (Array.isArray(schema.anyOf) && schema.anyOf.length)
-            return schema.anyOf.map((s) => tt(s, nextSeen)).join('|') || 'unknown';
+            return schema.anyOf.map((s) => tt(s, next)).join('|') || 'unknown';
         if (Array.isArray(schema.allOf) && schema.allOf.length)
-            return schema.allOf.map((s) => tt(s, nextSeen)).join('&') || 'unknown';
-        // enum
+            return schema.allOf.map((s) => tt(s, next)).join('&') || 'unknown';
         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
+        // array (parentheses when inner contains union/intersection)
         if (types.includes('array')) {
-            const inner = tt(isSchema(schema.items) ? schema.items : undefined, nextSeen);
-            const core = `${inner}[]`;
+            const item = isSchema(schema.items) ? schema.items : undefined;
+            const inner = tt(item, next);
+            const needParens = /[|&]/.test(inner) && !/^\(.*\)$/.test(inner);
+            const core = `${needParens ? `(${inner})` : 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)}`;
+                return `${k}${opt}:${tt(child, next)}`;
             });
             const ap = schema.additionalProperties;
-            const addl = ap === true
-                ? '[key:string]:unknown'
-                : isSchema(ap)
-                    ? `[key:string]:${tt(ap, nextSeen)}`
-                    : '';
+            const addl = ap === true ? '[key:string]:unknown' : isSchema(ap) ? `[key:string]:${tt(ap, next)}` : '';
             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
@@ -144,13 +122,11 @@ const isParameterObject = (v) => {
     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;
@@ -158,7 +134,6 @@ const createResolveParameter = (componentsParameters) => (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);
@@ -178,7 +153,7 @@ const HTTP_METHODS = [
     'patch',
     'trace',
 ];
-/** Extract the first suitable schema from requestBody.content by priority order */
+const hasSchemaProp = (v) => isRecord(v) && 'schema' in v;
 const pickBodySchema = (op) => {
     const rb = op.requestBody;
     if (!isRecord(rb))
@@ -196,14 +171,12 @@ const pickBodySchema = (op) => {
     ];
     for (const k of order) {
         const media = isRecord(content[k]) ? content[k] : undefined;
-        if (isRecord(media) && 'schema' in media && isSchema(media.schema)) {
+        if (hasSchemaProp(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) {
@@ -216,7 +189,6 @@ const createBuildParamsType = (tsTypeFromSchema) => (pathParams, queryParams) =>
     }
     return parts.length ? `{${parts.join(',')}}` : '';
 };
-/** Build function argument signature */
 const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
     ? `params:${paramsType}, body:${bodyType}`
     : paramsType
@@ -224,20 +196,7 @@ const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
         : 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) */
+/** pass query as-is (keep numbers/arrays) */
 const buildClientArgs = (pathParams, queryParams, hasBody) => {
     const pieces = [];
     if (pathParams.length) {
@@ -245,7 +204,7 @@ const buildClientArgs = (pathParams, queryParams, hasBody) => {
         pieces.push(`param:{${inner}}`);
     }
     if (queryParams.length) {
-        const inner = queryParams.map(buildQueryPiece).join(',');
+        const inner = queryParams.map((p) => `${p.name}:params.query.${p.name}`).join(',');
         pieces.push(`query:{${inner}}`);
     }
     if (hasBody)
@@ -276,36 +235,25 @@ const generateOperationCode = (path, method, item, deps) => {
         : `${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` +
-        '}');
+    const summaryBlock = summary ? ` * ${summary}\n *\n` : '';
+    const descriptionBlock = description ? ` * ${description}\n *\n` : '';
+    return `/**\n${summaryBlock}${descriptionBlock} * ${method.toUpperCase()} ${path}\n */\nexport async function ${funcName}(${argSig}){return await ${call}}`;
 };
 /* ─────────────────────────────── Entry ─────────────────────────────── */
 export default function rpc(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 s = (importCode ?? '').trim();
+    const header = s.length ? `${s}\n\n` : '';
     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))
@@ -331,6 +279,5 @@ export default function rpc(openapi, importCode) {
                 out.push(code);
         }
     }
-    // final string (compact; Prettier will handle formatting as configured)
-    return header + out.join('\n\n') + (out.length ? '\n' : '');
+    return `${header}${out.join('\n\n')}${out.length ? '\n' : ''}`;
 }

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

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

package/dist/utils/index.d.ts

@@ -34,6 +34,13 @@ export declare function parseCli(args: readonly string[]): {
     ok: false;
     error: string;
 };
+export declare function parseIO<T>(section: T): {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
 /**
  * Normalize a JSON Schema `type` value into an array of type strings.
  *
@@ -241,6 +248,13 @@ export declare function isRefObject(value: unknown): value is {
     $ref?: string;
     [key: string]: unknown;
 };
+/**
+ * Checks if a string is a valid HTTP method.
+ *
+ * @param method - The HTTP method to check.
+ * @returns `true` if the method is a valid HTTP method; otherwise `false`.
+ */
+export declare function isHttpMethod(method: string): method is 'get' | 'put' | 'post' | 'delete' | 'patch' | 'options' | 'head' | 'trace';
 /**
  * Checks if all given content types share the same schema definition.
  *

package/dist/utils/index.js

@@ -51,6 +51,29 @@ export function parseCli(args) {
         },
     };
 }
+export function parseIO(section) {
+    const inputExts = ['yaml', 'json', 'tsp'];
+    const outputExts = ['ts'];
+    const isString = (x) => typeof x === 'string';
+    const hasExt = (path, exts) => exts.some((e) => path.endsWith(`.${e}`));
+    if (section == null)
+        return { ok: true, value: section };
+    if (typeof section !== 'object')
+        return { ok: true, value: section };
+    if (Reflect.has(section, 'input')) {
+        const input = Reflect.get(section, 'input');
+        if (isString(input) && !hasExt(input, inputExts)) {
+            return { ok: false, error: 'input must be a .yaml, .json, or .tsp file' };
+        }
+    }
+    if (Reflect.has(section, 'output')) {
+        const output = Reflect.get(section, 'output');
+        if (isString(output) && !hasExt(output, outputExts)) {
+            return { ok: false, error: 'output must be a .ts file' };
+        }
+    }
+    return { ok: true, value: section };
+}
 /**
  * Normalize a JSON Schema `type` value into an array of type strings.
  *
@@ -302,6 +325,22 @@ export function getHandlerImports(handlerMaps) {
 export function isRefObject(value) {
     return typeof value === 'object' && value !== null;
 }
+/**
+ * Checks if a string is a valid HTTP method.
+ *
+ * @param method - The HTTP method to check.
+ * @returns `true` if the method is a valid HTTP method; otherwise `false`.
+ */
+export function isHttpMethod(method) {
+    return (method === 'get' ||
+        method === 'put' ||
+        method === 'post' ||
+        method === 'delete' ||
+        method === 'patch' ||
+        method === 'options' ||
+        method === 'head' ||
+        method === 'trace');
+}
 /**
  * Checks if all given content types share the same schema definition.
  *

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.21",
+  "version": "0.9.23",
   "type": "module",
   "license": "MIT",
   "keywords": [