hono-takibi 0.0.1

package/dist/core/zod/get-zod-string-format.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getZodFormatString = getZodFormatString;
+/**
+ * Mapping of OpenAPI formats to Zod validation methods
+ *
+ * @remarks
+ * - String formats map to string validation methods
+ * - Number formats map to number type
+ * - Empty string for unrecognized formats
+ */
+const FORMAT_STRING_TO_ZOD_VALIDATION = {
+    // max: '.max()',
+    // min: '.min()',
+    // length: '.length()',
+    email: '.email()',
+    uri: '.url()',
+    emoji: '.emoji()',
+    uuid: '.uuid()',
+    nanoid: '.nanoid()',
+    cuid: '.cuid()',
+    cuid2: '.cuid2()',
+    ulid: '.ulid()',
+    'date-time': '.datetime()',
+    ip: '.ip()',
+    cidr: '.cidr()',
+    trim: '.trim()',
+    toLowerCase: '.toLowerCase()',
+    toUpperCase: '.toUpperCase()',
+    date: '.date()',
+    time: '.time()',
+    duration: '.duration()',
+    base64: '.base64()',
+    binary: '.instanceof(Uint8Array)',
+};
+/**
+ * Converts OpenAPI format to Zod validation method
+ *
+ * @function getZodFormatString
+ * @param format - OpenAPI format type
+ * @returns Zod validation method string
+ *
+ * @example
+ * // String validations
+ * getZodFormatString('email')      // Returns: '.email()'
+ * getZodFormatString('uri')        // Returns: '.url()'
+ * getZodFormatString('uuid')       // Returns: '.uuid()'
+ * getZodFormatString('date-time')  // Returns: '.datetime()'
+ *
+ * @example
+ * // Number types
+ * getZodFormatString('int32')      // Returns: 'z.number()'
+ * getZodFormatString('float')      // Returns: 'z.number()'
+ *
+ * @example
+ * // Unknown format
+ * getZodFormatString('unknown')    // Returns: ''
+ *
+ * @remarks
+ * - Returns the corresponding Zod validation method for known formats
+ * - Returns empty string for unrecognized formats
+ * - Used in schema generation for request/response validation
+ */
+function getZodFormatString(format) {
+    return FORMAT_STRING_TO_ZOD_VALIDATION[format];
+}

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

@@ -0,0 +1,9 @@
+import type { OpenAPISpec } from '../../types';
+/**
+ * Generates TypeScript code from OpenAPI specification for Hono/zod-openapi
+ *
+ * @function generateHonoCode
+ * @param openAPISpec - OpenAPI specification object containing components and paths
+ * @returns Generated TypeScript code
+ */
+export declare function generateHono(openAPISpec: OpenAPISpec): string;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHono = generateHono;
+const generate_components_code_1 = require("../openapi/components/generate-components-code");
+const generate_route_code_1 = require("../openapi/paths/generate-route-code");
+/**
+ * Import statement for Hono's zod-openapi package
+ * @constant
+ */
+const IMPORT_CODE = "import { createRoute, z } from '@hono/zod-openapi';";
+/**
+ * Generates TypeScript code from OpenAPI specification for Hono/zod-openapi
+ *
+ * @function generateHonoCode
+ * @param openAPISpec - OpenAPI specification object containing components and paths
+ * @returns Generated TypeScript code
+ */
+function generateHono(openAPISpec) {
+    // 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);
+    // 4. generate route code
+    const routeCode = (0, generate_route_code_1.generateRouteCode)(paths);
+    // 5. generate hono code
+    return `${IMPORT_CODE}\n\n${componentsCode}\n\n${routeCode}`.trimEnd();
+}

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

