hono-takibi 0.4.3 → 0.4.5

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-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.d.ts

@@ -0,0 +1,23 @@
+import type { DefaultValue, ExampleValue } from '../../types';
+type GenerateZodNumberParams = {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean;
+    exclusiveMaximum?: boolean;
+    default?: DefaultValue;
+    example?: ExampleValue;
+    paramName?: string;
+    isPath?: boolean;
+};
+/**
+ * Generates zod  number
+ *
+ * @function generateZodNumber
+ * @param args - zod number params
+ * @returns zod number
+ */
+export declare function generateZodNumber(args: GenerateZodNumberParams): string;
+export {};

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 zod  number
+ *
+ * @function generateZodNumber
+ * @param args - zod number params
+ * @returns zod number
+ */
+function generateZodNumber(args) {
+    const validations = ['z.number()'];
+    // pattern
+    if (args.pattern) {
+        validations.push((0, generate_zod_regex_1.generateZodRegex)(args.pattern));
+    }
+    // minLength
+    if (args.minLength) {
+        validations.push((0, generate_zod_min_1.generateZodMin)(args.minLength));
+    }
+    // maxLength
+    if (args.maxLength) {
+        validations.push((0, generate_zod_max_1.generateZodMax)(args.maxLength));
+    }
+    // minimum
+    if (args.minimum) {
+        validations.push((0, generate_zod_min_1.generateZodMin)(args.minimum));
+    }
+    // maximum
+    if (args.maximum) {
+        validations.push((0, generate_zod_max_1.generateZodMax)(args.maximum));
+    }
+    // default
+    if (args.default) {
+        validations.push((0, generate_zod_default_1.generateZodDefault)(args.default));
+    }
+    // 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) {
+            validations.push((0, generate_zod_gt_1.generateZodGt)(args.minimum));
+        }
+    }
+    // lt
+    if (args.maximum) {
+        if (args.maximum > 0 && args.exclusiveMaximum) {
+            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,44 +1,45 @@
 import type { FormatString, ExampleValue, DefaultValue } from '../../types';
-type GenerateZodStringSchemaParams = {
+type GenerateZodStringParams = {
     pattern?: string;
     minLength?: number;
     maxLength?: number;
     format?: FormatString;
+    nullable?: boolean;
     default?: DefaultValue;
     example?: ExampleValue;
     paramName?: string;
     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,
@@ -46,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,25 +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((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");
@@ -12,6 +12,12 @@ 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");
+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
  *
@@ -101,20 +107,32 @@ 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,
             format: schema.format && (0, is_format_string_1.isFormatString)(schema.format) ? schema.format : undefined,
+            nullable: schema.nullable,
             default: schema.default,
             example: schema.example,
             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') {
-        return (0, generate_zod_number_schema_1.generateZodNumberSchema)({
+        const res = (0, generate_zod_number_1.generateZodNumber)({
             pattern: schema.pattern,
             minLength: schema.minLength,
             maxLength: schema.maxLength,
@@ -124,7 +142,22 @@ 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})`) &&
+            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})`) &&
+            schema.maximum) {
+            return (0, strip_max_if_lt_exist_helper_1.stripMaxIfLtExistHelper)(res, schema.maximum);
+        }
+        return res;
     }
     // integer
     if (schema.type === 'integer') {
@@ -140,8 +173,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.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"

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

@@ -1,21 +0,0 @@
-import type { DefaultValue, ExampleValue } from '../../types';
-type GenerateZodNumberSchemaParams = {
-    pattern?: string;
-    minLength?: number;
-    maxLength?: number;
-    minimum?: number;
-    maximum?: number;
-    default?: DefaultValue;
-    example?: ExampleValue;
-    paramName?: string;
-    isPath?: boolean;
-};
-/**
- * Generates a zod schema for a number.
- *
- * @function generateZodNumberSchema
- * @param args - The parameters to generate the zod schema.
- * @returns A zod schema for a number.
- */
-export declare function generateZodNumberSchema(args: GenerateZodNumberSchemaParams): string;
-export {};

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

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateZodNumberSchema = generateZodNumberSchema;
-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_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.
- *
- * @function generateZodNumberSchema
- * @param args - The parameters to generate the zod schema.
- * @returns A zod schema for a number.
- */
-function generateZodNumberSchema(args) {
-    const validations = ['z.number()'];
-    // pattern
-    if (args.pattern)
-        validations.push((0, generate_zod_regex_1.generateZodRegex)(args.pattern));
-    // minLength
-    if (args.minLength)
-        validations.push((0, generate_zod_min_1.generateZodMin)(args.minLength));
-    // maxLength
-    if (args.maxLength)
-        validations.push((0, generate_zod_max_1.generateZodMax)(args.maxLength));
-    // 0 falsy value
-    // minimum
-    if (typeof args.minimum === 'number')
-        validations.push((0, generate_zod_min_1.generateZodMin)(args.minimum));
-    // maximum
-    if (typeof args.maximum === 'number')
-        validations.push((0, generate_zod_max_1.generateZodMax)(args.maximum));
-    // default
-    if (args.default)
-        validations.push((0, generate_zod_default_1.generateZodDefault)(args.default));
-    // example
-    if (args.example)
-        validations.push((0, generate_zod_to_openapi_1.generateZodToOpenAPI)(args.example, args.paramName, args.isPath));
-    return validations.join('');
-}