hono-takibi 0.2.1 → 0.2.2

package/README.md

@@ -12,7 +12,6 @@ npm add -D hono-takibi
 
 You can customize the code generation behavior by creating a `hono-takibi.json` file in your project root.
 
-
 ### Schema Options
 
 | Option | Type | Default | Description |
@@ -27,9 +26,44 @@ You can customize the code generation behavior by creating a `hono-takibi.json`
 | `namingCase` | `"camelCase"` \| `"PascalCase"` | `"PascalCase"` | Naming convention for generated type definitions |
 | `exportEnabled` | `boolean` | `false` | When true, exports all type definitions |
 
+## Input and Output
+
+You can specify input and output paths in two ways:
+
+1. Command line arguments:
+
+2. Configuration file (`hono-takibi.json`):
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `input` | `string` | `""` | Input file path |
+| `output` | `string` | `""` | Output file path |
+
+> **⚠️** When using a configuration file, command line arguments are not required. The configuration file settings take precedence over command line arguments.
+>
+> **🔥** When you have configured `hono-takibi.json`, you can simply run:
+> ```bash
+> npx hono-takibi
+> ```
+
 ### Examples
 
-#### Default Behavior (camelCase schemas, PascalCase types)
+* Default Behavior (camelCase schemas, PascalCase types)
+
+```json
+{
+  "input": "src/openapi/openapi.yaml",
+  "output": "src/openapi/index.ts",
+  "schemaOptions": {
+    "namingCase": "camelCase",
+    "exportEnabled": false
+  },
+  "typeOptions": {
+    "namingCase": "PascalCase",
+    "exportEnabled": false
+  }
+}
+```
 
 ## Migrate Legacy APIs to Hono
 