@@ -0,0 +1,46 @@
+import type { Components } from '../../../types';
+/**
+ * Generates TypeScript code for OpenAPI components, converting them to Zod schemas.
+ * If no schemas are present, returns an empty string.
+ *
+ * @function generateComponentsCode
+ * @param components - OpenAPI components object containing schema definitions
+ * @returns Generated TypeScript code string containing Zod schema definitions and exports, or empty string if no schemas
+ *
+ * @example
+ * // With schemas
+ * const components = {
+ *   schemas: {
+ *     User: {
+ *       type: 'object',
+ *       properties: {
+ *         profile: { $ref: '#/components/schemas/Profile' }
+ *       }
+ *     },
+ *     Profile: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * }
+ * generateComponentsCode(components)
+ * // Returns:
+ * // export const profileSchema = z.object({ name: z.string() })
+ * // export const userSchema = z.object({ profile: profileSchema })
+ * // export const schemas = { profileSchema, userSchema }
+ *
+ * // Without schemas
+ * generateComponentsCode({})
+ * // Returns: ''
+ *
+ * @note The function:
+ * 1. Extracts schemas from components
+ * 2. Resolves dependencies between schemas to determine correct generation order
+ * 3. Returns empty string if no schemas are present
+ * 4. Generates Zod schema definitions for each schema
+ * 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;

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateComponentsCode = generateComponentsCode;
+const generate_zod_schema_definition_1 = require("../../zod/generate-zod-schema-definition");
+const generate_zod_schema_1 = require("../../../generators/zod/generate-zod-schema");
+const resolve_schemas_dependencies_1 = require("../../../core/schema/references/resolve-schemas-dependencies");
+const get_camel_case_schema_name_1 = require("../../../core/schema/references/get-camel-case-schema-name");
+const generate_schemas_export_1 = require("../paths/generate-schemas-export");
+/**
+ * Generates TypeScript code for OpenAPI components, converting them to Zod schemas.
+ * If no schemas are present, returns an empty string.
+ *
+ * @function generateComponentsCode
+ * @param components - OpenAPI components object containing schema definitions
+ * @returns Generated TypeScript code string containing Zod schema definitions and exports, or empty string if no schemas
+ *
+ * @example
+ * // With schemas
+ * const components = {
+ *   schemas: {
+ *     User: {
+ *       type: 'object',
+ *       properties: {
+ *         profile: { $ref: '#/components/schemas/Profile' }
+ *       }
+ *     },
+ *     Profile: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * }
+ * generateComponentsCode(components)
+ * // Returns:
+ * // export const profileSchema = z.object({ name: z.string() })
+ * // export const userSchema = z.object({ profile: profileSchema })
+ * // export const schemas = { profileSchema, userSchema }
+ *
+ * // Without schemas
+ * generateComponentsCode({})
+ * // Returns: ''
+ *
+ * @note The function:
+ * 1. Extracts schemas from components
+ * 2. Resolves dependencies between schemas to determine correct generation order
+ * 3. Returns empty string if no schemas are present
+ * 4. Generates Zod schema definitions for each schema
+ * 5. Creates exports for all schemas
+ * 6. Returns the complete code with proper ordering to avoid reference errors
+ */
+function generateComponentsCode(components) {
+    // 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 schemaDefinitions = orderedSchemas
+        .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.3 generate zod schema
+        const zodSchema = (0, generate_zod_schema_1.generateZodSchema)(schema);
+        // 4.4 generate zod schema definition
+        return (0, generate_zod_schema_definition_1.generateZodSchemaDefinition)(camelCaseSchemaName, zodSchema);
+    })
+        .join('\n\n');
+    // 5. generate export statement
+    const exports = (0, generate_schemas_export_1.generateSchemasExport)(orderedSchemas);
+    // 6. final code assembly
+    return `${schemaDefinitions}\n\n${exports}`;
+}

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

