hono-takibi 0.2.2 → 0.3.0

package/README.md

@@ -5,64 +5,7 @@
 ![img](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/img/hono-takibi.png)
 
 ```bash
-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 |
-
-## 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)
-
-```json
-{
-  "input": "src/openapi/openapi.yaml",
-  "output": "src/openapi/index.ts",
-  "schemaOptions": {
-    "namingCase": "camelCase",
-    "exportEnabled": false
-  },
-  "typeOptions": {
-    "namingCase": "PascalCase",
-    "exportEnabled": false
-  }
-}
+npm install -D hono-takibi
 ```
 
 ## Migrate Legacy APIs to Hono
@@ -501,6 +444,63 @@ export const deletePostsIdRoute = createRoute({
 })
 ```
 
+## 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 |
+|--------|------|---------|-------------|
+| `name` | `"camelCase"` \| `"PascalCase"` | `"camelCase"` | Naming convention for generated schema variables |
+| `export` | `boolean` | `false` | When true, exports all schema definitions |
+
+### Type Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `name` | `"camelCase"` \| `"PascalCase"` | `"PascalCase"` | Naming convention for generated type definitions |
+| `export` | `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)
+
+```json
+{
+  "input": "src/openapi/openapi.yaml",
+  "output": "src/openapi/index.ts",
+  "schema": {
+    "name": "camelCase",
+    "export": false
+  },
+  "type": {
+    "name": "PascalCase",
+    "export": false
+  }
+}
+```
+
 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

@@ -1,11 +1,11 @@
 export type Config = {
-    schemaOptions: {
-        namingCase: 'camelCase' | 'PascalCase';
-        exportEnabled: boolean;
+    schema: {
+        name: 'camelCase' | 'PascalCase';
+        export: boolean;
     };
-    typeOptions: {
-        namingCase: 'camelCase' | 'PascalCase';
-        exportEnabled: boolean;
+    type: {
+        name: 'camelCase' | 'PascalCase';
+        export: boolean;
     };
     input?: string;
     output?: string;

package/dist/config/index.js

@@ -7,13 +7,13 @@ exports.DEFAULT_CONFIG = void 0;
 exports.getConfig = getConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 exports.DEFAULT_CONFIG = {
-    schemaOptions: {
-        namingCase: 'camelCase',
-        exportEnabled: false,
+    schema: {
+        name: 'camelCase',
+        export: false,
     },
-    typeOptions: {
-        namingCase: 'PascalCase',
-        exportEnabled: false,
+    type: {
+        name: 'PascalCase',
+        export: false,
     },
 };
 /**

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

@@ -4,6 +4,6 @@ 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);
+    return config.type.name === 'camelCase' ? (0, decapitalize_1.decapitalize)(name) : (0, capitalize_1.capitalize)(name);
 };
 exports.getVariableNameHelper = getVariableNameHelper;

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

@@ -4,7 +4,7 @@ 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'
+    return config.schema.name === 'camelCase'
         ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(name)
         : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(name);
 };

package/dist/core/schema/references/extract-refs.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from '../../../types';
+export declare function extractRefs(schema: Schema): string[];

package/dist/core/schema/references/extract-refs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRefs = extractRefs;
+const is_ref_object_1 = require("../../validator/is-ref-object");
+function extractRefs(schema) {
+    const refs = [];
+    const traverse = (obj) => {
+        if (!(0, is_ref_object_1.isRefObject)(obj))
+            return;
+        for (const [key, value] of Object.entries(obj)) {
+            if (key !== '$ref') {
+                if ((0, is_ref_object_1.isRefObject)(value)) {
+                    traverse(value);
+                }
+                continue;
+            }
+            if (typeof value !== 'string')
+                continue;
+            const refParts = value.split('/');
+            const refName = refParts[refParts.length - 1];
+            refs.push(refName);
+        }
+    };
+    traverse(schema);
+    return refs;
+}

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

@@ -0,0 +1,11 @@
+import type { Config } from '../../../config';
+import type { Schema } from '../../../types';
+/**
+ * Retrieves the referenced schema name from a schema object.
+ *
+ * @param schema - The schema object
+ * @param config - The configuration object
+ * @returns The referenced schema name
+ * @throws Will throw an error if the $ref property or the reference name is not found
+ */
+export declare function getRefSchemaName(schema: Schema, config: Config): string;

package/dist/core/schema/references/get-ref-schema-name.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefSchemaName = getRefSchemaName;
+const get_variable_schema_name_helper_1 = require("../../helper/get-variable-schema-name-helper");
+const get_ref_name_1 = require("./get-ref-name");
+/**
+ * Retrieves the referenced schema name from a schema object.
+ *
+ * @param schema - The schema object
+ * @param config - The configuration object
+ * @returns The referenced schema name
+ * @throws Will throw an error if the $ref property or the reference name is not found
+ */
+function getRefSchemaName(schema, config) {
+    if (!schema.$ref) {
+        throw new Error('refName is not found');
+    }
+    const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
+    if (!refName) {
+        throw new Error('refName is not found');
+    }
+    return (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
+}

package/dist/core/schema/references/resolve-schemas-dependencies.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSchemasDependencies = resolveSchemasDependencies;
-const resolve_schema_order_1 = require("./resolve-schema-order");
-const resolve_schema_references_1 = require("./resolve-schema-references");
+const extract_refs_1 = require("./extract-refs");
 /**
  * Resolves dependencies between schemas and returns them in topological order for safe processing
  *
@@ -50,16 +49,50 @@ const resolve_schema_references_1 = require("./resolve-schema-references");
  * - Uses depth-first search for dependency resolution
  * - Automatically handles circular dependencies by preventing infinite recursion
  */
+// export function resolveSchemasDependencies(schemas: Record<string, Schema>): string[] {
+//   // 1. get schema reference relations as a map
+//   const dependencies = resolveSchemaReferences(schemas)
+//   // 2. initialize ordered list and visited set
+//   const ordered: string[] = []
+//   const visited = new Set<string>()
+//   // 3. resolve schema order
+//   for (const name of Object.keys(schemas)) {
+//     resolveSchemaOrder(name, dependencies, visited, ordered)
+//   }
+//   // 4. return ordered list
+//   return ordered
+// }
 function resolveSchemasDependencies(schemas) {
-    // 1. get schema reference relations as a map
-    const dependencies = (0, resolve_schema_references_1.resolveSchemaReferences)(schemas);
-    // 2. initialize ordered list and visited set
-    const ordered = [];
-    const visited = new Set();
-    // 3. resolve schema order
-    for (const name of Object.keys(schemas)) {
-        (0, resolve_schema_order_1.resolveSchemaOrder)(name, dependencies, visited, ordered);
+    const visited = {};
+    const temp = {};
+    const result = [];
+    const visit = (schemaName) => {
+        if (temp[schemaName]) {
+            throw new Error(`bad schema: ${schemaName}`);
+        }
+        if (!visited[schemaName]) {
+            temp[schemaName] = true;
+            const schema = schemas[schemaName];
+            if (schema) {
+                const refs = (0, extract_refs_1.extractRefs)(schema);
+                for (const ref of refs) {
+                    if (schemas[ref]) {
+                        visit(ref);
+                    }
+                    else {
+                        console.warn(`not found schema: ${ref}`);
+                    }
+                }
+            }
+            visited[schemaName] = true;
+            temp[schemaName] = false;
+            result.push(schemaName);
+        }
+    };
+    for (const schemaName of Object.keys(schemas)) {
+        if (!visited[schemaName]) {
+            visit(schemaName);
+        }
     }
-    // 4. return ordered list
-    return ordered;
+    return result;
 }

package/dist/core/validator/is-nullable-schema.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '../../types';
+/**
+ * Determines whether a given sub-schema is `nullable`.
+ *
+ * @param subSchema - The sub-schema to evaluate
+ * @returns `true` if `nullable` is set to `true` and it is the only key in the schema, otherwise `false`
+ */
+export declare function isNullableSchema(schema: Schema): boolean;

package/dist/core/validator/is-nullable-schema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullableSchema = isNullableSchema;
+/**
+ * Determines whether a given sub-schema is `nullable`.
+ *
+ * @param subSchema - The sub-schema to evaluate
+ * @returns `true` if `nullable` is set to `true` and it is the only key in the schema, otherwise `false`
+ */
+function isNullableSchema(schema) {
+    return 'nullable' in schema && schema.nullable === true && Object.keys(schema).length === 1;
+}

package/dist/core/validator/is-ref-object.d.ts

@@ -0,0 +1,6 @@
+type RefObject = {
+    $ref?: string;
+    [key: string]: unknown;
+};
+export declare function isRefObject(value: unknown): value is RefObject;
+export {};

package/dist/core/validator/is-ref-object.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRefObject = isRefObject;
+function isRefObject(value) {
+    return typeof value === 'object' && value !== null;
+}

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

@@ -28,7 +28,7 @@ function generateZodOpenAPIHono(openAPISpec, config) {
     // 5. generate types code
     const typesCode = (0, generate_types_code_1.generateTypesCode)(components, config);
     // 6. generate hono code
-    if (config.typeOptions.exportEnabled) {
+    if (config.type.export) {
         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/allof/generate-allof-code.d.ts

@@ -0,0 +1,10 @@
+import type { Schema } from '../../../../types';
+import type { Config } from '../../../../config';
+/**
+ * Converts an `allOf` schema into a Zod schema.
+ *
+ * @param schema - The OpenAPI schema object.
+ * @param config - The configuration object.
+ * @returns The generated Zod schema as a string.
+ */
+export declare function generateAllOfCode(schema: Schema, config: Config): string;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAllOfCode = generateAllOfCode;
+const process_alllof_1 = require("./process/process-alllof");
+/**
+ * Converts an `allOf` schema into a Zod schema.
+ *
+ * @param schema - The OpenAPI schema object.
+ * @param config - The configuration object.
+ * @returns The generated Zod schema as a string.
+ */
+function generateAllOfCode(schema, config) {
+    if (!schema.allOf || schema.allOf.length === 0) {
+        console.warn('not exists allOf');
+        return 'z.any()';
+    }
+    const { nullable, schemas } = (0, process_alllof_1.processAllOf)(schema.allOf, config);
+    if (schemas.length === 0) {
+        return nullable ? 'z.any().nullable()' : 'z.any()';
+    }
+    if (schemas.length === 1) {
+        return nullable ? `${schemas[0]}.nullable()` : schemas[0];
+    }
+    const intersection = `z.intersection(${schemas.join(',')})${nullable ? '.nullable()' : ''}`;
+    return intersection;
+}

package/dist/generators/openapi/components/allof/process/process-alllof.d.ts

@@ -0,0 +1,15 @@
+import type { Config } from '../../../../../config';
+import type { Schema } from '../../../../../types';
+type Accumulator = {
+    nullable: boolean;
+    schemas: string[];
+};
+/**
+ * Processes the `allOf` array, separating the `nullable` flag and the array of schemas.
+ *
+ * @param allOf - The `allOf` array.
+ * @param config - The configuration object.
+ * @returns An object containing the `nullable` flag and the generated array of schemas.
+ */
+export declare function processAllOf(allOf: Schema[], config: Config): Accumulator;
+export {};

package/dist/generators/openapi/components/allof/process/process-alllof.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAllOf = processAllOf;
+const is_nullable_schema_1 = require("../../../../../core/validator/is-nullable-schema");
+const generate_zod_schema_from_sub_schema_1 = require("../../../../zod/sub/generate-zod-schema-from-sub-schema");
+/**
+ * Processes the `allOf` array, separating the `nullable` flag and the array of schemas.
+ *
+ * @param allOf - The `allOf` array.
+ * @param config - The configuration object.
+ * @returns An object containing the `nullable` flag and the generated array of schemas.
+ */
+function processAllOf(allOf, config) {
+    return allOf.reduce((acc, subSchema) => {
+        if ((0, is_nullable_schema_1.isNullableSchema)(subSchema)) {
+            acc.nullable = true;
+            return acc;
+        }
+        const zodSchema = (0, generate_zod_schema_from_sub_schema_1.generateZodSchemaFromSubSchema)(subSchema, config);
+        acc.schemas.push(zodSchema);
+        return acc;
+    }, { nullable: false, schemas: [] });
+}

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAnyOfCode = generateAnyOfCode;
+const generate_zod_schema_1 = require("../../../zod/generate-zod-schema");
+const get_ref_schema_name_1 = require("../../../../core/schema/references/get-ref-schema-name");
+function generateAnyOfCode(schema, config) {
+    if (!schema.anyOf || schema.anyOf.length === 0) {
+        console.warn('not exists anyOf');
+        return 'z.any()';
+    }
+    const zodSchemas = schema.anyOf.map((subSchema) => {
+        subSchema.$ref ? (0, get_ref_schema_name_1.getRefSchemaName)(subSchema, config) : (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
+        return (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
+    });
+    return `z.union([${zodSchemas.join(', ')}])`;
+}

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

@@ -49,7 +49,7 @@ config) {
     // 5. generate export statement
     const exports = (0, generate_schemas_export_1.generateSchemasExport)(orderedSchemas, config);
     // 6. final code assembly
-    if (config.schemaOptions.exportEnabled) {
+    if (config.schema.export) {
         return `${schemaDefinitions}\n\n${exports}`;
     }
     return schemaDefinitions;

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

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

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOneOfCode = generateOneOfCode;
+const generate_zod_schema_1 = require("../../../zod/generate-zod-schema");
+const get_ref_schema_name_1 = require("../../../../core/schema/references/get-ref-schema-name");
+function generateOneOfCode(schema, config) {
+    if (!schema.oneOf || schema.oneOf.length === 0) {
+        console.warn('not exists oneOf');
+        return 'z.any()';
+    }
+    const zodSchemas = schema.oneOf.map((subSchema) => {
+        subSchema.$ref ? (0, get_ref_schema_name_1.getRefSchemaName)(subSchema, config) : (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
+        return (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
+    });
+    return `z.union([${zodSchemas.join(',')}])`;
+}

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

@@ -34,7 +34,7 @@ config) {
         const response = responses[code];
         // 2.1 no content (description only response)
         if (!response.content)
-            return `${code}:{description:'${(0, escape_quote_1.escapeQuote)(response.description)}',},`;
+            return `${code}:{description:'${(0, escape_quote_1.escapeQuote)(response.description ?? '')}',},`;
         // check duplication
         const contentTypes = Object.keys(response.content);
         const isUniqueSchema = (0, is_unique_content_schema_1.isUniqueContentSchema)(contentTypes, response.content);
@@ -46,7 +46,7 @@ config) {
                 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(',')}},},`;
