hono-takibi 0.1.5 → 0.2.1

package/README.md

@@ -8,6 +8,29 @@
 npm add -D hono-takibi
 ```
 
+## Configuration
+
+You can customize the code generation behavior by creating a `hono-takibi.json` file in your project root.
+
+
+### Schema Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `namingCase` | `"camelCase"` \| `"PascalCase"` | `"camelCase"` | Naming convention for generated schema variables |
+| `exportEnabled` | `boolean` | `false` | When true, exports all schema definitions |
+
+### Type Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `namingCase` | `"camelCase"` \| `"PascalCase"` | `"PascalCase"` | Naming convention for generated type definitions |
+| `exportEnabled` | `boolean` | `false` | When true, exports all type definitions |
+
+### Examples
+
+#### Default Behavior (camelCase schemas, PascalCase types)
+
 ## Migrate Legacy APIs to Hono
 
 **Hono Takibi** is an OpenAPI-to-Hono code generator, specifically developed to assist in migrating APIs from various programming languages to Hono. This tool automates the creation of type-safe Hono routes from your existing OpenAPI specifications, making it easier to transition from legacy systems (Ruby, Perl, PHP, etc.) to a modern Hono architecture.
@@ -465,12 +488,7 @@ We welcome feedback and contributions to improve the tool!
 
 ### Current Limitations
 
-1. **Schema Naming Convention**
-   - Only generates camelCase schema names
-   - Example: `Post` in OpenAPI becomes `postSchema` in generated code
-   - No support for custom naming conventions yet
-
-2. **OpenAPI Support**
+  **OpenAPI Support**
    - Not all OpenAPI features are supported
    - Complex schemas might not convert correctly
    - Limited support for certain response types

package/dist/config/index.d.ts

@@ -0,0 +1,17 @@
+export type Config = {
+    schemaOptions: {
+        namingCase: 'camelCase' | 'PascalCase';
+        exportEnabled: boolean;
+    };
+    typeOptions: {
+        namingCase: 'camelCase' | 'PascalCase';
+        exportEnabled: boolean;
+    };
+};
+export declare const DEFAULT_CONFIG: Config;
+/**
+ * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.
+ *
+ * @returns The configuration object.
+ */
+export declare function getConfig(): Config;

package/dist/config/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.getConfig = getConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+exports.DEFAULT_CONFIG = {
+    schemaOptions: {
+        namingCase: 'camelCase',
+        exportEnabled: false,
+    },
+    typeOptions: {
+        namingCase: 'PascalCase',
+        exportEnabled: false,
+    },
+};
+/**
+ * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.
+ *
+ * @returns The configuration object.
+ */
+function getConfig() {
+    const config = node_fs_1.default.existsSync('hono-takibi.json')
+        ? { ...exports.DEFAULT_CONFIG, ...JSON.parse(node_fs_1.default.readFileSync('hono-takibi.json', 'utf-8')) }
+        : exports.DEFAULT_CONFIG;
+    return config;
+}

package/dist/core/schema/references/get-pascal-case-schema-name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Generates a PascalCase schema name from a given schema name.
+ *
+ * @function getPascalCaseSchemaName
+ * @param schemaName - The original schema name.
+ * @returns The PascalCase schema name.
+ */
+export declare function getPascalCaseSchemaName(schemaName: string): string;

package/dist/core/schema/references/get-pascal-case-schema-name.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPascalCaseSchemaName = getPascalCaseSchemaName;
+const capitalize_1 = require("../../text/capitalize");
+/**
+ * Generates a PascalCase schema name from a given schema name.
+ *
+ * @function getPascalCaseSchemaName
+ * @param schemaName - The original schema name.
+ * @returns The PascalCase schema name.
+ */
+function getPascalCaseSchemaName(schemaName) {
+    const capitalizedSchemaName = (0, capitalize_1.capitalize)(schemaName);
+    return `${capitalizedSchemaName}Schema`;
+}

package/dist/generators/hono/generate-zod-openapi-hono.d.ts

@@ -1,3 +1,4 @@
+import type { Config } from '../../config';
 import type { OpenAPISpec } from '../../types';
 /**
  * Generates TypeScript code from OpenAPI specification for Hono/zod-openapi
@@ -6,4 +7,4 @@ import type { OpenAPISpec } from '../../types';
  * @param openAPISpec - OpenAPI specification object containing components and paths
  * @returns Generated TypeScript code
  */
-export declare function generateZodOpenAPIHono(openAPISpec: OpenAPISpec): string;
+export declare function generateZodOpenAPIHono(openAPISpec: OpenAPISpec, config: Config): string;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodOpenAPIHono = generateZodOpenAPIHono;
 const generate_components_code_1 = require("../openapi/components/generate-components-code");
 const generate_route_code_1 = require("../openapi/paths/generate-route-code");
+const generate_types_code_1 = require("../types/generate-types-code");
 /**
  * Import statement for Hono's zod-openapi package
  * @constant
@@ -15,15 +16,20 @@ const IMPORT_CODE = "import { createRoute, z } from '@hono/zod-openapi';";
  * @param openAPISpec - OpenAPI specification object containing components and paths
  * @returns Generated TypeScript code
  */
-function generateZodOpenAPIHono(openAPISpec) {
+function generateZodOpenAPIHono(openAPISpec, config) {
     // 1. get components
     const components = openAPISpec.components;
     // 2. get paths
     const { paths } = openAPISpec;
     // 3. generate components code
-    const componentsCode = (0, generate_components_code_1.generateComponentsCode)(components);
+    const componentsCode = (0, generate_components_code_1.generateComponentsCode)(components, config.schemaOptions.namingCase, config.schemaOptions.exportEnabled);
     // 4. generate route code
-    const routeCode = (0, generate_route_code_1.generateRouteCode)(paths);
-    // 5. generate hono code
+    const routeCode = (0, generate_route_code_1.generateRouteCode)(paths, config.schemaOptions.namingCase);
+    // 5. generate types code
+    const typesCode = (0, generate_types_code_1.generateTypesCode)(components, config);
+    // 6. generate hono code
+    if (config.typeOptions.exportEnabled) {
+        return `${IMPORT_CODE}\n\n${componentsCode}\n\n${typesCode}\n\n${routeCode}`.trimEnd();
+    }
     return `${IMPORT_CODE}\n\n${componentsCode}\n\n${routeCode}`.trimEnd();
 }

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

@@ -15,4 +15,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): string;
+export declare function generateComponentsCode(components: Components, namingCase?: 'camelCase' | 'PascalCase', exportEnabled?: boolean): string;

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

@@ -6,6 +6,7 @@ const generate_zod_schema_1 = require("../../../generators/zod/generate-zod-sche
 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");
 /**
  * Generates TypeScript code for OpenAPI components, converting them to Zod schemas.
  * If no schemas are present, returns an empty string.
@@ -22,7 +23,7 @@ const generate_schemas_export_1 = require("../paths/generate-schemas-export");
  * 5. Creates exports for all schemas
  * 6. Returns the complete code with proper ordering to avoid reference errors
  */
-function generateComponentsCode(components) {
+function generateComponentsCode(components, namingCase = 'camelCase', exportEnabled = true) {
     // 1. schema extraction
     const { schemas } = components;
     // 2. resolve schema dependencies to obtain proper ordering
@@ -36,16 +37,21 @@ function generateComponentsCode(components) {
         .map((schemaName) => {
         // 4.1 get schema definition corresponding to schema name
         const schema = schemas[schemaName];
-        // 4.2 get camelCase schema name
-        const camelCaseSchemaName = (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(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);
         // 4.3 generate zod schema
-        const zodSchema = (0, generate_zod_schema_1.generateZodSchema)(schema);
+        const zodSchema = (0, generate_zod_schema_1.generateZodSchema)(schema, undefined, undefined, namingCase);
         // 4.4 generate zod schema definition
-        return (0, generate_zod_schema_definition_1.generateZodSchemaDefinition)(camelCaseSchemaName, zodSchema, schemaName);
+        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);
+    const exports = (0, generate_schemas_export_1.generateSchemasExport)(orderedSchemas, namingCase);
     // 6. final code assembly
-    return `${schemaDefinitions}\n\n${exports}`;
+    if (exportEnabled) {
+        return `${schemaDefinitions}\n\n${exports}`;
+    }
+    return schemaDefinitions;
 }

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

@@ -18,4 +18,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): string;
+export declare function generateRouteCode(openAPIPaths: OpenAPIPaths, namingCase?: 'camelCase' | 'PascalCase'): string;

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

@@ -23,7 +23,7 @@ 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) {
+function generateRouteCode(openAPIPaths, namingCase = 'camelCase') {
     const routes = [];
     // 1. flattening and processing OpenAPI paths
     for (const [path, pathItem] of Object.entries(openAPIPaths)) {
@@ -45,7 +45,7 @@ function generateRouteCode(openAPIPaths) {
             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));
+            routes.push((0, generate_route_1.generateRoute)(path, method, pathItemValue, namingCase));
         }
     }
     // 4. exclude invalid routes and join them with a newline

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

@@ -21,4 +21,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): string;
+export declare function generateRoute(path: string, method: string, operation: Operation, namingCase: 'camelCase' | 'PascalCase'): string;

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

@@ -28,11 +28,11 @@ const escape_quote_1 = require("../../../core/text/escape-quote");
  * - Handles optional parameters appropriately
  * - Integrates with Hono's createRoute function
  */
-function generateRoute(path, method, operation) {
+function generateRoute(path, method, operation, namingCase) {
     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);
+    const requestParams = (0, generate_request_parameter_1.generateRequestParameter)(parameters, requestBody, namingCase);
     const create_args = {
         routeName,
         tagsCode: `tags:${tagList},`,
@@ -42,7 +42,7 @@ function generateRoute(path, method, operation) {
         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)}}` : '',