@@ -467,7 +501,6 @@ export const deletePostsIdRoute = createRoute({
 })
 ```
 
-
 This project is in **early development** and being maintained by a developer with about 2 years of experience. While I'm doing my best to create a useful tool:
 
 ### ⚠️ WARNING: Potential Breaking Changes Without Notice

package/dist/config/index.d.ts

@@ -7,6 +7,8 @@ export type Config = {
         namingCase: 'camelCase' | 'PascalCase';
         exportEnabled: boolean;
     };
+    input?: string;
+    output?: string;
 };
 export declare const DEFAULT_CONFIG: Config;
 /**

package/dist/core/helper/get-variable-name-helper.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '../../config';
+export declare const getVariableNameHelper: (name: string, config: Config) => string;

package/dist/core/helper/get-variable-name-helper.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariableNameHelper = void 0;
+const capitalize_1 = require("../text/capitalize");
+const decapitalize_1 = require("../text/decapitalize");
+const getVariableNameHelper = (name, config) => {
+    return config.typeOptions.namingCase === 'camelCase' ? (0, decapitalize_1.decapitalize)(name) : (0, capitalize_1.capitalize)(name);
+};
+exports.getVariableNameHelper = getVariableNameHelper;

package/dist/core/helper/get-variable-schema-name-helper.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '../../config';
+export declare const getVariableSchemaNameHelper: (name: string, config: Config) => string;

package/dist/core/helper/get-variable-schema-name-helper.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVariableSchemaNameHelper = void 0;
+const get_camel_case_schema_name_1 = require("../schema/references/get-camel-case-schema-name");
+const get_pascal_case_schema_name_1 = require("../schema/references/get-pascal-case-schema-name");
+const getVariableSchemaNameHelper = (name, config) => {
+    return config.schemaOptions.namingCase === 'camelCase'
+        ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(name)
+        : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(name);
+};
+exports.getVariableSchemaNameHelper = getVariableSchemaNameHelper;

package/dist/core/validator/is-all-optional.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if all properties in the object are optional
+ * @param objectProperties - An array of strings representing the object properties
+ * @returns A boolean indicating if all properties are optional
+ */
+export declare function isAllOptional(objectProperties: string[]): boolean;

package/dist/core/validator/is-all-optional.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllOptional = isAllOptional;
+/**
+ * Check if all properties in the object are optional
+ * @param objectProperties - An array of strings representing the object properties
+ * @returns A boolean indicating if all properties are optional
+ */
+function isAllOptional(objectProperties) {
+    return objectProperties.every((prop) => prop.includes('.optional()'));
+}

package/dist/generators/hono/generate-zod-openapi-hono.js

@@ -22,9 +22,9 @@ function generateZodOpenAPIHono(openAPISpec, config) {
     // 2. get paths
     const { paths } = openAPISpec;
     // 3. generate components code
-    const componentsCode = (0, generate_components_code_1.generateComponentsCode)(components, config.schemaOptions.namingCase, config.schemaOptions.exportEnabled);
+    const componentsCode = (0, generate_components_code_1.generateComponentsCode)(components, config);
     // 4. generate route code
-    const routeCode = (0, generate_route_code_1.generateRouteCode)(paths, config.schemaOptions.namingCase);
+    const routeCode = (0, generate_route_code_1.generateRouteCode)(paths, config);
     // 5. generate types code
     const typesCode = (0, generate_types_code_1.generateTypesCode)(components, config);
     // 6. generate hono code

package/dist/generators/openapi/components/generate-components-code.d.ts

@@ -1,4 +1,5 @@
 import type { Components } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates TypeScript code for OpenAPI components, converting them to Zod schemas.
  * If no schemas are present, returns an empty string.
@@ -15,4 +16,4 @@ import type { Components } from '../../../types';
  * 5. Creates exports for all schemas
  * 6. Returns the complete code with proper ordering to avoid reference errors
  */
-export declare function generateComponentsCode(components: Components, namingCase?: 'camelCase' | 'PascalCase', exportEnabled?: boolean): string;
+export declare function generateComponentsCode(components: Components, config: Config): string;

package/dist/generators/openapi/components/generate-components-code.js

@@ -4,9 +4,8 @@ exports.generateComponentsCode = generateComponentsCode;
 const generate_zod_schema_definition_1 = require("../../zod/generate-zod-schema-definition");
 const generate_zod_schema_1 = require("../../../generators/zod/generate-zod-schema");
 const resolve_schemas_dependencies_1 = require("../../../core/schema/references/resolve-schemas-dependencies");
-const get_camel_case_schema_name_1 = require("../../../core/schema/references/get-camel-case-schema-name");
 const generate_schemas_export_1 = require("../paths/generate-schemas-export");
-const get_pascal_case_schema_name_1 = require("../../../core/schema/references/get-pascal-case-schema-name");
+const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
 /**
  * Generates TypeScript code for OpenAPI components, converting them to Zod schemas.
  * If no schemas are present, returns an empty string.
@@ -23,7 +22,9 @@ const get_pascal_case_schema_name_1 = require("../../../core/schema/references/g
  * 5. Creates exports for all schemas
  * 6. Returns the complete code with proper ordering to avoid reference errors
  */
-function generateComponentsCode(components, namingCase = 'camelCase', exportEnabled = true) {
+function generateComponentsCode(components, 
+// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
+config) {
     // 1. schema extraction
     const { schemas } = components;
     // 2. resolve schema dependencies to obtain proper ordering
@@ -38,19 +39,17 @@ function generateComponentsCode(components, namingCase = 'camelCase', exportEnab
         // 4.1 get schema definition corresponding to schema name
         const schema = schemas[schemaName];
         // 4.2 get variable name
-        const variableName = namingCase === 'camelCase'
-            ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(schemaName)
-            : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(schemaName);
+        const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(schemaName, config);
         // 4.3 generate zod schema
-        const zodSchema = (0, generate_zod_schema_1.generateZodSchema)(schema, undefined, undefined, namingCase);
+        const zodSchema = (0, generate_zod_schema_1.generateZodSchema)(config, schema, undefined, undefined);
         // 4.4 generate zod schema definition
         return (0, generate_zod_schema_definition_1.generateZodSchemaDefinition)(variableName, zodSchema, schemaName);
     })
         .join('\n\n');
     // 5. generate export statement
-    const exports = (0, generate_schemas_export_1.generateSchemasExport)(orderedSchemas, namingCase);
+    const exports = (0, generate_schemas_export_1.generateSchemasExport)(orderedSchemas, config);
     // 6. final code assembly
-    if (exportEnabled) {
+    if (config.schemaOptions.exportEnabled) {
         return `${schemaDefinitions}\n\n${exports}`;
     }
     return schemaDefinitions;

package/dist/generators/openapi/paths/generate-route-code.d.ts

@@ -1,4 +1,5 @@
 import type { OpenAPIPaths } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates TypeScript code for all valid routes based on OpenAPI paths
  *
@@ -18,4 +19,4 @@ import type { OpenAPIPaths } from '../../../types';
  * - Generates type-safe route handlers using zod validation
  * - Combines all routes with proper spacing
  */
-export declare function generateRouteCode(openAPIPaths: OpenAPIPaths, namingCase?: 'camelCase' | 'PascalCase'): string;
+export declare function generateRouteCode(openAPIPaths: OpenAPIPaths, config: Config): string;

package/dist/generators/openapi/paths/generate-route-code.js

@@ -23,7 +23,9 @@ const is_operation_1 = require("../../../core/validator/is-operation");
  * - Generates type-safe route handlers using zod validation
  * - Combines all routes with proper spacing
  */
-function generateRouteCode(openAPIPaths, namingCase = 'camelCase') {
+function generateRouteCode(openAPIPaths, 
+// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
+config) {
     const routes = [];
     // 1. flattening and processing OpenAPI paths
     for (const [path, pathItem] of Object.entries(openAPIPaths)) {
@@ -45,7 +47,7 @@ function generateRouteCode(openAPIPaths, namingCase = 'camelCase') {
             if (!(0, is_operation_1.isOperation)(pathItemValue))
                 continue;
             // 3.5 generating the root code and adding it to the array
-            routes.push((0, generate_route_1.generateRoute)(path, method, pathItemValue, namingCase));
+            routes.push((0, generate_route_1.generateRoute)(path, method, pathItemValue, config));
         }
     }
     // 4. exclude invalid routes and join them with a newline

package/dist/generators/openapi/paths/generate-route.d.ts

@@ -1,4 +1,5 @@
 import type { Operation } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates TypeScript code for a Hono route based on OpenAPI operation details
  *
@@ -21,4 +22,4 @@ import type { Operation } from '../../../types';
  * - Handles optional parameters appropriately
  * - Integrates with Hono's createRoute function
  */
-export declare function generateRoute(path: string, method: string, operation: Operation, namingCase: 'camelCase' | 'PascalCase'): string;
+export declare function generateRoute(path: string, method: string, operation: Operation, config: Config): string;

package/dist/generators/openapi/paths/generate-route.js

@@ -28,11 +28,13 @@ const escape_quote_1 = require("../../../core/text/escape-quote");
  * - Handles optional parameters appropriately
  * - Integrates with Hono's createRoute function
  */
-function generateRoute(path, method, operation, namingCase) {
+function generateRoute(path, method, operation, 
+// namingCase: 'camelCase' | 'PascalCase',
+config) {
     const { tags, summary, description, security, parameters, requestBody, responses } = operation;
     const routeName = (0, generate_route_name_1.generateRouteName)(method, path);
     const tagList = tags ? JSON.stringify(tags) : '[]';
-    const requestParams = (0, generate_request_parameter_1.generateRequestParameter)(parameters, requestBody, namingCase);
+    const requestParams = (0, generate_request_parameter_1.generateRequestParameter)(parameters, requestBody, config);
     const create_args = {
         routeName,
         tagsCode: `tags:${tagList},`,
@@ -42,7 +44,7 @@ function generateRoute(path, method, operation, namingCase) {
         descriptionCode: description ? `description:'${(0, escape_quote_1.escapeQuote)(description)}',` : '',
         securityCode: security ? `security:${JSON.stringify(security)},` : '',
         requestParams: requestParams ? `${requestParams}` : '',
-        responsesCode: responses ? `responses:{${(0, generate_response_schema_1.generateResponseSchema)(responses, namingCase)}}` : '',
+        responsesCode: responses ? `responses:{${(0, generate_response_schema_1.generateResponseSchema)(responses, config)}}` : '',
     };
     return (0, generate_create_route_1.generateCreateRoute)(create_args);
 }

package/dist/generators/openapi/paths/generate-schemas-export.d.ts

@@ -1,3 +1,4 @@
+import type { Config } from '../../../config';
 /**
  * Generates a TypeScript export for a list of schema names
  *
@@ -8,4 +9,4 @@
  * @example
  * // Returns: 'export const schemas = { userSchema, postSchema }'
  */
-export declare function generateSchemasExport(orderedSchemas: string[], namingCase?: 'camelCase' | 'PascalCase'): string | undefined;
+export declare function generateSchemasExport(orderedSchemas: string[], config: Config): string;

package/dist/generators/openapi/paths/generate-schemas-export.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateSchemasExport = generateSchemasExport;
-const get_camel_case_schema_name_1 = require("../../../core/schema/references/get-camel-case-schema-name");
-const get_pascal_case_schema_name_1 = require("../../../core/schema/references/get-pascal-case-schema-name");
+const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
 /**
  * Generates a TypeScript export for a list of schema names
  *
@@ -13,13 +12,7 @@ const get_pascal_case_schema_name_1 = require("../../../core/schema/references/g
  * @example
  * // Returns: 'export const schemas = { userSchema, postSchema }'
  */
-function generateSchemasExport(orderedSchemas, namingCase = 'camelCase') {
-    if (namingCase === 'camelCase') {
-        const camelCaseSchemas = orderedSchemas.map((schemaName) => (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(schemaName));
-        return `export const schemas = {\n${camelCaseSchemas.join(',\n')}\n}`;
-    }
-    if (namingCase === 'PascalCase') {
-        const pascalCaseSchemas = orderedSchemas.map((schemaName) => (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(schemaName));
-        return `export const schemas = {\n${pascalCaseSchemas.join(',\n')}\n}`;
-    }
+function generateSchemasExport(orderedSchemas, config) {
+    const variableNames = orderedSchemas.map((schemaName) => (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(schemaName, config));
+    return `export const schemas = {\n${variableNames.join(',\n')}\n}`;
 }

package/dist/generators/request/params/generate-params-object.d.ts

@@ -1,4 +1,5 @@
 import type { ParamsObject, Parameters } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates a params object containing Zod schemas for different parameter locations
  *
@@ -12,4 +13,4 @@ import type { ParamsObject, Parameters } from '../../../types';
  * - Organizes parameters into appropriate objects based on their location
  * - Maintains empty objects for unused parameter locations
  */
-export declare function generateParamsObject(parameters: Parameters[], namingCase?: 'camelCase' | 'PascalCase'): ParamsObject;
+export declare function generateParamsObject(parameters: Parameters[], config: Config): ParamsObject;

package/dist/generators/request/params/generate-params-object.js

@@ -16,13 +16,15 @@ const generate_zod_schema_1 = require("../../zod/generate-zod-schema");
  * - Organizes parameters into appropriate objects based on their location
  * - Maintains empty objects for unused parameter locations
  */
-function generateParamsObject(parameters, namingCase = 'camelCase') {
+function generateParamsObject(parameters, 
+// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
+config) {
     return parameters.reduce((acc, param) => {
         const optionalSuffix = param.required ? '' : '.optional()';
         // path params are generated with the param name
         const baseSchema = param.in === 'path'
-            ? (0, generate_zod_schema_1.generateZodSchema)(param.schema, param.name, true, namingCase)
-            : (0, generate_zod_schema_1.generateZodSchema)(param.schema, namingCase);
+            ? (0, generate_zod_schema_1.generateZodSchema)(config, param.schema, param.name, true)
+            : (0, generate_zod_schema_1.generateZodSchema)(config, param.schema, param.name, false);
         // Initialize section if it doesn't exist
         if (!acc[param.in]) {
             acc[param.in] = {};

package/dist/generators/request/params/generate-request-parameter.d.ts

@@ -1,4 +1,5 @@
 import type { Parameters, RequestBody } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates TypeScript code for request validation based on OpenAPI specification
  *
@@ -19,4 +20,4 @@ import type { Parameters, RequestBody } from '../../../types';
  * - Properly combines parameters and body when both are present
  * - Handles schema references and inline schemas
  */
-export declare function generateRequestParameter(parameters: Parameters[] | undefined, requestBody: RequestBody | undefined, namingCase?: 'camelCase' | 'PascalCase'): string;
+export declare function generateRequestParameter(parameters: Parameters[] | undefined, requestBody: RequestBody | undefined, config: Config): string;

package/dist/generators/request/params/generate-request-parameter.js

@@ -28,7 +28,7 @@ const generate_zod_property_schema_1 = require("../../zod/generate-zod-property-
  * - Properly combines parameters and body when both are present
  * - Handles schema references and inline schemas
  */
-function generateRequestParameter(parameters, requestBody, namingCase = 'camelCase') {
+function generateRequestParameter(parameters, requestBody, config) {
     // Early return if no parameters or content
     if (!(parameters || requestBody?.content)) {
         return '';
@@ -36,7 +36,7 @@ function generateRequestParameter(parameters, requestBody, namingCase = 'camelCa
     const requestBodyContentTypes = Object.keys(requestBody?.content || {});
     const params = parameters
         ? (() => {
-            const paramsObj = (0, generate_params_object_1.generateParamsObject)(parameters, namingCase);
+            const paramsObj = (0, generate_params_object_1.generateParamsObject)(parameters, config);
             const requestParamsArr = (0, generate_request_params_array_1.generateRequestParamsArray)(paramsObj);
             return requestParamsArr.length ? (0, generate_format_request_object_1.generateFormatRequestObject)(requestParamsArr) : '';
         })()
@@ -46,7 +46,7 @@ function generateRequestParameter(parameters, requestBody, namingCase = 'camelCa
         const uniqueSchemas = new Map();
         for (const contentType of requestBodyContentTypes) {
             const { schema } = requestBody.content[contentType];
-            const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, namingCase);
+            const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, config);
             uniqueSchemas.set(zodSchema, zodSchema);
         }
         const request_body_required = requestBody.required ?? false;

package/dist/generators/response/schemas/generate-response-schema.d.ts

@@ -1,4 +1,5 @@
 import type { Responses } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates a response schema for different status codes
  *
@@ -19,4 +20,4 @@ import type { Responses } from '../../../types';
  * - Handles nested schema structures
  * - Automatically resolves schema references
  */
-export declare function generateResponseSchema(responses: Responses, namingCase?: 'camelCase' | 'PascalCase'): string;
+export declare function generateResponseSchema(responses: Responses, config: Config): string;

package/dist/generators/response/schemas/generate-response-schema.js

@@ -24,7 +24,9 @@ const generate_zod_property_schema_1 = require("../../zod/generate-zod-property-
  * - Handles nested schema structures
  * - Automatically resolves schema references
  */
-function generateResponseSchema(responses, namingCase = 'camelCase') {
+function generateResponseSchema(responses, 
+// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
+config) {
     // 1. get response codes (200, 404, etc.)
     const responseCodes = Object.keys(responses);
     // 2. processing for each response code
@@ -41,7 +43,7 @@ function generateResponseSchema(responses, namingCase = 'camelCase') {
             const contentParts = [];
             for (const contentType of contentTypes) {
                 const content = response.content[contentType];
-                const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(content.schema, namingCase);
+                const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(content.schema, config);
                 contentParts.push(`'${contentType}':{schema:${zodSchema}}`);
             }
             return `${code}:{description:'${(0, escape_quote_1.escapeQuote)(response.description)}',content:{${contentParts.join(',')}},},`;

package/dist/generators/types/generate-types-code.js

@@ -15,8 +15,6 @@ exports.generateTypesCode = generateTypesCode;
 //   // 4. generate code for each schema
 // }
 const resolve_schemas_dependencies_1 = require("../../core/schema/references/resolve-schemas-dependencies");
-// import { getCamelCaseSchemaName } from '../../core/schema/references/get-camel-case-schema-name'
-// import { getPascalCaseSchemaName } from '../../core/schema/references/get-pascal-case-schema-name'
 const generate_zod_infer_1 = require("../zod/generate-zod-infer");
 function generateTypesCode(components, config) {
     // 1. schema extraction

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

@@ -0,0 +1 @@
+export declare function generatePartialSchema(objectProperties: string[]): string;

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePartialSchema = generatePartialSchema;
+function generatePartialSchema(objectProperties) {
+    const cleanProperties = objectProperties.map((prop) => prop.replace('.optional()', ''));
+    return `z.object({${cleanProperties}}).partial()`;
+}

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

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodInfer = generateZodInfer;
-const get_camel_case_schema_name_1 = require("../../core/schema/references/get-camel-case-schema-name");
-const get_pascal_case_schema_name_1 = require("../../core/schema/references/get-pascal-case-schema-name");
-const capitalize_1 = require("../../core/text/capitalize");
-const decapitalize_1 = require("../../core/text/decapitalize");
+const get_variable_name_helper_1 = require("../../core/helper/get-variable-name-helper");
+const get_variable_schema_name_helper_1 = require("../../core/helper/get-variable-schema-name-helper");
 /**
  * Generates a TypeScript type definition for an inferred Zod schema.
  *
@@ -12,9 +10,7 @@ const decapitalize_1 = require("../../core/text/decapitalize");
  * @returns A string containing the inferred type definition.
  */
 function generateZodInfer(schema, config) {
-    const schemaName = config?.schemaOptions?.namingCase === 'camelCase'
-        ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(schema)
-        : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(schema);
-    const variableName = config?.typeOptions?.namingCase === 'camelCase' ? (0, decapitalize_1.decapitalize)(schema) : (0, capitalize_1.capitalize)(schema);
+    const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(schema, config);
+    const variableName = (0, get_variable_name_helper_1.getVariableNameHelper)(schema, config);
     return `export type ${variableName} = z.infer<typeof ${schemaName}>`;
 }

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

@@ -1,4 +1,5 @@
 import type { Schema } from '../../types';
+import type { Config } from '../../config';
 /**
  * Generates a Zod object schema with properties and their requirements
  *
@@ -47,4 +48,4 @@ import type { Schema } from '../../types';
  * - Uses .partial() when no properties are required
  * - Maintains property order from input
  */
-export declare function generateZodPropertiesSchema(properties: Record<string, Schema>, required: string[], namingCase?: 'camelCase' | 'PascalCase'): string;
+export declare function generateZodPropertiesSchema(properties: Record<string, Schema>, required: string[], config: Config): string;

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodPropertiesSchema = generateZodPropertiesSchema;
+const is_all_optional_1 = require("../../core/validator/is-all-optional");
+const generate_partial_schema_1 = require("./generate-partial-schema");
 const generate_zod_property_schema_1 = require("./generate-zod-property-schema");
 /**
  * Generates a Zod object schema with properties and their requirements
@@ -50,17 +52,19 @@ const generate_zod_property_schema_1 = require("./generate-zod-property-schema")
  * - Uses .partial() when no properties are required
  * - Maintains property order from input
  */
-function generateZodPropertiesSchema(properties, required, namingCase = 'camelCase') {
+function generateZodPropertiesSchema(properties, required, 
+// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
+config) {
     const objectProperties = Object.entries(properties).map(([key, schema]) => {
         const isRequired = required.includes(key);
-        const propertySchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, namingCase);
+        const propertySchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, config);
         return `${key}:${propertySchema}${isRequired ? '' : '.optional()'}`;
     });
-    const allOptional = objectProperties.every((prop) => prop.includes('.optional()'));
+    // Check if all properties are optional
+    const allOptional = (0, is_all_optional_1.isAllOptional)(objectProperties);
+    // If all properties are optional and no required properties, return partial schema
     if (required.length === 0 && allOptional) {
-        const cleanProperties = objectProperties.map((prop) => prop.replace('.optional()', ''));
-        return `z.object({${cleanProperties}}).partial()`;
+        return (0, generate_partial_schema_1.generatePartialSchema)(objectProperties);
     }
     return `z.object({${objectProperties}})`;
-    // return `z.object({${objectProperties}})${required.length === 0 ? '.partial()' : ''}`
 }

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

@@ -1,4 +1,5 @@
 import type { Schema } from '../../types';
+import type { Config } from '../../config';
 /**
  * Generates a Zod schema string for a given OpenAPI schema definition
  *
@@ -22,4 +23,4 @@ import type { Schema } from '../../types';
  * generatePropertySchema({ type: 'string' })
  * // Returns: 'z.string()'
  */
-export declare function generatePropertySchema(schema: Schema, namingCase?: 'camelCase' | 'PascalCase'): string;
+export declare function generatePropertySchema(schema: Schema, config: Config): string;

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

@@ -4,8 +4,7 @@ exports.generatePropertySchema = generatePropertySchema;
 const get_ref_name_1 = require("../../core/schema/references/get-ref-name");
 const generate_zod_array_1 = require("./generate-zod-array");
 const generate_zod_schema_1 = require("./generate-zod-schema");
-const get_camel_case_schema_name_1 = require("../../core/schema/references/get-camel-case-schema-name");
-const get_pascal_case_schema_name_1 = require("../../core/schema/references/get-pascal-case-schema-name");
+const get_variable_schema_name_helper_1 = require("../../core/helper/get-variable-schema-name-helper");
 // import { generateZodOpenAPIExample } from './generate-zod-openapi-example'
 /**
  * Generates a Zod schema string for a given OpenAPI schema definition
@@ -30,13 +29,13 @@ const get_pascal_case_schema_name_1 = require("../../core/schema/references/get-
  * generatePropertySchema({ type: 'string' })
  * // Returns: 'z.string()'
  */
-function generatePropertySchema(schema, namingCase = 'camelCase') {
+function generatePropertySchema(schema, 
+// namingCase: 'camelCase' | 'PascalCase' = 'camelCase',
+config) {
     if (schema.$ref) {
         const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
         if (refName) {
-            const variableName = namingCase === 'camelCase'
-                ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(refName)
-                : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(refName);
+            const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
             // return getRefName(variableName) || 'z.any()'
             return variableName || 'z.any()';
         }
@@ -44,11 +43,9 @@ function generatePropertySchema(schema, namingCase = 'camelCase') {
     if (schema.type === 'array' && schema.items?.$ref) {
         const refName = (0, get_ref_name_1.getRefName)(schema.items.$ref);
         if (refName) {
-            const variableName = namingCase === 'camelCase'
-                ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(refName)
-                : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(refName);
+            const variableName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
             return (0, generate_zod_array_1.generateZodArray)(variableName);
         }
     }
-    return (0, generate_zod_schema_1.generateZodSchema)(schema, undefined, undefined, namingCase);
+    return (0, generate_zod_schema_1.generateZodSchema)(config, schema, undefined, undefined);
 }

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

@@ -1,3 +1,4 @@
+import type { Config } from '../../config';
 import type { Format, Type } from '../../types';
 /**
  * Generates a Zod record schema for objects with additional properties
@@ -31,4 +32,4 @@ import type { Format, Type } from '../../types';
 export declare function generateZodRecordSchema(additionalProperties: {
     type: Type;
     format: Format;
-}): string;
+}, config: Config): string;

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

@@ -31,7 +31,7 @@ const generate_zod_schema_1 = require("./generate-zod-schema");
  * - Value type is determined by the additionalProperties schema
  * - Supports all Zod-compatible types and formats
  */
-function generateZodRecordSchema(additionalProperties) {
-    const schema = (0, generate_zod_schema_1.generateZodSchema)(additionalProperties);
+function generateZodRecordSchema(additionalProperties, config) {
+    const schema = (0, generate_zod_schema_1.generateZodSchema)(config, additionalProperties);
     return `z.record(z.string(),${schema})`;
 }

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

@@ -1,4 +1,5 @@
 import type { Schema } from '../../types';
+import type { Config } from '../../config';
 /**
  * Generates a Zod schema string from an OpenAPI/JSON Schema definition
  *
@@ -56,4 +57,4 @@ import type { Schema } from '../../types';
  * - Falls back to basic type mapping for simple types
  * - Returns z.any() for unknown types with a warning
  */
-export declare function generateZodSchema(schema: Schema, paramName?: string, isPath?: boolean, namingCase?: 'camelCase' | 'PascalCase'): string;
+export declare function generateZodSchema(config: Config, schema: Schema, paramName?: string, isPath?: boolean): string;

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

@@ -86,7 +86,7 @@ const TYPE_TO_ZOD_SCHEMA = {
  * - Falls back to basic type mapping for simple types
  * - Returns z.any() for unknown types with a warning
  */
-function generateZodSchema(schema, paramName, isPath, namingCase = 'camelCase') {
+function generateZodSchema(config, schema, paramName, isPath) {
     // enum
     if (schema.enum) {
         if (schema.example) {
@@ -97,10 +97,10 @@ function generateZodSchema(schema, paramName, isPath, namingCase = 'camelCase')
     // object
     if (schema.type === 'object') {
         if (schema.additionalProperties)
-            return (0, generate_zod_record_schema_1.generateZodRecordSchema)(schema.additionalProperties);
+            return (0, generate_zod_record_schema_1.generateZodRecordSchema)(schema.additionalProperties, config);
         if (!schema.properties)
             return 'z.object({})';
-        return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(schema.properties, schema.required || [], namingCase);
+        return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(schema.properties, schema.required || [], config);
     }
     // string
     if (schema.type === 'string') {
@@ -144,7 +144,7 @@ function generateZodSchema(schema, paramName, isPath, namingCase = 'camelCase')
     }
     // array
     if (schema.type === 'array' && schema.items)
-        return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(schema.items, undefined, undefined, namingCase));
+        return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(config, schema.items, undefined, undefined));
     // fallback
     if (schema.type)
         return TYPE_TO_ZOD_SCHEMA[schema.type];

package/dist/index.js

@@ -34,9 +34,10 @@ async function main(dev = false, config = (0, config_1.getConfig)()) {
     // 2. slice [ 'example/pet-store.yaml', '-o', 'routes/petstore-index.ts' ]
     const args = process.argv.slice(2);
     // 3. input = 'example/pet-store.yaml'
-    const input = args[0];
+    const input = config.input ?? args[0];
+    // const input = args[0]
     // 4. output = 'routes/petstore-index.ts'
-    const output = args[args.indexOf('-o') + 1];
+    const output = config.output ?? args[args.indexOf('-o') + 1];
     try {
         // 5. parse OpenAPI YAML or JSON
         const openAPI = (await swagger_parser_1.default.parse(input));

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