hono-takibi 0.8.6 → 0.8.7

package/dist/cli/index.d.ts

@@ -1,9 +1,12 @@
-import type { Result } from '../result/index.js';
 /**
  * CLI entry point for `hono-takibi`.
  *
  * @returns A `Result` containing help text or CLI execution result.
  */
-export declare function honoTakibi(): Promise<Result<{
-    message: string;
-}, string>>;
+export declare function honoTakibi(): Promise<{
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/cli/index.js

@@ -1,4 +1,4 @@
-import { asyncAndThen, ok } from '../result/index.js';
+import { asyncAndThen } from '../result/index.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]
@@ -22,9 +22,15 @@ export async function honoTakibi() {
         return args.length === 1 && (args[0] === '--help' || args[0] === '-h');
     };
     if (isHelpRequested(args)) {
-        return ok({
-            message: HELP_TEXT,
-        });
+        return {
+            ok: true,
+            value: 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)));
+    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) => {
+        return {
+            ok: true,
+            value: result,
+        };
+    }));
 }

package/dist/cli/takibi.d.ts

@@ -1,4 +1,3 @@
-import type { Result } from '../result/index.js';
 /**
  * Generates TypeScript code from an OpenAPI spec and optional templates.
  *
@@ -11,6 +10,10 @@ import type { Result } from '../result/index.js';
  * @param basePath - Optional base path for template output.
  * @returns A `Result` containing a success message or an error string.
  */
-export declare function takibi(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, exportSchema: boolean, exportType: boolean, template: boolean, test: boolean, basePath?: string): Promise<Result<{
-    message: string;
-}, string>>;
+export declare function takibi(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, exportSchema: boolean, exportType: boolean, template: boolean, test: boolean, basePath?: string): Promise<{
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/cli/takibi.js

@@ -3,7 +3,7 @@ import { fmt } from '../format/index.js';
 import { mkdir, writeFile } from '../fsp/index.js';
 import zodOpenAPIHono from '../generator/zod-openapi-hono/openapi/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-import { asyncAndThen, ok } from '../result/index.js';
+import { asyncAndThen } from '../result/index.js';
 import { templateCode } from './template-code.js';
 /**
  * Generates TypeScript code from an OpenAPI spec and optional templates.
@@ -19,10 +19,14 @@ import { templateCode } from './template-code.js';
  */
 export async function takibi(input, output, exportSchema, exportType, template, test, basePath) {
     return await asyncAndThen(await parseOpenAPI(input), async (openAPI) => asyncAndThen(await fmt(zodOpenAPIHono(openAPI, exportSchema, exportType)), async (code) => asyncAndThen(await mkdir(path.dirname(output)), async () => asyncAndThen(await writeFile(output, code), async () => template && output.includes('/')
-        ? asyncAndThen(await templateCode(openAPI, output, test, basePath), async () => ok({
-            message: 'Generated code and template files written',
-        }))
-        : ok({
-            message: `Generated code written to ${output}`,
-        })))));
+        ? asyncAndThen(await templateCode(openAPI, output, test, basePath), async () => {
+            return {
+                ok: true,
+                value: 'Generated code and template files written',
+            };
+        })
+        : {
+            ok: true,
+            value: `Generated code written to ${output}`,
+        }))));
 }

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

@@ -1,7 +1,6 @@
 import { resolveSchemasDependencies } from '../../../../helper/resolve-schemas-dependencies.js';
-import { zodToOpenAPI } from '../../../../helper/zod-to-openapi.js';
 import { zodToOpenAPISchema } from '../../../../helper/zod-to-openapi-schema.js';
