hono-takibi 0.6.2 → 0.6.3

package/dist/core/helper/get-to-safe-identifier-helper.d.ts

@@ -0,0 +1,6 @@
+/**
+ * getToSafeIdentifierHelper
+ * @param {string} str - The string to be converted to a safe identifier
+ * @returns {string} - A normalized, safe identifier
+ */
+export declare function getToSafeIdentifierHelper(str: string): string;

package/dist/core/helper/get-to-safe-identifier-helper.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToSafeIdentifierHelper = getToSafeIdentifierHelper;
+/**
+ * getToSafeIdentifierHelper
+ * @param {string} str - The string to be converted to a safe identifier
+ * @returns {string} - A normalized, safe identifier
+ */
+function getToSafeIdentifierHelper(str) {
+    const trimmed = str.trim();
+    if (trimmed.includes('-')) {
+        return trimmed.replace(/\s*-\s*/g, '_');
+    }
+    return trimmed;
+}

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

@@ -20,13 +20,48 @@ function generateZodEnum(schema) {
     if (schema.type === 'number' && schema.enum) {
         return `z.literal(${schema.enum})`;
     }
+    // integer
+    if (schema.type === 'integer' && schema.enum) {
+        if (schema.enum.length > 1) {
+            const literals = schema.enum.map((value) => `z.literal(${value})`);
+            return `z.union([${literals}])`;
+        }
+        return `z.literal(${schema.enum[0]})`;
+    }
     // bigint
     if (schema.type === 'bigint' && schema.enum) {
-        return `z.literal(${schema.enum}n)`;
+        return `z.literal(${schema.enum})`;
+    }
+    // array
+    if (schema.type === 'array' && Array.isArray(schema.enum)) {
+        if (schema.enum.length === 1 && Array.isArray(schema.enum[0])) {
+            const tupleItems = schema.enum[0].map((item) => `z.literal(${item})`).join(', ');
+            return `z.tuple([${tupleItems}])`;
+        }
+        // union
+        const unionParts = schema.enum.map((value) => {
+            if (Array.isArray(value)) {
+                const tupleItems = value.map((item) => `z.literal(${item})`);
+                return `z.tuple([${tupleItems}])`;
+            }
+            return `z.literal(${value})`;
+        });
+        return `z.union([${unionParts}])`;
     }
     // boolean
     if (schema.type === 'boolean' && schema.enum) {
         return `z.literal(${schema.enum})`;
     }
-    return `z.enum(${JSON.stringify(schema.enum)})`;
+    // enum.length > 1
+    if (schema.enum.length > 1) {
+        const allStrings = schema.enum.every((v) => typeof v === 'string');
+        if (allStrings) {
+            return `z.enum(${JSON.stringify(schema.enum)})`;
+        }
+        const unionLiterals = schema.enum.map((value) => value === null
+            ? 'z.null()'
+            : `z.literal(${typeof value === 'string' ? `'${value}'` : value})`);
+        return `z.union([${unionLiterals}])`;
+    }
+    return `z.literal(${typeof schema.enum[0] === 'string' ? `'${schema.enum[0]}'` : schema.enum[0]})`;
 }

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

