hono-takibi 0.0.1

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

@@ -0,0 +1,34 @@
+/**
+ * Generates a request object with parameters and optional request body
+ *
+ * @function generateRequestParams
+ * @param required - Whether the request body is required
+ * @param zodSchema - Zod schema string for request body validation
+ * @returns Generated request body configuration string
+ *
+ * @example
+ * // Required request body with user schema
+ * generateRequestBody(true, 'z.object({ name: z.string() })')
+ * // Returns:
+ * // body:{
+ * //   required:true,
+ * //   content:{
+ * //     'application/json':{
+ * //       schema:z.object({ name: z.string() }),
+ * //     },
+ * //   },
+ * // },
+ *
+ * // Optional request body with post schema
+ * generateRequestBody(false, 'z.object({ title: z.string() })')
+ * // Returns:
+ * // body:{
+ * //   required:false,
+ * //   content:{
+ * //     'application/json':{
+ * //       schema:z.object({ title: z.string() }),
+ * //     },
+ * //   },
+ * // },
+ */
+export declare function generateRequestParams(requestBodyCode: string): string;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestParams = generateRequestParams;
+/**
+ * Generates a request object with parameters and optional request body
+ *
+ * @function generateRequestParams
+ * @param required - Whether the request body is required
+ * @param zodSchema - Zod schema string for request body validation
+ * @returns Generated request body configuration string
+ *
+ * @example
+ * // Required request body with user schema
+ * generateRequestBody(true, 'z.object({ name: z.string() })')
+ * // Returns:
+ * // body:{
+ * //   required:true,
+ * //   content:{
+ * //     'application/json':{
+ * //       schema:z.object({ name: z.string() }),
+ * //     },
+ * //   },
+ * // },
+ *
+ * // Optional request body with post schema
+ * generateRequestBody(false, 'z.object({ title: z.string() })')
+ * // Returns:
+ * // body:{
+ * //   required:false,
+ * //   content:{
+ * //     'application/json':{
+ * //       schema:z.object({ title: z.string() }),
+ * //     },
+ * //   },
+ * // },
+ */
+function generateRequestParams(requestBodyCode) {
+    return `request:{${requestBodyCode}},`;
+}

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

