hono-takibi 0.3.0 → 0.3.2

package/README.md

@@ -452,16 +452,25 @@ You can customize the code generation behavior by creating a `hono-takibi.json`
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `name` | `"camelCase"` \| `"PascalCase"` | `"camelCase"` | Naming convention for generated schema variables |
+| `name` | `"PascalCase"` \| `"camelCase"` | `"PascalCase"` | Naming convention for generated schema variables |
 | `export` | `boolean` | `false` | When true, exports all schema definitions |
 
 ### Type Options
 
 | Option | Type | Default | Description |
 |--------|------|---------|-------------|
-| `name` | `"camelCase"` \| `"PascalCase"` | `"PascalCase"` | Naming convention for generated type definitions |
+| `name` | `"PascalCase"` \| `"camelCase"` | `"PascalCase"` | Naming convention for generated type definitions |
 | `export` | `boolean` | `false` | When true, exports all type definitions |
 
+### App Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| output | boolean | false | Controls the generation of application and handler files. When enabled, creates both the main application file and corresponding route handlers |
+| test | boolean | false | Enables automatic generation of test files for your API endpoints. |
+| basePath | string | "" | Specifies the base URL path for your API endpoints. |
+| isDev | string | "process.env.NODE_ENV" | Defines the environment variable used to determine development mode. Controls features like Swagger UI availability |
+
 ## Input and Output
 
 You can specify input and output paths in two ways:
@@ -484,19 +493,23 @@ You can specify input and output paths in two ways:
 
 ### Examples
 
-* Default Behavior (camelCase schemas, PascalCase types)
+* Default Behavior (PascalCase schemas, PascalCase types)
 
 ```json
 {
-  "input": "src/openapi/openapi.yaml",
-  "output": "src/openapi/index.ts",
   "schema": {
-    "name": "camelCase",
+    "name": "PascalCase",
     "export": false
   },
   "type": {
     "name": "PascalCase",
     "export": false
+  },
+  "app": {
+    "output": true,
+    "test": true,
+    "basePath": "api",
+    "isDev": "process.env.NODE_ENV"
   }
 }
 ```

package/dist/config/index.d.ts

@@ -1,12 +1,18 @@
 export type Config = {
     schema: {
-        name: 'camelCase' | 'PascalCase';
+        name: 'PascalCase' | 'camelCase';
         export: boolean;
     };
     type: {
-        name: 'camelCase' | 'PascalCase';
+        name: 'PascalCase' | 'camelCase';
         export: boolean;
     };
+    app?: {
+        output?: boolean;
+        test?: boolean;
+        basePath?: string;
+        isDev?: string;
+    };
     input?: string;
     output?: string;
 };

package/dist/config/index.js

