hono-takibi 0.4.4 → 0.4.5

package/dist/generators/zod/generate-zod-gt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate Zod gt validation
+ *
+ * @param minimum - Minimum value
+ * @returns Zod gt validation string
+ */
+export declare function generateZodGt(minimum: number): string;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodGt = generateZodGt;
+/**
+ * Generate Zod gt validation
+ *
+ * @param minimum - Minimum value
+ * @returns Zod gt validation string
+ */
+function generateZodGt(minimum) {
+    return `.gt(${minimum})`;
+}

package/dist/generators/zod/generate-zod-length.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates a Zod length validation string
+ *
+ * @param length - The length value to validate against
+ * @returns The Zod length validation string
+ *
+ * @example
+ * const lengthValidation = generateZodLength(10)
+ * // Returns: 'length(10)'
+ */
+export declare function generateZodLength(length: number): string;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodLength = generateZodLength;
+/**
+ * Generates a Zod length validation string
+ *
+ * @param length - The length value to validate against
+ * @returns The Zod length validation string
+ *
+ * @example
+ * const lengthValidation = generateZodLength(10)
+ * // Returns: 'length(10)'
+ */
+function generateZodLength(length) {
+    return `.length(${length})`;
+}

package/dist/generators/zod/generate-zod-lt.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate Zod lt validation
+ *
+ * @param maximum - Maximum value
+ * @returns Zod lt validation string
+ */
+export declare function generateZodLt(maximum: number): string;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodLt = generateZodLt;
+/**
+ * Generate Zod lt validation
+ *
+ * @param maximum - Maximum value
+ * @returns Zod lt validation string
+ */
+function generateZodLt(maximum) {
+    return `.lt(${maximum})`;
+}

package/dist/generators/zod/generate-zod-nullable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a zod nullable validation
+ *
+ * @returns zod nullable
+ */
+export declare function generateZodNullable(): string;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodNullable = generateZodNullable;
+/**
+ * Generates a zod nullable validation
+ *
+ * @returns zod nullable
+ */
+function generateZodNullable() {
+    return '.nullable()';
+}

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

@@ -1,5 +1,5 @@
 import type { DefaultValue, ExampleValue } from '../../types';
-type GenerateZodNumberSchemaParams = {
+type GenerateZodNumberParams = {
     pattern?: string;
     minLength?: number;
     maxLength?: number;
@@ -13,11 +13,11 @@ type GenerateZodNumberSchemaParams = {
     isPath?: boolean;
 };
 /**
- * Generates a zod schema for a number.
+ * Generates zod  number
  *
- * @function generateZodNumberSchema
- * @param args - The parameters to generate the zod schema.
- * @returns A zod schema for a number.
+ * @function generateZodNumber
+ * @param args - zod number params
+ * @returns zod number
  */
-export declare function generateZodNumberSchema(args: GenerateZodNumberSchemaParams): string;
+export declare function generateZodNumber(args: GenerateZodNumberParams): string;
 export {};

package/dist/generators/zod/{generate-zod-number-schema.js → generate-zod-number.js}

@@ -1,41 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateZodNumberSchema = generateZodNumberSchema;
+exports.generateZodNumber = generateZodNumber;
 const generate_zod_default_1 = require("./generate-zod-default");
+const generate_zod_gt_1 = require("./generate-zod-gt");
+const generate_zod_lt_1 = require("./generate-zod-lt");
 const generate_zod_max_1 = require("./generate-zod-max");
 const generate_zod_min_1 = require("./generate-zod-min");
 const generate_zod_regex_1 = require("./generate-zod-regex");
 const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
 /**
- * Generates a zod schema for a number.
+ * Generates zod  number
  *
- * @function generateZodNumberSchema
- * @param args - The parameters to generate the zod schema.
- * @returns A zod schema for a number.
+ * @function generateZodNumber
+ * @param args - zod number params
+ * @returns zod number
  */
-function generateZodNumberSchema(args) {
+function generateZodNumber(args) {
     const validations = ['z.number()'];
     // pattern
-    if (args.pattern)
+    if (args.pattern) {
         validations.push((0, generate_zod_regex_1.generateZodRegex)(args.pattern));
+    }
     // minLength
-    if (args.minLength)
+    if (args.minLength) {
         validations.push((0, generate_zod_min_1.generateZodMin)(args.minLength));
+    }
     // maxLength
-    if (args.maxLength)
+    if (args.maxLength) {
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maxLength));
+    }
     // minimum
-    if (args.minimum)
+    if (args.minimum) {
         validations.push((0, generate_zod_min_1.generateZodMin)(args.minimum));
+    }
     // maximum
-    if (args.maximum)
+    if (args.maximum) {
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maximum));
+    }
     // default