@@ -51,11 +51,15 @@ function generateZodNumber(args) {
     }
     // nonpositive
     if (args.minimum === 0 && !args.exclusiveMinimum) {
-        validations.push('.nonpositive()');
+        if (!args.default) {
+            validations.push('.nonpositive()');
+        }
     }
     // negative
     if (args.maximum === 0 && args.exclusiveMaximum) {
-        validations.push('.negative()');
+        if (!args.default) {
+            validations.push('.negative()');
+        }
     }
     // gt
     if (args.minimum) {

package/dist/generator/zod/generate-zod.js

@@ -1,19 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZod = generateZod;
-const generate_zod_array_1 = require("./generate-zod-array");
-const generate_zod_string_1 = require("./generate-zod-string");
 const is_format_string_1 = require("../../core/validator/is-format-string");
-const generate_zod_number_1 = require("./generate-zod-number");
-const generate_zod_integer_schema_1 = require("./generate-zod-integer-schema");
 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 generate_zod_number_1 = require("./generate-zod-number");
+const generate_zod_integer_schema_1 = require("./generate-zod-integer-schema");
+const generate_zod_length_1 = require("./generate-zod-length");
+const generate_zod_array_1 = require("./generate-zod-array");
+const generate_zod_string_1 = require("./generate-zod-string");
 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");
 const generate_oneof_code_1 = require("../zod-openapi-hono/openapi/component/oneof/generate-oneof-code");
 const generate_anyof_code_1 = require("../zod-openapi-hono/openapi/component/anyof/generate-anyof-code");

package/dist/generator/zod/openapi/generate-zod-to-openapi-schema-definition.js

@@ -23,13 +23,20 @@ const generate_zod_infer_1 = require("../generate-zod-infer");
  */
 function generateZodToOpenAPISchemaDefinition(schemaName, zodSchema, config) {
     const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(schemaName, config);
+    // "-" → "_"
+    const safeVariableName = variableName.replace(/[^a-zA-Z0-9_$]/g, '_');
+    // "-" → "_"
+    const safeSchemaName = schemaName.replace(/[^a-zA-Z0-9_$]/g, '_');
     // schema code
     const schemaCode = config.schema.export
-        ? `export const ${variableName} = ${zodSchema}.openapi('${schemaName}')`
-        : `const ${variableName} = ${zodSchema}.openapi('${schemaName}')`;
+        ? `export const ${safeVariableName} = ${zodSchema}.openapi('${safeSchemaName}')`
+        : `const ${safeVariableName} = ${zodSchema}.openapi('${safeSchemaName}')`;
     // zod infer code
     const typeVariableName = (0, get_variable_name_helper_1.getVariableNameHelper)(schemaName, config);
-    const zodInferCode = config.type.export ? (0, generate_zod_infer_1.generateZodInfer)(typeVariableName, variableName) : '';
+    const safeTypeVariableName = typeVariableName.replace(/[^a-zA-Z0-9_$]/g, '_');
+    const zodInferCode = config.type.export
+        ? (0, generate_zod_infer_1.generateZodInfer)(safeTypeVariableName, safeVariableName)
+        : '';
     // return code
     return `${schemaCode}\n\n${zodInferCode}`;
 }

package/dist/generator/zod/property/generate-zod-properties-schema.js

@@ -4,6 +4,7 @@ exports.generateZodPropertiesSchema = generateZodPropertiesSchema;
 const is_all_optional_1 = require("../../../core/validator/is-all-optional");
 const generate_zod_partial_schema_1 = require("../generate-zod-partial-schema");
 const generate_zod_property_schema_1 = require("./generate-zod-property-schema");
+const get_to_safe_identifier_helper_1 = require("../../../core/helper/get-to-safe-identifier-helper");
 /**
  * Generates a Zod object schema with properties and their requirements
  * @param { Record<string, Schema> } properties - Record of property names to their schema definitions
@@ -50,7 +51,9 @@ function generateZodPropertiesSchema(properties, required, config) {
     const objectProperties = Object.entries(properties).map(([key, schema]) => {
         const isRequired = required.includes(key);
         const propertySchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, config);
-        return `${key}:${propertySchema}${isRequired ? '' : '.optional()'}`;
+        const safePropertySchema = (0, get_to_safe_identifier_helper_1.getToSafeIdentifierHelper)(propertySchema);
+        const safeKey = (0, get_to_safe_identifier_helper_1.getToSafeIdentifierHelper)(key);
+        return `${safeKey}:${safePropertySchema}${isRequired ? '' : '.optional()'}`;
     });
     // Check if all properties are optional
     const allOptional = (0, is_all_optional_1.isAllOptional)(objectProperties);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateArrayReferenceSchema = generateArrayReferenceSchema;
+const get_to_safe_identifier_helper_1 = require("../../../core/helper/get-to-safe-identifier-helper");
 const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
 const get_ref_name_1 = require("../../../core/schema/references/get-ref-name");
 const generate_zod_array_1 = require("../generate-zod-array");
@@ -19,5 +20,6 @@ function generateArrayReferenceSchema(schema, config) {
         return 'z.array(z.any())';
     }
     const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
-    return (0, generate_zod_array_1.generateZodArray)(variableName);
+    const safeVariableName = (0, get_to_safe_identifier_helper_1.getToSafeIdentifierHelper)(variableName);
+    return (0, generate_zod_array_1.generateZodArray)(safeVariableName);
 }

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