hono-takibi 0.8.1 → 0.8.2

package/dist/cli/takibi.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 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/parse-openapi.js';
+import { parseOpenAPI } from '../openapi/index.js';
 import { asyncAndThen, ok } from '../result/index.js';
 import { templateCode } from './template-code.js';
 /**

package/dist/generator/zod/helper/array-reference-schema.js

@@ -1,4 +1,4 @@
-import { array, refName } from '../../../utils/index.js';
+import { refName } from '../../../utils/index.js';
 /**
  * Generates a Zod schema string for an array of referenced schemas.
  *
@@ -36,5 +36,5 @@ export function arrayReferenceSchema(schema) {
     if (!ref) {
         return 'z.array(z.any())';
     }
-    return array(`${ref}Schema`);
+    return `z.array(${ref}Schema)`;
 }

package/dist/generator/zod/index.js

@@ -1,7 +1,6 @@
 import { allOf } from '../../helper/allof.js';
 import { anyOf } from '../../helper/anyof.js';
 import { maybeApplyNullability, pickTypes } from '../../helper/index.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';
@@ -59,8 +58,9 @@ import { _enum, array, integer, number, object, string } from './z/index.js';
  */
 export function zod(schema) {
     /* $ref */
-    if (schema.$ref)
+    if (schema.$ref) {
         return `${refName(schema.$ref)}Schema`;
+    }
     /* const */
     if (schema.const !== undefined) {
         return maybeApplyNullability(`z.literal(${JSON.stringify(schema.const)})`, schema);
@@ -111,11 +111,12 @@ export function zod(schema) {
         return allOf(schema);
     }
     if (schema.not) {
-        return not(schema);
+        return 'z.unknown()';
     }
     /* null only */
-    if (types.length === 1 && types[0] === 'null')
+    if (types.length === 1 && types[0] === 'null') {
         return 'z.null()';
+    }
     console.warn(`Unknown schema: ${JSON.stringify(schema)} - fallback to z.any()`);
     return 'z.any()';
 }

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

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

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

@@ -1,27 +1,20 @@
-import { length, max, min } from '../../../utils/index.js';
 import { zod } from '../index.js';
 export function array(schema) {
-    // fall back to any[] if items が無い
     const z = `z.array(${schema.items ? zod(schema.items) : 'z.any()'})`;
-    // minItems / maxItems → .min() / .max()
-    if (schema.minItems !== undefined && schema.maxItems !== undefined) {
-        return schema.minItems === schema.maxItems
-            ? `${z}${length(schema.minItems)}`
-            : `${z}${min(schema.minItems)}${max(schema.maxItems)}`;
+    // minItems / maxItems → .length() / .min() / .max()
+    if (typeof schema.minItems === 'number' && typeof schema.maxItems === 'number') {
+        // minItems === maxItems → .length(n)
+        if (schema.minItems === schema.maxItems) {
+            return `${z}.length(${schema.minItems})`;
+        }
+        // minItems ≠ maxItems → .min(n).max(n)
+        return `${z}.min(${schema.minItems}).max(${schema.maxItems})`;
     }
-    if (schema.minItems !== undefined)
-        return `${z}${min(schema.minItems)}`;
-    if (schema.maxItems !== undefined)
-        return `${z}${max(schema.maxItems)}`;
-    /* legacy: minLength / maxLength on array */
-    if (schema.minLength !== undefined && schema.maxLength !== undefined) {
-        return schema.minLength === schema.maxLength
-            ? `${z}${length(schema.minLength)}`
-            : `${z}${min(schema.minLength)}${max(schema.maxLength)}`;
+    if (typeof schema.minItems === 'number') {
+        return `${z}.min(${schema.minItems})`;
+    }
+    if (typeof schema.maxItems === 'number') {
+        return `${z}.max(${schema.maxItems})`;
     }
-    if (schema.minLength !== undefined)
-        return `${z}${min(schema.minLength)}`;
-    if (schema.maxLength !== undefined)
-        return `${z}${max(schema.maxLength)}`;
     return z;
 }

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

@@ -1,4 +1,4 @@
-import type { Schema } from '../../../openapi/types.js';
+import type { Schema } from '../../../openapi/index.js';
 /**
  * Generate a Zod enum schema string from an OpenAPI Schema object.
  *

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

@@ -3,5 +3,4 @@ export { _enum } from './enum.js';
 export { integer } from './integer.js';
 export { number } from './number.js';
 export { object } from './object.js';
-export { record } from './record.js';
 export { string } from './string.js';

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

@@ -3,5 +3,4 @@ export { _enum } from './enum.js';
 export { integer } from './integer.js';
 export { number } from './number.js';
 export { object } from './object.js';
-export { record } from './record.js';
 export { string } from './string.js';

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

@@ -1,4 +1,4 @@
-import type { Schema } from '../../../openapi/types.js';
+import type { Schema } from '../../../openapi/index.js';
 /**
  * Generates a Zod schema for integer types based on OpenAPI schema.
  * Supports int32, int64, and bigint formats.

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

@@ -1,4 +1,3 @@
-import { regex } from '../../../utils/index.js';
 /**
  * Generates a Zod schema for integer types based on OpenAPI schema.
  * Supports int32, int64, and bigint formats.
@@ -7,55 +6,90 @@ import { regex } from '../../../utils/index.js';
  * @returns The Zod schema string
  */
 export function integer(schema) {
-    /* ─────────────── 1. base type ─────────────── */
     const isInt32 = schema.format === 'int32';
     const isInt64 = schema.format === 'int64';
     const isBigInt = schema.format === 'bigint';
-    const out = [
+    const o = [
         isInt32 ? 'z.int32()' : isInt64 ? 'z.int64()' : isBigInt ? 'z.bigint()' : 'z.int()',
     ];
-    /* ─────────────── 2. helpers ─────────────── */
-    /**
-     * Converts a numeric literal into the correct representation
-     * for int64 / bigint boundaries and defaults.
-     */
-    const lit = (n, forceCtor = false) => {
-        if (isBigInt || forceCtor)
+    const lit = (n) => {
+        if (isBigInt)
             return `BigInt(${n})`;
         if (isInt64)
             return `${n}n`;
         return `${n}`;
     };
-    /* ─────────────── 3. pattern ─────────────── */
-    if (schema.pattern)
-        out.push(regex(schema.pattern));
-    /* ─────────────── 4. lower bound ─────────────── */
-    if (typeof schema.exclusiveMinimum === 'number') {
-        out.push(`.gt(${lit(schema.exclusiveMinimum)})`);
+    // minimum
+    if (schema.minimum !== undefined || schema.exclusiveMinimum !== undefined) {
+        // > 0
+        // z.int().positive().safeParse(1) // { success: true }
+        // z.int().positive().safeParse(0) // { success: false }
+        if ((schema.minimum ?? schema.exclusiveMinimum) === 0 && schema.exclusiveMinimum === true) {
+            o.push('.positive()');
+        }
+        // >= 0
+        // z.int().nonnegative().safeParse(0) // { success: true }
+        // z.int().nonnegative().safeParse(-1) // { success: false }
+        else if ((schema.minimum ?? schema.exclusiveMinimum) === 0 &&
+            schema.exclusiveMinimum === false) {
+            o.push('.nonnegative()');
+        }
+        // > value
+        // z.int().gt(100) // value > 100
+        // z.int().gt(100).safeParse(101) // { success: true }
+        // z.int().gt(100).safeParse(100) // { success: false }
+        else if ((schema.exclusiveMinimum === true || schema.minimum === undefined) &&
+            typeof (schema.minimum ?? schema.exclusiveMinimum) === 'number') {
+            o.push(`.gt(${lit((schema.minimum ?? schema.exclusiveMinimum))})`);
+        }
+        // >= value
+        // z.int().min(100) // value >= 100
+        // z.int().min(100).safeParse(100) // { success: true }
+        // z.int().min(100).safeParse(99) // { success: false }
+        else if (typeof schema.minimum === 'number') {
+            o.push(`.min(${lit(schema.minimum)})`);
+        }
     }
-    else if (schema.minimum === 0 && schema.exclusiveMinimum === true) {
-        out.push('.positive()');
+    // maximum
+    if (schema.maximum !== undefined || schema.exclusiveMaximum !== undefined) {
+        // < 0
+        // z.int().negative().safeParse(-1) // { success: true }
+        // z.int().negative().safeParse(0) // { success: false }
+        if ((schema.maximum ?? schema.exclusiveMaximum) === 0 && schema.exclusiveMaximum === true) {
+            o.push('.negative()');
+        }
+        // <= 0
+        // z.int().nonpositive().safeParse(0) // { success: true }
+        // z.int().nonpositive().safeParse(1) // { success: false }
+        else if ((schema.maximum ?? schema.exclusiveMaximum) === 0 &&
+            schema.exclusiveMaximum === false) {
+            o.push('.nonpositive()');
+        }
+        // < value
+        // z.int().lt(100) // value < 100
+        // z.int().lt(100).safeParse(99) -> { success: true }
+        // z.int().lt(100).safeParse(100) -> { success: false }
+        else if ((schema.exclusiveMaximum === true || schema.maximum === undefined) &&
+            typeof (schema.maximum ?? schema.exclusiveMaximum) === 'number') {
+            o.push(`.lt(${lit((schema.maximum ?? schema.exclusiveMaximum))})`);
+        }
+        // <= value
+        // z.int().max(100) // value <= 100
+        // z.int().max(100).safeParse(100) -> { success: true }
+        // z.int().max(100).safeParse(101) -> { success: false }
+        else if (typeof schema.maximum === 'number') {
+            o.push(`.max(${lit(schema.maximum)})`);
+        }
     }
-    else if (typeof schema.minimum === 'number') {
-        out.push(`.min(${lit(schema.minimum)})`);
+    // multipleOf
+    // z.int().multipleOf(2).safeParse(2) // { success: true }
+    // z.int().multipleOf(2).safeParse(1) // { success: false }
+    if (schema.multipleOf !== undefined && typeof schema.multipleOf === 'number') {
+        o.push(`.multipleOf(${lit(schema.multipleOf)})`);
     }
-    /* ─────────────── 5. upper bound ─────────────── */
-    if (typeof schema.exclusiveMaximum === 'number') {
-        out.push(`.lt(${lit(schema.exclusiveMaximum)})`);
+    // default (always last)
+    if (schema.default !== undefined && typeof schema.default === 'number') {
+        o.push(`.default(${lit(schema.default)})`);
     }
-    else if (schema.maximum === 0 && schema.exclusiveMaximum === true) {
-        out.push('.negative()');
-    }
-    else if (typeof schema.maximum === 'number') {
-        out.push(`.max(${lit(schema.maximum)})`);
-    }
-    /* ─────────────── 6. default (always last) ─────────────── */
-    if (schema.default !== undefined) {
-        const def = typeof schema.default === 'number'
-            ? lit(schema.default, /* forceCtor: BigInt as needed */ true)
-            : JSON.stringify(schema.default);
-        out.push(`.default(${def})`);
-    }
-    /* ─────────────── 7. finish ─────────────── */
-    return out.join('');
+    return o.join('');
 }

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

@@ -1,2 +1,9 @@
-import type { Schema } from '../../../openapi/types.js';
+import type { Schema } from '../../../openapi/index.js';
+/**
+ * Generates a Zod schema for number types based on OpenAPI schema.
+ * Supports float, float32, float64, and number formats.
+ *
+ * @param schema - The OpenAPI schema object
+ * @returns The Zod schema string
+ */
 export declare function number(schema: Schema): string;

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

@@ -1,53 +1,85 @@
-import { _default, gt, lt, max, min, regex } from '../../../utils/index.js';
+/**
+ * Generates a Zod schema for number types based on OpenAPI schema.
+ * Supports float, float32, float64, and number formats.
+ *
+ * @param schema - The OpenAPI schema object
+ * @returns The Zod schema string
+ */
 export function number(schema) {
-    const parts = [
+    const o = [
         schema.format === 'float' || schema.format === 'float32'
             ? 'z.float32()'
             : schema.format === 'float64'
                 ? 'z.float64()'
                 : 'z.number()',
     ];
-    if (schema.pattern)
-        parts.push(regex(schema.pattern));
-    if (schema.minLength !== undefined)
-        parts.push(min(schema.minLength));
-    if (schema.maxLength !== undefined)
-        parts.push(max(schema.maxLength));
-    /* -------- lower bound -------- */
+    // minimum
     if (schema.minimum !== undefined) {
-        if (schema.minimum === 0) {
-            parts.push(schema.exclusiveMinimum ? '.positive()' : '.nonpositive()');
+        // > 0
+        // z.number().positive().safeParse(1) // { success: true }
+        // z.number().positive().safeParse(0) // { success: false }
+        if (schema.minimum === 0 && schema.exclusiveMinimum === true) {
+            o.push('.positive()');
         }
+        // >= 0
+        // z.number().nonnegative().safeParse(0) // { success: true }
+        // z.number().nonnegative().safeParse(-1) // { success: false }
+        else if (schema.minimum === 0 && schema.exclusiveMinimum === false) {
+            o.push('.nonnegative()');
+        }
+        // > value
+        // z.number().gt(100) // value > 100
         else if (schema.exclusiveMinimum === true) {
-            parts.push(gt(schema.minimum));
+            o.push(`.gt(${schema.minimum})`);
         }
+        // >= value
+        // z.number().min(100) // value >= 100
         else {
-            parts.push(min(schema.minimum));
+            o.push(`.min(${schema.minimum})`);
         }
     }
     else if (typeof schema.exclusiveMinimum === 'number') {
-        // numeric exclusiveMinimum without minimum
-        parts.push(gt(schema.exclusiveMinimum));
+        // > value (no minimum)
+        o.push(`.gt(${schema.exclusiveMinimum})`);
     }
-    /* -------- upper bound -------- */
+    // maximum
     if (schema.maximum !== undefined) {
-        if (schema.maximum === 0) {
-            parts.push(schema.exclusiveMaximum ? '.negative()' : '.nonnegative()');
+        // < 0
+        // z.number().negative().safeParse(-1) // { success: true }
+        // z.number().negative().safeParse(0) // { success: false }
+        if (schema.maximum === 0 && schema.exclusiveMaximum === true) {
+            o.push('.negative()');
+        }
+        // <= 0
+        // z.number().nonpositive().safeParse(0) // { success: true }
+        // z.number().nonpositive().safeParse(1) // { success: false }
+        else if (schema.maximum === 0 && schema.exclusiveMaximum === false) {
+            o.push('.nonpositive()');
         }
+        // < value
+        // z.number().lt(100) // value < 100
         else if (schema.exclusiveMaximum === true) {
-            parts.push(lt(schema.maximum));
+            o.push(`.lt(${schema.maximum})`);
         }
+        // <= value
+        // z.number().max(100) // value <= 100
         else {
-            parts.push(max(schema.maximum));
+            o.push(`.max(${schema.maximum})`);
         }
     }
     else if (typeof schema.exclusiveMaximum === 'number') {
-        // numeric exclusiveMaximum without maximum
-        parts.push(lt(schema.exclusiveMaximum));
+        // < value (no maximum)
+        o.push(`.lt(${schema.exclusiveMaximum})`);
+    }
+    // multipleOf
+    // z.number().multipleOf(2).safeParse(2) // { success: true }
+    // z.number().multipleOf(2).safeParse(1) // { success: false }
+    if (schema.multipleOf !== undefined) {
+        o.push(`.multipleOf(${schema.multipleOf})`);
     }
-    /* -------- default (always last) -------- */
+    // default (always last)
     if (schema.default !== undefined) {
-        parts.push(_default(schema.default));
+        o.push(`.default(${JSON.stringify(schema.default)})`);
     }
-    return parts.join('');
+    return o.join('');
 }

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

@@ -1,4 +1,4 @@
-import type { Schema } from '../../../openapi/types.js';
+import type { Schema } from '../../../openapi/index.js';
 /**
  * Generates a Zod object schema from an OpenAPI schema definition.
  *

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

@@ -1,8 +1,9 @@
 import { allOf } from '../../../helper/allof.js';
 import { anyOf } from '../../../helper/anyof.js';
 import { oneOf } from '../../../helper/oneof.js';
+import { zodToOpenAPI } from '../../../helper/zod-to-openapi.js';
 import { propertiesSchema } from '../helper/properties-schema.js';
-import { record } from './record.js';
+import { zod } from '../index.js';
 /**
  * Generates a Zod object schema from an OpenAPI schema definition.
  *
@@ -20,7 +21,7 @@ export function object(schema) {
             }
             return 'z.any()';
         }
-        return record(schema.additionalProperties);
+        return `z.record(z.string(),${zodToOpenAPI(zod(schema.additionalProperties), schema.additionalProperties)})`;
     }
     if (schema.properties) {
         const zodSchema = propertiesSchema(schema.properties, Array.isArray(schema.required) ? schema.required : []);

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

@@ -1,3 +1,3 @@
-import type { Schema } from '../../../openapi/types.js';
+import type { Schema } from '../../../openapi/index.js';
 /** Build a Zod string schema from an OpenAPI string schema. */
 export declare function string(schema: Schema): string;

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

@@ -1,4 +1,4 @@
-import { _default, length, max, min, regex } from '../../../utils/index.js';
+import { regex } from '../../../utils/index.js';
 const FORMAT_STRING = {
     email: '.email()',
     uuid: '.uuid()',
@@ -30,26 +30,24 @@ const FORMAT_STRING = {
 /** Build a Zod string schema from an OpenAPI string schema. */
 export function string(schema) {
     const parts = [];
-    /* ---------- base / format ---------- */
-    const fmt = schema.format && FORMAT_STRING[schema.format];
-    parts.push(fmt ? `z${fmt}` : 'z.string()');
-    /* ---------- pattern ---------- */
+    const format = schema.format && FORMAT_STRING[schema.format];
+    parts.push(format ? `z${format}` : 'z.string()');
     if (schema.pattern)
         parts.push(regex(schema.pattern));
-    /* ---------- length constraints ---------- */
-    const { minLength, maxLength } = schema;
     // special-case: equal min & max  → .length()
-    if (minLength !== undefined && maxLength !== undefined && minLength === maxLength) {
-        parts.push(length(minLength)); // utils.length() -> '.length(n)'
+    if (schema.minLength !== undefined &&
+        schema.maxLength !== undefined &&
+        schema.minLength === schema.maxLength) {
+        parts.push(`.length(${schema.minLength})`);
     }
     else {
-        if (minLength !== undefined)
-            parts.push(min(minLength));
-        if (maxLength !== undefined)
-            parts.push(max(maxLength));
+        if (schema.minLength !== undefined)
+            parts.push(`.min(${schema.minLength})`);
+        if (schema.maxLength !== undefined)
+            parts.push(`.max(${schema.maxLength})`);
     }
-    /* ---------- default (always last) ---------- */
+    /* default (always last)*/
     if (schema.default !== undefined)
-        parts.push(_default(schema.default));
+        parts.push(`.default(${JSON.stringify(schema.default)})`);
     return parts.join('');
 }

package/dist/generator/zod-openapi-hono/app/helper/docs.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAPI } from '../../../../openapi/types.js';
+import type { OpenAPI } from '../../../../openapi/index.js';
 /**
  * Extracts top-level OpenAPI document metadata.
  *

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

@@ -1,8 +1,8 @@
-import type { Parameters } from '../../../../../openapi/types.js';
+import type { Parameters } from '../../../../../openapi/index.js';
 /**
  * Generates a Zod schema string for a query parameter, with coercion applied based on its type.
  *
- * @param baseSchema - The base Zod schema string.
+ * @param schema - The base Zod schema string.
  * @param param - The OpenAPI parameter object.
  * @returns The transformed Zod schema string.
  *
@@ -11,4 +11,4 @@ import type { Parameters } from '../../../../../openapi/types.js';
  * - Applies `stringbool` to booleans to support string-based boolean input.
  * - Returns the base schema unchanged for other types or locations.
  */
-export declare function queryParameter(baseSchema: string, param: Parameters): string;
+export declare function queryParameter(schema: string, param: Parameters): string;

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

@@ -1,8 +1,7 @@
-import { coerce, stringbool } from '../../../../../utils/index.js';
 /**
  * Generates a Zod schema string for a query parameter, with coercion applied based on its type.
  *
- * @param baseSchema - The base Zod schema string.
+ * @param schema - The base Zod schema string.
  * @param param - The OpenAPI parameter object.
  * @returns The transformed Zod schema string.
  *
@@ -11,15 +10,15 @@ import { coerce, stringbool } from '../../../../../utils/index.js';
  * - Applies `stringbool` to booleans to support string-based boolean input.
  * - Returns the base schema unchanged for other types or locations.
  */
-export function queryParameter(baseSchema, param) {
+export function queryParameter(schema, param) {
     if (param.in === 'query' && param.schema.type === 'number') {
-        return coerce(baseSchema);
+        return `z.coerce.${schema.replace('z.', '')}`;
     }
     if (param.in === 'query' && param.schema.type === 'boolean') {
-        return stringbool(baseSchema);
+        return schema.replace('boolean', 'stringbool');
     }
     if (param.in === 'query' && param.schema.type === 'date') {
-        return coerce(baseSchema);
+        return `z.coerce.${schema.replace('z.', '')}`;
     }
-    return baseSchema;
+    return schema;
 }

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

@@ -1,4 +1,3 @@
-import { schema } from '../../../../../utils/index.js';
 /**
  * Generates an array of Zod validator strings from OpenAPI parameter objects.
  *
@@ -20,7 +19,9 @@ export function requestParamsArray(paramsObj) {
         const obj = paramsObj[section];
         // 2.1 process only if object is not empty
         if (Object.keys(obj).length) {
-            const s = schema(obj);
+            const s = `z.object({${Object.entries(obj)
+                .map(([key, val]) => `${key}:${val}`)
+                .join(',')}})`;
             // path is params convention
             if (section === 'path') {
                 return `params:${s}`;

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

@@ -4,7 +4,7 @@ import type { Content } from '../../../../../../openapi/index.js';
  *
  * @param required - Indicates if the request body is required.
  * @param content - OpenAPI content object describing media types and schemas.
- * @param zodSchema - Zod schema string used for validation.
+ * @param schema - Zod schema string used for validation.
  * @returns A formatted request body definition string, or an empty string if unsupported.
  */
-export declare function requestBody(required: boolean, content: Content, zodSchema: string): string;
+export declare function requestBody(required: boolean, content: Content, schema: string): string;

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

@@ -1,13 +1,13 @@
-import { coerce, isUniqueContentSchema } from '../../../../../../utils/index.js';
+import { isUniqueContentSchema } from '../../../../../../utils/index.js';
 /**
  * Generates a request body configuration string for a route.
  *
  * @param required - Indicates if the request body is required.
  * @param content - OpenAPI content object describing media types and schemas.
- * @param zodSchema - Zod schema string used for validation.
+ * @param schema - Zod schema string used for validation.
  * @returns A formatted request body definition string, or an empty string if unsupported.
  */
-export function requestBody(required, content, zodSchema) {
+export function requestBody(required, content, schema) {
     const contentTypes = Object.keys(content);
     if (contentTypes.length === 0)
         return '';
@@ -18,11 +18,11 @@ export function requestBody(required, content, zodSchema) {
         const contentParts = [];
         for (const contentType of contentTypes) {
             // z.date() → z.coerce.date()
-            if (zodSchema.includes('z.date()')) {
-                contentParts.push(`'${contentType}':{schema:${coerce(zodSchema)}}`);
+            if (schema.includes('z.date()')) {
+                contentParts.push(`'${contentType}':{schema:z.coerce.${schema.replace('z.', '')}}`);
             }
             else {
-                contentParts.push(`'${contentType}':{schema:${zodSchema}}`);
+                contentParts.push(`'${contentType}':{schema:${schema}}`);
             }
         }
         return `body:{required:${required},content:{${contentParts.join(',')}},},`;

package/dist/helper/allof.d.ts

@@ -1,4 +1,4 @@
-import type { Schema } from '../openapi/types.js';
+import type { Schema } from '../openapi/index.js';
 /**
  * Converts an OpenAPI `allOf` schema into a Zod intersection schema.
  *

package/dist/helper/allof.js

@@ -1,5 +1,4 @@
 import { zodSchemaFromSubSchema } from '../generator/zod/helper/zod-schema-from-sub-schema.js';
-import { intersection, isNullableSchema } from '../utils/index.js';
 /**
  * Converts an OpenAPI `allOf` schema into a Zod intersection schema.
  *
@@ -18,7 +17,12 @@ export function allOf(schema) {
         return 'z.any()';
     }
     const { nullable, schemas } = schema.allOf.reduce((acc, subSchema) => {
-        if (isNullableSchema(subSchema)) {
+        const isNullable = typeof subSchema === 'object' &&
+            subSchema !== null &&
+            'nullable' in subSchema &&
+            subSchema.nullable === true &&
+            Object.keys(subSchema).length === 1;
+        if (isNullable) {
             acc.nullable = true;
             return acc;
         }
@@ -32,5 +36,5 @@ export function allOf(schema) {
     if (schemas.length === 1) {
         return nullable ? `${schemas[0]}.nullable()` : schemas[0];
     }
-    return `${intersection(schemas)}${nullable ? '.nullable()' : ''}`;
+    return `z.intersection(${schemas.join(',')})${nullable ? '.nullable()' : ''}`;
 }

package/dist/helper/anyof.d.ts

@@ -1,4 +1,4 @@
-import type { Schema } from '../openapi/types.js';
+import type { Schema } from '../openapi/index.js';
 /**
  * Converts an OpenAPI `anyOf` schema into a Zod union expression.
  *