hono-takibi 0.0.1

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRoute = generateRoute;
+const generate_create_route_1 = require("./generate-create-route");
+const generate_request_parameter_1 = require("../../request/params/generate-request-parameter");
+const generate_response_schema_1 = require("../../response/schemas/generate-response-schema");
+const generate_route_name_1 = require("./generate-route-name");
+/**
+ * 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
+ */
+function generateRoute(path, method, operation) {
+    const { tags, 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);
+    const create_args = {
+        routeName,
+        tagsCode: `tags:${tagList},`,
+        methodCode: `method:'${method}',`,
+        pathCode: `path:'${path}',`,
+        descriptionCode: description ? `description:'${description}',` : '',
+        securityCode: security ? `security:${JSON.stringify(security)},` : '',
+        requestParams: requestParams ? `${requestParams}` : '',
+        responsesCode: responses ? `responses:{${(0, generate_response_schema_1.generateResponseSchema)(responses)}}` : '',
+    };
+    return (0, generate_create_route_1.generateCreateRoute)(create_args);
+}

package/dist/generators/openapi/paths/generate-schemas-export.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates a TypeScript export for a list of schema names
+ *
+ * @function generateSchemasExport
+ * @param orderedSchemas - Array of schema names
+ * @returns TypeScript code for exporting schemas
+ *
+ * @example
+ * // Returns: 'export const schemas = { userSchema, postSchema }'
+ */
+export declare function generateSchemasExport(orderedSchemas: string[]): string;