-    if (args.default)
+    if (args.default) {
         validations.push((0, generate_zod_default_1.generateZodDefault)(args.default));
+    }
     // example
-    if (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
@@ -53,15 +62,13 @@ function generateZodNumberSchema(args) {
     // gt
     if (args.minimum) {
         if (args.minimum > 0 && args.exclusiveMinimum) {
-            const res = `.gt(${args.minimum})`;
-            validations.push(res);
+            validations.push((0, generate_zod_gt_1.generateZodGt)(args.minimum));
         }
     }
     // lt
     if (args.maximum) {
         if (args.maximum > 0 && args.exclusiveMaximum) {
-            const res = `.lt(${args.maximum})`;
-            validations.push(res);
+            validations.push((0, generate_zod_lt_1.generateZodLt)(args.maximum));
         }
     }
     return validations.join('');

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

@@ -1,5 +1,5 @@
 import type { FormatString, ExampleValue, DefaultValue } from '../../types';
-type GenerateZodStringSchemaParams = {
+type GenerateZodStringParams = {
     pattern?: string;
     minLength?: number;
     maxLength?: number;
@@ -11,35 +11,35 @@ type GenerateZodStringSchemaParams = {
     isPath?: boolean;
 };
 /**
- * Generates a Zod schema string for string validation
+ * Generates zod string schema
  *
- * @function generateZodStringSchema
- * @param args - Parameters for string schema generation
- * @returns Generated Zod schema string with chained validations
+ * @function generateZodString
+ * @param args - zod string params
+ * @returns zod string
  *
  * @example
  * // Basic string validation
- * generateZodStringSchema({})
+ * generateZodString({})
  * // Returns: 'z.string()'
  *
  * @example
  * // With regex pattern
- * generateZodStringSchema({ pattern: '^[A-Z]+$' })
+ * generateZodString({ pattern: '^[A-Z]+$' })
  * // Returns: 'z.string().regex(/^[A-Z]+$/)'
  *
  * @example
  * // With length constraints
- * generateZodStringSchema({ minLength: 3, maxLength: 10 })
+ * generateZodString({ minLength: 3, maxLength: 10 })
  * // Returns: 'z.string().min(3).max(10)'
  *
  * @example
  * // With format
- * generateZodStringSchema({ format: 'email' })
+ * generateZodString({ format: 'email' })
  * // Returns: 'z.string().email()'
  *
  * @example
  * // Combined validations
- * generateZodStringSchema({
+ * generateZodString({
  *   pattern: '^[a-z]+$',
  *   minLength: 3,
  *   maxLength: 10,
@@ -47,5 +47,5 @@ type GenerateZodStringSchemaParams = {
  * })
  * // Returns: 'z.string().regex(/^[a-z]+$/).min(3).max(10).email()'
  */
-export declare function generateZodStringSchema(args: GenerateZodStringSchemaParams): string;
+export declare function generateZodString(args: GenerateZodStringParams): string;
 export {};

package/dist/generators/zod/{generate-zod-string-schema.js → generate-zod-string.js}

@@ -1,42 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateZodStringSchema = generateZodStringSchema;
+exports.generateZodString = generateZodString;
 const get_zod_string_format_1 = require("../../core/zod/get-zod-string-format");
 const generate_zod_default_1 = require("./generate-zod-default");
 const generate_zod_max_1 = require("./generate-zod-max");
 const generate_zod_min_1 = require("./generate-zod-min");
+const generate_zod_nullable_1 = require("./generate-zod-nullable");
 const generate_zod_regex_1 = require("./generate-zod-regex");
 const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
 /**
- * Generates a Zod schema string for string validation
+ * Generates zod string schema
  *
- * @function generateZodStringSchema
- * @param args - Parameters for string schema generation
- * @returns Generated Zod schema string with chained validations
+ * @function generateZodString
+ * @param args - zod string params
+ * @returns zod string
  *
  * @example
  * // Basic string validation
- * generateZodStringSchema({})
+ * generateZodString({})
  * // Returns: 'z.string()'
  *
  * @example
  * // With regex pattern
- * generateZodStringSchema({ pattern: '^[A-Z]+$' })
+ * generateZodString({ pattern: '^[A-Z]+$' })
  * // Returns: 'z.string().regex(/^[A-Z]+$/)'
  *
  * @example
  * // With length constraints
- * generateZodStringSchema({ minLength: 3, maxLength: 10 })
+ * generateZodString({ minLength: 3, maxLength: 10 })
  * // Returns: 'z.string().min(3).max(10)'
  *
  * @example
  * // With format
- * generateZodStringSchema({ format: 'email' })
+ * generateZodString({ format: 'email' })
  * // Returns: 'z.string().email()'
  *
  * @example
  * // Combined validations
- * generateZodStringSchema({
+ * generateZodString({
  *   pattern: '^[a-z]+$',
  *   minLength: 3,
  *   maxLength: 10,
@@ -44,28 +45,35 @@ const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
  * })
  * // Returns: 'z.string().regex(/^[a-z]+$/).min(3).max(10).email()'
  */
-function generateZodStringSchema(args) {
+function generateZodString(args) {
     const validations = ['z.string()'];
     // pattern
-    if (args.pattern)
+    if (args.pattern) {
         validations.push((0, generate_zod_regex_1.generateZodRegex)(args.pattern));
+    }
     // minLength
-    if (args.minLength)
+    if (args.minLength) {
         validations.push((0, generate_zod_min_1.generateZodMin)(args.minLength));
+    }
     // maxLength
-    if (args.maxLength)
+    if (args.maxLength) {
         validations.push((0, generate_zod_max_1.generateZodMax)(args.maxLength));
+    }
     // format
-    if (args.format)
+    if (args.format) {
         validations.push((0, get_zod_string_format_1.getZodFormatString)(args.format));
+    }
     // default
-    if (args.default)
+    if (args.default) {
         validations.push((0, generate_zod_default_1.generateZodDefault)(args.default));
+    }
     // nullable
-    if (args.nullable)
-        validations.push('.nullable()');
+    if (args.nullable) {
+        validations.push((0, generate_zod_nullable_1.generateZodNullable)());
+    }
     // example
-    if (args.example)
+    if (args.example) {
         validations.push((0, generate_zod_to_openapi_1.generateZodToOpenAPI)(args.example, args.paramName, args.isPath));
+    }
     return validations.join('');
 }

package/dist/generators/zod/helper/strip-max-if-lt-exist-helper.d.ts

@@ -0,0 +1 @@
+export declare function stripMaxIfLtExistHelper(str: string, maximum: number): string;

package/dist/generators/zod/helper/strip-max-if-lt-exist-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripMaxIfLtExistHelper = stripMaxIfLtExistHelper;
+function stripMaxIfLtExistHelper(str, maximum) {
+    return str.replace(`.max(${maximum})`, '');
+}

package/dist/generators/zod/helper/strip-min-if-gt-exist-helper.d.ts

@@ -0,0 +1 @@
+export declare function stripMinIfgTExistHelper(str: string, minimum: number): string;

package/dist/generators/zod/helper/strip-min-if-gt-exist-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripMinIfgTExistHelper = stripMinIfgTExistHelper;
+function stripMinIfgTExistHelper(str, minimum) {
+    return str.replace(`.min(${minimum})`, '');
+}

package/dist/generators/zod/helper/strip-min-max-exist-helper.d.ts

@@ -0,0 +1 @@
+export declare function stripMinMaxExistHelper(str: string, min: number, max: number): string;

package/dist/generators/zod/helper/strip-min-max-exist-helper.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripMinMaxExistHelper = stripMinMaxExistHelper;
+function stripMinMaxExistHelper(str, min, max) {
+    return str.replace(`.min(${min})`, '').replace(`.max(${max})`, '');
+}

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

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodSchema = generateZodSchema;
 const generate_zod_array_1 = require("../generate-zod-array");
-const generate_zod_string_schema_1 = require("../generate-zod-string-schema");
+const generate_zod_string_1 = require("../generate-zod-string");
 const is_format_string_1 = require("../../../core/validator/is-format-string");
-const generate_zod_number_schema_1 = require("../generate-zod-number-schema");
+const generate_zod_number_1 = require("../generate-zod-number");
 const generate_zod_integer_schema_1 = require("../generate-zod-integer-schema");
 const generate_allof_code_1 = require("../../zod-openapi-hono/openapi/component/allof/generate-allof-code");
 const generate_anyof_code_1 = require("../../zod-openapi-hono/openapi/component/anyof/generate-anyof-code");
@@ -14,6 +14,10 @@ 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");
+const strip_min_if_gt_exist_helper_1 = require("../helper/strip-min-if-gt-exist-helper");
+const strip_max_if_lt_exist_helper_1 = require("../helper/strip-max-if-lt-exist-helper");
+const generate_zod_length_1 = require("../generate-zod-length");
+const strip_min_max_exist_helper_1 = require("../helper/strip-min-max-exist-helper");
 /**
  * Mapping of OpenAPI/JSON Schema types to Zod schema strings
  *
@@ -103,7 +107,7 @@ function generateZodSchema(config, schema, paramName, isPath) {
     }
     // string
     if (schema.type === 'string') {
-        return (0, generate_zod_string_schema_1.generateZodStringSchema)({
+        const res = (0, generate_zod_string_1.generateZodString)({
             pattern: schema.pattern,
             minLength: schema.minLength,
             maxLength: schema.maxLength,
@@ -114,10 +118,21 @@ function generateZodSchema(config, schema, paramName, isPath) {
             paramName,
             isPath,
         });
+        // length
+        if (schema.minLength &&
+            schema.maxLength &&
+            schema.maxLength &&
+            schema.minLength === schema.maxLength &&
+            res.includes(`min(${schema.minLength})`) &&
+            res.includes(`max(${schema.maxLength})`)) {
+            const property = (0, strip_min_max_exist_helper_1.stripMinMaxExistHelper)(res, schema.minLength, schema.maxLength);
+            return `${property}${(0, generate_zod_length_1.generateZodLength)(schema.minLength)}`;
+        }
+        return res;
     }
     // number
     if (schema.type === 'number') {
-        const res = (0, generate_zod_number_schema_1.generateZodNumberSchema)({
+        const res = (0, generate_zod_number_1.generateZodNumber)({
             pattern: schema.pattern,
             minLength: schema.minLength,
             maxLength: schema.maxLength,
@@ -131,12 +146,16 @@ function generateZodSchema(config, schema, paramName, isPath) {
             exclusiveMaximum: schema.exclusiveMaximum,
         });
         // gt
-        if (res.includes(`min(${schema.minimum})`) && res.includes(`gt(${schema.minimum})`)) {
-            return res.replace(`.min(${schema.minimum})`, '');
+        if (res.includes(`min(${schema.minimum})`) &&
+            res.includes(`gt(${schema.minimum})`) &&
+            schema.minimum) {
+            return (0, strip_min_if_gt_exist_helper_1.stripMinIfgTExistHelper)(res, schema.minimum);
         }
         // lt
-        if (res.includes(`max(${schema.maximum})`) && res.includes(`lt(${schema.maximum})`)) {
-            return res.replace(`.max(${schema.maximum})`, '');
+        if (res.includes(`max(${schema.maximum})`) &&
+            res.includes(`lt(${schema.maximum})`) &&
+            schema.maximum) {
+            return (0, strip_max_if_lt_exist_helper_1.stripMaxIfLtExistHelper)(res, schema.maximum);
         }
         return res;
     }

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.4",
+  "version": "0.4.5",
   "license": "MIT",
   "keywords": [
     "hono",
@@ -34,6 +34,7 @@
     }
   },
   "scripts": {
+    "takibis": "pnpm build && tsx index.ts",
     "dev": "vite --host",
     "deps": "rm -rf node_modules && pnpm install",
     "build": "tsc",
@@ -50,6 +51,7 @@
     "@hono/zod-openapi": "^0.18.3",
     "@types/node": "^22.10.2",
     "@vitest/coverage-v8": "^2.1.8",
+    "tsx": "^4.7.1",
     "typescript": "^5.7.2",
     "vite": "^6.1.0",
     "vitest": "^2.1.8"