@@ -8,13 +8,17 @@ exports.getConfig = getConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 exports.DEFAULT_CONFIG = {
     schema: {
-        name: 'camelCase',
+        name: 'PascalCase',
         export: false,
     },
     type: {
         name: 'PascalCase',
         export: false,
     },
+    app: {
+        output: false,
+        test: false,
+    },
 };
 /**
  * Loads the configuration from the `hono-takibi.json` file or returns the default configuration.

package/dist/core/{schema/references/get-camel-case-schema-name.js → helper/get-camel-case-schema-name-helper.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getCamelCaseSchemaName = getCamelCaseSchemaName;
-const decapitalize_1 = require("../../text/decapitalize");
+const decapitalize_1 = require("../text/decapitalize");
 /**
  * Generates a camelCase schema name from a given schema name.
  *

package/dist/core/{schema/references/get-pascal-case-schema-name.js → helper/get-pascal-case-schema-name-helper.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPascalCaseSchemaName = getPascalCaseSchemaName;
-const capitalize_1 = require("../../text/capitalize");
+const capitalize_1 = require("../text/capitalize");
 /**
  * Generates a PascalCase schema name from a given schema name.
  *

package/dist/core/helper/get-variable-schema-name-helper.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVariableSchemaNameHelper = void 0;
-const get_camel_case_schema_name_1 = require("../schema/references/get-camel-case-schema-name");
-const get_pascal_case_schema_name_1 = require("../schema/references/get-pascal-case-schema-name");
+const get_camel_case_schema_name_helper_1 = require("./get-camel-case-schema-name-helper");
+const get_pascal_case_schema_name_helper_1 = require("./get-pascal-case-schema-name-helper");
 const getVariableSchemaNameHelper = (name, config) => {
     return config.schema.name === 'camelCase'
-        ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(name)
-        : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(name);
+        ? (0, get_camel_case_schema_name_helper_1.getCamelCaseSchemaName)(name)
+        : (0, get_pascal_case_schema_name_helper_1.getPascalCaseSchemaName)(name);
 };
 exports.getVariableSchemaNameHelper = getVariableSchemaNameHelper;

package/dist/core/text/sanitize.d.ts

@@ -0,0 +1 @@
+export declare function sanitize(text: string): string;

package/dist/core/text/sanitize.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitize = sanitize;
+function sanitize(text) {
+    return text.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+}

package/dist/format/index.d.ts

@@ -0,0 +1 @@
+export declare function formatCode(code: string): Promise<string>;

package/dist/format/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCode = formatCode;
+const prettier_1 = require("prettier");
+async function formatCode(code) {
+    return await (0, prettier_1.format)(code, {
+        parser: 'typescript',
+        printWidth: 100,
+        singleQuote: true,
+        semi: false,
+    });
+}

package/dist/generators/app/generate-app-route-handler.d.ts

@@ -0,0 +1 @@
+export declare function generateAppRouteHandler(routeName: string, handlerName: string): string;

package/dist/generators/app/generate-app-route-handler.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAppRouteHandler = generateAppRouteHandler;
+function generateAppRouteHandler(routeName, handlerName) {
+    return `.openapi(${routeName},${handlerName})`;
+}

package/dist/generators/handler/generate-handler-name.d.ts

@@ -0,0 +1 @@
+export declare function generateHandlerName(method: string, path: string): string;

package/dist/generators/handler/generate-handler-name.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHandlerName = generateHandlerName;
+const generate_route_name_1 = require("../openapi/paths/generate-route-name");
+function generateHandlerName(method, path) {
+    return `${(0, generate_route_name_1.generateRouteName)(method, path)}Handler`;
+}

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

@@ -0,0 +1 @@
+export declare function generateHandler(handlerName: string, routeName: string): string;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHandler = generateHandler;
+function generateHandler(handlerName, routeName) {
+    return `export const ${handlerName}:RouteHandler<typeof ${routeName}>=async(c)=>{}`;
+}

package/dist/generators/hono/app/generators/generate-apply-openapi-routes.d.ts

@@ -0,0 +1,5 @@
+export declare function generateApplyOpenapiRoutes(routeMappings: {
+    routeName: string;
+    handlerName: string;
+    path: string;
+}[]): string;

package/dist/generators/hono/app/generators/generate-apply-openapi-routes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApplyOpenapiRoutes = generateApplyOpenapiRoutes;
+const generate_app_route_handler_1 = require("../../../app/generate-app-route-handler");
+function generateApplyOpenapiRoutes(routeMappings) {
+    return routeMappings
+        .map(({ routeName, handlerName }) => {
+        return (0, generate_app_route_handler_1.generateAppRouteHandler)(routeName, handlerName);
+    })
+        .join('\n');
+}

package/dist/generators/hono/app/generators/generate-import-routes.d.ts

@@ -0,0 +1,3 @@
+export declare function generateImportRoutes(importsMap: {
+    [importPath: string]: string[];
+}): string[];

package/dist/generators/hono/app/generators/generate-import-routes.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportRoutes = generateImportRoutes;
+function generateImportRoutes(importsMap) {
+    const importRoutes = [];
+    for (const [importPath, names] of Object.entries(importsMap)) {
+        const uniqueNames = Array.from(new Set(names));
+        if (importPath.includes('/index.ts')) {
+            const normalizedPath = importPath.replace(/\/index\.ts$/, '');
+            importRoutes.push(`import { ${uniqueNames.join(',')} } from './${normalizedPath}';`);
+        }
+        else {
+            importRoutes.push(`import { ${uniqueNames.join(',')} } from './${importPath}';`);
+        }
+    }
+    return importRoutes;
+}

package/dist/generators/hono/app/helper/get-route-maps.d.ts

@@ -0,0 +1,6 @@
+import type { OpenAPISpec } from '../../../../types';
+export declare function getRouteMaps(openAPISpec: OpenAPISpec): {
+    routeName: string;
+    handlerName: string;
+    path: string;
+}[];

package/dist/generators/hono/app/helper/get-route-maps.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRouteMaps = getRouteMaps;
+const generate_handler_name_1 = require("../../../handler/generate-handler-name");
+const generate_route_name_1 = require("../../../openapi/paths/generate-route-name");
+function getRouteMaps(openAPISpec) {
+    const paths = openAPISpec.paths;
+    const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
+        return Object.entries(pathItem).flatMap(([method]) => {
+            const routeName = (0, generate_route_name_1.generateRouteName)(method, path);
+            const handlerName = (0, generate_handler_name_1.generateHandlerName)(method, path);
+            return { routeName, handlerName, path };
+        });
+    });
+    return routeMappings;
+}

package/dist/generators/hono/app/helper/process-import-map.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from '../../../../config';
+export declare function processImportMap(routeMappings: {
+    routeName: string;
+    handlerName: string;
+    path: string;
+}[], config: Config): {
+    [importPath: string]: string[];
+};

package/dist/generators/hono/app/helper/process-import-map.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processImportMap = processImportMap;
+function processImportMap(routeMappings, config) {
+    const importsMap = {};
+    for (const { routeName } of routeMappings) {
+        const importPath = config.output;
+        if (!importPath) {
+            throw new Error('Output path is required');
+        }
+        if (!importsMap[importPath]) {
+            importsMap[importPath] = [];
+        }
+        importsMap[importPath].push(routeName);
+    }
+    return importsMap;
+}

package/dist/generators/hono/app/index.d.ts

@@ -0,0 +1,3 @@
+import type { OpenAPISpec } from '../../../types';
+import type { Config } from '../../../config';
+export declare function generateApp(openAPISpec: OpenAPISpec, config: Config): string;

package/dist/generators/hono/app/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateApp = generateApp;
+const generate_docs_1 = require("../../openapi/docs/generate-docs");
+const get_handler_imports_1 = require("../handler/import/get-handler-imports");
+const get_route_maps_1 = require("./helper/get-route-maps");
+const generate_import_handlers_1 = require("../handler/import/generate-import-handlers");
+const generate_register_component_1 = require("../../openapi/components/generate-register-component");
+const generate_import_routes_1 = require("./generators/generate-import-routes");
+const generate_apply_openapi_routes_1 = require("./generators/generate-apply-openapi-routes");
+const process_import_map_1 = require("./helper/process-import-map");
+const OPENAPI_HONO_IMPORT = `import { OpenAPIHono } from '@hono/zod-openapi'`;
+const SWAGGER_UI_IMPORT = `import { swaggerUI } from '@hono/swagger-ui'`;
+const APP = 'const app = new OpenAPIHono()';
+const ADD_TYPE = 'export type AddType = typeof api';
+const EXPORT_APP = 'export default app';
+function generateApp(openAPISpec, config) {
+    const routeMappings = (0, get_route_maps_1.getRouteMaps)(openAPISpec);
+    const importsMap = (0, process_import_map_1.processImportMap)(routeMappings, config);
+    const importRoutes = (0, generate_import_routes_1.generateImportRoutes)(importsMap);
+    const handlerImportsMap = (0, get_handler_imports_1.getHandlerImports)(routeMappings);
+    const importHandlers = (0, generate_import_handlers_1.generateImportHandlers)(handlerImportsMap, config);
+    const importHandlersCode = importHandlers.join('\n');
+    const applyOpenapiRoutes = (0, generate_apply_openapi_routes_1.generateApplyOpenapiRoutes)(routeMappings);
+    const openAPIHono = config.app?.basePath ? `${APP}.basePath('${config.app.basePath}')` : APP;
+    const app = `app${applyOpenapiRoutes}`;
+    const api = `const api = ${app}`;
+    const docs = (0, generate_docs_1.generateDocs)(openAPISpec);
+    const isDev = config?.app?.isDev
+        ? `const isDev = ${config.app.isDev} === 'development'`
+        : `const isDev = process.env.NODE_ENV === 'development'`;
+    const basePath = config?.app?.basePath ? `/${config.app.basePath}/doc` : '/doc';
+    const { components } = openAPISpec;
+    const registerComponent = components?.securitySchemes
+        ? (0, generate_register_component_1.generateRegisterComponent)(components.securitySchemes)
+        : '';
+    const swagger = `if(isDev){${registerComponent}\napp.doc('${'/doc'}',${JSON.stringify(docs)}).get('/ui',swaggerUI({url:'${basePath}'}))}`;
+    const sections = [
+        // 1. imports
+        [OPENAPI_HONO_IMPORT, SWAGGER_UI_IMPORT, importRoutes.join(''), importHandlersCode].join('\n'),
+        // 2. app initialization
+        openAPIHono,
+        // 3. api setup
+        api,
+        // 4. development settings
+        isDev,
+        // 5. swagger setup
+        swagger,
+        // 6. types and exports
+        ADD_TYPE,
+        // 7. export app
+        EXPORT_APP,
+    ];
+    return sections.join('\n\n');
+}

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

@@ -18,7 +18,10 @@ const IMPORT_CODE = "import { createRoute, z } from '@hono/zod-openapi';";
  */
 function generateZodOpenAPIHono(openAPISpec, config) {
     // 1. get components
-    const components = openAPISpec.components;
+    const components = openAPISpec.components ? openAPISpec.components : undefined;
+    if (!components) {
+        throw new Error(`Cannot destructure property 'schemas' of 'components' as it is undefined.`);
+    }
     // 2. get paths
     const { paths } = openAPISpec;
     // 3. generate components code

package/dist/generators/hono/handler/generate-zod-openapi-hono-handler.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPISpec } from '../../../types';
+import type { Config } from '../../../config';
+export type HandlerOutput = {
+    fileName: string;
+    testFileName: string;
+    routeHandlerContents: string[];
+    routeNames: string[];
+};
+export declare function generateZodOpenapiHonoHandler(openapi: OpenAPISpec, config: Config): Promise<void>;

