hono-takibi 0.0.1

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

@@ -0,0 +1,34 @@
+import type { Format, Type } from '../../types';
+/**
+ * Generates a Zod record schema for objects with additional properties
+ *
+ * @function generateZodRecordSchema
+ * @param additionalProperties - Schema definition for record values
+ * @param additionalProperties.type - Type of the record values (e.g., 'string', 'number')
+ * @param additionalProperties.format - Format specification for the value type (e.g., 'date-time', 'email')
+ * @returns Generated Zod record schema string
+ *
+ * @example
+ * // Basic string values
+ * generateZodRecordSchema({ type: 'string', format: undefined })
+ * // Returns: 'z.record(z.string(), z.string())'
+ *
+ * @example
+ * // Email format values
+ * generateZodRecordSchema({ type: 'string', format: 'email' })
+ * // Returns: 'z.record(z.string(), z.string().email())'
+ *
+ * @example
+ * // Integer values
+ * generateZodRecordSchema({ type: 'integer', format: 'int64' })
+ * // Returns: 'z.record(z.string(), z.number().int())'
+ *
+ * @remarks
+ * - Always uses string keys (z.string())
+ * - Value type is determined by the additionalProperties schema
+ * - Supports all Zod-compatible types and formats
+ */
+export declare function generateZodRecordSchema(additionalProperties: {
+    type: Type;
+    format: Format;
+}): string;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodRecordSchema = generateZodRecordSchema;
+const generate_zod_schema_1 = require("./generate-zod-schema");
+/**
+ * Generates a Zod record schema for objects with additional properties
+ *
+ * @function generateZodRecordSchema
+ * @param additionalProperties - Schema definition for record values
+ * @param additionalProperties.type - Type of the record values (e.g., 'string', 'number')
+ * @param additionalProperties.format - Format specification for the value type (e.g., 'date-time', 'email')
+ * @returns Generated Zod record schema string
+ *
+ * @example
+ * // Basic string values
+ * generateZodRecordSchema({ type: 'string', format: undefined })
+ * // Returns: 'z.record(z.string(), z.string())'
+ *
+ * @example
+ * // Email format values
+ * generateZodRecordSchema({ type: 'string', format: 'email' })
+ * // Returns: 'z.record(z.string(), z.string().email())'
+ *
+ * @example
+ * // Integer values
+ * generateZodRecordSchema({ type: 'integer', format: 'int64' })
+ * // Returns: 'z.record(z.string(), z.number().int())'
+ *
+ * @remarks
+ * - Always uses string keys (z.string())
+ * - 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);
+    return `z.record(z.string(), ${schema})`;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * Creates a Zod schema constant declaration
+ *
+ * @function generateZodSchemaDefinition
+ * @param name - Name of the schema constant
+ * @param zodSchema - Zod schema definition string
+ * @returns Generated constant declaration string
+ *
+ * @example
+ * generateZodSchemaDefinition('userSchema', 'z.object({ id: z.number(), name: z.string() })')
+ * // Returns: 'const userSchema = z.object({ id: z.number(), name: z.string() })'
+ *
+ * @example
+ * generateZodSchemaDefinition('statusSchema', 'z.enum(["active", "inactive"])')
+ * // Returns: 'const statusSchema = z.enum(["active", "inactive"])'
+ *
+ * @remarks
+ * - Used for generating Zod schema constant declarations
+ * - Part of OpenAPI to Zod schema conversion process
+ * - Creates reusable schema definitions
+ */
+export declare function generateZodSchemaDefinition(name: string, zodSchema: string): string;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodSchemaDefinition = generateZodSchemaDefinition;
+/**
+ * Creates a Zod schema constant declaration
+ *
+ * @function generateZodSchemaDefinition
+ * @param name - Name of the schema constant
+ * @param zodSchema - Zod schema definition string
+ * @returns Generated constant declaration string
+ *
+ * @example
+ * generateZodSchemaDefinition('userSchema', 'z.object({ id: z.number(), name: z.string() })')
+ * // Returns: 'const userSchema = z.object({ id: z.number(), name: z.string() })'
+ *
+ * @example
+ * generateZodSchemaDefinition('statusSchema', 'z.enum(["active", "inactive"])')
+ * // Returns: 'const statusSchema = z.enum(["active", "inactive"])'
+ *
+ * @remarks
+ * - Used for generating Zod schema constant declarations
+ * - Part of OpenAPI to Zod schema conversion process
+ * - Creates reusable schema definitions
+ */
+function generateZodSchemaDefinition(name, zodSchema) {
+    return `const ${name} = ${zodSchema}`;
+}

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