@@ -0,0 +1,58 @@
+type GenerateCreateRouteParams = {
+    routeName: string;
+    tagsCode: string;
+    methodCode: string;
+    pathCode: string;
+    descriptionCode?: string;
+    securityCode?: string;
+    requestParams: string;
+    responsesCode: string;
+};
+/**
+ * Generates TypeScript code for a Hono route definition
+ *
+ * @function generateCreateRoute
+ * @param args - Object containing route definition properties
+ * @returns Generated TypeScript code string for the route definition
+ *
+ * @example
+ * const args = {
+ *   routeName: 'getUsersRoute',
+ *   tagsCode: 'tags:["users"],',
+ *   methodCode: 'method:"get",',
+ *   pathCode: 'path:"/users",',
+ *   descriptionCode: 'description:"Get all users",',
+ *   securityCode: 'security:[{"bearerAuth":[]}],',
+ *   requestParams: 'request:{query:z.object({limit:z.number()})},',
+ *   responsesCode: 'responses:{200:{description:"Success",content:{"application/json":{schema:UserList}}}}'
+ * }
+ *
+ * const code = generateCreateRoute(args)
+ * // Returns:
+ * // export const getUsersRoute = createRoute({
+ * //   tags:["users"],
+ * //   method:"get",
+ * //   path:"/users",
+ * //   description:"Get all users",
+ * //   security:[{"bearerAuth":[]}],
+ * //   request:{query:z.object({limit:z.number()})},
+ * //   responses:{200:{description:"Success",content:{"application/json":{schema:UserList}}}}
+ * // })
+ *
+ * @note
+ * - Combines all route properties into a single createRoute call
+ * - Handles:
+ *   - Route name export
+ *   - OpenAPI tags
+ *   - HTTP method
+ *   - Path definition
+ *   - Route description
+ *   - Security requirements
+ *   - Request parameters and validation
+ *   - Response definitions
+ * - Properties are joined without additional spacing
+ * - Undefined/empty properties are safely handled
+ * - Creates a valid TypeScript export statement
+ */
+export declare function generateCreateRoute(args: GenerateCreateRouteParams): string;
+export {};

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCreateRoute = generateCreateRoute;
+/**
+ * Generates TypeScript code for a Hono route definition
+ *
+ * @function generateCreateRoute
+ * @param args - Object containing route definition properties
+ * @returns Generated TypeScript code string for the route definition
+ *
+ * @example
+ * const args = {
+ *   routeName: 'getUsersRoute',
+ *   tagsCode: 'tags:["users"],',
+ *   methodCode: 'method:"get",',
+ *   pathCode: 'path:"/users",',
+ *   descriptionCode: 'description:"Get all users",',
+ *   securityCode: 'security:[{"bearerAuth":[]}],',
+ *   requestParams: 'request:{query:z.object({limit:z.number()})},',
+ *   responsesCode: 'responses:{200:{description:"Success",content:{"application/json":{schema:UserList}}}}'
+ * }
+ *
+ * const code = generateCreateRoute(args)
+ * // Returns:
+ * // export const getUsersRoute = createRoute({
+ * //   tags:["users"],
+ * //   method:"get",
+ * //   path:"/users",
+ * //   description:"Get all users",
+ * //   security:[{"bearerAuth":[]}],
+ * //   request:{query:z.object({limit:z.number()})},
+ * //   responses:{200:{description:"Success",content:{"application/json":{schema:UserList}}}}
+ * // })
+ *
+ * @note
+ * - Combines all route properties into a single createRoute call
+ * - Handles:
+ *   - Route name export
+ *   - OpenAPI tags
+ *   - HTTP method
+ *   - Path definition
+ *   - Route description
+ *   - Security requirements
+ *   - Request parameters and validation
+ *   - Response definitions
+ * - Properties are joined without additional spacing
+ * - Undefined/empty properties are safely handled
+ * - Creates a valid TypeScript export statement
+ */
+function generateCreateRoute(args) {
+    const properties = [
+        args.tagsCode,
+        args.methodCode,
+        args.pathCode,
+        args.descriptionCode,
+        args.securityCode,
+        args.requestParams,
+        args.responsesCode,
+    ].join('');
+    return `export const ${args.routeName}=createRoute({${properties}})`;
+}

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