package/dist/generators/hono/handler/generate-zod-openapi-hono-handler.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodOpenapiHonoHandler = generateZodOpenapiHonoHandler;
+const node_fs_1 = __importDefault(require("node:fs"));
+const generate_handler_1 = require("../../handler/generate-handler");
+const generate_route_name_1 = require("../../openapi/paths/generate-route-name");
+const group_handlers_by_file_name_helper_1 = require("./helper/group-handlers-by-file-name-helper");
+const format_1 = require("../../../format");
+const generate_handler_name_1 = require("../../handler/generate-handler-name");
+const ROUTE_HANDLER = `import type { RouteHandler } from '@hono/zod-openapi'`;
+async function generateZodOpenapiHonoHandler(openapi, config) {
+    const paths = openapi.paths;
+    const handlers = [];
+    for (const [path, pathItem] of Object.entries(paths)) {
+        for (const [method] of Object.entries(pathItem)) {
+            const routeName = (0, generate_route_name_1.generateRouteName)(method, path);
+            const handlerName = (0, generate_handler_name_1.generateHandlerName)(method, path);
+            const routeHandlerContent = (0, generate_handler_1.generateHandler)(handlerName, routeName);
+            const path_name = path
+                .replace(/[\/{}-]/g, ' ')
+                .trim()
+                .split(/\s+/)[0];
+            const fileName = path_name.length === 0 ? 'index_handler.ts' : `${path_name}_handler.ts`;
+            const testFileName = path_name.length === 0 ? 'index_handler.test.ts' : `${path_name}_handler.test.ts`;
+            handlers.push({
+                fileName,
+                testFileName,
+                routeHandlerContents: [routeHandlerContent],
+                routeNames: [routeName],
+            });
+        }
+    }
+    const mergedHandlers = (0, group_handlers_by_file_name_helper_1.groupHandlersByFileNameHelper)(handlers);
+    for (const handler of mergedHandlers) {
+        if (config.app?.output === true) {
+            const dirPath = config?.output?.replace(/\/[^/]+\.ts$/, '');
+            const handlerPath = dirPath === 'index.ts' ? 'handler' : `${dirPath}/handler`;
+            if (!node_fs_1.default.existsSync(handlerPath)) {
+                node_fs_1.default.mkdirSync(handlerPath, { recursive: true });
+            }
+            const routeTypes = handler.routeNames.map((routeName) => `${routeName}`).join(', ');
+            const match = config.output?.match(/[^/]+\.ts$/);
+            const matchPath = match ? match[0] : '';
+            const path = config.output === '.' || config.output === './' ? config.output : `../${matchPath}`;
+            const importRouteTypes = routeTypes ? `import type { ${routeTypes} } from '${path}';` : '';
+            const importStatements = `${ROUTE_HANDLER}\n${importRouteTypes}`;
+            const fileContent = `${importStatements}\n\n${handler.routeHandlerContents.join('\n\n')}`;
+            node_fs_1.default.writeFileSync(`${handlerPath}/${handler.fileName}`, await (0, format_1.formatCode)(fileContent), {
+                encoding: 'utf-8',
+            });
+            if (config.app.test) {
+                node_fs_1.default.writeFileSync(`${handlerPath}/${handler.testFileName}`, '', {
+                    encoding: 'utf-8',
+                });
+            }
+        }
+    }
+}

