hono-takibi 0.8.3 → 0.8.4

package/dist/cli/index.d.ts

@@ -1,4 +1,4 @@
-import { type Result } from '../result/index.js';
+import type { Result } from '../result/index.js';
 /**
  * CLI entry point for `hono-takibi`.
  *

package/dist/cli/index.js

@@ -1,6 +1,5 @@
 import { asyncAndThen, ok } from '../result/index.js';
-import { isHelpRequested, sliceArgv } from '../utils/index.js';
-import { parseCli } from './parse.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]
 
@@ -17,8 +16,15 @@ Options:
  * @returns A `Result` containing help text or CLI execution result.
  */
 export async function honoTakibi() {
-    const args = sliceArgv(process.argv);
-    return isHelpRequested(sliceArgv(process.argv))
-        ? ok({ message: HELP_TEXT })
-        : await asyncAndThen(parseCli(args), async (cli) => asyncAndThen(await takibi(cli.input, cli.output, cli.exportSchema ?? false, cli.exportType ?? false, cli.template ?? false, cli.test ?? false, cli.basePath), async (result) => ok(result)));
+    // 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');
+    };
+    if (isHelpRequested(args)) {
+        return ok({
+            message: HELP_TEXT,
+        });
+    }
+    return await asyncAndThen(parseCli(args), async (cli) => asyncAndThen(await takibi(cli.input, cli.output, cli.exportSchema ?? false, cli.exportType ?? false, cli.template ?? false, cli.test ?? false, cli.basePath), async (result) => ok(result)));
 }

package/dist/format/index.d.ts

@@ -1,8 +1,15 @@
-import type { Result } from '../result/index.js';
 /**
  * Formats TypeScript source with Prettier.
  *
  * @param code - Source code to format.
  * @returns A `Result` containing the formatted code or an error message.
  */
-export declare function fmt(code: string): Promise<Result<string, string>>;
+export declare function fmt(code: string): Promise<{
+    ok: true;
+    value: string;
+    error?: undefined;
+} | {
+    ok: false;
+    error: string;
+    value?: undefined;
+}>;

package/dist/fsp/index.d.ts

@@ -1,18 +1,29 @@
-import type { Result } from '../result/index.js';
 /**
  * Creates a directory if it does not already exist.
  *
  * @param dir - Directory path to create.
  * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
-export declare function mkdir(dir: string): Promise<Result<void, string>>;
+export declare function mkdir(dir: string): Promise<{
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    value: undefined;
+}>;
 /**
  * Reads the contents of a directory.
  *
  * @param dir - Directory to read.
  * @returns A `Result` with the file list on success, otherwise an error message.
  */