@@ -0,0 +1,59 @@
+import type { Responses } from '../../../types';
+/**
+ * Generates a response schema for different status codes
+ *
+ * @function generateResponseSchema
+ * @param responses - OpenAPI response definitions for different status codes
+ * @returns Generated TypeScript code string for response validation
+ *
+ * @example
+ * const responses = {
+ *   '200': {
+ *     description: 'Success response',
+ *     content: {
+ *       'application/json': {
+ *         schema: {
+ *           type: 'object',
+ *           properties: {
+ *             users: {
+ *               type: 'array',
+ *               items: { $ref: '#/components/schemas/User' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   '404': {
+ *     description: 'Not found',
+ *     content: {
+ *       'application/json': {
+ *         schema: { $ref: '#/components/schemas/Error' }
+ *       }
+ *     }
+ *   },
+ *   '204': {
+ *     description: 'No content'
+ *   }
+ * }
+ *
+ * const schema = generateResponseSchema(responses)
+ * // Returns:
+ * // 200:{description:'Success response',content:{'application/json':{schema:z.object({users:z.array(User)})}}},
+ * // 404:{description:'Not found',content:{'application/json':{schema:Error}}},
+ * // 204:{description:'No content',}
+ *
+ * @note
+ * - Handles multiple response status codes
+ * - Supports:
+ *   - JSON response bodies
+ *   - Schema references
+ *   - Array responses
+ *   - No-content responses
+ *   - Inline schema definitions
+ * - Generates Zod validation schemas for each response
+ * - Preserves response descriptions
+ * - Handles nested schema structures
+ * - Automatically resolves schema references
+ */
+export declare function generateResponseSchema(responses: Responses): string;

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateResponseSchema = generateResponseSchema;
+const generate_zod_property_schema_1 = require("../../zod/generate-zod-property-schema");
+/**
+ * Generates a response schema for different status codes
+ *
+ * @function generateResponseSchema
+ * @param responses - OpenAPI response definitions for different status codes
+ * @returns Generated TypeScript code string for response validation
+ *
+ * @example
+ * const responses = {
+ *   '200': {
+ *     description: 'Success response',
+ *     content: {
+ *       'application/json': {
+ *         schema: {
+ *           type: 'object',
+ *           properties: {
+ *             users: {
+ *               type: 'array',
+ *               items: { $ref: '#/components/schemas/User' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   },
+ *   '404': {
+ *     description: 'Not found',
+ *     content: {
+ *       'application/json': {
+ *         schema: { $ref: '#/components/schemas/Error' }
+ *       }
+ *     }
+ *   },
+ *   '204': {
+ *     description: 'No content'
+ *   }
+ * }
+ *
+ * const schema = generateResponseSchema(responses)
+ * // Returns:
+ * // 200:{description:'Success response',content:{'application/json':{schema:z.object({users:z.array(User)})}}},
+ * // 404:{description:'Not found',content:{'application/json':{schema:Error}}},
+ * // 204:{description:'No content',}
+ *
+ * @note
+ * - Handles multiple response status codes
+ * - Supports:
+ *   - JSON response bodies
+ *   - Schema references
+ *   - Array responses
+ *   - No-content responses
+ *   - Inline schema definitions
+ * - Generates Zod validation schemas for each response
+ * - Preserves response descriptions
+ * - Handles nested schema structures
+ * - Automatically resolves schema references
+ */
+function generateResponseSchema(responses) {
+    // 1. get response codes (200, 404, etc.)
+    const responseCodes = Object.keys(responses);
+    // 2. processing for each response code
+    const responseEntries = responseCodes.map((code) => {
+        const response = responses[code];
+        // 2.1 no content (description only response)
+        if (!response.content)
+            return `${code}:{description:'${response.description}',},`;
+        // 2.2 processing application/json content types
+        const jsonContent = response.content['application/json'];
+        if (!jsonContent)
+            return `${code}:{description:'${response.description}',},`;
+        // 2.3 generate zod schema
+        const schema = jsonContent.schema;
+        const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema);
+        // 2.4 generating a response definition
+        return `${code}:{description:'${response.description}',content:{'application/json':{schema:${zodSchema},},},},`;
+    });
+    // 3.combine all response definitions
+    return responseEntries.join('');
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Generates a Zod array schema with the specified schema type
+ *
+ * @function generateZodArray
+ * @param zodSchema - Schema type for array elements (e.g., 'Address', 'z.string().min(3)')
+ * @returns Zod array schema string wrapped with z.array()
+ *
+ * @example
+ * // With type reference
+ * generateZodArray('Address')
+ * // Returns: 'z.array(Address)'
+ *
+ * // With primitive Zod schema
+ * generateZodArray('z.string()')
+ * // Returns: 'z.array(z.string())'
+ *
+ * // With complex Zod schema
+ * generateZodArray('z.string().min(3).max(10)')
+ * // Returns: 'z.array(z.string().min(3).max(10))'
+ *
+ * // With nested schema
+ * generateZodArray('z.object({ name: z.string() })')
+ * // Returns: 'z.array(z.object({ name: z.string() }))'
+ *
+ * @note
+ * - Commonly used in OpenAPI to Zod schema conversion
+ * - Accepts both type references and Zod schema strings
+ * - The input schema should be a valid Zod schema or type reference
+ * - Used for generating array type validations
+ */
+export declare function generateZodArray(zodSchema: string): string;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodArray = generateZodArray;
+/**
+ * Generates a Zod array schema with the specified schema type
+ *
+ * @function generateZodArray
+ * @param zodSchema - Schema type for array elements (e.g., 'Address', 'z.string().min(3)')
+ * @returns Zod array schema string wrapped with z.array()
+ *
+ * @example
+ * // With type reference
+ * generateZodArray('Address')
+ * // Returns: 'z.array(Address)'
+ *
+ * // With primitive Zod schema
+ * generateZodArray('z.string()')
+ * // Returns: 'z.array(z.string())'
+ *
+ * // With complex Zod schema
+ * generateZodArray('z.string().min(3).max(10)')
+ * // Returns: 'z.array(z.string().min(3).max(10))'
+ *
+ * // With nested schema
+ * generateZodArray('z.object({ name: z.string() })')
+ * // Returns: 'z.array(z.object({ name: z.string() }))'
+ *
+ * @note
+ * - Commonly used in OpenAPI to Zod schema conversion
+ * - Accepts both type references and Zod schema strings
+ * - The input schema should be a valid Zod schema or type reference
+ * - Used for generating array type validations
+ */
+function generateZodArray(zodSchema) {
+    return `z.array(${zodSchema})`;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * @description
+ * Generates a zod pipe function to coerce a value to a zod schema.
+ *
+ * @function generateZodCoerce
+ * @param z - The zod schema to coerce to.
+ * @param zodSchema - The zod schema to coerce.
+ * @returns A zod pipe function to coerce a value to a zod schema.
+ */
+export declare function generateZodCoerce(z: string, zodSchema: string): string;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodCoerce = generateZodCoerce;
+const remove_zod_prefix_1 = require("../../core/text/remove-zod-prefix");
+/**
+ * @description
+ * Generates a zod pipe function to coerce a value to a zod schema.
+ *
+ * @function generateZodCoerce
+ * @param z - The zod schema to coerce to.
+ * @param zodSchema - The zod schema to coerce.
+ * @returns A zod pipe function to coerce a value to a zod schema.
+ */
+function generateZodCoerce(z, zodSchema) {
+    const zod = (0, remove_zod_prefix_1.removeZodPrefix)(zodSchema);
+    return `${z}.pipe(z.coerce.${zod})`;
+}

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

@@ -0,0 +1,15 @@
+type GenerateZodIntegerSchemaParams = {
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+};
+/**
+ * Generates a zod schema for an integer.
+ *
+ * @function generateZodIntegerSchema
+ * @param args - The parameters to generate the zod schema.
+ * @returns A zod schema for an integer.
+ */
+export declare function generateZodIntegerSchema(args: GenerateZodIntegerSchemaParams): string;
+export {};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodIntegerSchema = generateZodIntegerSchema;
+/**
+ * Generates a zod schema for an integer.
+ *
+ * @function generateZodIntegerSchema
+ * @param args - The parameters to generate the zod schema.
+ * @returns A zod schema for an integer.
+ */
+function generateZodIntegerSchema(args) {
+    const validations = ['z.number().int()'];
+    const { minLength, maxLength, minimum, maximum } = args;
+    if (minLength)
+        validations.push(`.min(${minLength})`);
+    if (maxLength)
+        validations.push(`.max(${maxLength})`);
+    // 0 falsy value
+    if (typeof minimum === 'number')
+        validations.push(`.min(${minimum})`);
+    if (typeof maximum === 'number')
+        validations.push(`.max(${maximum})`);
+    return validations.join('');
+}

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

@@ -0,0 +1,16 @@
+type GenerateZodNumberSchemaParams = {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+};
+/**
+ * Generates a zod schema for a number.
+ *
+ * @function generateZodNumberSchema
+ * @param args - The parameters to generate the zod schema.
+ * @returns A zod schema for a number.
+ */
+export declare function generateZodNumberSchema(args: GenerateZodNumberSchemaParams): string;
+export {};

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodNumberSchema = generateZodNumberSchema;
+/**
+ * Generates a zod schema for a number.
+ *
+ * @function generateZodNumberSchema
+ * @param args - The parameters to generate the zod schema.
+ * @returns A zod schema for a number.
+ */
+function generateZodNumberSchema(args) {
+    const validations = ['z.number()'];
+    const { pattern, minLength, maxLength, minimum, maximum } = args;
+    if (pattern)
+        validations.push(`.regex(/${pattern}/)`);
+    if (minLength)
+        validations.push(`.min(${minLength})`);
+    if (maxLength)
+        validations.push(`.max(${maxLength})`);
+    // 0 falsy value
+    if (typeof minimum === 'number')
+        validations.push(`.min(${minimum})`);
+    if (typeof maximum === 'number')
+        validations.push(`.max(${maximum})`);
+    return validations.join('');
+}

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

@@ -0,0 +1,36 @@
+/**
+ * Generates a Zod object schema from a record of property types
+ *
+ * @function generateZodObjectSchema
+ * @param object - Record of property names and their Zod type strings
+ * @returns Generated Zod object schema string
+ *
+ * @example
+ * // Basic object
+ * generateZodObjectSchema({ name: 'z.string()' })
+ * // Returns: 'z.object({name:z.string()})'
+ *
+ * // Multiple properties
+ * generateZodObjectSchema({
+ *   name: 'z.string()',
+ *   age: 'z.number()',
+ *   isActive: 'z.boolean()'
+ * })
+ * // Returns: 'z.object({name:z.string(),age:z.number(),isActive:z.boolean()})'
+ *
+ * // With validated types
+ * generateZodObjectSchema({
+ *   email: 'z.string().email()',
+ *   age: 'z.number().min(0)'
+ * })
+ * // Returns: 'z.object({email:z.string().email(),age:z.number().min(0)})'
+ *
+ * @note
+ * - Each property value should be a valid Zod type string
+ * - Properties are joined with commas in the resulting object
+ * - Commonly used for generating simple object schemas
+ * - Does not support nested objects directly (use full schema generator for complex objects)
+ *
+ * @see generateZodSchema for complex object schema generation
+ */
+export declare function generateZodObjectSchema(object: Record<string, string>): string;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodObjectSchema = generateZodObjectSchema;
+/**
+ * Generates a Zod object schema from a record of property types
+ *
+ * @function generateZodObjectSchema
+ * @param object - Record of property names and their Zod type strings
+ * @returns Generated Zod object schema string
+ *
+ * @example
+ * // Basic object
+ * generateZodObjectSchema({ name: 'z.string()' })
+ * // Returns: 'z.object({name:z.string()})'
+ *
+ * // Multiple properties
+ * generateZodObjectSchema({
+ *   name: 'z.string()',
+ *   age: 'z.number()',
+ *   isActive: 'z.boolean()'
+ * })
+ * // Returns: 'z.object({name:z.string(),age:z.number(),isActive:z.boolean()})'
+ *
+ * // With validated types
+ * generateZodObjectSchema({
+ *   email: 'z.string().email()',
+ *   age: 'z.number().min(0)'
+ * })
+ * // Returns: 'z.object({email:z.string().email(),age:z.number().min(0)})'
+ *
+ * @note
+ * - Each property value should be a valid Zod type string
+ * - Properties are joined with commas in the resulting object
+ * - Commonly used for generating simple object schemas
+ * - Does not support nested objects directly (use full schema generator for complex objects)
+ *
+ * @see generateZodSchema for complex object schema generation
+ */
+function generateZodObjectSchema(object) {
+    return `z.object({${Object.entries(object)
+        .map(([key, val]) => `${key}:${val}`)
+        .join(',')}})`;
+}

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

@@ -0,0 +1,50 @@
+import type { Schema } from '../../types';
+/**
+ * Generates a Zod object schema with properties and their requirements
+ *
+ * @function generateZodPropertiesSchema
+ * @param properties - Record of property names to their schema definitions
+ * @param required - Array of property names that are required
+ * @returns Generated Zod object schema string
+ *
+ * @example
+ * // Order schema with optional fields
+ * generateZodPropertiesSchema(
+ *   {
+ *     id: { type: 'integer', format: 'int64' },
+ *     status: { type: 'string', enum: ['placed', 'approved', 'delivered'] }
+ *   },
+ *   []
+ * )
+ * // Returns: 'z.object({id: z.number().int().optional(),status: z.enum(["placed","approved","delivered"]).optional()})'
+ *
+ * @example
+ * // Pet schema with required fields
+ * generateZodPropertiesSchema(
+ *   {
+ *     name: { type: 'string' },
+ *     photoUrls: { type: 'array', items: { type: 'string' } }
+ *   },
+ *   ['name', 'photoUrls']
+ * )
+ * // Returns: 'z.object({name: z.string(),photoUrls: z.array(z.string())})'
+ *
+ * @example
+ * // Address schema with references
+ * generateZodPropertiesSchema(
+ *   {
+ *     category: { '$ref': '#/components/schemas/Category' },
+ *     tags: { type: 'array', items: { '$ref': '#/components/schemas/Tag' } }
+ *   },
+ *   []
+ * )
+ * // Returns: 'z.object({category: categorySchema.optional(),tags: z.array(tagSchema).optional()})'
+ *
+ * @remarks
+ * - Generates Zod schema strings for object properties
+ * - Handles required and optional properties
+ * - Supports primitive types, arrays, and references
+ * - Uses .partial() when no properties are required
+ * - Maintains property order from input
+ */
+export declare function generateZodPropertiesSchema(properties: Record<string, Schema>, required: string[]): string;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodPropertiesSchema = generateZodPropertiesSchema;
+const generate_zod_property_schema_1 = require("./generate-zod-property-schema");
+/**
+ * Generates a Zod object schema with properties and their requirements
+ *
+ * @function generateZodPropertiesSchema
+ * @param properties - Record of property names to their schema definitions
+ * @param required - Array of property names that are required
+ * @returns Generated Zod object schema string
+ *
+ * @example
+ * // Order schema with optional fields
+ * generateZodPropertiesSchema(
+ *   {
+ *     id: { type: 'integer', format: 'int64' },
+ *     status: { type: 'string', enum: ['placed', 'approved', 'delivered'] }
+ *   },
+ *   []
+ * )
+ * // Returns: 'z.object({id: z.number().int().optional(),status: z.enum(["placed","approved","delivered"]).optional()})'
+ *
+ * @example
+ * // Pet schema with required fields
+ * generateZodPropertiesSchema(
+ *   {
+ *     name: { type: 'string' },
+ *     photoUrls: { type: 'array', items: { type: 'string' } }
+ *   },
+ *   ['name', 'photoUrls']
+ * )
+ * // Returns: 'z.object({name: z.string(),photoUrls: z.array(z.string())})'
+ *
+ * @example
+ * // Address schema with references
+ * generateZodPropertiesSchema(
+ *   {
+ *     category: { '$ref': '#/components/schemas/Category' },
+ *     tags: { type: 'array', items: { '$ref': '#/components/schemas/Tag' } }
+ *   },
+ *   []
+ * )
+ * // Returns: 'z.object({category: categorySchema.optional(),tags: z.array(tagSchema).optional()})'
+ *
+ * @remarks
+ * - Generates Zod schema strings for object properties
+ * - Handles required and optional properties
+ * - Supports primitive types, arrays, and references
+ * - Uses .partial() when no properties are required
+ * - Maintains property order from input
+ */
+function generateZodPropertiesSchema(properties, required) {
+    const objectProperties = Object.entries(properties).map(([key, schema]) => {
+        const isRequired = required.includes(key);
+        const propertySchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema);
+        return `${key}: ${propertySchema}${isRequired ? '' : '.optional()'}`;
+    });
+    return `z.object({${objectProperties}})${required ? '' : '.partial()'}`;
+}

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