package/dist/generators/hono/handler/helper/group-handlers-by-file-name-helper.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerOutput } from '../generate-zod-openapi-hono-handler';
+export declare function groupHandlersByFileNameHelper(handlers: HandlerOutput[]): HandlerOutput[];

package/dist/generators/hono/handler/helper/group-handlers-by-file-name-helper.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupHandlersByFileNameHelper = groupHandlersByFileNameHelper;
+function groupHandlersByFileNameHelper(handlers) {
+    const mergedMap = new Map();
+    for (const handler of handlers) {
+        if (mergedMap.has(handler.fileName)) {
+            const existing = mergedMap.get(handler.fileName);
+            if (existing) {
+                existing.routeHandlerContents.push(...handler.routeHandlerContents);
+                existing.routeNames.push(...handler.routeNames);
+            }
+        }
+        else {
+            mergedMap.set(handler.fileName, {
+                fileName: handler.fileName,
+                testFileName: handler.testFileName,
+                routeHandlerContents: [...handler.routeHandlerContents],
+                routeNames: [...handler.routeNames],
+            });
+        }
+    }
+    return Array.from(mergedMap.values());
+}

package/dist/generators/hono/handler/import/generate-import-handlers.d.ts

@@ -0,0 +1,4 @@
+import type { Config } from '../../../../config';
+export declare function generateImportHandlers(handlerImportsMap: {
+    [fileName: string]: string[];
+}, config: Config): string[];

package/dist/generators/hono/handler/import/generate-import-handlers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImportHandlers = generateImportHandlers;
+function generateImportHandlers(handlerImportsMap, config) {
+    const importHandlers = [];
+    for (const [fileName, handlers] of Object.entries(handlerImportsMap)) {
+        const uniqueHandlers = Array.from(new Set(handlers));
+        if (config?.app?.output === true) {
+            const replacePath = config?.output?.replace(/\/[^/]+\.ts$/, '');
+            const dirPath = replacePath === undefined ? '.' : replacePath;
+            const handlerPath = dirPath === 'index.ts' ? 'handler' : `${dirPath}/handler`;
+            if (dirPath === '.') {
+                importHandlers.push(`import { ${uniqueHandlers.join(',')} } from '${handlerPath}/${fileName}';`);
+            }
+            else {
+                importHandlers.push(`import { ${uniqueHandlers.join(',')} } from './${handlerPath}/${fileName}';`);
+            }
+        }
+    }
+    return importHandlers;
+}

package/dist/generators/hono/handler/import/get-handler-imports.d.ts

@@ -0,0 +1,7 @@
+export declare function getHandlerImports(handlerMaps: {
+    routeName: string;
+    handlerName: string;
+    path: string;
+}[]): {
+    [fileName: string]: string[];
+};

package/dist/generators/hono/handler/import/get-handler-imports.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHandlerImports = getHandlerImports;
+function getHandlerImports(handlerMaps) {
+    const getHandlerImports = {};
+    for (const { handlerName, path } of handlerMaps) {
+        const path_name = path
+            .replace(/[\/{}-]/g, ' ')
+            .trim()
+            .split(/\s+/)[0];
+        const fileName = path_name.length === 0 ? 'index_handler.ts' : `${path_name}_handler.ts`;
+        if (!getHandlerImports[fileName]) {
+            getHandlerImports[fileName] = [];
+        }
+        getHandlerImports[fileName].push(handlerName);
+    }
+    return getHandlerImports;
+}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAllOfCode = generateAllOfCode;
 const process_alllof_1 = require("./process/process-alllof");