-export declare function readdir(dir: string): Promise<Result<string[], string>>;
+export declare function readdir(dir: string): Promise<{
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    value: string[];
+}>;
 /**
  * Writes UTF-8 text to a file, creating it if necessary.
  *
@@ -20,4 +31,10 @@ export declare function readdir(dir: string): Promise<Result<string[], string>>;
  * @param data - Text data to write.
  * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
-export declare function writeFile(path: string, data: string): Promise<Result<void, string>>;
+export declare function writeFile(path: string, data: string): Promise<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/fsp/index.js

@@ -1,5 +1,4 @@
 import fsp from 'node:fs/promises';
-import { err, ok } from '../result/index.js';
 /**
  * Creates a directory if it does not already exist.
  *
@@ -9,10 +8,16 @@ import { err, ok } from '../result/index.js';
 export async function mkdir(dir) {
     try {
         await fsp.mkdir(dir, { recursive: true });
-        return ok(undefined);
+        return {
+            ok: true,
+            value: undefined,
+        };
     }
     catch (e) {
-        return err(e instanceof Error ? e.message : String(e));
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
     }
 }
 /**
@@ -24,10 +29,14 @@ export async function mkdir(dir) {
 export async function readdir(dir) {
     try {
         const files = await fsp.readdir(dir);
-        return ok(files);
+        // return ok(files)
+        return { ok: true, value: files };
     }
     catch (e) {
-        return err(e instanceof Error ? e.message : String(e));
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
     }
 }
 /**
@@ -40,9 +49,9 @@ export async function readdir(dir) {
 export async function writeFile(path, data) {
     try {
         await fsp.writeFile(path, data, 'utf-8');
-        return ok(undefined);
+        return { ok: true, value: undefined };
     }
     catch (e) {
-        return err(e instanceof Error ? e.message : String(e));
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
 }

package/dist/generator/zod/helper/index.d.ts

@@ -1,5 +1,2 @@
-export { arrayReferenceSchema } from './array-reference-schema.js';
 export { propertiesSchema } from './properties-schema.js';
 export { propertySchema } from './property-schema.js';
-export { referenceSchema } from './reference-schema.js';
-export { zodSchemaFromSubSchema } from './zod-schema-from-sub-schema.js';

package/dist/generator/zod/helper/index.js

@@ -1,5 +1,2 @@
-export { arrayReferenceSchema } from './array-reference-schema.js';
 export { propertiesSchema } from './properties-schema.js';
 export { propertySchema } from './property-schema.js';
-export { referenceSchema } from './reference-schema.js';
-export { zodSchemaFromSubSchema } from './zod-schema-from-sub-schema.js';

package/dist/generator/zod/helper/property-schema.js

@@ -1,8 +1,6 @@
 import { zodToOpenAPI } from '../../../helper/zod-to-openapi.js';
-import { isArrayWithSchemaReference } from '../../../utils/index.js';
+import { refName } from '../../../utils/index.js';
 import { zod } from '../index.js';
-import { arrayReferenceSchema } from './array-reference-schema.js';
-import { referenceSchema } from './reference-schema.js';
 /**
  * Generates a Zod-compatible schema string for a given property.
  *
@@ -30,10 +28,18 @@ import { referenceSchema } from './reference-schema.js';
  */
 export function propertySchema(schema) {
     if (Boolean(schema.$ref) === true) {
-        return referenceSchema(schema);
+        if (schema.$ref) {
+            const ref = refName(schema.$ref);
+            return `${ref}Schema`;
+        }
+        return 'z.any()';
     }
-    if (isArrayWithSchemaReference(schema)) {
-        return arrayReferenceSchema(schema);
+    if (schema.type === 'array' && Boolean(schema.items?.$ref)) {
+        if (schema.items?.$ref) {
+            const ref = refName(schema.items.$ref);
+            return `z.array(${ref}Schema)`;
+        }
+        return 'z.array(z.any())';
     }
     return zodToOpenAPI(zod(schema), schema);
 }

package/dist/generator/zod/index.js

@@ -1,8 +1,10 @@
 import { allOf } from '../../helper/allof.js';
 import { anyOf } from '../../helper/anyof.js';
+import { _const } from '../../helper/const.js';
+import { not } from '../../helper/not.js';
 import { oneOf } from '../../helper/oneof.js';
 import { refName } from '../../utils/index.js';
-import { _enum, array, integer, number, object, string } from './z/index.js';
+import { _enum, array, boolean, date, integer, number, object, string } from './z/index.js';
 /**
  * Converts an OpenAPI `Schema` object into a Zod schema string.
  *
@@ -65,15 +67,13 @@ export function zod(schema) {
     }
     /* const */
     if (schema.const !== undefined) {
-        const base = `z.literal(${JSON.stringify(schema.const)})`;
-        const isNullable = schema.nullable === true ||
-            (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
-        return isNullable ? `${base}.nullable()` : base;
+        return _const(schema);
     }
     /* enum */
     if (schema.enum) {
         return _enum(schema);
     }
+    /* properties */
     if (schema.properties) {
         return object(schema);
     }
@@ -82,16 +82,12 @@ export function zod(schema) {
     };
     const types = pickTypes(schema.type);
     /* object */
-    if (pickTypes(schema.type).includes('object')) {
+    if (types.includes('object')) {
         return object(schema);
     }
     /* date */
     if (types.includes('date')) {
-        const addNullable = (expr) => schema.nullable === true ||
-            (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null')
-            ? `${expr}.nullable()`
-            : expr;
-        return addNullable('z.date()');
+        return date(schema);
     }
     /* string */
     if (types.includes('string')) {
@@ -111,11 +107,7 @@ export function zod(schema) {
     }
     /* boolean */
     if (types.includes('boolean')) {
-        const addNullable = (expr) => schema.nullable === true ||
-            (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null')
-            ? `${expr}.nullable()`
-            : expr;
-        return addNullable('z.boolean()');
+        return boolean(schema);
     }
     /* combinators */
     if (schema.oneOf) {
@@ -128,17 +120,12 @@ export function zod(schema) {
         return allOf(schema);
     }
     if (schema.not) {
-        const isNullable = schema.nullable === true ||
-            (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
-        if (isNullable) {
-            return 'z.unknown().nullable()';
-        }
-        return 'z.unknown()';
+        return not(schema);
     }
     /* null only */
     if (types.length === 1 && types[0] === 'null') {
         return 'z.null()';
     }
-    console.warn(`Unknown schema: ${JSON.stringify(schema)} - fallback to z.any()`);
+    console.warn('fallback to z.any()');
     return 'z.any()';
 }

package/dist/generator/zod/z/array.js

@@ -1,23 +1,32 @@
 import { zod } from '../index.js';
 export function array(schema) {
-    const z = `z.array(${schema.items ? zod(schema.items) : 'z.any()'})`;
+    const array = `z.array(${schema.items ? zod(schema.items) : 'z.any()'})`;
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
     if (typeof schema.minItems === 'number' && typeof schema.maxItems === 'number') {
         if (schema.minItems === schema.maxItems) {
-            return isNullable
-                ? `${z}.length(${schema.minItems}).nullable()`
-                : `${z}.length(${schema.minItems})`;
+            const z = isNullable
+                ? `${array}.length(${schema.minItems}).nullable()`
+                : `${array}.length(${schema.minItems})`;
+            return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
         }
-        return isNullable
-            ? `${z}.min(${schema.minItems}).max(${schema.maxItems}).nullable()`
-            : `${z}.min(${schema.minItems}).max(${schema.maxItems})`;
+        const z = isNullable
+            ? `${array}.min(${schema.minItems}).max(${schema.maxItems}).nullable()`
+            : `${array}.min(${schema.minItems}).max(${schema.maxItems})`;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
     if (typeof schema.minItems === 'number') {
-        return isNullable ? `${z}.min(${schema.minItems}).nullable()` : `${z}.min(${schema.minItems})`;
+        const z = isNullable
+            ? `${array}.min(${schema.minItems}).nullable()`
+            : `${array}.min(${schema.minItems})`;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
     if (typeof schema.maxItems === 'number') {
-        return isNullable ? `${z}.max(${schema.maxItems}).nullable()` : `${z}.max(${schema.maxItems})`;
+        const z = isNullable
+            ? `${array}.max(${schema.maxItems}).nullable()`
+            : `${array}.max(${schema.maxItems})`;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
-    return isNullable ? `${z}.nullable()` : z;
+    const z = isNullable ? `${array}.nullable()` : array;
+    return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
 }

package/dist/generator/zod/z/boolean.d.ts

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

package/dist/generator/zod/z/boolean.js

@@ -0,0 +1,6 @@
+export function boolean(schema) {
+    const isNullable = schema.nullable === true ||
+        (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
+    const z = isNullable ? 'z.boolean().nullable()' : 'z.boolean()';
+    return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
+}

package/dist/generator/zod/z/date.d.ts

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

package/dist/generator/zod/z/date.js

@@ -0,0 +1,6 @@
+export function date(schema) {
+    const isNullable = schema.nullable === true ||
+        (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
+    const z = isNullable ? 'z.date().nullable()' : 'z.date()';
+    return schema.default ? `${z}.default(new Date(${JSON.stringify(schema.default)}))` : z;
+}

package/dist/generator/zod/z/enum.js

@@ -4,24 +4,25 @@
 export function _enum(schema) {
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
-    const wrapNullable = (expr) => (isNullable ? `${expr}.nullable()` : expr);
     // number
     if (schema.type === 'number' && schema.enum) {
-        const expr = schema.enum.length > 1
+        const _enum = schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
-        return wrapNullable(expr);
+        const z = isNullable ? `${_enum}.nullable()` : _enum;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
     // integer
     if (schema.type === 'integer' && schema.enum) {
-        const expr = schema.enum.length > 1
+        const _enum = schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
-        return wrapNullable(expr);
+        const z = isNullable ? `${_enum}.nullable()` : _enum;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
     // array
     if (schema.type === 'array' && Array.isArray(schema.enum)) {
-        const expr = (() => {
+        const _enum = (() => {
             if (schema.enum.length === 1 && Array.isArray(schema.enum[0])) {
                 const tupleItems = schema.enum[0].map((item) => `z.literal(${item})`).join(', ');
                 return `z.tuple([${tupleItems}])`;
@@ -35,29 +36,37 @@ export function _enum(schema) {
             });
             return `z.union([${unionParts.join(',')}])`;
         })();
-        return wrapNullable(expr);
+        const z = isNullable ? `${_enum}.nullable()` : _enum;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
     // boolean
     if (schema.type === 'boolean' && schema.enum) {
-        const expr = schema.enum.length > 1
+        const _enum = schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
-        return wrapNullable(expr);
+        const z = isNullable ? `${_enum}.nullable()` : _enum;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
+    // enum
     if (schema.enum) {
-        const expr = (() => {
+        const _enum = (() => {
             if (schema.enum.length > 1) {
                 const allStrings = schema.enum.every((v) => typeof v === 'string');
                 if (allStrings) {
                     return `z.enum(${JSON.stringify(schema.enum)})`;
                 }
                 const unionLiterals = schema.enum.map((v) => v === null ? 'z.null()' : `z.literal(${typeof v === 'string' ? `'${v}'` : v})`);
+                // if (schema.discriminator?.propertyName) {
+                //   return `z.discriminatedUnion('${schema.discriminator.propertyName}',[${unionLiterals.join(',')}])`
+                // }
                 return `z.union([${unionLiterals.join(',')}])`;
             }
             const v = schema.enum[0];
             return `z.literal(${typeof v === 'string' ? `'${v}'` : v})`;
         })();
-        return wrapNullable(expr);
+        const z = isNullable ? `${_enum}.nullable()` : _enum;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
-    return 'z.any()';
+    const z = isNullable ? 'z.any().nullable()' : 'z.any()';
+    return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
 }

package/dist/generator/zod/z/index.d.ts

@@ -1,4 +1,6 @@
 export { array } from './array.js';
+export { boolean } from './boolean.js';
+export { date } from './date.js';
 export { _enum } from './enum.js';
 export { integer } from './integer.js';
 export { number } from './number.js';

package/dist/generator/zod/z/index.js

@@ -1,4 +1,6 @@
 export { array } from './array.js';
+export { boolean } from './boolean.js';
+export { date } from './date.js';
 export { _enum } from './enum.js';
 export { integer } from './integer.js';
 export { number } from './number.js';

package/dist/generator/zod/z/integer.js

@@ -87,14 +87,15 @@ export function integer(schema) {
     if (schema.multipleOf !== undefined && typeof schema.multipleOf === 'number') {
         o.push(`.multipleOf(${lit(schema.multipleOf)})`);
     }
-    // default (always last)
-    if (schema.default !== undefined && typeof schema.default === 'number') {
-        o.push(`.default(${lit(schema.default)})`);
-    }
+    // nullable
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
     if (isNullable) {
         o.push('.nullable()');
     }
+    // default (always last)
+    if (schema.default !== undefined && typeof schema.default === 'number') {
+        o.push(`.default(${lit(schema.default)})`);
+    }
     return o.join('');
 }

package/dist/generator/zod/z/number.js

@@ -77,15 +77,15 @@ export function number(schema) {
     if (schema.multipleOf !== undefined) {
         o.push(`.multipleOf(${schema.multipleOf})`);
     }
-    // default
-    if (schema.default !== undefined) {
-        o.push(`.default(${JSON.stringify(schema.default)})`);
-    }
     // nullable
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
     if (isNullable) {
         o.push('.nullable()');
     }
+    // default (always last)
+    if (schema.default !== undefined) {
+        o.push(`.default(${JSON.stringify(schema.default)})`);
+    }
     return o.join('');
 }

package/dist/generator/zod/z/object.js

@@ -1,5 +1,6 @@
 import { allOf } from '../../../helper/allof.js';
 import { anyOf } from '../../../helper/anyof.js';
+import { not } from '../../../helper/not.js';
 import { oneOf } from '../../../helper/oneof.js';
 import { zodToOpenAPI } from '../../../helper/zod-to-openapi.js';
 import { propertiesSchema } from '../helper/properties-schema.js';
@@ -13,42 +14,48 @@ import { zod } from '../index.js';
 export function object(schema) {
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
-    const addNullable = (expr) => (isNullable ? `${expr}.nullable()` : expr);
     if (schema.additionalProperties) {
         if (typeof schema.additionalProperties === 'boolean') {
             if (schema.properties) {
                 const z = propertiesSchema(schema.properties, Array.isArray(schema.required) ? schema.required : []);
                 if (schema.additionalProperties === true) {
-                    return addNullable(z.replace('object', 'looseObject'));
+                    if (isNullable) {
+                        return `${z.replace('object', 'looseObject')}.nullable()`;
+                    }
+                    return z.replace('object', 'looseObject');
                 }
             }
-            return addNullable('z.any()');
+            const z = isNullable ? 'z.any().nullable()' : 'z.any()';
+            return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
         }
-        const value = zodToOpenAPI(zod(schema.additionalProperties), schema.additionalProperties);
-        return addNullable(`z.record(z.string(),${value})`);
+        const s = zodToOpenAPI(zod(schema.additionalProperties), schema.additionalProperties);
+        const z = isNullable ? `z.record(z.string(),${s}).nullable()` : `z.record(z.string(),${s})`;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
     if (schema.properties) {
-        const zodSchema = propertiesSchema(schema.properties, Array.isArray(schema.required) ? schema.required : []);
+        const s = propertiesSchema(schema.properties, Array.isArray(schema.required) ? schema.required : []);
         if (schema.additionalProperties === false) {
-            return addNullable(zodSchema.replace('object', 'strictObject'));
+            const z = isNullable
+                ? `${s.replace('object', 'strictObject')}.nullable()`
+                : s.replace('object', 'strictObject');
+            return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
         }
-        return addNullable(zodSchema);
-    }
-    // call allOf, oneOf, anyOf, or not use addNullable
-    if (schema.allOf) {
-        return allOf(schema);
+        const z = isNullable ? `${s}.nullable()` : s;
+        return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
     }
+    // allOf, oneOf, anyOf, not
     if (schema.oneOf) {
         return oneOf(schema);
     }
     if (schema.anyOf) {
         return anyOf(schema);
     }
+    if (schema.allOf) {
+        return allOf(schema);
+    }
     if (schema.not) {
-        if (isNullable) {
-            return 'z.unknown().nullable()';
-        }
-        return 'z.unknown()';
+        return not(schema);
     }
-    return addNullable('z.object({})');
+    const z = isNullable ? 'z.object({}).nullable()' : 'z.object({})';
+    return schema.default ? `${z}.default(${JSON.stringify(schema.default)})` : z;
 }

package/dist/generator/zod/z/string.js

@@ -32,9 +32,11 @@ export function string(schema) {
     const o = [];
     const format = schema.format && FORMAT_STRING[schema.format];
     o.push(format ? `z.${format}` : 'z.string()');
+    // pattern
     if (schema.pattern) {
         o.push(regex(schema.pattern));
     }
+    // length
     if (schema.minLength !== undefined &&
         schema.maxLength !== undefined &&
         schema.minLength === schema.maxLength) {
@@ -48,13 +50,13 @@ export function string(schema) {
             o.push(`.max(${schema.maxLength})`);
         }
     }
-    if (schema.default !== undefined) {
-        o.push(`.default(${JSON.stringify(schema.default)})`);
-    }
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
     if (isNullable) {
         o.push('.nullable()');
     }
+    if (schema.default !== undefined) {
+        o.push(`.default(${JSON.stringify(schema.default)})`);
+    }
     return o.join('');
 }

package/dist/generator/zod-openapi-hono/app/index.js

@@ -1,6 +1,6 @@
-import { applyOpenapiRoutes, getHandlerImports, importHandlers, importMap, importRoutes, registerComponent, } from '../../../utils/index.js';
-import { docs } from './helper/docs.js';
-import { getRouteMaps } from './helper/get-route-maps.js';
+import { docs } from '../../../helper/docs.js';
+import { getRouteMaps } from '../../../helper/get-route-maps.js';
+import { getHandlerImports, importHandlers, importMap, importRoutes, registerComponent, } from '../../../utils/index.js';
 /**
  * Generates a Hono app with OpenAPI and Swagger UI integration.
  *
@@ -26,7 +26,11 @@ export function app(openapi, output, basePath) {
         basePath
             ? `${'const app = new OpenAPIHono()'}.basePath('${basePath}')`
             : 'const app = new OpenAPIHono()',
-        `export const api = ${`app${applyOpenapiRoutes(routeMappings)}`}`,
+        `export const api = ${`app${routeMappings
+            .map(({ routeName, handlerName }) => {
+            return `.openapi(${routeName},${handlerName})`;
+        })
+            .join('\n')}`}`,
         swagger,
         'export type AddType = typeof api',
         'export default app',

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

@@ -1,6 +1,6 @@
 import { fmt } from '../../../format/index.js';
 import { mkdir, writeFile } from '../../../fsp/index.js';
-import { groupHandlersByFileName, handler, routeName } from '../../../utils/index.js';
+import { groupHandlersByFileName, routeName } from '../../../utils/index.js';
 /**
  * Generates route handler files for a Hono app using Zod and OpenAPI.
  *
@@ -14,7 +14,7 @@ export 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 = handler(`${routeName(method, path)}Handler`, routeName(method, path));
+            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')

package/dist/generator/zod-openapi-hono/openapi/route/params/index.d.ts

@@ -1,4 +1,3 @@
 export { paramsObject } from './params-object.js';
 export { queryParameter } from './query-parameter.js';
 export { requestParameter } from './request-parameter.js';
-export { requestParamsArray } from './request-params-array.js';

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

@@ -1,4 +1,3 @@
 export { paramsObject } from './params-object.js';
 export { queryParameter } from './query-parameter.js';
 export { requestParameter } from './request-parameter.js';
-export { requestParamsArray } from './request-params-array.js';