hono-takibi 0.2.2 → 0.3.1

package/README.md

@@ -5,64 +5,7 @@
 ![img](https://raw.githubusercontent.com/nakita628/hono-takibi/refs/heads/main/assets/img/hono-takibi.png)
 
 ```bash
-npm add -D hono-takibi
-```
-
-## Configuration
-
-You can customize the code generation behavior by creating a `hono-takibi.json` file in your project root.
-
-### Schema Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `namingCase` | `"camelCase"` \| `"PascalCase"` | `"camelCase"` | Naming convention for generated schema variables |
-| `exportEnabled` | `boolean` | `false` | When true, exports all schema definitions |
-
-### Type Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `namingCase` | `"camelCase"` \| `"PascalCase"` | `"PascalCase"` | Naming convention for generated type definitions |
-| `exportEnabled` | `boolean` | `false` | When true, exports all type definitions |
-
-## Input and Output
-
-You can specify input and output paths in two ways:
-
-1. Command line arguments:
-
-2. Configuration file (`hono-takibi.json`):
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `input` | `string` | `""` | Input file path |
-| `output` | `string` | `""` | Output file path |
-
-> **⚠️** When using a configuration file, command line arguments are not required. The configuration file settings take precedence over command line arguments.
->
-> **🔥** When you have configured `hono-takibi.json`, you can simply run:
-> ```bash
-> npx hono-takibi
-> ```
-
-### Examples
-
-* Default Behavior (camelCase schemas, PascalCase types)
-
-```json
-{
-  "input": "src/openapi/openapi.yaml",
-  "output": "src/openapi/index.ts",
-  "schemaOptions": {
-    "namingCase": "camelCase",
-    "exportEnabled": false
-  },
-  "typeOptions": {
-    "namingCase": "PascalCase",
-    "exportEnabled": false
-  }
-}
+npm install -D hono-takibi
 ```
 
 ## Migrate Legacy APIs to Hono
@@ -501,6 +444,76 @@ export const deletePostsIdRoute = createRoute({
 })
 ```
 
+## Configuration
+
+You can customize the code generation behavior by creating a `hono-takibi.json` file in your project root.
+
+### Schema Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `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` | `"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:
+
+1. Command line arguments:
+
+2. Configuration file (`hono-takibi.json`):
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `input` | `string` | `""` | Input file path |
+| `output` | `string` | `""` | Output file path |
+
+> **⚠️** When using a configuration file, command line arguments are not required. The configuration file settings take precedence over command line arguments.
+>
+> **🔥** When you have configured `hono-takibi.json`, you can simply run:
+> ```bash
+> npx hono-takibi
+> ```
+
+### Examples
+
+* Default Behavior (PascalCase schemas, PascalCase types)
+
+```json
+{
+  "schema": {
+    "name": "PascalCase",
+    "export": false
+  },
+  "type": {
+    "name": "PascalCase",
+    "export": false
+  },
+  "app": {
+    "output": true,
+    "test": true,
+    "basePath": "api",
+    "isDev": "process.env.NODE_ENV"
+  }
+}
+```
+
 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

package/dist/config/index.d.ts

@@ -1,11 +1,17 @@
 export type Config = {
-    schemaOptions: {
-        namingCase: 'camelCase' | 'PascalCase';
-        exportEnabled: boolean;
+    schema: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
     };
-    typeOptions: {
-        namingCase: 'camelCase' | 'PascalCase';
-        exportEnabled: boolean;
+    type: {
+        name: 'PascalCase' | 'camelCase';
+        export: boolean;
+    };
+    app?: {
+        output?: boolean;
+        test?: boolean;
+        basePath?: string;
+        isDev?: string;
     };
     input?: string;
     output?: string;

package/dist/config/index.js

@@ -7,13 +7,17 @@ exports.DEFAULT_CONFIG = void 0;
 exports.getConfig = getConfig;
 const node_fs_1 = __importDefault(require("node:fs"));
 exports.DEFAULT_CONFIG = {
-    schemaOptions: {
-        namingCase: 'camelCase',
-        exportEnabled: false,
+    schema: {
+        name: 'PascalCase',
+        export: false,
     },
-    typeOptions: {
-        namingCase: 'PascalCase',
-        exportEnabled: false,
+    type: {
+        name: 'PascalCase',
+        export: false,
+    },
+    app: {
+        output: false,
+        test: false,
     },
 };
 /**

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-name-helper.js

@@ -4,6 +4,6 @@ exports.getVariableNameHelper = void 0;
 const capitalize_1 = require("../text/capitalize");
 const decapitalize_1 = require("../text/decapitalize");
 const getVariableNameHelper = (name, config) => {
-    return config.typeOptions.namingCase === 'camelCase' ? (0, decapitalize_1.decapitalize)(name) : (0, capitalize_1.capitalize)(name);
+    return config.type.name === 'camelCase' ? (0, decapitalize_1.decapitalize)(name) : (0, capitalize_1.capitalize)(name);
 };
 exports.getVariableNameHelper = getVariableNameHelper;

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.schemaOptions.namingCase === 'camelCase'
-        ? (0, get_camel_case_schema_name_1.getCamelCaseSchemaName)(name)
-        : (0, get_pascal_case_schema_name_1.getPascalCaseSchemaName)(name);
+    return config.schema.name === 'camelCase'
+        ? (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/schema/references/extract-refs.d.ts

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

package/dist/core/schema/references/extract-refs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractRefs = extractRefs;
+const is_ref_object_1 = require("../../validator/is-ref-object");
+function extractRefs(schema) {
+    const refs = [];
+    const traverse = (obj) => {
+        if (!(0, is_ref_object_1.isRefObject)(obj))
+            return;
+        for (const [key, value] of Object.entries(obj)) {
+            if (key !== '$ref') {
+                if ((0, is_ref_object_1.isRefObject)(value)) {
+                    traverse(value);
+                }
+                continue;
+            }
+            if (typeof value !== 'string')
+                continue;
+            const refParts = value.split('/');
+            const refName = refParts[refParts.length - 1];
+            refs.push(refName);
+        }
+    };
+    traverse(schema);
+    return refs;
+}

package/dist/core/schema/references/get-ref-schema-name.d.ts

@@ -0,0 +1,11 @@
+import type { Config } from '../../../config';
+import type { Schema } from '../../../types';
+/**
+ * Retrieves the referenced schema name from a schema object.
+ *
+ * @param schema - The schema object
+ * @param config - The configuration object
+ * @returns The referenced schema name
+ * @throws Will throw an error if the $ref property or the reference name is not found
+ */
+export declare function getRefSchemaName(schema: Schema, config: Config): string;

package/dist/core/schema/references/get-ref-schema-name.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRefSchemaName = getRefSchemaName;
+const get_variable_schema_name_helper_1 = require("../../helper/get-variable-schema-name-helper");
+const get_ref_name_1 = require("./get-ref-name");
+/**
+ * Retrieves the referenced schema name from a schema object.
+ *
+ * @param schema - The schema object
+ * @param config - The configuration object
+ * @returns The referenced schema name
+ * @throws Will throw an error if the $ref property or the reference name is not found
+ */
+function getRefSchemaName(schema, config) {
+    if (!schema.$ref) {
+        throw new Error('refName is not found');
+    }
+    const refName = (0, get_ref_name_1.getRefName)(schema.$ref);
+    if (!refName) {
+        throw new Error('refName is not found');
+    }
+    return (0, get_variable_schema_name_helper_1.getVariableSchemaNameHelper)(refName, config);
+}

package/dist/core/schema/references/resolve-schemas-dependencies.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveSchemasDependencies = resolveSchemasDependencies;
-const resolve_schema_order_1 = require("./resolve-schema-order");
-const resolve_schema_references_1 = require("./resolve-schema-references");
+const extract_refs_1 = require("./extract-refs");
 /**
  * Resolves dependencies between schemas and returns them in topological order for safe processing
  *
@@ -50,16 +49,50 @@ const resolve_schema_references_1 = require("./resolve-schema-references");
  * - Uses depth-first search for dependency resolution
  * - Automatically handles circular dependencies by preventing infinite recursion
  */
+// export function resolveSchemasDependencies(schemas: Record<string, Schema>): string[] {
+//   // 1. get schema reference relations as a map
+//   const dependencies = resolveSchemaReferences(schemas)
+//   // 2. initialize ordered list and visited set
+//   const ordered: string[] = []
+//   const visited = new Set<string>()
+//   // 3. resolve schema order
+//   for (const name of Object.keys(schemas)) {
+//     resolveSchemaOrder(name, dependencies, visited, ordered)
+//   }
+//   // 4. return ordered list
+//   return ordered
+// }
 function resolveSchemasDependencies(schemas) {
-    // 1. get schema reference relations as a map
-    const dependencies = (0, resolve_schema_references_1.resolveSchemaReferences)(schemas);
-    // 2. initialize ordered list and visited set
-    const ordered = [];
-    const visited = new Set();
-    // 3. resolve schema order
-    for (const name of Object.keys(schemas)) {
-        (0, resolve_schema_order_1.resolveSchemaOrder)(name, dependencies, visited, ordered);
+    const visited = {};
+    const temp = {};
+    const result = [];
+    const visit = (schemaName) => {
+        if (temp[schemaName]) {
+            throw new Error(`bad schema: ${schemaName}`);
+        }
+        if (!visited[schemaName]) {
+            temp[schemaName] = true;
+            const schema = schemas[schemaName];
+            if (schema) {
+                const refs = (0, extract_refs_1.extractRefs)(schema);
+                for (const ref of refs) {
+                    if (schemas[ref]) {
+                        visit(ref);
+                    }
+                    else {
+                        console.warn(`not found schema: ${ref}`);
+                    }
+                }
+            }
+            visited[schemaName] = true;
+            temp[schemaName] = false;
+            result.push(schemaName);
+        }
+    };
+    for (const schemaName of Object.keys(schemas)) {
+        if (!visited[schemaName]) {
+            visit(schemaName);
+        }
     }
-    // 4. return ordered list
-    return ordered;
+    return result;
 }

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/core/validator/is-nullable-schema.d.ts

@@ -0,0 +1,8 @@
+import type { Schema } from '../../types';
+/**
+ * Determines whether a given sub-schema is `nullable`.
+ *
+ * @param subSchema - The sub-schema to evaluate
+ * @returns `true` if `nullable` is set to `true` and it is the only key in the schema, otherwise `false`
+ */
+export declare function isNullableSchema(schema: Schema): boolean;

package/dist/core/validator/is-nullable-schema.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNullableSchema = isNullableSchema;
+/**
+ * Determines whether a given sub-schema is `nullable`.
+ *
+ * @param subSchema - The sub-schema to evaluate
+ * @returns `true` if `nullable` is set to `true` and it is the only key in the schema, otherwise `false`
+ */
+function isNullableSchema(schema) {
+    return 'nullable' in schema && schema.nullable === true && Object.keys(schema).length === 1;
+}

package/dist/core/validator/is-ref-object.d.ts

@@ -0,0 +1,6 @@
+type RefObject = {
+    $ref?: string;
+    [key: string]: unknown;
+};
+export declare function isRefObject(value: unknown): value is RefObject;
+export {};

package/dist/core/validator/is-ref-object.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRefObject = isRefObject;
+function isRefObject(value) {
+    return typeof value === 'object' && value !== null;
+}

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');
+}