@@ -0,0 +1,53 @@
+import type { OpenAPIPaths } from '../../../types';
+/**
+ * Generates TypeScript code for all valid routes based on OpenAPI paths
+ *
+ * @function generateRouteCode
+ * @param openAPIPaths - OpenAPI paths object containing route definitions
+ * @returns Generated TypeScript code string for all valid routes
+ *
+ * @example
+ * const paths = {
+ *   '/users': {
+ *     get: {
+ *       operationId: 'getUsers',
+ *       responses: {
+ *         '200': {
+ *           description: 'List of users',
+ *           content: {
+ *             'application/json': {
+ *               schema: { $ref: '#/components/schemas/UserList' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     post: {
+ *       operationId: 'createUser',
+ *       requestBody: {
+ *         content: {
+ *           'application/json': {
+ *             schema: { $ref: '#/components/schemas/CreateUserInput' }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const code = generateRouteCode(paths)
+ * // Returns TypeScript code for both GET and POST /users routes
+ *
+ * @note
+ * - Processes each path and HTTP method combination
+ * - Validates HTTP methods and operation objects
+ * - Skips invalid or unsupported route definitions
+ * - Handles:
+ *   - Path parameters
+ *   - Query parameters
+ *   - Request bodies
+ *   - Response schemas
+ * - Generates type-safe route handlers using zod validation
+ * - Combines all routes with proper spacing
+ */
+export declare function generateRouteCode(openAPIPaths: OpenAPIPaths): string;

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouteCode = generateRouteCode;
+const is_http_method_1 = require("../../../core/validator/is-http-method");
+const generate_route_1 = require("./generate-route");
+const is_operation_1 = require("../../../core/validator/is-operation");
+/**
+ * Generates TypeScript code for all valid routes based on OpenAPI paths
+ *
+ * @function generateRouteCode
+ * @param openAPIPaths - OpenAPI paths object containing route definitions
+ * @returns Generated TypeScript code string for all valid routes
+ *
+ * @example
+ * const paths = {
+ *   '/users': {
+ *     get: {
+ *       operationId: 'getUsers',
+ *       responses: {
+ *         '200': {
+ *           description: 'List of users',
+ *           content: {
+ *             'application/json': {
+ *               schema: { $ref: '#/components/schemas/UserList' }
+ *             }
+ *           }
+ *         }
+ *       }
+ *     },
+ *     post: {
+ *       operationId: 'createUser',
+ *       requestBody: {
+ *         content: {
+ *           'application/json': {
+ *             schema: { $ref: '#/components/schemas/CreateUserInput' }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const code = generateRouteCode(paths)
+ * // Returns TypeScript code for both GET and POST /users routes
+ *
+ * @note
+ * - Processes each path and HTTP method combination
+ * - Validates HTTP methods and operation objects
+ * - Skips invalid or unsupported route definitions
+ * - Handles:
+ *   - Path parameters
+ *   - Query parameters
+ *   - Request bodies
+ *   - Response schemas
+ * - Generates type-safe route handlers using zod validation
+ * - Combines all routes with proper spacing
+ */
+function generateRouteCode(openAPIPaths) {
+    const routes = [];
+    // 1. flattening and processing OpenAPI paths
+    for (const [path, pathItem] of Object.entries(openAPIPaths)) {
+        // 2.skip if path definition does not exist
+        if (!pathItem)
+            continue;
+        // 3. loop through HTTP methods for each path
+        for (const [method, pathItemValue] of Object.entries(pathItem)) {
+            // 3.1. skip parameters key and undefined operations
+            if (method === 'parameters' || !pathItemValue)
+                continue;
+            // 3.2. check if the method is an actual HTTP method
+            if (!(0, is_http_method_1.isHttpMethod)(method))
+                continue;
+            // 3.3 exclude the possibility of string or Parameter[]
+            if (typeof pathItemValue === 'string' || Array.isArray(pathItemValue))
+                continue;
+            // 3.4 at this point, pathItemValue is only a possibility for Operation
+            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));
+        }
+    }
+    // 4. exclude invalid routes and join them with a newline
+    return routes.filter(Boolean).join('\n\n');
+}

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