+            return `${code}:{description:'${(0, escape_quote_1.escapeQuote)(response.description ?? '')}',content:{${contentParts.join(',')}},},`;
         }
     });
     // 3.combine all response definitions

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

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

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

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

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

@@ -2,7 +2,7 @@
 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_partial_schema_1 = require("./generate-zod-partial-schema");
 const generate_zod_property_schema_1 = require("./generate-zod-property-schema");
 /**
  * Generates a Zod object schema with properties and their requirements
@@ -64,7 +64,7 @@ config) {
     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) {
-        return (0, generate_partial_schema_1.generatePartialSchema)(objectProperties);
+        return (0, generate_zod_partial_schema_1.generateZodPartialSchema)(objectProperties);
     }
     return `z.object({${objectProperties}})`;
 }

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

@@ -8,6 +8,10 @@ const generate_zod_record_schema_1 = require("./generate-zod-record-schema");
 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_integer_schema_1 = require("./generate-zod-integer-schema");
+const generate_allof_code_1 = require("../openapi/components/allof/generate-allof-code");
+const generate_anyof_code_1 = require("../openapi/components/anyof/generate-anyof-code");
+const generate_oneof_code_1 = require("../openapi/components/oneof/generate-oneof-code");
+const get_variable_schema_name_helper_1 = require("../../core/helper/get-variable-schema-name-helper");
 /**
  * Mapping of OpenAPI/JSON Schema types to Zod schema strings
  *
@@ -98,8 +102,19 @@ function generateZodSchema(config, schema, paramName, isPath) {
     if (schema.type === 'object') {
         if (schema.additionalProperties)
             return (0, generate_zod_record_schema_1.generateZodRecordSchema)(schema.additionalProperties, config);
-        if (!schema.properties)
+        if (schema.allOf) {
+            return (0, generate_allof_code_1.generateAllOfCode)(schema, config);
+        }
+        if (schema.oneOf) {
+            return (0, generate_oneof_code_1.generateOneOfCode)(schema, config);
+        }
+        if (schema.anyOf) {
+            return (0, generate_anyof_code_1.generateAnyOfCode)(schema, config);
+        }
+        if (!schema.properties) {
+            // console.log(schema)
             return 'z.object({})';
+        }
         return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(schema.properties, schema.required || [], config);
     }
     // string
@@ -145,9 +160,25 @@ function generateZodSchema(config, schema, paramName, isPath) {
     // array
     if (schema.type === 'array' && schema.items)
         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);
+    }
+    if (schema.anyOf) {
+        return (0, generate_anyof_code_1.generateAnyOfCode)(schema, config);
+    }
+    if (schema.oneOf) {
+        return (0, generate_oneof_code_1.generateOneOfCode)(schema, config);
+    }
+    if (schema.$ref) {
+        const refParts = schema.$ref.split('/');
+        const refName = refParts[refParts.length - 1];
+        const schemaName = (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
+        return schemaName;
+    }
     // fallback
-    if (schema.type)
+    if (schema.type) {
         return TYPE_TO_ZOD_SCHEMA[schema.type];
-    console.warn(`Unknown type: ${schema.type}, falling back to z.any()`);
+    }
+    console.warn(`Unknown type: ${schema.type}, ${JSON.stringify(schema)} falling back to z.any()`);
     return 'z.any()';
 }

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

@@ -0,0 +1,10 @@
+import type { Config } from '../../../config';
+import type { Schema } from '../../../types';
+/**
+ * Generates a Zod schema from a sub-schema.
+ *
+ * @param subSchema - The sub-schema object.
+ * @param config - The configuration object.
+ * @returns The generated Zod schema as a string.
+ */
+export declare function generateZodSchemaFromSubSchema(subSchema: Schema, config: Config): string;

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodSchemaFromSubSchema = generateZodSchemaFromSubSchema;
+const get_ref_schema_name_1 = require("../../../core/schema/references/get-ref-schema-name");
+const generate_zod_schema_1 = require("../generate-zod-schema");
+/**
+ * Generates a Zod schema from a sub-schema.
+ *
+ * @param subSchema - The sub-schema object.
+ * @param config - The configuration object.
+ * @returns The generated Zod schema as a string.
+ */
+function generateZodSchemaFromSubSchema(subSchema, config) {
+    return subSchema.$ref ? (0, get_ref_schema_name_1.getRefSchemaName)(subSchema, config) : (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
+}

package/dist/types/index.d.ts

@@ -83,7 +83,7 @@ type SecurityRequirementObject = {
  * Operation definition
  */
 export type Operation = {
-    tags: string[];
+    tags?: string[];
     summary?: string;
     description?: string;
     operationId?: string;
@@ -96,8 +96,9 @@ export type Operation = {
  * Response definition with description and content
  */
 export type ResponseDefinition = {
-    description: string;
+    description?: string;
     content?: Content;
+    $ref?: string;
     headers?: {
         [key: string]: {
             description?: string;
@@ -130,6 +131,7 @@ export type Schema = {
     required?: string[];
     items?: Schema;
     enum?: string[];
+    nullable?: boolean;
     additionalProperties?: {
         type: Type;
         format: Format;
@@ -140,6 +142,15 @@ export type Schema = {
         wrapped?: boolean;
     };
     security?: SecurityRequirementObject[];
+    oneOf?: Schema[];
+    allOf?: Schema[];
+    anyOf?: Schema[];
+    discriminator?: {
+        propertyName?: string;
+    };
+    externalDocs?: {
+        url?: string;
+    };
 };
 /**
  * Components section of OpenAPI spec

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

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

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