package/dist/generators/openapi/paths/generate-schemas-export.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemasExport = generateSchemasExport;
+const get_camel_case_schema_name_1 = require("../../../core/schema/references/get-camel-case-schema-name");
+/**
+ * Generates a TypeScript export for a list of schema names
+ *
+ * @function generateSchemasExport
+ * @param orderedSchemas - Array of schema names
+ * @returns TypeScript code for exporting schemas
+ *
+ * @example
+ * // Returns: 'export const schemas = { userSchema, postSchema }'
+ */
+function generateSchemasExport(orderedSchemas) {
+    const camelCaseSchemas = orderedSchemas.map((schemaName) => (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(schemaName));
+    return `export const schemas = {\n${camelCaseSchemas.join(',\n')}\n}`;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Generates a request validation string by inserting request body validation code into existing request parameters
+ *
+ * @function 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:{...}}'
+ */
+export declare function generateInsertRequestBody(requestParams: string, requestBodyCode: string): string;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInsertRequestBody = generateInsertRequestBody;
+/**
+ * Generates a request validation string by inserting request body validation code into existing request parameters
+ *
+ * @function 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

@@ -0,0 +1,18 @@
+/**
+ * Generates a request body configuration for OpenAPI schema
+ *
+ * @function generateRequestBody
+ * @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, zodSchema: string): string;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestBody = generateRequestBody;
+/**
+ * Generates a request body configuration for OpenAPI schema
+ *
+ * @function generateRequestBody
+ * @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() }),},},},'
+ */
+function generateRequestBody(required, zodSchema) {
+    return `body:{required:${required},content:{'application/json':{schema:${zodSchema},},},},`;
+}

package/dist/generators/request/object/generate-format-request-object.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Generates a formatted request object string for request validation
+ *
+ * @function generateFormatRequestObject
+ * @param requestParamsArray - Array of Zod schema strings for request validation
+ * @returns Formatted request validator object string
+ *
+ * @example
+ * // Single parameter
+ * generateFormatRequestObject(['query:z.object({page:z.string()})'])
+ * // Returns: 'request:{query:z.object({page:z.string()})}'
+ *
+ * @example
+ * // Multiple parameters
+ * generateFormatRequestObject([
+ *   'query:z.object({page:z.string(),rows:z.string()})',
+ *   'params:z.object({id:z.string()})'
+ * ])
+ * // Returns: 'request:{
+ * //   query:z.object({page:z.string(),rows:z.string()}),
+ * //   params:z.object({id:z.string()})
+ * // }'
+ *
+ * @example
+ * // Empty array
+ * generateFormatRequestObject([])
+ * // Returns: 'request:{}'
+ */
+export declare function generateFormatRequestObject(requestParamsArray: string[]): string;

package/dist/generators/request/object/generate-format-request-object.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFormatRequestObject = generateFormatRequestObject;
+/**
+ * Generates a formatted request object string for request validation
+ *
+ * @function generateFormatRequestObject
+ * @param requestParamsArray - Array of Zod schema strings for request validation
+ * @returns Formatted request validator object string
+ *
+ * @example
+ * // Single parameter
+ * generateFormatRequestObject(['query:z.object({page:z.string()})'])
+ * // Returns: 'request:{query:z.object({page:z.string()})}'
+ *
+ * @example
+ * // Multiple parameters
+ * generateFormatRequestObject([
+ *   'query:z.object({page:z.string(),rows:z.string()})',
+ *   'params:z.object({id:z.string()})'
+ * ])
+ * // Returns: 'request:{
+ * //   query:z.object({page:z.string(),rows:z.string()}),
+ * //   params:z.object({id:z.string()})
+ * // }'
+ *
+ * @example
+ * // Empty array
+ * generateFormatRequestObject([])
+ * // Returns: 'request:{}'
+ */
+function generateFormatRequestObject(requestParamsArray) {
+    return `request:{${requestParamsArray.join(',')}},`;
+}

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

@@ -0,0 +1,62 @@
+import type { ParamsObject, Parameters } from '../../../types';
+/**
+ * Generates a params object containing Zod schemas for different parameter locations
+ *
+ * @function generateParamsObject
+ * @param parameters - Array of OpenAPI path parameters
+ * @returns ParamsObject with Zod schemas organized by parameter location
+ *
+ * @example
+ * // Query and path parameters
+ * generateParamsObject([
+ *   {
+ *     name: 'userId',
+ *     in: 'path',
+ *     required: true,
+ *     schema: { type: 'string' }
+ *   },
+ *   {
+ *     name: 'filter',
+ *     in: 'query',
+ *     required: false,
+ *     schema: { type: 'string' }
+ *   }
+ * ])
+ * // Returns:
+ * // {
+ * //   query: { filter: 'z.string().optional()' },
+ * //   params: { userId: 'z.string()' },
+ * //   headers: {},
+ * //   body: {}
+ * // }
+ *
+ * @example
+ * // Body parameter
+ * generateParamsObject([
+ *   {
+ *     name: 'user',
+ *     in: 'body',
+ *     required: true,
+ *     schema: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * ])
+ * // Returns:
+ * // {
+ * //   query: {},
+ * //   params: {},
+ * //   headers: {},
+ * //   body: { user: 'z.object({name: z.string().optional()})' }
+ * // }
+ *
+ * @remarks
+ * - Creates Zod schemas for each parameter based on its schema definition
+ * - Handles optional parameters by adding .optional() suffix
+ * - Organizes parameters into appropriate objects based on their location
+ * - Maintains empty objects for unused parameter locations
+ */
+export declare function generateParamsObject(parameters: Parameters[]): ParamsObject;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateParamsObject = generateParamsObject;
+const generate_zod_coerce_1 = require("../../zod/generate-zod-coerce");
+const generate_zod_schema_1 = require("../../zod/generate-zod-schema");
+/**
+ * Mapping of parameter locations to their corresponding object keys
+ */
+const PARAM_LOCATION_TO_KEY = {
+    query: 'query',
+    path: 'params',
+    header: 'headers',
+    body: 'body',
+};
+/**
+ * Generates a params object containing Zod schemas for different parameter locations
+ *
+ * @function generateParamsObject
+ * @param parameters - Array of OpenAPI path parameters
+ * @returns ParamsObject with Zod schemas organized by parameter location
+ *
+ * @example
+ * // Query and path parameters
+ * generateParamsObject([
+ *   {
+ *     name: 'userId',
+ *     in: 'path',
+ *     required: true,
+ *     schema: { type: 'string' }
+ *   },
+ *   {
+ *     name: 'filter',
+ *     in: 'query',
+ *     required: false,
+ *     schema: { type: 'string' }
+ *   }
+ * ])
+ * // Returns:
+ * // {
+ * //   query: { filter: 'z.string().optional()' },
+ * //   params: { userId: 'z.string()' },
+ * //   headers: {},
+ * //   body: {}
+ * // }
+ *
+ * @example
+ * // Body parameter
+ * generateParamsObject([
+ *   {
+ *     name: 'user',
+ *     in: 'body',
+ *     required: true,
+ *     schema: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * ])
+ * // Returns:
+ * // {
+ * //   query: {},
+ * //   params: {},
+ * //   headers: {},
+ * //   body: { user: 'z.object({name: z.string().optional()})' }
+ * // }
+ *
+ * @remarks
+ * - Creates Zod schemas for each parameter based on its schema definition
+ * - Handles optional parameters by adding .optional() suffix
+ * - Organizes parameters into appropriate objects based on their location
+ * - Maintains empty objects for unused parameter locations
+ */
+function generateParamsObject(parameters) {
+    const initialParamsObj = {
+        query: {},
+        params: {},
+        headers: {},
+        body: {},
+    };
+    return parameters.reduce((acc, param) => {
+        const optionalSuffix = param.required ? '' : '.optional()';
+        const paramLocation = PARAM_LOCATION_TO_KEY[param.in];
+        // query && integer
+        const zodSchema = (paramLocation === 'query' && param.schema.type === 'number') ||
+            param.schema.type === 'integer'
+            ? (0, generate_zod_coerce_1.generateZodCoerce)('z.string()', (0, generate_zod_schema_1.generateZodSchema)(param.schema))
+            : (0, generate_zod_schema_1.generateZodSchema)(param.schema);
+        acc[paramLocation][param.name] = `${zodSchema}${optionalSuffix}`;
+        return acc;
+    }, initialParamsObj);
+}

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

@@ -0,0 +1,49 @@
+import type { Parameters, RequestBody } from '../../../types';
+/**
+ * Generates TypeScript code for request validation based on OpenAPI specification
+ *
+ * @function generateRequestParameter
+ *
+ * @param parameters - Array of path parameters from OpenAPI specification
+ * @param requestBody - Request body definition from OpenAPI specification
+ * @returns Generated TypeScript code string for request validation
+ *
+ * @example
+ * // Path parameters only
+ * const params = [{
+ *   name: 'userId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: { type: 'string' }
+ * }]
+ * generateRequestParameter(params, undefined)
+ * // Returns: 'request: { params: z.object({ userId: z.string() }) }'
+ *
+ * // Request body only
+ * const body = {
+ *   content: {
+ *     'application/json': {
+ *       schema: { $ref: '#/components/schemas/CreateUser' }
+ *     }
+ *   },
+ *   required: true
+ * }
+ * generateRequestParameter(undefined, body)
+ * // Returns: 'request: { json: CreateUser }'
+ *
+ * // Both parameters and body
+ * generateRequestParameter(params, body)
+ * // Returns: 'request: { params: z.object({ userId: z.string() }), json: CreateUser }'
+ *
+ * @note
+ * - Handles both path parameters and request body validation
+ * - Supports:
+ *   - Path parameters with Zod validation
+ *   - JSON request bodies with schema references
+ *   - Array type request bodies
+ *   - Required/optional request bodies
+ * - Returns empty string if no parameters or body are defined
+ * - Properly combines parameters and body when both are present
+ * - Handles schema references and inline schemas
+ */
+export declare function generateRequestParameter(parameters: Parameters[] | undefined, requestBody: RequestBody | undefined): string;

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestParameter = generateRequestParameter;
+const generate_format_request_object_1 = require("../object/generate-format-request-object");
+const generate_params_object_1 = require("./generate-params-object");
+const generate_request_body_1 = require("../body/generate-request-body");
+const generate_request_params_array_1 = require("./generate-request-params-array");
+const generate_insert_request_body_1 = require("../body/generate-insert-request-body");
+const generate_request_params_1 = require("./generate-request-params");
+const generate_zod_property_schema_1 = require("../../zod/generate-zod-property-schema");
+/**
+ * Generates TypeScript code for request validation based on OpenAPI specification
+ *
+ * @function generateRequestParameter
+ *
+ * @param parameters - Array of path parameters from OpenAPI specification
+ * @param requestBody - Request body definition from OpenAPI specification
+ * @returns Generated TypeScript code string for request validation
+ *
+ * @example
+ * // Path parameters only
+ * const params = [{
+ *   name: 'userId',
+ *   in: 'path',
+ *   required: true,
+ *   schema: { type: 'string' }
+ * }]
+ * generateRequestParameter(params, undefined)
+ * // Returns: 'request: { params: z.object({ userId: z.string() }) }'
+ *
+ * // Request body only
+ * const body = {
+ *   content: {
+ *     'application/json': {
+ *       schema: { $ref: '#/components/schemas/CreateUser' }
+ *     }
+ *   },
+ *   required: true
+ * }
+ * generateRequestParameter(undefined, body)
+ * // Returns: 'request: { json: CreateUser }'
+ *
+ * // Both parameters and body
+ * generateRequestParameter(params, body)
+ * // Returns: 'request: { params: z.object({ userId: z.string() }), json: CreateUser }'
+ *
+ * @note
+ * - Handles both path parameters and request body validation
+ * - Supports:
+ *   - Path parameters with Zod validation
+ *   - JSON request bodies with schema references
+ *   - Array type request bodies
+ *   - Required/optional request bodies
+ * - Returns empty string if no parameters or body are defined
+ * - Properly combines parameters and body when both are present
+ * - Handles schema references and inline schemas
+ */
+function generateRequestParameter(parameters, requestBody) {
+    if (!(parameters || requestBody?.content?.['application/json'])) {
+        return '';
+    }
+    const params = parameters
+        ? (() => {
+            const paramsObj = (0, generate_params_object_1.generateParamsObject)(parameters);
+            const requestParamsArr = (0, generate_request_params_array_1.generateRequestParamsArray)(paramsObj);
+            return requestParamsArr.length ? (0, generate_format_request_object_1.generateFormatRequestObject)(requestParamsArr) : '';
+        })()
+        : '';
+    if (requestBody?.content?.['application/json']) {
+        const schema = requestBody.content['application/json'].schema;
+        const zodSchema = (0, generate_zod_property_schema_1.generatePropertySchema)(schema);
+        const request_body_required = requestBody.required ?? false;
+        const requestBodyCode = (0, generate_request_body_1.generateRequestBody)(request_body_required, zodSchema);
+        return params
+            ? (0, generate_insert_request_body_1.generateInsertRequestBody)(params, requestBodyCode)
+            : (0, generate_request_params_1.generateRequestParams)(requestBodyCode);
+    }
+    return params;
+}

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

@@ -0,0 +1,37 @@
+import type { ParamsObject } from '../../../types';
+/**
+ * Generates an array of Zod schema strings for non-empty parameter sections
+ *
+ * @function generateRequestParamsArray
+ * @param paramsObj - Object containing query, path, and header parameter schemas
+ * @returns Array of Zod schema strings for non-empty parameter sections
+ *
+ * @example
+ * // Input object with query and path parameters
+ * const params = {
+ *   query: { page: 'z.string()', limit: 'z.number()' },
+ *   params: { id: 'z.string()' },
+ *   headers: {}
+ * }
+ *
+ * generateRequestParamsArray(params)
+ * // Returns:
+ * // [
+ * //   'query:z.object({ page: z.string(), limit: z.number() })',
+ * //   'params:z.object({ id: z.string() })'
+ * // ]
+ *
+ * @example
+ * // Input object with only headers
+ * const params = {
+ *   query: {},
+ *   params: {},
+ *   headers: { 'x-api-key': 'z.string()' }
+ *   body: {}
+ * }
+ *
+ * generateRequestParamsArray(params)
+ * // Returns:
+ * // ['headers:z.object({ "x-api-key": z.string() })']
+ */
+export declare function generateRequestParamsArray(paramsObj: ParamsObject): string[];

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRequestParamsArray = generateRequestParamsArray;
+const generate_zod_object_schema_1 = require("../../zod/generate-zod-object-schema");
+/**
+ * Generates an array of Zod schema strings for non-empty parameter sections
+ *
+ * @function generateRequestParamsArray
+ * @param paramsObj - Object containing query, path, and header parameter schemas
+ * @returns Array of Zod schema strings for non-empty parameter sections
+ *
+ * @example
+ * // Input object with query and path parameters
+ * const params = {
+ *   query: { page: 'z.string()', limit: 'z.number()' },
+ *   params: { id: 'z.string()' },
+ *   headers: {}
+ * }
+ *
+ * generateRequestParamsArray(params)
+ * // Returns:
+ * // [
+ * //   'query:z.object({ page: z.string(), limit: z.number() })',
+ * //   'params:z.object({ id: z.string() })'
+ * // ]
+ *
+ * @example
+ * // Input object with only headers
+ * const params = {
+ *   query: {},
+ *   params: {},
+ *   headers: { 'x-api-key': 'z.string()' }
+ *   body: {}
+ * }
+ *
+ * generateRequestParamsArray(params)
+ * // Returns:
+ * // ['headers:z.object({ "x-api-key": z.string() })']
+ */
+function generateRequestParamsArray(paramsObj) {
+    // 1.  define sections to be processed
+    const sections = ['query', 'params', 'headers'];
+    // 2. processing of each section
+    return (sections
+        .map((section) => {
+        const obj = paramsObj[section];
+        // 2.1 process only if object is not empty
+        if (Object.keys(obj).length) {
+            const schema = (0, generate_zod_object_schema_1.generateZodObjectSchema)(obj);
+            return `${section}:${schema}`;
+        }
+        return null;
+    })
+        // 3. exclude null and return only an array of strings
+        .filter((item) => item !== null));
+}