+const generate_zod_intersection_1 = require("../../../zod/generate-zod-intersection");
 /**
  * Converts an `allOf` schema into a Zod schema.
  *
@@ -21,6 +22,7 @@ function generateAllOfCode(schema, config) {
     if (schemas.length === 1) {
         return nullable ? `${schemas[0]}.nullable()` : schemas[0];
     }
-    const intersection = `z.intersection(${schemas.join(',')})${nullable ? '.nullable()' : ''}`;
+    const intersectionSchema = (0, generate_zod_intersection_1.generateZodIntersection)(schemas);
+    const intersection = `${intersectionSchema}${nullable ? '.nullable()' : ''}`;
     return intersection;
 }

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAnyOfCode = generateAnyOfCode;
-const generate_zod_schema_1 = require("../../../zod/generate-zod-schema");
+const generate_zod_schema_1 = require("../../../zod/schema/generate-zod-schema");
 const get_ref_schema_name_1 = require("../../../../core/schema/references/get-ref-schema-name");
+const generate_zod_union_1 = require("../../../zod/generate-zod-union");
 function generateAnyOfCode(schema, config) {
     if (!schema.anyOf || schema.anyOf.length === 0) {
         console.warn('not exists anyOf');
@@ -12,5 +13,5 @@ function generateAnyOfCode(schema, config) {
         subSchema.$ref ? (0, get_ref_schema_name_1.getRefSchemaName)(subSchema, config) : (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
         return (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
     });
-    return `z.union([${zodSchemas.join(', ')}])`;
+    return (0, generate_zod_union_1.generateZodUnion)(zodSchemas);
 }

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

@@ -1,8 +1,8 @@
 "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 generate_zod_to_openapi_schema_definition_1 = require("../../zod/openapi/generate-zod-to-openapi-schema-definition");
+const generate_zod_schema_1 = require("../../zod/schema/generate-zod-schema");
 const resolve_schemas_dependencies_1 = require("../../../core/schema/references/resolve-schemas-dependencies");
 const generate_schemas_export_1 = require("../paths/generate-schemas-export");
 const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
@@ -27,6 +27,9 @@ function generateComponentsCode(components,
 config) {
     // 1. schema extraction
     const { schemas } = components;
+    if (!schemas) {
+        return '';
+    }
     // 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
@@ -43,7 +46,7 @@ config) {
         // 4.3 generate zod schema
         const zodSchema = (0, generate_zod_schema_1.generateZodSchema)(config, schema, undefined, undefined);
         // 4.4 generate zod schema definition
-        return (0, generate_zod_schema_definition_1.generateZodSchemaDefinition)(variableName, zodSchema, schemaName);
+        return (0, generate_zod_to_openapi_schema_definition_1.generateZodToOpenAPISchemaDefinition)(variableName, zodSchema, schemaName);
     })
         .join('\n\n');
     // 5. generate export statement

package/dist/generators/openapi/components/generate-register-component.d.ts

@@ -0,0 +1,2 @@
+import type { SecuritySchemes } from '../../../types';
+export declare function generateRegisterComponent(securitySchemes: SecuritySchemes): string;

package/dist/generators/openapi/components/generate-register-component.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRegisterComponent = generateRegisterComponent;
+function generateRegisterComponent(securitySchemes) {
+    return Object.entries(securitySchemes)
+        .map(([name, scheme]) => {
+        return `app.openAPIRegistry.registerComponent('securitySchemes', '${name}', ${JSON.stringify(scheme)})`;
+    })
+        .join('\n');
+}

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

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateOneOfCode = generateOneOfCode;
-const generate_zod_schema_1 = require("../../../zod/generate-zod-schema");
+const generate_zod_schema_1 = require("../../../zod/schema/generate-zod-schema");
 const get_ref_schema_name_1 = require("../../../../core/schema/references/get-ref-schema-name");
+const generate_zod_union_1 = require("../../../zod/generate-zod-union");
 function generateOneOfCode(schema, config) {
     if (!schema.oneOf || schema.oneOf.length === 0) {
         console.warn('not exists oneOf');
@@ -12,5 +13,5 @@ function generateOneOfCode(schema, config) {
         subSchema.$ref ? (0, get_ref_schema_name_1.getRefSchemaName)(subSchema, config) : (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
         return (0, generate_zod_schema_1.generateZodSchema)(config, subSchema);
     });
-    return `z.union([${zodSchemas.join(',')}])`;
+    return (0, generate_zod_union_1.generateZodUnion)(zodSchemas);
 }

package/dist/generators/openapi/docs/generate-docs.d.ts

@@ -0,0 +1,8 @@
+import type { OpenAPISpec } from '../../../types';
+export declare function generateDocs(openAPISpec: OpenAPISpec): {
+    openapi: string | undefined;
+    info: OpenAPISpec['info'];
+    servers: OpenAPISpec['servers'];
+    externalDocs: OpenAPISpec['externalDocs'];
+    tags: OpenAPISpec['tags'];
+};

package/dist/generators/openapi/docs/generate-docs.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDocs = generateDocs;
+function generateDocs(openAPISpec) {
+    return {
+        openapi: openAPISpec.openapi,
+        info: openAPISpec.info,
+        servers: openAPISpec.servers,
+        externalDocs: openAPISpec.externalDocs,
+        tags: openAPISpec.tags,
+    };
+}

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

@@ -5,7 +5,7 @@ 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");
-const escape_quote_1 = require("../../../core/text/escape-quote");
+const sanitize_1 = require("../../../core/text/sanitize");
 /**
  * Generates TypeScript code for a Hono route based on OpenAPI operation details
  *
@@ -40,8 +40,8 @@ config) {
         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)}',` : '',
+        summaryCode: summary ? `summary:'${(0, sanitize_1.sanitize)(summary)}',` : '',
+        descriptionCode: description ? `description:'${(0, sanitize_1.sanitize)(description)}',` : '',
         securityCode: security ? `security:${JSON.stringify(security)},` : '',
         requestParams: requestParams ? `${requestParams}` : '',
         responsesCode: responses ? `responses:{${(0, generate_response_schema_1.generateResponseSchema)(responses, config)}}` : '',

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

@@ -2,7 +2,7 @@
 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");
+const generate_zod_schema_1 = require("../../zod/schema/generate-zod-schema");
 /**
  * Generates a params object containing Zod schemas for different parameter locations
  *

package/dist/generators/types/generate-types-code.js

@@ -19,6 +19,9 @@ const generate_zod_infer_1 = require("../zod/generate-zod-infer");
 function generateTypesCode(components, config) {
     // 1. schema extraction
     const { schemas } = components;
+    if (!schemas) {
+        return '';
+    }
     // 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

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

@@ -0,0 +1,2 @@
+import type { Schema } from '../../types';
+export declare function generateZodEnum(schema: Schema): string;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodEnum = generateZodEnum;
+const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
+function generateZodEnum(schema) {
+    if (schema.example) {
+        const openapi_example = (0, generate_zod_to_openapi_1.generateZodToOpenAPI)(schema.example);
+        return `z.enum(${JSON.stringify(schema.enum)})${openapi_example}`;
+    }
+    return `z.enum(${JSON.stringify(schema.enum)})`;
+}

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

@@ -5,7 +5,7 @@ const generate_zod_default_1 = require("./generate-zod-default");
 const generate_zod_max_1 = require("./generate-zod-max");
 const generate_zod_min_1 = require("./generate-zod-min");
 const generate_zod_regex_1 = require("./generate-zod-regex");
-const generate_zod_to_openapi_1 = require("./generate-zod-to-openapi");
+const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
 /**
  * Generates a zod schema for an integer.
  *

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

@@ -0,0 +1,7 @@
+/**
+ * Generates a Zod intersection schema.
+ *
+ * @param schemas - The schemas to intersect.
+ * @returns The generated Zod intersection schema as a string.
+ */
+export declare function generateZodIntersection(schemas: string[]): string;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodIntersection = generateZodIntersection;
+/**
+ * Generates a Zod intersection schema.
+ *
+ * @param schemas - The schemas to intersect.
+ * @returns The generated Zod intersection schema as a string.
+ */
+function generateZodIntersection(schemas) {
+    return `z.intersection(${schemas.join(',')})`;
+}

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