+        responsesCode: responses ? `responses:{${(0, generate_response_schema_1.generateResponseSchema)(responses, namingCase)}}` : '',
     };
     return (0, generate_create_route_1.generateCreateRoute)(create_args);
 }

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

@@ -8,4 +8,4 @@
  * @example
  * // Returns: 'export const schemas = { userSchema, postSchema }'
  */
-export declare function generateSchemasExport(orderedSchemas: string[]): string;
+export declare function generateSchemasExport(orderedSchemas: string[], namingCase?: 'camelCase' | 'PascalCase'): string | undefined;

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

@@ -2,6 +2,7 @@
 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");
 /**
  * Generates a TypeScript export for a list of schema names
  *
@@ -12,7 +13,13 @@ const get_camel_case_schema_name_1 = require("../../../core/schema/references/ge
  * @example
  * // Returns: 'export const schemas = { userSchema, postSchema }'
  */
-function generateSchemasExport(orderedSchemas) {
-    const camelCaseSchemas = orderedSchemas.map((schemaName) => (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(schemaName));
-    return `export const schemas = {\n${camelCaseSchemas.join(',\n')}\n}`;
+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}`;
+    }
 }

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

@@ -12,4 +12,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[]): ParamsObject;
+export declare function generateParamsObject(parameters: Parameters[], namingCase?: 'camelCase' | 'PascalCase'): ParamsObject;

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

@@ -16,13 +16,13 @@ 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) {
+function generateParamsObject(parameters, namingCase = 'camelCase') {
     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)
-            : (0, generate_zod_schema_1.generateZodSchema)(param.schema);
+            ? (0, generate_zod_schema_1.generateZodSchema)(param.schema, param.name, true, namingCase)
+            : (0, generate_zod_schema_1.generateZodSchema)(param.schema, namingCase);
         // Initialize section if it doesn't exist
         if (!acc[param.in]) {
             acc[param.in] = {};

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

@@ -19,4 +19,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): string;
+export declare function generateRequestParameter(parameters: Parameters[] | undefined, requestBody: RequestBody | undefined, namingCase?: 'camelCase' | 'PascalCase'): 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) {
+function generateRequestParameter(parameters, requestBody, namingCase = 'camelCase') {
     // Early return if no parameters or content
     if (!(parameters || requestBody?.content)) {
         return '';
@@ -36,7 +36,7 @@ function generateRequestParameter(parameters, requestBody) {
     const requestBodyContentTypes = Object.keys(requestBody?.content || {});
     const params = parameters
         ? (() => {
-            const paramsObj = (0, generate_params_object_1.generateParamsObject)(parameters);
+            const paramsObj = (0, generate_params_object_1.generateParamsObject)(parameters, namingCase);
             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) {
         const uniqueSchemas = new Map();
         for (const contentType of requestBodyContentTypes) {
             const { schema } = requestBody.content[contentType];
-            const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema);
+            const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, namingCase);
             uniqueSchemas.set(zodSchema, zodSchema);
         }
         const request_body_required = requestBody.required ?? false;

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

@@ -19,4 +19,4 @@ import type { Responses } from '../../../types';
  * - Handles nested schema structures
  * - Automatically resolves schema references
  */
-export declare function generateResponseSchema(responses: Responses): string;
+export declare function generateResponseSchema(responses: Responses, namingCase?: 'camelCase' | 'PascalCase'): string;

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

@@ -24,7 +24,7 @@ const generate_zod_property_schema_1 = require("../../zod/generate-zod-property-
  * - Handles nested schema structures
  * - Automatically resolves schema references
  */
-function generateResponseSchema(responses) {
+function generateResponseSchema(responses, namingCase = 'camelCase') {
     // 1. get response codes (200, 404, etc.)
     const responseCodes = Object.keys(responses);
     // 2. processing for each response code
@@ -41,7 +41,7 @@ function generateResponseSchema(responses) {
             const contentParts = [];
             for (const contentType of contentTypes) {
                 const content = response.content[contentType];
-                const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(content.schema);
+                const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(content.schema, namingCase);
                 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.d.ts

@@ -0,0 +1,3 @@
+import type { Components } from '../../types';
+import type { Config } from '../../config';
+export declare function generateTypesCode(components: Components, config: Config): string;

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

@@ -0,0 +1,35 @@
+"use strict";
+// import { resolveSchemasDependencies } from "../../core/schema/references/resolve-schemas-dependencies";
+// import type { Components } from "../../types";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTypesCode = generateTypesCode;
+// export function generateTypesCode(components: Components) {
+//   // 1. schema extraction
+//   const { schemas } = components
+//   // 2. resolve schema dependencies to obtain proper ordering
+//   const orderedSchemas = resolveSchemasDependencies(schemas)
+//   // 3. if there are no schemas, return an empty string
+//   if (orderedSchemas.length === 0) {
+//     return ''
+//   }
+//   // 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
+    const { schemas } = components;
+    // 2. resolve schema dependencies to obtain proper ordering
+    const orderedSchemas = (0, resolve_schemas_dependencies_1.resolveSchemasDependencies)(schemas);
+    // 3. if there are no schemas, return an empty string
+    if (orderedSchemas.length === 0) {
+        return '';
+    }
+    // 4. generate code for each schema
+    const typeDefinitions = orderedSchemas.map((schemaName) => {
+        return (0, generate_zod_infer_1.generateZodInfer)(schemaName, config);
+    });
+    return typeDefinitions.join('\n\n');
+}

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

@@ -0,0 +1,8 @@
+import type { Config } from '../../config';
+/**
+ * Generates a TypeScript type definition for an inferred Zod schema.
+ *
+ * @param schemaName - The name of the Zod schema to infer.
+ * @returns A string containing the inferred type definition.
+ */
+export declare function generateZodInfer(schema: string, config: Config): string;

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

@@ -0,0 +1,20 @@
+"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");
+/**
+ * Generates a TypeScript type definition for an inferred Zod schema.
+ *
+ * @param schemaName - The name of the Zod schema to infer.
+ * @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);
+    return `export type ${variableName} = z.infer<typeof ${schemaName}>`;
+}

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

@@ -47,4 +47,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[]): string;
+export declare function generateZodPropertiesSchema(properties: Record<string, Schema>, required: string[], namingCase?: 'camelCase' | 'PascalCase'): string;

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

@@ -50,12 +50,17 @@ 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) {
+function generateZodPropertiesSchema(properties, required, namingCase = 'camelCase') {
     const objectProperties = Object.entries(properties).map(([key, schema]) => {
         const isRequired = required.includes(key);
-        const propertySchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema);
+        const propertySchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema, namingCase);
         return `${key}:${propertySchema}${isRequired ? '' : '.optional()'}`;
     });
-    // Maybe you don't need to use .partial().
-    return `z.object({${objectProperties}})${required ? '' : '.partial()'}`;
+    const allOptional = objectProperties.every((prop) => prop.includes('.optional()'));
+    if (required.length === 0 && allOptional) {
+        const cleanProperties = objectProperties.map((prop) => prop.replace('.optional()', ''));
+        return `z.object({${cleanProperties}}).partial()`;
+    }
+    return `z.object({${objectProperties}})`;
+    // return `z.object({${objectProperties}})${required.length === 0 ? '.partial()' : ''}`
 }

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

@@ -22,4 +22,4 @@ import type { Schema } from '../../types';
  * generatePropertySchema({ type: 'string' })
  * // Returns: 'z.string()'
  */
-export declare function generatePropertySchema(schema: Schema): string;
+export declare function generatePropertySchema(schema: Schema, namingCase?: 'camelCase' | 'PascalCase'): string;

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

@@ -5,6 +5,7 @@ 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");
 // import { generateZodOpenAPIExample } from './generate-zod-openapi-example'
 /**
  * Generates a Zod schema string for a given OpenAPI schema definition
@@ -29,20 +30,25 @@ const get_camel_case_schema_name_1 = require("../../core/schema/references/get-c
  * generatePropertySchema({ type: 'string' })
  * // Returns: 'z.string()'
  */
-function generatePropertySchema(schema) {
+function generatePropertySchema(schema, namingCase = 'camelCase') {
     if (schema.$ref) {
         const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
         if (refName) {
-            const camelCaseRefName = (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(refName);
-            return (0, get_ref_name_1.getRefName)(camelCaseRefName) || 'z.any()';
+            const variableName = namingCase === 'camelCase'
+                ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(refName)
+                : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(refName);
+            // return getRefName(variableName) || 'z.any()'
+            return variableName || 'z.any()';
         }
     }
     if (schema.type === 'array' && schema.items?.$ref) {
         const refName = (0, get_ref_name_1.getRefName)(schema.items.$ref);
         if (refName) {
-            const camelCaseRefName = (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(refName);
-            return (0, generate_zod_array_1.generateZodArray)(camelCaseRefName);
+            const variableName = namingCase === 'camelCase'
+                ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(refName)
+                : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(refName);
+            return (0, generate_zod_array_1.generateZodArray)(variableName);
         }
     }
-    return (0, generate_zod_schema_1.generateZodSchema)(schema);
+    return (0, generate_zod_schema_1.generateZodSchema)(schema, undefined, undefined, namingCase);
 }

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

@@ -56,4 +56,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): string;
+export declare function generateZodSchema(schema: Schema, paramName?: string, isPath?: boolean, namingCase?: 'camelCase' | 'PascalCase'): string;

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

@@ -86,70 +86,68 @@ 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) {
-    const { type, format, pattern, minLength, maxLength, minimum, maximum, default: defaultValue, // reserved word
-    example, properties, required = [], items, enum: enumValues, additionalProperties, } = schema;
+function generateZodSchema(schema, paramName, isPath, namingCase = 'camelCase') {
     // enum
-    if (enumValues) {
-        if (example) {
-            return `z.enum(${JSON.stringify(enumValues)}).openapi({example:${JSON.stringify(example)}})`;
+    if (schema.enum) {
+        if (schema.example) {
+            return `z.enum(${JSON.stringify(schema.enum)}).openapi({example:${JSON.stringify(schema.example)}})`;
         }
-        return `z.enum(${JSON.stringify(enumValues)})`;
+        return `z.enum(${JSON.stringify(schema.enum)})`;
     }
     // object
-    if (type === 'object') {
-        if (additionalProperties)
-            return (0, generate_zod_record_schema_1.generateZodRecordSchema)(additionalProperties);
-        if (!properties)
+    if (schema.type === 'object') {
+        if (schema.additionalProperties)
+            return (0, generate_zod_record_schema_1.generateZodRecordSchema)(schema.additionalProperties);
+        if (!schema.properties)
             return 'z.object({})';
-        return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(properties, required);
+        return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(schema.properties, schema.required || [], namingCase);
     }
     // string
-    if (type === 'string') {
+    if (schema.type === 'string') {
         return (0, generate_zod_string_schema_1.generateZodStringSchema)({
-            pattern,
-            minLength,
-            maxLength,
-            format: format && (0, is_format_string_1.isFormatString)(format) ? format : undefined,
-            default: defaultValue,
-            example,
+            pattern: schema.pattern,
+            minLength: schema.minLength,
+            maxLength: schema.maxLength,
+            format: schema.format && (0, is_format_string_1.isFormatString)(schema.format) ? schema.format : undefined,
+            default: schema.default,
+            example: schema.example,
             paramName,
             isPath,
         });
     }
     // number
-    if (type === 'number') {
+    if (schema.type === 'number') {
         return (0, generate_zod_number_schema_1.generateZodNumberSchema)({
-            pattern,
-            minLength,
-            maxLength,
-            minimum,
-            maximum,
-            default: defaultValue,
-            example,
+            pattern: schema.pattern,
+            minLength: schema.minLength,
+            maxLength: schema.maxLength,
+            minimum: schema.minimum,
+            maximum: schema.maximum,
+            default: schema.default,
+            example: schema.example,
             paramName,
             isPath,
         });
     }
     // integer
-    if (type === 'integer') {
+    if (schema.type === 'integer') {
         return (0, generate_zod_integer_schema_1.generateZodIntegerSchema)({
-            minLength,
-            maxLength,
-            minimum,
-            maximum,
-            default: defaultValue,
-            example,
+            minLength: schema.minLength,
+            maxLength: schema.maxLength,
+            minimum: schema.minimum,
+            maximum: schema.maximum,
+            default: schema.default,
+            example: schema.example,
             paramName,
             isPath,
         });
     }
     // array
-    if (type === 'array' && items)
-        return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(items));
+    if (schema.type === 'array' && schema.items)
+        return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(schema.items, undefined, undefined, namingCase));
     // fallback
-    if (type)
-        return TYPE_TO_ZOD_SCHEMA[type];
-    console.warn(`Unknown type: ${type}, falling back to z.any()`);
+    if (schema.type)
+        return TYPE_TO_ZOD_SCHEMA[schema.type];
+    console.warn(`Unknown type: ${schema.type}, falling back to z.any()`);
     return 'z.any()';
 }

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import type { Config } from './config';
 /**
  * CLI entry point for hono-takibi
  *
@@ -17,4 +18,4 @@
  * npx hono-takibi openapi.yaml -o routes.ts
  * ```
  */
-export declare function main(dev?: boolean): Promise<boolean>;
+export declare function main(dev?: boolean, config?: Config): Promise<boolean>;

package/dist/index.js

@@ -10,6 +10,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const prettier_1 = require("prettier");
 const generate_zod_openapi_hono_1 = require("./generators/hono/generate-zod-openapi-hono");
+const config_1 = require("./config");
 /**
  * CLI entry point for hono-takibi
  *
@@ -28,7 +29,7 @@ const generate_zod_openapi_hono_1 = require("./generators/hono/generate-zod-open
  * npx hono-takibi openapi.yaml -o routes.ts
  * ```
  */
-async function main(dev = false) {
+async function main(dev = false, config = (0, config_1.getConfig)()) {
     // 1. argv ['**/bin/node', '**/dist/index.js', 'example/pet-store.yaml', '-o', 'routes/petstore-index.ts']
     // 2. slice [ 'example/pet-store.yaml', '-o', 'routes/petstore-index.ts' ]
     const args = process.argv.slice(2);
@@ -40,7 +41,7 @@ async function main(dev = false) {
         // 5. parse OpenAPI YAML or JSON
         const openAPI = (await swagger_parser_1.default.parse(input));
         // 6. generate Hono code
-        const hono = (0, generate_zod_openapi_hono_1.generateZodOpenAPIHono)(openAPI);
+        const hono = (0, generate_zod_openapi_hono_1.generateZodOpenAPIHono)(openAPI, config);
         // 7. format code
         const formattedCode = await (0, prettier_1.format)(hono, {
             parser: 'typescript',

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