hono-takibi 0.4.3 → 0.4.4

package/dist/generators/zod/generate-zod-enum.js

@@ -7,5 +7,17 @@ function generateZodEnum(schema) {
         const openapi_example = (0, generate_zod_to_openapi_1.generateZodToOpenAPI)(schema.example);
         return `z.enum(${JSON.stringify(schema.enum)})${openapi_example}`;
     }
+    // number
+    if (schema.type === 'number' && schema.enum) {
+        return `z.literal(${schema.enum})`;
+    }
+    // bigint
+    if (schema.type === 'bigint' && schema.enum) {
+        return `z.literal(${schema.enum}n)`;
+    }
+    // boolean
+    if (schema.type === 'boolean' && schema.enum) {
+        return `z.literal(${schema.enum})`;
+    }
     return `z.enum(${JSON.stringify(schema.enum)})`;
 }

package/dist/generators/zod/generate-zod-number-schema.d.ts

@@ -5,6 +5,8 @@ type GenerateZodNumberSchemaParams = {
     maxLength?: number;
     minimum?: number;
     maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
     default?: DefaultValue;
     example?: ExampleValue;
     paramName?: string;

package/dist/generators/zod/generate-zod-number-schema.js

@@ -24,12 +24,11 @@ function generateZodNumberSchema(args) {
     // maxLength
     if (args.maxLength)
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maxLength));
-    // 0 falsy value
     // minimum
-    if (typeof args.minimum === 'number')
+    if (args.minimum)
         validations.push((0, generate_zod_min_1.generateZodMin)(args.minimum));
     // maximum
-    if (typeof args.maximum === 'number')
+    if (args.maximum)
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maximum));
     // default
     if (args.default)
@@ -37,5 +36,33 @@ function generateZodNumberSchema(args) {
     // example
     if (args.example)
         validations.push((0, generate_zod_to_openapi_1.generateZodToOpenAPI)(args.example, args.paramName, args.isPath));
+    // 0 falsy value
+    // minimum === 0
+    // positive
+    if (args.minimum === 0 && args.exclusiveMinimum) {
+        validations.push('.positive()');
+    }
+    // nonpositive
+    if (args.minimum === 0 && !args.exclusiveMinimum) {
+        validations.push('.nonpositive()');
+    }
+    // negative
+    if (args.maximum === 0 && args.exclusiveMaximum) {
+        validations.push('.negative()');
+    }
+    // gt
+    if (args.minimum) {
+        if (args.minimum > 0 && args.exclusiveMinimum) {
+            const res = `.gt(${args.minimum})`;
+            validations.push(res);
+        }
+    }
+    // lt
+    if (args.maximum) {
+        if (args.maximum > 0 && args.exclusiveMaximum) {
+            const res = `.lt(${args.maximum})`;
+            validations.push(res);
+        }
+    }
     return validations.join('');
 }

package/dist/generators/zod/generate-zod-string-schema.d.ts

@@ -4,6 +4,7 @@ type GenerateZodStringSchemaParams = {
     minLength?: number;
     maxLength?: number;
     format?: FormatString;
+    nullable?: boolean;
     default?: DefaultValue;
     example?: ExampleValue;
     paramName?: string;

package/dist/generators/zod/generate-zod-string-schema.js

@@ -61,6 +61,9 @@ function generateZodStringSchema(args) {
     // default
     if (args.default)
         validations.push((0, generate_zod_default_1.generateZodDefault)(args.default));
+    // nullable
+    if (args.nullable)
+        validations.push('.nullable()');
     // example
     if (args.example)
         validations.push((0, generate_zod_to_openapi_1.generateZodToOpenAPI)(args.example, args.paramName, args.isPath));

package/dist/generators/zod/schema/generate-zod-schema.js

@@ -12,6 +12,8 @@ const generate_oneof_code_1 = require("../../zod-openapi-hono/openapi/component/
 const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
 const generate_zod_object_1 = require("../generate-zod-object");
 const generate_zod_enum_1 = require("../generate-zod-enum");
+const generate_zod_max_1 = require("../generate-zod-max");
+const generate_zod_min_1 = require("../generate-zod-min");
 /**
  * Mapping of OpenAPI/JSON Schema types to Zod schema strings
  *
@@ -106,6 +108,7 @@ function generateZodSchema(config, schema, paramName, isPath) {
             minLength: schema.minLength,
             maxLength: schema.maxLength,
             format: schema.format && (0, is_format_string_1.isFormatString)(schema.format) ? schema.format : undefined,
+            nullable: schema.nullable,
             default: schema.default,
             example: schema.example,
             paramName,
@@ -114,7 +117,7 @@ function generateZodSchema(config, schema, paramName, isPath) {
     }
     // number
     if (schema.type === 'number') {
-        return (0, generate_zod_number_schema_1.generateZodNumberSchema)({
+        const res = (0, generate_zod_number_schema_1.generateZodNumberSchema)({
             pattern: schema.pattern,
             minLength: schema.minLength,
             maxLength: schema.maxLength,
@@ -124,7 +127,18 @@ function generateZodSchema(config, schema, paramName, isPath) {
             example: schema.example,
             paramName,
             isPath,
+            exclusiveMinimum: schema.exclusiveMinimum,
+            exclusiveMaximum: schema.exclusiveMaximum,
         });
+        // gt
+        if (res.includes(`min(${schema.minimum})`) && res.includes(`gt(${schema.minimum})`)) {
+            return res.replace(`.min(${schema.minimum})`, '');
+        }
+        // lt
+        if (res.includes(`max(${schema.maximum})`) && res.includes(`lt(${schema.maximum})`)) {
+            return res.replace(`.max(${schema.maximum})`, '');
+        }
+        return res;
     }
     // integer
     if (schema.type === 'integer') {
@@ -140,8 +154,28 @@ function generateZodSchema(config, schema, paramName, isPath) {
         });
     }
     // array
-    if (schema.type === 'array' && schema.items)
+    if (schema.type === 'array' && schema.items) {
+        if (schema.minItems && schema.maxItems) {
+            const minItemsSchema = (0, generate_zod_min_1.generateZodMin)(schema.minItems);
+            const maxItemsSchema = (0, generate_zod_max_1.generateZodMax)(schema.maxItems);
+            const zodArray = (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+            const res = `${zodArray}${minItemsSchema}${maxItemsSchema}`;
+            return res;
+        }
+        if (schema.minItems) {
+            const minItemsSchema = (0, generate_zod_min_1.generateZodMin)(schema.minItems);
+            const zodArray = (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+            const res = `${zodArray}${minItemsSchema}`;
+            return res;
+        }
+        if (schema.maxItems) {
+            const maxItemsSchema = (0, generate_zod_max_1.generateZodMax)(schema.maxItems);
+            const zodArray = (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+            const res = `${zodArray}${maxItemsSchema}`;
+            return res;
+        }
         return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
+    }
     if (schema.allOf) {
         return (0, generate_allof_code_1.generateAllOfCode)(schema, config);
     }

package/dist/types/index.d.ts

@@ -129,6 +129,10 @@ export type Schema = {
     maxLength?: number;
     minimum?: number;
     maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    minItems?: number;
+    maxItems?: number;
     default?: DefaultValue;
     example?: ExampleValue;
     properties?: Record<string, Schema>;

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.4.3",
+  "version": "0.4.4",
   "license": "MIT",
   "keywords": [
     "hono",