@@ -5,7 +5,7 @@ const generate_zod_default_1 = require("./generate-zod-default");
 const generate_zod_max_1 = require("./generate-zod-max");
 const generate_zod_min_1 = require("./generate-zod-min");
 const generate_zod_regex_1 = require("./generate-zod-regex");
-const generate_zod_to_openapi_1 = require("./generate-zod-to-openapi");
+const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
 /**
  * Generates a zod schema for a number.
  *

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

@@ -0,0 +1,3 @@
+import type { Schema } from '../../types';
+import type { Config } from '../../config';
+export declare function generateZodObject(schema: Schema, config: Config): string;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodObject = generateZodObject;
+const generate_zod_record_schema_1 = require("./generate-zod-record-schema");
+const generate_allof_code_1 = require("../openapi/components/allof/generate-allof-code");
+const generate_oneof_code_1 = require("../openapi/components/oneof/generate-oneof-code");
+const generate_anyof_code_1 = require("../openapi/components/anyof/generate-anyof-code");
+const generate_zod_properties_schema_1 = require("./generate-zod-properties-schema");
+function generateZodObject(schema, config) {
+    if (schema.additionalProperties)
+        return (0, generate_zod_record_schema_1.generateZodRecordSchema)(schema.additionalProperties, config);
+    if (schema.allOf) {
+        return (0, generate_allof_code_1.generateAllOfCode)(schema, config);
+    }
+    if (schema.oneOf) {
+        return (0, generate_oneof_code_1.generateOneOfCode)(schema, config);
+    }
+    if (schema.anyOf) {
+        return (0, generate_anyof_code_1.generateAnyOfCode)(schema, config);
+    }
+    if (!schema.properties) {
+        return 'z.object({})';
+    }
+    return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(schema.properties, schema.required || [], config);
+}

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

@@ -3,7 +3,7 @@ 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 generate_zod_schema_1 = require("./schema/generate-zod-schema");
 const get_variable_schema_name_helper_1 = require("../../core/helper/get-variable-schema-name-helper");
 // import { generateZodOpenAPIExample } from './generate-zod-openapi-example'
 /**

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodRecordSchema = generateZodRecordSchema;
-const generate_zod_schema_1 = require("./generate-zod-schema");
+const generate_zod_schema_1 = require("./schema/generate-zod-schema");
 /**
  * Generates a Zod record schema for objects with additional properties
  *

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

@@ -6,7 +6,7 @@ const generate_zod_default_1 = require("./generate-zod-default");
 const generate_zod_max_1 = require("./generate-zod-max");
 const generate_zod_min_1 = require("./generate-zod-min");
 const generate_zod_regex_1 = require("./generate-zod-regex");
-const generate_zod_to_openapi_1 = require("./generate-zod-to-openapi");
+const generate_zod_to_openapi_1 = require("./openapi/generate-zod-to-openapi");
 /**
  * Generates a Zod schema string for string validation
  *

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

@@ -0,0 +1,12 @@
+/**
+ * Generates a Zod union schema
+ *
+ * @function generateZodUnion
+ * @param schemas - An array of Zod schema strings
+ * @returns A Zod union schema string
+ *
+ * @example
+ * generateZodUnion(['z.string()', 'z.number()'])
+ * // Returns: 'z.union([z.string(), z.number()])'
+ */
+export declare function generateZodUnion(schemas: string[]): string;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateZodUnion = generateZodUnion;
+/**
+ * Generates a Zod union schema
+ *
+ * @function generateZodUnion
+ * @param schemas - An array of Zod schema strings
+ * @returns A Zod union schema string
+ *
+ * @example
+ * generateZodUnion(['z.string()', 'z.number()'])
+ * // Returns: 'z.union([z.string(), z.number()])'
+ */
+function generateZodUnion(schemas) {
+    return `z.union([${schemas.join(',')}])`;
+}

package/dist/generators/zod/{generate-zod-schema-definition.d.ts → openapi/generate-zod-to-openapi-schema-definition.d.ts}

@@ -19,4 +19,4 @@
  * - Part of OpenAPI to Zod schema conversion process
  * - Creates reusable schema definitions
  */