@@ -0,0 +1,59 @@
+import type { Schema } from '../../types';
+/**
+ * Generates a Zod schema string from an OpenAPI/JSON Schema definition
+ *
+ * @function generateZodSchema
+ * @param schema - The schema definition object
+ * @param schema.type - The type of the schema (e.g., 'string', 'object', 'array')
+ * @param schema.format - Optional format specification (e.g., 'date-time', 'email')
+ * @param schema.pattern - Optional regex pattern for string validation
+ * @param schema.minLength - Optional minimum length for string validation
+ * @param schema.maxLength - Optional maximum length for string validation
+ * @param schema.properties - Object properties definition
+ * @param schema.required - Array of required property names
+ * @param schema.items - Schema for array items
+ * @param schema.enum - Array of enum values
+ * @param schema.additionalProperties - Schema for additional properties in objects
+ * @returns Generated Zod schema string
+ *
+ * @example
+ * // Enum type
+ * generateZodSchema({ enum: ['active', 'inactive'] })
+ * // Returns: 'z.enum(["active","inactive"])'
+ *
+ * @example
+ * // Object with properties
+ * generateZodSchema({
+ *   type: 'object',
+ *   properties: {
+ *     name: { type: 'string' },
+ *     age: { type: 'number' }
+ *   },
+ *   required: ['name']
+ * })
+ * // Returns: 'z.object({name: z.string(), age: z.number().optional()})'
+ *
+ * @example
+ * // String with validation
+ * generateZodSchema({
+ *   type: 'string',
+ *   minLength: 3,
+ *   maxLength: 10,
+ *   pattern: '^[a-z]+$'
+ * })
+ * // Returns: 'z.string().min(3).max(10).regex(/^[a-z]+$/)'
+ *
+ * @example
+ * // Array with items
+ * generateZodSchema({
+ *   type: 'array',
+ *   items: { type: 'string' }
+ * })
+ * // Returns: 'z.array(z.string())'
+ *
+ * @remarks
+ * - Handles special cases first (enum, object, string with validation, array with items)
+ * - Falls back to basic type mapping for simple types
+ * - Returns z.any() for unknown types with a warning
+ */
+export declare function generateZodSchema(schema: Schema): string;

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodSchema = generateZodSchema;
+const generate_zod_array_1 = require("./generate-zod-array");
+const generate_zod_string_schema_1 = require("./generate-zod-string-schema");
+const generate_zod_properties_schema_1 = require("./generate-zod-properties-schema");
+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");
+/**
+ * Mapping of OpenAPI/JSON Schema types to Zod schema strings
+ *
+ * @remarks
+ * - Basic types are mapped directly to their Zod equivalents
+ * - Complex types (object, string with validation, array with items) are handled separately
+ * - Used as a fallback for simple type conversions
+ */
+const TYPE_TO_ZOD_SCHEMA = {
+    number: 'z.number()',
+    integer: 'z.number().int()',
+    bigint: 'z.bigint()',
+    boolean: 'z.boolean()',
+    date: 'z.date()',
+    null: 'z.null()',
+    any: 'z.any()',
+    unknown: 'z.unknown()',
+    string: 'z.string()',
+    object: 'z.object({})',
+    array: 'z.array()',
+};
+/**
+ * Generates a Zod schema string from an OpenAPI/JSON Schema definition
+ *
+ * @function generateZodSchema
+ * @param schema - The schema definition object
+ * @param schema.type - The type of the schema (e.g., 'string', 'object', 'array')
+ * @param schema.format - Optional format specification (e.g., 'date-time', 'email')
+ * @param schema.pattern - Optional regex pattern for string validation
+ * @param schema.minLength - Optional minimum length for string validation
+ * @param schema.maxLength - Optional maximum length for string validation
+ * @param schema.properties - Object properties definition
+ * @param schema.required - Array of required property names
+ * @param schema.items - Schema for array items
+ * @param schema.enum - Array of enum values
+ * @param schema.additionalProperties - Schema for additional properties in objects
+ * @returns Generated Zod schema string
+ *
+ * @example
+ * // Enum type
+ * generateZodSchema({ enum: ['active', 'inactive'] })
+ * // Returns: 'z.enum(["active","inactive"])'
+ *
+ * @example
+ * // Object with properties
+ * generateZodSchema({
+ *   type: 'object',
+ *   properties: {
+ *     name: { type: 'string' },
+ *     age: { type: 'number' }
+ *   },
+ *   required: ['name']
+ * })
+ * // Returns: 'z.object({name: z.string(), age: z.number().optional()})'
+ *
+ * @example
+ * // String with validation
+ * generateZodSchema({
+ *   type: 'string',
+ *   minLength: 3,
+ *   maxLength: 10,
+ *   pattern: '^[a-z]+$'
+ * })
+ * // Returns: 'z.string().min(3).max(10).regex(/^[a-z]+$/)'
+ *
+ * @example
+ * // Array with items
+ * generateZodSchema({
+ *   type: 'array',
+ *   items: { type: 'string' }
+ * })
+ * // Returns: 'z.array(z.string())'
+ *
+ * @remarks
+ * - Handles special cases first (enum, object, string with validation, array with items)
+ * - Falls back to basic type mapping for simple types
+ * - Returns z.any() for unknown types with a warning
+ */
+function generateZodSchema(schema) {
+    const { type, format, pattern, minLength, maxLength, minimum, maximum, properties, required = [], items, enum: enumValues, additionalProperties, } = schema;
+    if (enumValues) {
+        return `z.enum(${JSON.stringify(enumValues)})`;
+    }
+    if (type === 'object') {
+        if (additionalProperties) {
+            return (0, generate_zod_record_schema_1.generateZodRecordSchema)(additionalProperties);
+        }
+        if (!properties) {
+            return 'z.object({})';
+        }
+        return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(properties, required);
+    }
+    if (type === 'string') {
+        return (0, generate_zod_string_schema_1.generateZodStringSchema)({
+            pattern,
+            minLength,
+            maxLength,
+            format: format && (0, is_format_string_1.isFormatString)(format) ? format : undefined,
+        });
+    }
+    if (type === 'number') {
+        return (0, generate_zod_number_schema_1.generateZodNumberSchema)({
+            pattern,
+            minLength,
+            maxLength,
+            minimum,
+            maximum,
+        });
+    }
+    if (type === 'integer') {
+        return (0, generate_zod_integer_schema_1.generateZodIntegerSchema)({
+            minLength,
+            maxLength,
+            minimum,
+            maximum,
+        });
+    }
+    if (type === 'array' && items) {
+        return (0, generate_zod_array_1.generateZodArray)(generateZodSchema(items));
+    }
+    if (type) {
+        return TYPE_TO_ZOD_SCHEMA[type];
+    }
+    console.warn(`Unknown type: ${type}, falling back to z.any()`);
+    return 'z.any()';
+}

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

