hono-takibi 0.1.3 → 0.1.5

package/README.md

@@ -4,13 +4,17 @@
 
 ![img](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/img/hono-takibi.png)
 
+```bash
+npm add -D hono-takibi
+```
+
 ## Migrate Legacy APIs to Hono
 
 **Hono Takibi** is an OpenAPI-to-Hono code generator, specifically developed to assist in migrating APIs from various programming languages to Hono. This tool automates the creation of type-safe Hono routes from your existing OpenAPI specifications, making it easier to transition from legacy systems (Ruby, Perl, PHP, etc.) to a modern Hono architecture.
 
 ## What Problem Does It Solve?
 
-Moving to [Zod OpenAPI Hono](https://hono.dev/examples/zod-openapi) requires:
+Moving to [@hono/zod-openapi](https://hono.dev/examples/zod-openapi) requires:
 
 * Manual conversion of OpenAPI paths to Hono routes
 * Translation of OpenAPI schemas to Zod schemas
@@ -23,20 +27,10 @@ If you have OpenAPI specifications, Hono Takibi automates the conversion process
 - Generating type-safe route definitions
 - Creating proper variable names and exports
 
-```bash
-npm add -D hono-takibi
-```
-
-# Usage
-
-```bash
-npx hono-takibi path/to/input.yaml -o path/to/output.ts
-```
-
-# Example
+## Usage
 
 ```bash
-npx hono-takibi example/hono-rest-example.yaml -o routes/index.ts
+npx hono-takibi path/to/openapi.yaml -o path/to/output_hono.ts
 ```
 
 input:
@@ -165,19 +159,21 @@ paths:
       parameters:
         - in: query
           name: page
-          required: false
+          required: true
           schema:
             type: integer
             minimum: 0
             default: 1
+            example: 1
           description: The page number to retrieve. Must be a positive integer. Defaults to 1.
         - in: query
           name: rows
-          required: false
+          required: true
           schema:
             type: integer
             minimum: 0
             default: 10
+            example: 10
           description: The number of posts per page. Must be a positive integer. Defaults to 10.
       responses:
         '200':
@@ -272,6 +268,7 @@ paths:
           schema:
             type: string
             format: uuid
+            example: 123e4567-e89b-12d3-a456-426614174000
           description: Unique identifier of the post.
       responses:
         '204':
@@ -299,14 +296,16 @@ output:
 ```ts
 import { createRoute, z } from '@hono/zod-openapi'
 
-const errorSchema = z.object({ message: z.string() })
+const errorSchema = z.object({ message: z.string() }).openapi('Error')
 
-const postSchema = z.object({
-  id: z.string().uuid(),
-  post: z.string().min(1).max(140),
-  createdAt: z.string().datetime(),
-  updatedAt: z.string().datetime(),
-})
+const postSchema = z
+  .object({
+    id: z.string().uuid(),
+    post: z.string().min(1).max(140),
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+  })
+  .openapi('Post')
 
 export const schemas = {
   errorSchema,
@@ -317,11 +316,16 @@ export const getRoute = createRoute({
   tags: ['Hono'],
   method: 'get',
   path: '/',
+  summary: 'Welcome message',
   description: 'Retrieve a simple welcome message from the Hono API.',
   responses: {
     200: {
       description: 'Successful response with a welcome message.',
-      content: { 'application/json': { schema: z.object({ message: z.string() }) } },
+      content: {
+        'application/json': {
+          schema: z.object({ message: z.string().openapi({ example: 'Hono🔥' }) }),
+        },
+      },
     },
   },
 })
@@ -330,6 +334,7 @@ export const postPostsRoute = createRoute({
   tags: ['Post'],
   method: 'post',
   path: '/posts',
+  summary: 'Create a new post',
   description: 'Submit a new post with a maximum length of 140 characters.',
   request: {
     body: {
@@ -357,12 +362,13 @@ export const getPostsRoute = createRoute({
   tags: ['Post'],
   method: 'get',
   path: '/posts',
+  summary: 'Retrieve a list of posts',
   description:
     'Retrieve a paginated list of posts. Specify the page number and the number of posts per page.',
   request: {
     query: z.object({
-      page: z.string().pipe(z.coerce.number().int().min(0)).optional(),
-      rows: z.string().pipe(z.coerce.number().int().min(0)).optional(),
+      page: z.string().pipe(z.coerce.number().int().min(0).default(1).openapi({ example: 1 })),
+      rows: z.string().pipe(z.coerce.number().int().min(0).default(10).openapi({ example: 10 })),
     }),
   },
   responses: {
@@ -385,6 +391,7 @@ export const putPostsIdRoute = createRoute({
   tags: ['Post'],
   method: 'put',
   path: '/posts/{id}',
+  summary: 'Update an existing post',
   description: 'Update the content of an existing post identified by its unique ID.',
   request: {
     body: {
@@ -410,8 +417,19 @@ export const deletePostsIdRoute = createRoute({
   tags: ['Post'],
   method: 'delete',
   path: '/posts/{id}',
+  summary: 'Delete a post',
   description: 'Delete an existing post identified by its unique ID.',
-  request: { params: z.object({ id: z.string().uuid() }) },
+  request: {
+    params: z.object({
+      id: z
+        .string()
+        .uuid()
+        .openapi({
+          param: { name: 'id', in: 'path' },
+          example: '123e4567-e89b-12d3-a456-426614174000',
+        }),
+    }),
+  },
   responses: {
     204: { description: 'Post successfully deleted.' },
     400: {
@@ -426,6 +444,9 @@ export const deletePostsIdRoute = createRoute({
 })
 ```
 
+
+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
 
 **This package is in active development and may introduce breaking changes without prior notice.**

package/dist/core/validator/is-format-number.d.ts

@@ -1,2 +1,10 @@
 import type { Format, FormatNumber } from '../../types';
+/**
+ * Checks if the format is a number type
+ *
+ * @function isFormatNumber
+ *
+ * @param format - OpenAPI format type
+ * @returns true if the format is a number type, false otherwise
+ */
 export declare function isFormatNumber(format: Format): format is FormatNumber;

package/dist/core/validator/is-format-number.js

@@ -1,6 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFormatNumber = isFormatNumber;
+/**
+ * Checks if the format is a number type
+ *
+ * @function isFormatNumber
+ *
+ * @param format - OpenAPI format type
+ * @returns true if the format is a number type, false otherwise
+ */
 function isFormatNumber(format) {
     return ['int32', 'int64', 'float', 'double'].includes(format);
 }

package/dist/core/validator/is-format-string.d.ts

@@ -1,2 +1,9 @@
 import type { Format, FormatString } from '../../types';
+/**
+ * Checks if the format is a string type
+ *
+ * @function isFormatString
+ * @param format - OpenAPI format type
+ * @returns true if the format is a string type, false otherwise
+ */
 export declare function isFormatString(format: Format): format is FormatString;

package/dist/core/validator/is-format-string.js

@@ -1,6 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isFormatString = isFormatString;
+/**
+ * Checks if the format is a string type
+ *
+ * @function isFormatString
+ * @param format - OpenAPI format type
+ * @returns true if the format is a string type, false otherwise
+ */
 function isFormatString(format) {
     return [
         'email',

package/dist/core/validator/is-http-method.js

@@ -15,5 +15,6 @@ function isHttpMethod(method) {
         method === 'delete' ||
         method === 'patch' ||
         method === 'options' ||
-        method === 'head');
+        method === 'head' ||
+        method === 'trace');
 }

package/dist/core/validator/is-unique-content-schema.d.ts

@@ -0,0 +1,8 @@
+import type { Content } from '../../types';
+/**
+ * Get unique content schema
+ * @param contentTypes - Content types
+ * @param content - Content
+ * @returns Unique content schema
+ */
+export declare function isUniqueContentSchema(contentTypes: string[], content: Content): boolean;

package/dist/core/validator/is-unique-content-schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUniqueContentSchema = isUniqueContentSchema;
+/**
+ * Get unique content schema
+ * @param contentTypes - Content types
+ * @param content - Content
+ * @returns Unique content schema
+ */
+function isUniqueContentSchema(contentTypes, content) {
+    const schema = new Set(contentTypes.map((type) => JSON.stringify(content?.[type].schema)));
+    return schema.size === 1;
+}

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

@@ -7,34 +7,6 @@ import type { Components } from '../../../types';
  * @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

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

@@ -14,34 +14,6 @@ const generate_schemas_export_1 = require("../paths/generate-schemas-export");
  * @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
@@ -69,7 +41,7 @@ function generateComponentsCode(components) {
         // 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);
+        return (0, generate_zod_schema_definition_1.generateZodSchemaDefinition)(camelCaseSchemaName, zodSchema, schemaName);
     })
         .join('\n\n');
     // 5. generate export statement

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

@@ -3,6 +3,7 @@ type GenerateCreateRouteParams = {
     tagsCode: string;
     methodCode: string;
     pathCode: string;
+    summaryCode?: string;
     descriptionCode?: string;
     securityCode?: string;
     requestParams: string;

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

@@ -52,6 +52,7 @@ function generateCreateRoute(args) {
         args.tagsCode,
         args.methodCode,
         args.pathCode,
+        args.summaryCode,
         args.descriptionCode,
         args.securityCode,
         args.requestParams,

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

@@ -6,38 +6,6 @@ import type { OpenAPIPaths } from '../../../types';
  * @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

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

@@ -11,38 +11,6 @@ const is_operation_1 = require("../../../core/validator/is-operation");
  * @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
@@ -67,9 +35,9 @@ function generateRouteCode(openAPIPaths) {
             // 3.1. skip parameters key and undefined operations
             if (method === 'parameters' || !pathItemValue)
                 continue;
-            // 3.2. check if the method is an actual HTTP method
+            // 3.2. check if the method is an HTTP method
             if (!(0, is_http_method_1.isHttpMethod)(method))
-                continue;
+                throw new Error('Invalid HTTP method');
             // 3.3 exclude the possibility of string or Parameter[]
             if (typeof pathItemValue === 'string' || Array.isArray(pathItemValue))
                 continue;

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

@@ -5,19 +5,6 @@
  * @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

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

@@ -9,19 +9,6 @@ const capitalize_1 = require("../../../core/text/capitalize");
  * @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

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

@@ -8,33 +8,6 @@ import type { Operation } from '../../../types';
  * @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

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

@@ -15,33 +15,6 @@ const escape_quote_1 = require("../../../core/text/escape-quote");
  * @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
@@ -56,7 +29,7 @@ const escape_quote_1 = require("../../../core/text/escape-quote");
  * - Integrates with Hono's createRoute function
  */
 function generateRoute(path, method, operation) {
-    const { tags, description, security, parameters, requestBody, responses } = operation;
+    const { tags, summary, description, security, parameters, requestBody, responses } = operation;
     const routeName = (0, generate_route_name_1.generateRouteName)(method, path);
     const tagList = tags ? JSON.stringify(tags) : '[]';
     const requestParams = (0, generate_request_parameter_1.generateRequestParameter)(parameters, requestBody);
@@ -65,6 +38,7 @@ function generateRoute(path, method, operation) {
         tagsCode: `tags:${tagList},`,
         methodCode: `method:'${method}',`,
         pathCode: `path:'${path}',`,
+        summaryCode: summary ? `summary:'${(0, escape_quote_1.escapeQuote)(summary)}',` : '',
         descriptionCode: description ? `description:'${(0, escape_quote_1.escapeQuote)(description)}',` : '',
         securityCode: security ? `security:${JSON.stringify(security)},` : '',
         requestParams: requestParams ? `${requestParams}` : '',

package/dist/generators/request/body/generate-insert-request-body.d.ts

@@ -5,28 +5,5 @@
  * @param requestParams - Existing request parameters string
  * @param requestBodyCode - Request body validation code to insert
  * @returns Combined request validation string
- *
- * @example
- * // Adding body validation to query parameters
- * const params = 'request:{query:z.object({id:z.string()})}'
- * const body = 'body:{content:{"application/json":{schema:z.object({name:z.string()})}}}'
- *
- * generateInsertRequestBody(params, body)
- * // Returns:
- * // 'request:{
- * //   body:{
- * //     content:{
- * //       "application/json":{
- * //         schema:z.object({name:z.string()})
- * //       }
- * //     }
- * //   },
- * //   query:z.object({id:z.string()})
- * // }'
- *
- * @example
- * // Adding body to empty request
- * generateInsertRequestBody('request:{}', 'body:{...}')
- * // Returns: 'request:{body:{...}}'
  */
 export declare function generateInsertRequestBody(requestParams: string, requestBodyCode: string): string;

package/dist/generators/request/body/generate-insert-request-body.js

@@ -8,29 +8,6 @@ exports.generateInsertRequestBody = generateInsertRequestBody;
  * @param requestParams - Existing request parameters string
  * @param requestBodyCode - Request body validation code to insert
  * @returns Combined request validation string
- *
- * @example
- * // Adding body validation to query parameters
- * const params = 'request:{query:z.object({id:z.string()})}'
- * const body = 'body:{content:{"application/json":{schema:z.object({name:z.string()})}}}'
- *
- * generateInsertRequestBody(params, body)
- * // Returns:
- * // 'request:{
- * //   body:{
- * //     content:{
- * //       "application/json":{
- * //         schema:z.object({name:z.string()})
- * //       }
- * //     }
- * //   },
- * //   query:z.object({id:z.string()})
- * // }'
- *
- * @example
- * // Adding body to empty request
- * generateInsertRequestBody('request:{}', 'body:{...}')
- * // Returns: 'request:{body:{...}}'
  */
 function generateInsertRequestBody(requestParams, requestBodyCode) {
     return requestParams.replace('request:{', `request:{${requestBodyCode}`);

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

@@ -6,14 +6,5 @@ import type { Content } from '../../../types';
  * @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
- * generateRequestBody(true, 'z.object({ name: z.string() })')
- * // Returns: 'body:{required:true,content:{'application/json':{schema:z.object({ name: z.string() }),},},},'
- *
- * // Optional request body
- * generateRequestBody(false, 'z.object({ age: z.number() })')
- * // Returns: 'body:{required:false,content:{'application/json':{schema:z.object({ age: z.number() }),},},},'
  */
 export declare function generateRequestBody(required: boolean, content: Content, zodSchema: string): string;