-export declare function generateZodSchemaDefinition(name: string, zodSchema: string, schemaName: string): string;
+export declare function generateZodToOpenAPISchemaDefinition(name: string, zodSchema: string, schemaName: string): string;

package/dist/generators/zod/{generate-zod-schema-definition.js → openapi/generate-zod-to-openapi-schema-definition.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateZodSchemaDefinition = generateZodSchemaDefinition;
+exports.generateZodToOpenAPISchemaDefinition = generateZodToOpenAPISchemaDefinition;
 /**
  * Creates a Zod schema constant declaration
  *
@@ -22,6 +22,6 @@ exports.generateZodSchemaDefinition = generateZodSchemaDefinition;
  * - Part of OpenAPI to Zod schema conversion process
  * - Creates reusable schema definitions
  */
-function generateZodSchemaDefinition(name, zodSchema, schemaName) {
+function generateZodToOpenAPISchemaDefinition(name, zodSchema, schemaName) {
     return `const ${name} = ${zodSchema}.openapi('${schemaName}')`;
 }

package/dist/generators/zod/{generate-zod-to-openapi.d.ts → openapi/generate-zod-to-openapi.d.ts}

@@ -1,4 +1,4 @@
-import type { ExampleValue } from '../../types';
+import type { ExampleValue } from '../../../types';
 /**
  * Generate OpenAPI example value from Zod example value
  *

package/dist/generators/zod/{generate-zod-schema.d.ts → schema/generate-zod-schema.d.ts}

@@ -1,5 +1,5 @@
-import type { Schema } from '../../types';
-import type { Config } from '../../config';
+import type { Schema } from '../../../types';
+import type { Config } from '../../../config';
 /**
  * Generates a Zod schema string from an OpenAPI/JSON Schema definition
  *

package/dist/generators/zod/{generate-zod-schema.js → schema/generate-zod-schema.js}

@@ -1,17 +1,17 @@
 "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");
-const generate_allof_code_1 = require("../openapi/components/allof/generate-allof-code");
-const generate_anyof_code_1 = require("../openapi/components/anyof/generate-anyof-code");
-const generate_oneof_code_1 = require("../openapi/components/oneof/generate-oneof-code");
-const get_variable_schema_name_helper_1 = require("../../core/helper/get-variable-schema-name-helper");
+const generate_zod_array_1 = require("../generate-zod-array");
+const generate_zod_string_schema_1 = require("../generate-zod-string-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");
+const generate_allof_code_1 = require("../../openapi/components/allof/generate-allof-code");
+const generate_anyof_code_1 = require("../../openapi/components/anyof/generate-anyof-code");
+const generate_oneof_code_1 = require("../../openapi/components/oneof/generate-oneof-code");
+const get_variable_schema_name_helper_1 = require("../../../core/helper/get-variable-schema-name-helper");
+const generate_zod_object_1 = require("../generate-zod-object");
+const generate_zod_enum_1 = require("../generate-zod-enum");
 /**
  * Mapping of OpenAPI/JSON Schema types to Zod schema strings
  *
@@ -93,29 +93,11 @@ const TYPE_TO_ZOD_SCHEMA = {
 function generateZodSchema(config, schema, paramName, isPath) {
     // enum
     if (schema.enum) {
-        if (schema.example) {
-            return `z.enum(${JSON.stringify(schema.enum)}).openapi({example:${JSON.stringify(schema.example)}})`;
-        }
-        return `z.enum(${JSON.stringify(schema.enum)})`;
+        return (0, generate_zod_enum_1.generateZodEnum)(schema);
     }
     // object
     if (schema.type === 'object') {
-        if (schema.additionalProperties)
-            return (0, generate_zod_record_schema_1.generateZodRecordSchema)(schema.additionalProperties, config);
-        if (schema.allOf) {
-            return (0, generate_allof_code_1.generateAllOfCode)(schema, config);
-        }
-        if (schema.oneOf) {
-            return (0, generate_oneof_code_1.generateOneOfCode)(schema, config);
-        }
-        if (schema.anyOf) {
-            return (0, generate_anyof_code_1.generateAnyOfCode)(schema, config);
-        }
-        if (!schema.properties) {
-            // console.log(schema)
-            return 'z.object({})';
-        }
-        return (0, generate_zod_properties_schema_1.generateZodPropertiesSchema)(schema.properties, schema.required || [], config);
+        return (0, generate_zod_object_1.generateZodObject)(schema, config);
     }
     // string
     if (schema.type === 'string') {

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateZodSchemaFromSubSchema = generateZodSchemaFromSubSchema;
 const get_ref_schema_name_1 = require("../../../core/schema/references/get-ref-schema-name");
-const generate_zod_schema_1 = require("../generate-zod-schema");
+const generate_zod_schema_1 = require("../schema/generate-zod-schema");
 /**
  * Generates a Zod schema from a sub-schema.
  *

package/dist/index.js

@@ -8,9 +8,11 @@ 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_zod_openapi_hono_1 = require("./generators/hono/generate-zod-openapi-hono");
+const generate_zod_openapi_hono_handler_1 = require("./generators/hono/handler/generate-zod-openapi-hono-handler");
 const config_1 = require("./config");
+const format_1 = require("./format");
+const app_1 = require("./generators/hono/app");
 /**
  * CLI entry point for hono-takibi
  *
@@ -35,23 +37,19 @@ async function main(dev = false, config = (0, config_1.getConfig)()) {
     const args = process.argv.slice(2);
     // 3. input = 'example/pet-store.yaml'
     const input = config.input ?? args[0];
-    // const input = args[0]
+    config.input = input;
     // 4. output = 'routes/petstore-index.ts'
     const output = config.output ?? args[args.indexOf('-o') + 1];
+    config.output = output;
     try {
         // 5. parse OpenAPI YAML or JSON
         const openAPI = (await swagger_parser_1.default.parse(input));
         // 6. generate Hono code
         const hono = (0, generate_zod_openapi_hono_1.generateZodOpenAPIHono)(openAPI, config);
         // 7. format code
-        const formattedCode = await (0, prettier_1.format)(hono, {
-            parser: 'typescript',
-            printWidth: 100,
-            singleQuote: true,
-            semi: false,
-        });
+        const formattedCode = await (0, format_1.formatCode)(hono);
         // 8. write to file
-        if (output) {
+        if (config.output) {
             // 8.1 output routes/petstore-index.ts
             const outputDir = node_path_1.default.dirname(output);
             // 8.2 outputDir routes
@@ -61,6 +59,27 @@ async function main(dev = false, config = (0, config_1.getConfig)()) {
         }
         // 9. write to file
         node_fs_1.default.writeFileSync(output, formattedCode, { encoding: 'utf-8' });
+        // Vite Plugin Mode
+        const mode = process.argv[5];
+        const vite = process.argv[6];
+        if (mode === '--mode' && vite === 'vite') {
+            node_fs_1.default.writeFileSync(output, formattedCode, { encoding: 'utf-8' });
+            console.log(`Generated code written to ${output}`);
+            return true;
+        }
+        // 10. generate app code
+        const appCode = (0, app_1.generateApp)(openAPI, config);
+        if (config.app?.output === true) {
+            // 10.1 generate handler code
+            await (0, generate_zod_openapi_hono_handler_1.generateZodOpenapiHonoHandler)(openAPI, config);
+            // 10.2 format app code
+            const formattedAppCode = await (0, format_1.formatCode)(appCode);
+            // 10.3 write to file
+            const defaultFileName = 'index.ts';
+            const alternativeFileName = 'main.ts';
+            const outputFile = node_fs_1.default.existsSync(defaultFileName) ? alternativeFileName : defaultFileName;
+            node_fs_1.default.writeFileSync(outputFile, formattedAppCode, { encoding: 'utf-8' });
+        }
         console.log(`Generated code written to ${output}`);
         return true;
     }

package/dist/types/index.d.ts

@@ -7,6 +7,10 @@ export type OpenAPI = Awaited<ReturnType<typeof SwaggerParser.parse>>;
  * Extended OpenAPI specification with required components and paths
  */
 export type OpenAPISpec = OpenAPI & {
+    openapi?: string;
+    servers?: string | {
+        url: string;
+    }[];
     components: Components;
 } & {
     paths: OpenAPIPaths;
@@ -156,9 +160,17 @@ export type Schema = {
  * Components section of OpenAPI spec
  */
 export type Components = {
-    schemas: Record<string, Schema>;
+    schemas?: Record<string, Schema>;
     parameters?: Record<string, Parameters>;
     requestBodies?: Record<string, RequestBody>;
+    securitySchemes?: SecuritySchemes;
+};
+export type SecuritySchemes = {
+    [key: string]: {
+        type?: string;
+        scheme?: string;
+        bearerFormat?: string;
+    };
 };
 /**
  * Dynamic parameter section type

package/dist/vite-plugin/index.d.ts

@@ -0,0 +1,10 @@
+type HonoTakibiPluginOptions = {
+    input: string;
+    output: string;
+    packageManager: 'pnpm' | 'npm' | 'yarn' | 'bun';
+};
+export default function honoTakibiPlugin(options: HonoTakibiPluginOptions): {
+    name: string;
+    configureServer(server: any): void;
+};
+export {};

package/dist/vite-plugin/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = honoTakibiPlugin;
+const node_child_process_1 = require("node:child_process");
+function honoTakibiPlugin(options) {
+    return {
+        name: 'hono-takibi-plugin',
+        // biome-ignore lint/suspicious/noExplicitAny: <explanation>
+        configureServer(server) {
+            server.watcher.add(options.input);
+            server.watcher.on('change', () => {
+                const commandPrefixMap = {
+                    npm: 'npx',
+                    pnpm: 'pnpm',
+                    yarn: 'yarn',
+                    bun: 'bun',
+                };
+                const commandPrefix = commandPrefixMap[options.packageManager];
+                const command = `${commandPrefix} hono-takibi ${options.input} -o ${options.output} --mode vite`;
+                (0, node_child_process_1.exec)(command, (error) => {
+                    if (error) {
+                        console.error(`[hono-takibi-plugin] error: ${error.message}`);
+                        return;
+                    }
+                    // reload
+                    server.ws.send({ type: 'full-reload' });
+                });
+            });
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "license": "MIT",
   "keywords": [
     "hono",
@@ -26,7 +26,15 @@
   "bin": {
     "hono-takibi": "dist/index.js"
   },
+  "exports": {
+    "./vite-plugin": {
+      "types": "./dist/vite-plugin/index.d.ts",
+      "import": "./dist/vite-plugin/index.js",
+      "require": "./dist/vite-plugin/index.js"
+    }
+  },
   "scripts": {
+    "dev": "vite --host",
     "deps": "rm -rf node_modules && pnpm install",
     "build": "tsc",
     "typecheck": "tsc --noEmit",
@@ -43,6 +51,7 @@
     "@types/node": "^22.10.2",
     "@vitest/coverage-v8": "^2.1.8",
     "typescript": "^5.7.2",
+    "vite": "^6.1.0",
     "vitest": "^2.1.8"
   }
 }