@@ -0,0 +1,25 @@
+import type { Schema } from '../../types';
+/**
+ * Generates a Zod schema string for a given OpenAPI schema definition
+ *
+ * @function generatePropertySchema
+ * @param schema - OpenAPI schema definition
+ * @returns Generated Zod schema string
+ *
+ * @example
+ * // Reference type
+ * generatePropertySchema({ $ref: '#/components/schemas/User' })
+ * // Returns: 'userSchema'
+ *
+ * // Array with reference type
+ * generatePropertySchema({
+ *   type: 'array',
+ *   items: { $ref: '#/components/schemas/Post' }
+ * })
+ * // Returns: 'z.array(postSchema)'
+ *
+ * // Basic type
+ * generatePropertySchema({ type: 'string' })
+ * // Returns: 'z.string()'
+ */
+export declare function generatePropertySchema(schema: Schema): string;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+/**
+ * Generates a Zod schema string for a given OpenAPI schema definition
+ *
+ * @function generatePropertySchema
+ * @param schema - OpenAPI schema definition
+ * @returns Generated Zod schema string
+ *
+ * @example
+ * // Reference type
+ * generatePropertySchema({ $ref: '#/components/schemas/User' })
+ * // Returns: 'userSchema'
+ *
+ * // Array with reference type
+ * generatePropertySchema({
+ *   type: 'array',
+ *   items: { $ref: '#/components/schemas/Post' }
+ * })
+ * // Returns: 'z.array(postSchema)'
+ *
+ * // Basic type
+ * generatePropertySchema({ type: 'string' })
+ * // Returns: 'z.string()'
+ */
+function generatePropertySchema(schema) {
+    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()';
+        }
+    }
+    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);
+        }
+    }
+    return (0, generate_zod_schema_1.generateZodSchema)(schema);
+}