@@ -0,0 +1,30 @@
+/**
+ * Generates a route name from HTTP method and path
+ *
+ * @param method - HTTP method (e.g., 'get', 'post', 'put')
+ * @param path - URL path pattern (e.g., '/users/{id}/posts')
+ * @returns Formatted route name string
+ *
+ * @example
+ * // Basic path
+ * generateRouteName('get', '/users')
+ * // Returns: 'getUsersRoute'
+ *
+ * // Path with parameters
+ * generateRouteName('post', '/users/{id}/posts')
+ * // Returns: 'postUsersIdPostsRoute'
+ *
+ * // Path with hyphens
+ * generateRouteName('put', '/user-profiles/{id}')
+ * // Returns: 'putUserProfilesIdRoute'
+ *
+ * @remarks
+ * Transformation process:
+ * 1. Replace special characters (/{}-)  with spaces
+ * 2. Remove leading and trailing spaces
+ * 3. Split string by consecutive spaces
+ * 4. Capitalize each word
+ * 5. Join all words together
+ * 6. Add HTTP method and Route suffix
+ */
+export declare function generateRouteName(method: string, path: string): string;

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouteName = generateRouteName;
+const capitalize_1 = require("../../../core/text/capitalize");
+/**
+ * Generates a route name from HTTP method and path
+ *
+ * @param method - HTTP method (e.g., 'get', 'post', 'put')
+ * @param path - URL path pattern (e.g., '/users/{id}/posts')
+ * @returns Formatted route name string
+ *
+ * @example
+ * // Basic path
+ * generateRouteName('get', '/users')
+ * // Returns: 'getUsersRoute'
+ *
+ * // Path with parameters
+ * generateRouteName('post', '/users/{id}/posts')
+ * // Returns: 'postUsersIdPostsRoute'
+ *
+ * // Path with hyphens
+ * generateRouteName('put', '/user-profiles/{id}')
+ * // Returns: 'putUserProfilesIdRoute'
+ *
+ * @remarks
+ * Transformation process:
+ * 1. Replace special characters (/{}-)  with spaces
+ * 2. Remove leading and trailing spaces
+ * 3. Split string by consecutive spaces
+ * 4. Capitalize each word
+ * 5. Join all words together
+ * 6. Add HTTP method and Route suffix
+ */
+function generateRouteName(method, path) {
+    // 1. api_path: `/user/createWithList`
+    // 2. replace(/[\/{}-]/g, ' ') -> ` user createWithList`
+    // 3. trim() -> `user createWithList`
+    // 4. split(/\s+/) -> `['user', 'createWithList']`
+    // 5. map(capitalize) -> `['User', 'CreateWithList']`
+    // 6. join('') -> `UserCreateWithList`
+    const api_path = path
+        .replace(/[\/{}-]/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .map(capitalize_1.capitalize)
+        .join('');
+    return `${method}${api_path}Route`;
+}

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

@@ -0,0 +1,51 @@
+import type { Operation } from '../../../types';
+/**
+ * Generates TypeScript code for a Hono route based on OpenAPI operation details
+ *
+ * @function generateRoute
+ * @param path - The URL path pattern for the route
+ * @param method - The HTTP method (GET, POST, etc.)
+ * @param operation - The OpenAPI Operation object containing route details
+ * @returns Generated TypeScript code string for the route
+ *
+ * @example
+ * const operation = {
+ *   tags: ['users'],
+ *   description: 'Create a new user',
+ *   security: [{ bearerAuth: [] }],
+ *   requestBody: {
+ *     content: {
+ *       'application/json': {
+ *         schema: { $ref: '#/components/schemas/CreateUserInput' }
+ *       }
+ *     }
+ *   },
+ *   responses: {
+ *     '201': {
+ *       description: 'User created successfully',
+ *       content: {
+ *         'application/json': {
+ *           schema: { $ref: '#/components/schemas/User' }
+ *         }
+ *       }
+ *     }
+ *   }
+ * }
+ *
+ * const route = generateRoute('/users', 'post', operation)
+ * // Returns: TypeScript code for a type-safe POST /users route
+ *
+ * @note
+ * - Generates a complete route definition including:
+ *   - Route name based on method and path
+ *   - OpenAPI tags for documentation
+ *   - HTTP method and path
+ *   - Route description
+ *   - Security requirements
+ *   - Request parameters and body validation
+ *   - Response schemas for different status codes
+ * - All components are properly escaped and formatted
+ * - Handles optional parameters appropriately
+ * - Integrates with Hono's createRoute function
+ */
+export declare function generateRoute(path: string, method: string, operation: Operation): string;