-import zod from '../../../zod/index.js';
+import { zodToOpenAPI } from '../../../zod-to-openapi/index.js';
 /**
  * Converts OpenAPI component schemas to Zod-based TypeScript definitions.
  *
@@ -33,7 +32,7 @@ export function componentsCode(components, exportSchema, exportType) {
         // 4.1 get schema definition corresponding to schema name
         const schema = schemas[schemaName];
         // 4.2 generate zod schema
-        const zodSchema = zodToOpenAPI(zod(schema), schema);
+        const zodSchema = zodToOpenAPI(schema);
         // 4.3 generate zod schema definition
         return zodToOpenAPISchema(schemaName, zodSchema, exportSchema, exportType);
     })

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

@@ -1,4 +1,3 @@
-import { isHttpMethod } from '../../../../utils/index.js';
 import { route } from './route.js';
 /**
  * Generates TypeScript code for all valid Hono routes from OpenAPI paths.
@@ -24,9 +23,6 @@ export function routeCode(openAPIPaths) {
             // 3.1. skip parameters key and undefined operations
             if (method === 'parameters' || !pathItemValue)
                 continue;
-            // 3.2. check if the method is an HTTP method
-            if (!isHttpMethod(method))
-                throw new Error('Invalid HTTP method');
             // 3.3 exclude the possibility of string or Parameter[]
             if (typeof pathItemValue === 'string' || Array.isArray(pathItemValue))
                 continue;

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

@@ -1,6 +1,5 @@
-import { zodToOpenAPI } from '../../../../../helper/zod-to-openapi.js';
 import { getToSafeIdentifier } from '../../../../../utils/index.js';
-import zod from '../../../../zod/index.js';
+import { zodToOpenAPI } from '../../../../zod-to-openapi/index.js';
 import { queryParameter } from './index.js';
 /**
  * Converts OpenAPI component schemas into TypeScript code using Zod.
@@ -17,12 +16,12 @@ import { queryParameter } from './index.js';
  */
 export function paramsObject(parameters) {
     return parameters.reduce((acc, param) => {
-        const z = zod(param.schema);
+        // const z = zod(param.schema)
         const optionalSuffix = param.required ? '' : '.optional()';
         // path params are generated with the param name
         const baseSchema = param.in
-            ? zodToOpenAPI(z, param.schema, param.name, param.in)
-            : zodToOpenAPI(z, param.schema, param.name);
+            ? zodToOpenAPI(param.schema, param.name, param.in)
+            : zodToOpenAPI(param.schema, param.name);
         // Initialize section if it doesn't exist
         if (!acc[param.in]) {
             acc[param.in] = {};

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

@@ -1,5 +1,5 @@
 import { requestParamsArray } from '../../../../../utils/index.js';
-import { propertySchema } from '../../../../zod/helper/property-schema.js';
+import { zodToOpenAPI } from '../../../../zod-to-openapi/index.js';
 import { requestBody } from '../request/body/index.js';
 import { paramsObject } from './index.js';
 /**
@@ -35,7 +35,7 @@ export function requestParameter(parameters, body) {
         const uniqueSchemas = new Map();
         for (const contentType of requestBodyContentTypes) {
             const { schema } = body.content[contentType];
-            const z = propertySchema(schema);
+            const z = zodToOpenAPI(schema);
             uniqueSchemas.set(z, z);
         }
         const request_body_required = body.required ?? false;

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

@@ -1,5 +1,5 @@
 import { escapeStringLiteral, isUniqueContentSchema } from '../../../../../utils/index.js';
-import { propertySchema } from '../../../../zod/helper/property-schema.js';
+import { zodToOpenAPI } from '../../../../zod-to-openapi/index.js';
 /**
  * Generates a Zod-compatible response schema definition from OpenAPI responses.
  *
@@ -29,7 +29,7 @@ export function response(responses) {
             const contentParts = [];
             for (const contentType of contentTypes) {
                 const content = response.content[contentType];
-                const zodSchema = propertySchema(content.schema);
+                const zodSchema = zodToOpenAPI(content.schema);
                 const examples = content.examples;
                 const exampleString = examples && Object.keys(examples).length > 0
                     ? `,examples:{${Object.entries(examples)

package/dist/generator/zod-to-openapi/index.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../../openapi/index.js';
+export declare function zodToOpenAPI(schema: Schema, paramName?: string, paramIn?: 'path' | 'query' | 'header' | 'cookie'): string;

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

@@ -0,0 +1,141 @@
+import { wrap } from '../../helper/wrap.js';
+import { normalizeTypes, refSchema } from '../../utils/index.js';
+import { array } from './z/array.js';
+import { _enum } from './z/enum.js';
+import { integer } from './z/integer.js';
+import { number } from './z/number.js';
+import { object } from './z/object.js';
+import { string } from './z/string.js';
+export function zodToOpenAPI(schema, paramName, paramIn) {
+    if (schema === undefined)
+        throw new Error('hono-takibi: only #/components/schemas/* is supported');
+    // ref
+    if (schema.$ref) {
+        if (Boolean(schema.$ref) === true) {
+            return wrap(refSchema(schema.$ref), schema, paramName, paramIn);
+        }
+        if (schema.type === 'array' && Boolean(schema.items?.$ref)) {
+            if (schema.items?.$ref) {
+                const ref = wrap(refSchema(schema.items.$ref), schema.items);
+                return `z.array(${ref})`;
+            }
+            const z = 'z.array(z.any())';
+            return wrap(z, schema, paramName, paramIn);
+        }
+        const z = 'z.any()';
+        return wrap(z, schema, paramName, paramIn);
+    }
+    /* combinators */
+    // allOf
+    if (schema.allOf) {
+        if (!schema.allOf || schema.allOf.length === 0) {
+            return wrap('z.any()', schema);
+        }
+        const { schemas, nullable } = schema.allOf.reduce((acc, s) => {
+            const isOnlyNullable = (typeof s === 'object' && s.type === 'null') ||
+                (typeof s === 'object' && s?.nullable === true && Object.keys(s).length === 1);
+            if (isOnlyNullable) {
+                return {
+                    schemas: acc.schemas,
+                    nullable: true,
+                };
+            }
+            const z = zodToOpenAPI(s, paramName, paramIn);
+            return {
+                schemas: [...acc.schemas, wrap(z, s)],
+                nullable: acc.nullable,
+            };
+        }, {
+            schemas: [],
+            nullable: schema.nullable === true ||
+                (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null'),
+        });
+        if (schemas.length === 0) {
+            return wrap('z.any()', { ...schema, nullable }, paramName, paramIn);
+        }
+        if (schemas.length === 1) {
+            return wrap(schemas[0], { ...schema, nullable }, paramName, paramIn);
+        }
+        const z = `z.intersection(${schemas.join(',')})`;
+        return wrap(z, schema, paramName, paramIn);
+    }
+    // anyOf
+    if (schema.anyOf) {
+        if (!schema.anyOf || schema.anyOf.length === 0) {
+            return 'z.any()';
+        }
+        const schemas = schema.anyOf.map((subSchema) => {
+            return zodToOpenAPI(subSchema, paramName, paramIn);
+        });
+        const z = `z.union([${schemas.join(',')}])`;
+        return wrap(z, schema);
+    }
+    // oneOf
+    if (schema.oneOf) {
+        if (!schema.oneOf || schema.oneOf.length === 0) {
+            return 'z.any()';
+        }
+        const schemas = schema.oneOf.map((schema) => {
+            return zodToOpenAPI(schema, paramName, paramIn);
+        });
+        // discriminatedUnion Support hesitant
+        // This is because using intersection causes a type error.
+        // const discriminator = schema.discriminator?.propertyName
+        // const z = discriminator
+        //   ? `z.discriminatedUnion('${discriminator}',[${schemas.join(',')}])`
+        //   : `z.union([${schemas.join(',')}])`
+        const z = `z.union([${schemas.join(',')}])`;
+        return wrap(z, schema, paramName, paramIn);
+    }
+    // not
+    if (schema.not) {
+        if (typeof schema.not === 'object' && schema.not.type && typeof schema.not.type === 'string') {
+            const predicate = `(v) => typeof v !== '${schema.not.type}'`;
+            return `z.any().refine(${predicate})`;
+        }
+        if (typeof schema.not === 'object' && Array.isArray(schema.not.enum)) {
+            const list = JSON.stringify(schema.not.enum);
+            const predicate = `(v) => !${list}.includes(v)`;
+            return `z.any().refine(${predicate})`;
+        }
+        return 'z.any()';
+    }
+    // const
+    if (schema.const) {
+        const z = `z.literal(${JSON.stringify(schema.const)})`;
+        return wrap(z, schema, paramName, paramIn);
+    }
+    /* enum */
+    if (schema.enum)
+        return wrap(_enum(schema), schema, paramName, paramIn);
+    /* properties */
+    if (schema.properties)
+        return wrap(object(schema), schema, paramName, paramIn);
+    const t = normalizeTypes(schema.type);
+    /* string */
+    if (t.includes('string'))
+        return wrap(string(schema), schema, paramName, paramIn);
+    /* number */
+    if (t.includes('number'))
+        return wrap(number(schema), schema, paramName, paramIn);
+    /* integer & bigint */
+    if (t.includes('integer'))
+        return wrap(integer(schema), schema, paramName, paramIn);
+    /* boolean */
+    if (t.includes('boolean'))
+        return wrap('z.boolean()', schema, paramName, paramIn);
+    /* array */
+    if (t.includes('array'))
+        return wrap(array(schema), schema, paramName, paramIn);
+    /* object */
+    if (t.includes('object'))
+        return wrap(object(schema), schema, paramName, paramIn);
+    /* date */
+    if (t.includes('date'))
+        return wrap('z.date()', schema, paramName, paramIn);
+    /* null only */
+    if (t.length === 1 && t[0] === 'null')
+        return wrap('z.null()', schema, paramName, paramIn);
+    console.warn(`fallback to z.any(): schema=${JSON.stringify(schema)}`);
+    return wrap('z.any()', schema, paramName, paramIn);
+}

package/dist/generator/zod-to-openapi/z/array.js

@@ -0,0 +1,17 @@
+import { zodToOpenAPI } from '../index.js';
+export function array(schema) {
+    const array = `z.array(${schema.items ? zodToOpenAPI(schema.items) : 'z.any()'})`;
+    if (typeof schema.minItems === 'number' && typeof schema.maxItems === 'number') {
+        if (schema.minItems === schema.maxItems) {
+            return `${array}.length(${schema.minItems})`;
+        }
+        return `${array}.min(${schema.minItems}).max(${schema.maxItems})`;
+    }
+    if (typeof schema.minItems === 'number') {
+        return `${array}.min(${schema.minItems})`;
+    }
+    if (typeof schema.maxItems === 'number') {
+        return `${array}.max(${schema.maxItems})`;
+    }
+    return array;
+}

package/dist/generator/{zod → zod-to-openapi}/z/enum.d.ts

@@ -1,5 +1,2 @@
 import type { Schema } from '../../../openapi/index.js';
-/**
- * Generate a Zod enum schema string from an OpenAPI Schema object (nullable対応含む).
- */
 export declare function _enum(schema: Schema): string;

package/dist/generator/zod-to-openapi/z/enum.js

@@ -0,0 +1,41 @@
+export function _enum(schema) {
+    /* -------------------------- helpers -------------------------- */
+    const hasType = (t) => schema.type === t || (Array.isArray(schema.type) && schema.type.some((x) => x === t));
+    const lit = (v) => v === null ? 'null' : typeof v === 'string' ? `'${v}'` : String(v);
+    const tuple = (arr) => `z.tuple([${arr.map((i) => `z.literal(${lit(i)})`).join(',')}])`;
+    /* --------------------------- guard --------------------------- */
+    if (!schema.enum || schema.enum.length === 0)
+        return 'z.any()';
+    /* ------------------- number / integer enum ------------------- */
+    if (hasType('number') || hasType('integer')) {
+        return schema.enum.length > 1
+            ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
+            : `z.literal(${schema.enum[0]})`;
+    }
+    /* ----------------------- boolean enum ------------------------ */
+    if (hasType('boolean')) {
+        return schema.enum.length > 1
+            ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
+            : `z.literal(${schema.enum[0]})`;
+    }
+    /* ----------------------- array enum -------------------------- */
+    if (hasType('array')) {
+        if (schema.enum.length === 1 && Array.isArray(schema.enum[0])) {
+            return tuple(schema.enum[0]);
+        }
+        const parts = schema.enum.map((v) => (Array.isArray(v) ? tuple(v) : `z.literal(${lit(v)})`));
+        return `z.union([${parts.join(',')}])`;
+    }
+    /* ----------------------- string enum ------------------------- */
+    if (schema.enum.every((v) => typeof v === 'string')) {
+        return schema.enum.length > 1
+            ? `z.enum(${JSON.stringify(schema.enum)})`
+            : `z.literal('${schema.enum[0]}')`;
+    }
+    /* -------------------- mixed / null only ---------------------- */
+    if (schema.enum.length > 1) {
+        const parts = schema.enum.map((v) => `z.literal(${lit(v)})`);
+        return `z.union([${parts.join(',')}])`;
+    }
+    return `z.literal(${lit(schema.enum[0])})`;
+}

package/dist/generator/{zod → zod-to-openapi}/z/index.d.ts

@@ -1,6 +1,4 @@
 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 → zod-to-openapi}/z/index.js

@@ -1,6 +1,4 @@
 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 → zod-to-openapi}/z/integer.js

@@ -1,4 +1,3 @@
-import { wrap } from '../../../helper/wrap.js';
 /**
  * Generates a Zod schema for integer types based on OpenAPI schema.
  * Supports int32, int64, and bigint formats.
@@ -88,6 +87,5 @@ export function integer(schema) {
     if (schema.multipleOf !== undefined && typeof schema.multipleOf === 'number') {
         o.push(`.multipleOf(${lit(schema.multipleOf)})`);
     }
-    const z = o.join('');
-    return wrap(z, schema);
+    return o.join('');
 }

package/dist/generator/{zod → zod-to-openapi}/z/number.js

@@ -1,4 +1,3 @@
-import { wrap } from '../../../helper/wrap.js';
 /**
  * Generates a Zod schema for number types based on OpenAPI schema.
  * Supports float, float32, float64, and number formats.
@@ -78,6 +77,5 @@ export function number(schema) {
     if (schema.multipleOf !== undefined) {
         o.push(`.multipleOf(${schema.multipleOf})`);
     }
-    const z = o.join('');
-    return wrap(z, schema);
+    return o.join('');
 }

package/dist/generator/zod-to-openapi/z/object.js

@@ -0,0 +1,40 @@
+import { propertiesSchema } from '../../../helper/properties-schema.js';
+import { zodToOpenAPI } from '../index.js';
+/**
+ * Generates a Zod object schema from an OpenAPI schema definition.
+ *
+ * @param schema - Schema definition.
+ * @returns The Zod object schema string.
+ */
+export function object(schema) {
+    // // allOf, oneOf, anyOf, not
+    if (schema.oneOf)
+        return zodToOpenAPI(schema);
+    if (schema.anyOf)
+        return zodToOpenAPI(schema);
+    if (schema.allOf)
+        return zodToOpenAPI(schema);
+    if (schema.not)
+        return zodToOpenAPI(schema);
+    if (schema.additionalProperties) {
+        if (typeof schema.additionalProperties === 'boolean') {
+            if (schema.properties) {
+                const s = propertiesSchema(schema.properties, Array.isArray(schema.required) ? schema.required : []);
+                if (schema.additionalProperties === true) {
+                    return s.replace('object', 'looseObject');
+                }
+            }
+            return 'z.any()';
+        }
+        const s = zodToOpenAPI(schema.additionalProperties);
+        return `z.record(z.string(),${s})`;
+    }
+    if (schema.properties) {
+        const s = propertiesSchema(schema.properties, Array.isArray(schema.required) ? schema.required : []);
+        if (schema.additionalProperties === false) {
+            return s.replace('object', 'strictObject');
+        }
+        return s;
+    }
+    return 'z.object({})';
+}

package/dist/generator/{zod → zod-to-openapi}/z/string.js

@@ -1,4 +1,3 @@
-import { wrap } from '../../../helper/wrap.js';
 import { regex } from '../../../utils/index.js';
 const FORMAT_STRING = {
     email: 'email()',
@@ -51,6 +50,5 @@ export function string(schema) {
             o.push(`.max(${schema.maxLength})`);
         }
     }
-    const z = o.join('');
-    return wrap(z, schema);
+    return o.join('');
 }

package/dist/helper/index.d.ts

@@ -1,11 +1,6 @@
-export { allOf } from './allof.js';
-export { anyOf } from './anyof.js';
 export { docs } from './docs.js';
 export { getRouteMaps } from './get-route-maps.js';
-export { normalizeTypes } from './normalize-types.js';
-export { not } from './not.js';
-export { oneOf } from './oneof.js';
+export { propertiesSchema } from './properties-schema.js';
 export { resolveSchemasDependencies } from './resolve-schemas-dependencies.js';
 export { wrap } from './wrap.js';
-export { zodToOpenAPI } from './zod-to-openapi.js';
 export { zodToOpenAPISchema } from './zod-to-openapi-schema.js';

package/dist/helper/index.js

@@ -1,11 +1,6 @@
-export { allOf } from './allof.js';
-export { anyOf } from './anyof.js';
 export { docs } from './docs.js';
 export { getRouteMaps } from './get-route-maps.js';
-export { normalizeTypes } from './normalize-types.js';
-export { not } from './not.js';
-export { oneOf } from './oneof.js';
+export { propertiesSchema } from './properties-schema.js';
 export { resolveSchemasDependencies } from './resolve-schemas-dependencies.js';
 export { wrap } from './wrap.js';
-export { zodToOpenAPI } from './zod-to-openapi.js';
 export { zodToOpenAPISchema } from './zod-to-openapi-schema.js';

package/dist/{generator/zod/helper → helper}/properties-schema.d.ts

@@ -1,4 +1,4 @@
-import type { Schema } from '../../../openapi/index.js';
+import type { Schema } from '../openapi/index.js';
 /**
  * Generates a Zod object schema string from a set of OpenAPI properties.
  *

package/dist/{generator/zod/helper → helper}/properties-schema.js

@@ -1,5 +1,5 @@
-import { getToSafeIdentifier } from '../../../utils/index.js';
-import { propertySchema } from './property-schema.js';
+import { zodToOpenAPI } from '../generator/zod-to-openapi/index.js';
+import { getToSafeIdentifier } from '../utils/index.js';
 /**
  * Generates a Zod object schema string from a set of OpenAPI properties.
  *
@@ -48,7 +48,7 @@ export function propertiesSchema(properties, required) {
     const objectProperties = Object.entries(properties).map(([key, schema]) => {
         const isRequired = required.includes(key);
         const safeKey = getToSafeIdentifier(key);
-        return `${safeKey}:${propertySchema(schema)}${isRequired ? '' : '.optional()'}`;
+        return `${safeKey}:${zodToOpenAPI(schema)}${isRequired ? '' : '.optional()'}`;
     });
     // Check if all properties are optional
     const allOptional = objectProperties.every((prop) => prop.includes('.optional()'));

package/dist/helper/wrap.d.ts

@@ -1,2 +1,2 @@
 import type { Schema } from '../openapi/index.js';
-export declare function wrap(zod: string, schema: Schema): string;
+export declare function wrap(zod: string, schema: Schema, paramName?: string, paramIn?: string): string;

package/dist/helper/wrap.js

@@ -1,4 +1,4 @@
-export function wrap(zod, schema) {
+export function wrap(zod, schema, paramName, paramIn) {
     const formatLiteral = (v) => {
         // boolean true or false
         if (typeof v === 'boolean') {
@@ -14,9 +14,6 @@ export function wrap(zod, schema) {
             }
             return `${v}`;
         }
-        if (typeof v === 'bigint') {
-            return `${v}n`;
-        }
         // date
         if (schema.type === 'date' && typeof v === 'string') {
             return `new Date(${JSON.stringify(v)})`;
@@ -29,8 +26,26 @@ export function wrap(zod, schema) {
         return JSON.stringify(v);
     };
     // why schema.default !== undefined becasue schema.default === 0  // → falsy
-    const z = schema.default !== undefined ? `${zod}.default(${formatLiteral(schema.default)})` : zod;
+    const s = schema.default !== undefined ? `${zod}.default(${formatLiteral(schema.default)})` : zod;
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
-    return isNullable ? `${z}.nullable()` : z;
+    const z = isNullable ? `${s}.nullable()` : s;
+    const openapiProps = [];
+    if (paramIn && paramName) {
+        const required = paramIn === 'path' ? true : !!schema.required;
+        openapiProps.push(`param:{in:"${paramIn}",name:${JSON.stringify(paramName)},required:${required}}`);
+    }
+    // Add 'example' if defined
+    if ('example' in schema && schema.example !== undefined) {
+        openapiProps.push(`example:${JSON.stringify(schema.example)}`);
+    }
+    // Add 'examples' if defined
+    if ('examples' in schema && Array.isArray(schema.examples) && schema.examples.length > 0) {
+        openapiProps.push(`examples:${JSON.stringify(schema.examples)}`);
+    }
+    // Add 'description' if defined
+    if ('description' in schema && schema.description !== undefined) {
+        openapiProps.push(`description:${JSON.stringify(schema.description)}`);
+    }
+    return openapiProps.length === 0 ? z : `${z}.openapi({${openapiProps.join(',')}})`;
 }

package/dist/index.js

@@ -18,7 +18,7 @@ import { honoTakibi } from './cli/index.js';
  */
 honoTakibi().then((result) => {
     if (result.ok) {
-        console.log(result.value.message);
+        console.log(result.value);
         process.exit(0);
     }
     else {

package/dist/openapi/index.d.ts

@@ -126,7 +126,7 @@ export type Schema = {
     example?: unknown;
     examples?: unknown;
     properties?: Record<string, Schema>;
-    required?: string[] | boolean;
+    required?: string[];
     items?: Schema;
     enum?: (string | number | boolean | null | (string | number | boolean | null)[])[];
     nullable?: boolean;