@@ -0,0 +1,46 @@
+import type { FormatString } from '../../types';
+type GenerateZodStringSchemaParams = {
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    format?: FormatString;
+};
+/**
+ * Generates a Zod schema string for string validation
+ *
+ * @function generateZodStringSchema
+ * @param args - Parameters for string schema generation
+ * @returns Generated Zod schema string with chained validations
+ *
+ * @example
+ * // Basic string validation
+ * generateZodStringSchema({})
+ * // Returns: 'z.string()'
+ *
+ * @example
+ * // With regex pattern
+ * generateZodStringSchema({ pattern: '^[A-Z]+$' })
+ * // Returns: 'z.string().regex(/^[A-Z]+$/)'
+ *
+ * @example
+ * // With length constraints
+ * generateZodStringSchema({ minLength: 3, maxLength: 10 })
+ * // Returns: 'z.string().min(3).max(10)'
+ *
+ * @example
+ * // With format
+ * generateZodStringSchema({ format: 'email' })
+ * // Returns: 'z.string().email()'
+ *
+ * @example
+ * // Combined validations
+ * generateZodStringSchema({
+ *   pattern: '^[a-z]+$',
+ *   minLength: 3,
+ *   maxLength: 10,
+ *   format: 'email'
+ * })
+ * // Returns: 'z.string().regex(/^[a-z]+$/).min(3).max(10).email()'
+ */
+export declare function generateZodStringSchema(args: GenerateZodStringSchemaParams): string;
+export {};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodStringSchema = generateZodStringSchema;
+const get_zod_string_format_1 = require("../../core/zod/get-zod-string-format");
+/**
+ * Generates a Zod schema string for string validation
+ *
+ * @function generateZodStringSchema
+ * @param args - Parameters for string schema generation
+ * @returns Generated Zod schema string with chained validations
+ *
+ * @example
+ * // Basic string validation
+ * generateZodStringSchema({})
+ * // Returns: 'z.string()'
+ *
+ * @example
+ * // With regex pattern
+ * generateZodStringSchema({ pattern: '^[A-Z]+$' })
+ * // Returns: 'z.string().regex(/^[A-Z]+$/)'
+ *
+ * @example
+ * // With length constraints
+ * generateZodStringSchema({ minLength: 3, maxLength: 10 })
+ * // Returns: 'z.string().min(3).max(10)'
+ *
+ * @example
+ * // With format
+ * generateZodStringSchema({ format: 'email' })
+ * // Returns: 'z.string().email()'
+ *
+ * @example
+ * // Combined validations
+ * generateZodStringSchema({
+ *   pattern: '^[a-z]+$',
+ *   minLength: 3,
+ *   maxLength: 10,
+ *   format: 'email'
+ * })
+ * // Returns: 'z.string().regex(/^[a-z]+$/).min(3).max(10).email()'
+ */
+function generateZodStringSchema(args) {
+    const validations = ['z.string()'];
+    const { pattern, minLength, maxLength, format } = args;
+    if (pattern)
+        validations.push(`.regex(/${pattern}/)`);
+    if (minLength)
+        validations.push(`.min(${minLength})`);
+    if (maxLength)
+        validations.push(`.max(${maxLength})`);
+    if (format)
+        validations.push((0, get_zod_string_format_1.getZodFormatString)(format));
+    return validations.join('');
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for hono-takibi
+ *
+ * Usage:
+ * ```
+ * hono-takibi <input-file> [-o output-file]
+ * ```
+ *
+ * @example
+ * ```bash
+ * # Global install
+ * npm install -g hono-takibi
+ * hono-takibi openapi.yaml -o routes.ts
+ *
+ * # NPX usage
+ * npx hono-takibi openapi.yaml -o routes.ts
+ * ```
+ */
+export declare function main(dev?: boolean): Promise<boolean>;

package/dist/index.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const swagger_parser_1 = __importDefault(require("@apidevtools/swagger-parser"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const prettier_1 = require("prettier");
+const generate_hono_1 = require("./generators/hono/generate-hono");
+/**
+ * CLI entry point for hono-takibi
+ *
+ * Usage:
+ * ```
+ * hono-takibi <input-file> [-o output-file]
+ * ```
+ *
+ * @example
+ * ```bash
+ * # Global install
+ * npm install -g hono-takibi
+ * hono-takibi openapi.yaml -o routes.ts
+ *
+ * # NPX usage
+ * npx hono-takibi openapi.yaml -o routes.ts
+ * ```
+ */
+async function main(dev = false) {
+    // 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);
+    // 3. input = 'example/pet-store.yaml'
+    const input = args[0];
+    // 4. output = 'routes/petstore-index.ts'
+    const output = args[args.indexOf('-o') + 1];
+    try {
+        // 5. parse OpenAPI YAML or JSON
+        const openAPI = (await swagger_parser_1.default.parse(input));
+        // 6. generate Hono code
+        const hono = (0, generate_hono_1.generateHono)(openAPI);
+        // 7. format code
+        const formattedCode = await (0, prettier_1.format)(hono, {
+            parser: 'typescript',
+            printWidth: 100,
+            singleQuote: true,
+            semi: false,
+        });
+        // 8. write to file
+        if (output) {
+            // 8.1 output routes/petstore-index.ts
+            const outputDir = node_path_1.default.dirname(output);
+            // 8.2 outputDir routes
+            if (!node_fs_1.default.existsSync(outputDir)) {
+                node_fs_1.default.mkdirSync(outputDir, { recursive: true });
+            }
+        }
+        // 9. write to file
+        node_fs_1.default.writeFileSync(output, formattedCode, { encoding: 'utf-8' });
+        console.log(`Generated code written to ${output}`);
+        return true;
+    }
+    catch (e) {
+        console.error('Usage: hono-takibi <input-file> [-o output-file]');
+        if (e instanceof Error) {
+            console.error('Error processing OpenAPI document:', e.message);
+            if (dev) {
+                throw e;
+            }
+        }
+        if (dev) {
+            throw new Error('Unknown error occurred');
+        }
+        return false;
+    }
+}
+if (require.main === module) {
+    main().then((success) => {
+        if (!success) {
+            process.exit(1);
+        }
+    });
+}