katax-cli 1.1.3 → 1.2.0

package/dist/commands/init.js

@@ -1,221 +1,284 @@
-import inquirer from 'inquirer';
-import ora from 'ora';
-import path from 'path';
-import crypto from 'crypto';
-import { execa } from 'execa';
-import { success, error, gray, title, info } from '../utils/logger.js';
-import { directoryExists, ensureDir, writeFile } from '../utils/file-utils.js';
+import inquirer from "inquirer";
+import ora from "ora";
+import path from "path";
+import crypto from "crypto";
+import { execa } from "execa";
+import { success, error, gray, title, info } from "../utils/logger.js";
+import { directoryExists, ensureDir, writeFile, } from "../utils/file-utils.js";
+import { generateSwaggerSetup } from "../templates/generators/swagger-template.js";
 export async function initCommand(projectName, options = {}) {
-    title('🚀 Katax CLI - Initialize API Project');
-    let finalProjectName = projectName || '';
+    title("🚀 Katax CLI - Initialize API Project");
+    let finalProjectName = projectName || "";
     if (!finalProjectName) {
         const answer = await inquirer.prompt([
             {
-                type: 'input',
-                name: 'projectName',
-                message: 'Project name:',
-                default: 'my-api',
+                type: "input",
+                name: "projectName",
+                message: "Project name:",
+                default: "my-api",
                 validate: (input) => {
                     if (!/^[a-z0-9-_]+$/i.test(input)) {
-                        return 'Project name can only contain letters, numbers, hyphens, and underscores';
+                        return "Project name can only contain letters, numbers, hyphens, and underscores";
                     }
                     return true;
-                }
-            }
+                },
+            },
         ]);
         finalProjectName = answer.projectName;
     }
     const projectPath = path.join(process.cwd(), finalProjectName);
     if (directoryExists(projectPath) && !options.force) {
         error(`Directory "${finalProjectName}" already exists!`);
-        gray('Use --force to overwrite\n');
+        gray("Use --force to overwrite\n");
         process.exit(1);
     }
     const answers = await inquirer.prompt([
         {
-            type: 'input',
-            name: 'description',
-            message: 'Project description:',
-            default: 'REST API built with Express and TypeScript'
+            type: "input",
+            name: "description",
+            message: "Project description:",
+            default: "REST API built with Express and TypeScript",
         },
         {
-            type: 'list',
-            name: 'database',
-            message: 'Select database:',
+            type: "list",
+            name: "database",
+            message: "Select database:",
             choices: [
-                { name: 'PostgreSQL', value: 'postgresql' },
-                { name: 'MySQL', value: 'mysql' },
-                { name: 'MongoDB', value: 'mongodb' },
-                { name: 'None (no database)', value: 'none' }
+                { name: "PostgreSQL", value: "postgresql" },
+                { name: "MySQL", value: "mysql" },
+                { name: "MongoDB", value: "mongodb" },
+                { name: "None (no database)", value: "none" },
             ],
-            default: 'postgresql'
+            default: "postgresql",
         },
         {
-            type: 'list',
-            name: 'authentication',
-            message: 'Add authentication?',
+            type: "list",
+            name: "authentication",
+            message: "Add authentication?",
             choices: [
-                { name: 'JWT Authentication', value: 'jwt' },
-                { name: 'None', value: 'none' }
+                { name: "JWT Authentication", value: "jwt" },
+                { name: "None", value: "none" },
             ],
-            default: 'jwt'
+            default: "jwt",
+        },
+        {
+            type: "confirm",
+            name: "validation",
+            message: "Use katax-core for validation?",
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "swagger",
+            message: "Install Swagger/OpenAPI documentation?",
+            default: true,
         },
         {
-            type: 'confirm',
-            name: 'validation',
-            message: 'Use katax-core for validation?',
-            default: true
+            type: "confirm",
+            name: "useKataxServiceManager",
+            message: "Use katax-service-manager for services? (logger, database, etc.)",
+            default: true,
         },
         {
-            type: 'input',
-            name: 'port',
-            message: 'Server port:',
-            default: '3000',
+            type: "confirm",
+            name: "useRedis",
+            message: "Add Redis cache support?",
+            default: false,
+            when: (answers) => answers.useKataxServiceManager,
+        },
+        {
+            type: "input",
+            name: "port",
+            message: "Server port:",
+            default: "3000",
             validate: (input) => {
                 const port = parseInt(input);
                 if (isNaN(port) || port < 1 || port > 65535) {
-                    return 'Port must be a number between 1 and 65535';
+                    return "Port must be a number between 1 and 65535";
                 }
                 return true;
-            }
-        }
+            },
+        },
     ]);
     let dbConfig = {};
-    if (answers.database !== 'none') {
+    if (answers.database !== "none") {
         const dbQuestions = [];
-        if (answers.database === 'postgresql' || answers.database === 'mysql') {
+        if (answers.database === "postgresql" || answers.database === "mysql") {
             dbQuestions.push({
-                type: 'input',
-                name: 'host',
-                message: `${answers.database === 'postgresql' ? 'PostgreSQL' : 'MySQL'} host:`,
-                default: 'localhost'
+                type: "input",
+                name: "host",
+                message: `${answers.database === "postgresql" ? "PostgreSQL" : "MySQL"} host:`,
+                default: "localhost",
             }, {
-                type: 'input',
-                name: 'port',
-                message: `${answers.database === 'postgresql' ? 'PostgreSQL' : 'MySQL'} port:`,
-                default: answers.database === 'postgresql' ? '5432' : '3306'
+                type: "input",
+                name: "port",
+                message: `${answers.database === "postgresql" ? "PostgreSQL" : "MySQL"} port:`,
+                default: answers.database === "postgresql" ? "5432" : "3306",
             }, {
-                type: 'input',
-                name: 'user',
-                message: 'Database user:',
-                default: 'postgres'
+                type: "input",
+                name: "user",
+                message: "Database user:",
+                default: "postgres",
             }, {
-                type: 'password',
-                name: 'password',
-                message: 'Database password:',
-                default: 'password'
+                type: "password",
+                name: "password",
+                message: "Database password:",
+                default: "password",
             }, {
-                type: 'input',
-                name: 'database',
-                message: 'Database name:',
-                default: finalProjectName.toLowerCase().replace(/-/g, '_')
+                type: "input",
+                name: "database",
+                message: "Database name:",
+                default: finalProjectName.toLowerCase().replace(/-/g, "_"),
             });
         }
-        else if (answers.database === 'mongodb') {
+        else if (answers.database === "mongodb") {
             dbQuestions.push({
-                type: 'input',
-                name: 'host',
-                message: 'MongoDB host:',
-                default: 'localhost'
+                type: "input",
+                name: "host",
+                message: "MongoDB host:",
+                default: "localhost",
             }, {
-                type: 'input',
-                name: 'port',
-                message: 'MongoDB port:',
-                default: '27017'
+                type: "input",
+                name: "port",
+                message: "MongoDB port:",
+                default: "27017",
             }, {
-                type: 'input',
-                name: 'database',
-                message: 'Database name:',
-                default: finalProjectName.toLowerCase().replace(/-/g, '_')
+                type: "input",
+                name: "database",
+                message: "Database name:",
+                default: finalProjectName.toLowerCase().replace(/-/g, "_"),
             }, {
-                type: 'confirm',
-                name: 'useAuth',
-                message: 'Use authentication?',
-                default: false
+                type: "confirm",
+                name: "useAuth",
+                message: "Use authentication?",
+                default: false,
             });
         }
         dbConfig = await inquirer.prompt(dbQuestions);
-        if (answers.database === 'mongodb' && dbConfig.useAuth) {
+        if (answers.database === "mongodb" && dbConfig.useAuth) {
             const authConfig = await inquirer.prompt([
                 {
-                    type: 'input',
-                    name: 'user',
-                    message: 'MongoDB user:',
-                    default: 'admin'
+                    type: "input",
+                    name: "user",
+                    message: "MongoDB user:",
+                    default: "admin",
                 },
                 {
-                    type: 'password',
-                    name: 'password',
-                    message: 'MongoDB password:',
-                    default: 'password'
-                }
+                    type: "password",
+                    name: "password",
+                    message: "MongoDB password:",
+                    default: "password",
+                },
             ]);
             dbConfig.user = authConfig.user;
             dbConfig.password = authConfig.password;
         }
     }
+    let redisConfig = {};
+    if (answers.useRedis) {
+        redisConfig = await inquirer.prompt([
+            {
+                type: "input",
+                name: "host",
+                message: "Redis host:",
+                default: "localhost",
+            },
+            {
+                type: "input",
+                name: "port",
+                message: "Redis port:",
+                default: "6379",
+            },
+            {
+                type: "password",
+                name: "password",
+                message: "Redis password (leave empty for no password):",
+                default: "",
+            },
+            {
+                type: "input",
+                name: "db",
+                message: "Redis database number:",
+                default: "0",
+            },
+        ]);
+    }
     const config = {
         name: finalProjectName,
         description: answers.description,
-        type: 'rest-api',
+        type: "rest-api",
         typescript: true,
         database: answers.database,
         authentication: answers.authentication,
-        validation: answers.validation ? 'katax-core' : 'none',
-        orm: 'none',
+        validation: answers.validation ? "katax-core" : "none",
+        swagger: answers.swagger,
+        orm: "none",
         port: parseInt(answers.port),
-        dbConfig
+        useKataxServiceManager: answers.useKataxServiceManager,
+        useRedis: answers.useRedis || false,
+        redisConfig,
+        dbConfig,
     };
     let generateJwtSecrets = false;
-    if (config.authentication === 'jwt') {
+    if (config.authentication === "jwt") {
         const jwtAnswer = await inquirer.prompt([
             {
-                type: 'confirm',
-                name: 'generate',
-                message: 'Generate JWT secrets automatically?',
-                default: true
-            }
+                type: "confirm",
+                name: "generate",
+                message: "Generate JWT secrets automatically?",
+                default: true,
+            },
         ]);
         generateJwtSecrets = jwtAnswer.generate;
     }
-    gray('\n📋 Project Configuration:');
+    gray("\n📋 Project Configuration:");
     gray(`  Name: ${config.name}`);
     gray(`  Database: ${config.database}`);
     gray(`  Auth: ${config.authentication}`);
     gray(`  Validation: ${config.validation}`);
+    gray(`  Swagger: ${config.swagger ? "Yes" : "No"}`);
+    gray(`  Service Manager: ${config.useKataxServiceManager ? "katax-service-manager" : "manual"}`);
+    if (config.useKataxServiceManager) {
+        gray(`  Redis Cache: ${config.useRedis ? "Yes" : "No"}`);
+    }
     gray(`  Port: ${config.port}\n`);
-    const spinner = ora('Creating project structure...').start();
+    const spinner = ora("Creating project structure...").start();
     try {
         await createProjectStructure(projectPath, config, generateJwtSecrets);
-        spinner.succeed('Project structure created');
-        spinner.start('Installing dependencies...');
+        spinner.succeed("Project structure created");
+        spinner.start("Installing dependencies...");
         await installDependencies(projectPath);
-        spinner.succeed('Dependencies installed');
+        spinner.succeed("Dependencies installed");
         success(`\n✨ Project "${finalProjectName}" created successfully!\n`);
-        info('Next steps:');
+        info("Next steps:");
         gray(`  cd ${finalProjectName}`);
         gray(`  npm run dev\n`);
-        info('Available commands:');
+        info("Available commands:");
         gray(`  katax add endpoint <name>    - Add a new endpoint`);
         gray(`  katax generate crud <name>   - Generate CRUD resource`);
         gray(`  katax info                   - Show project structure\n`);
+        if (config.swagger) {
+            info("📖 API Documentation:");
+            gray(`  Open http://localhost:${config.port}/docs after starting the server`);
+            gray(`  Swagger UI is pre-configured and ready to use!\n`);
+        }
     }
     catch (err) {
-        spinner.fail('Failed to create project');
-        error(err instanceof Error ? err.message : 'Unknown error');
+        spinner.fail("Failed to create project");
+        error(err instanceof Error ? err.message : "Unknown error");
         process.exit(1);
     }
 }
 async function installDependencies(projectPath) {
-    await execa('npm', ['install'], {
+    await execa("npm", ["install"], {
         cwd: projectPath,
-        stdio: 'ignore'
+        stdio: "ignore",
     });
 }
 async function createDatabaseConnection(projectPath, config) {
-    const destPath = path.join(projectPath, 'src/database/connection.ts');
-    let content = '';
-    if (config.database === 'postgresql') {
+    const destPath = path.join(projectPath, "src/database/connection.ts");
+    let content = "";
+    if (config.database === "postgresql") {
         content = [
             "import { Pool } from 'pg';",
             "import dotenv from 'dotenv';",
@@ -268,10 +331,10 @@ async function createDatabaseConnection(projectPath, config) {
             "  };",
             "  ",
             "  return client;",
-            "}"
-        ].join('\n');
+            "}",
+        ].join("\n");
     }
-    else if (config.database === 'mysql') {
+    else if (config.database === "mysql") {
         content = [
             "import mysql from 'mysql2/promise';",
             "",
@@ -294,10 +357,10 @@ async function createDatabaseConnection(projectPath, config) {
             "",
             "export async function getConnection() {",
             "  return await pool.getConnection();",
-            "}"
-        ].join('\n');
+            "}",
+        ].join("\n");
     }
-    else if (config.database === 'mongodb') {
+    else if (config.database === "mongodb") {
         content = [
             "import { MongoClient, Db } from 'mongodb';",
             "",
@@ -344,103 +407,105 @@ async function createDatabaseConnection(projectPath, config) {
             "  return db;",
             "}",
             "",
-            "export default { connect, disconnect, getDb };"
-        ].join('\n');
+            "export default { connect, disconnect, getDb };",
+        ].join("\n");
     }
     await writeFile(destPath, content);
 }
 async function createProjectStructure(projectPath, config, generateJwtSecrets) {
     const dirs = [
-        'src',
-        'src/api',
-        'src/config',
-        'src/middleware',
-        'src/shared',
-        'src/types'
+        "src",
+        "src/api",
+        "src/config",
+        "src/middleware",
+        "src/shared",
+        "src/types",
     ];
-    if (config.database !== 'none') {
-        dirs.push('src/database');
+    if (config.database !== "none") {
+        dirs.push("src/database");
     }
-    dirs.push('src/api/hello');
+    dirs.push("src/api/hello");
     for (const dir of dirs) {
         await ensureDir(path.join(projectPath, dir));
     }
     const packageJson = {
         name: config.name,
-        version: '1.0.0',
+        version: "1.0.0",
         description: config.description,
-        type: 'module',
-        main: 'dist/index.js',
+        type: "module",
+        main: "dist/index.js",
         scripts: {
-            dev: 'nodemon --watch src --exec tsx src/index.ts',
-            build: 'tsc',
-            start: 'node dist/index.js',
-            lint: 'eslint . --ext .ts',
-            format: 'prettier --write "src/**/*.ts"'
+            dev: "nodemon --watch src --exec tsx src/index.ts",
+            build: "tsc",
+            start: "node dist/index.js",
+            lint: "eslint . --ext .ts",
+            format: 'prettier --write "src/**/*.ts"',
         },
-        keywords: ['api', 'express', 'typescript'],
-        author: '',
-        license: 'MIT',
+        keywords: ["api", "express", "typescript"],
+        author: "",
+        license: "MIT",
         dependencies: {
-            express: '^4.18.2',
-            cors: '^2.8.5',
-            dotenv: '^16.3.1',
-            pino: '^8.17.2',
-            'pino-pretty': '^10.3.1',
-            ...(config.validation === 'katax-core' && { 'katax-core': '^1.5.0' }),
-            ...(config.authentication === 'jwt' && {
-                jsonwebtoken: '^9.0.2',
-                bcrypt: '^5.1.1'
+            express: "^4.18.2",
+            cors: "^2.8.5",
+            dotenv: "^16.3.1",
+            ...(config.useKataxServiceManager
+                ? { "katax-service-manager": "^0.1.0" }
+                : { pino: "^8.17.2", "pino-pretty": "^10.3.1" }),
+            ...(config.validation === "katax-core" && { "katax-core": "^1.5.0" }),
+            ...(config.authentication === "jwt" && {
+                jsonwebtoken: "^9.0.2",
+                bcrypt: "^5.1.1",
             }),
-            ...(config.database === 'postgresql' && { pg: '^8.11.3' }),
-            ...(config.database === 'mysql' && { mysql2: '^3.6.5' }),
-            ...(config.database === 'mongodb' && { mongodb: '^6.3.0' })
+            ...(config.swagger && { "swagger-ui-express": "^5.0.0" }),
+            ...(config.database === "postgresql" && { pg: "^8.11.3" }),
+            ...(config.database === "mysql" && { mysql2: "^3.6.5" }),
+            ...(config.database === "mongodb" && { mongodb: "^6.3.0" }),
+            ...(config.useRedis && { ioredis: "^5.3.2" }),
         },
         devDependencies: {
-            '@types/express': '^4.17.21',
-            '@types/cors': '^2.8.17',
-            '@types/node': '^22.10.5',
-            ...(config.authentication === 'jwt' && {
-                '@types/jsonwebtoken': '^9.0.5',
-                '@types/bcrypt': '^5.0.2'
+            "@types/express": "^4.17.21",
+            "@types/cors": "^2.8.17",
+            "@types/node": "^22.10.5",
+            ...(config.authentication === "jwt" && {
+                "@types/jsonwebtoken": "^9.0.5",
+                "@types/bcrypt": "^5.0.2",
             }),
-            ...(config.database === 'postgresql' && { '@types/pg': '^8.10.9' }),
-            typescript: '^5.3.3',
-            tsx: '^4.7.0',
-            nodemon: '^3.0.2',
-            eslint: '^8.56.0',
-            '@typescript-eslint/eslint-plugin': '^6.19.0',
-            '@typescript-eslint/parser': '^6.19.0',
-            prettier: '^3.2.4'
-        }
+            ...(config.swagger && { "@types/swagger-ui-express": "^4.1.6" }),
+            ...(config.database === "postgresql" && { "@types/pg": "^8.10.9" }),
+            typescript: "^5.3.3",
+            tsx: "^4.7.0",
+            nodemon: "^3.0.2",
+            eslint: "^8.56.0",
+            "@typescript-eslint/eslint-plugin": "^6.19.0",
+            "@typescript-eslint/parser": "^6.19.0",
+            prettier: "^3.2.4",
+        },
     };
-    await writeFile(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+    await writeFile(path.join(projectPath, "package.json"), JSON.stringify(packageJson, null, 2));
     const tsConfig = {
         compilerOptions: {
-            target: 'ES2022',
-            module: 'ESNext',
-            lib: ['ES2022'],
-            moduleResolution: 'node',
+            target: "ES2022",
+            module: "ESNext",
+            lib: ["ES2022"],
+            moduleResolution: "node",
             esModuleInterop: true,
             allowSyntheticDefaultImports: true,
             forceConsistentCasingInFileNames: true,
             strict: true,
             skipLibCheck: true,
             resolveJsonModule: true,
-            declaration: true,
-            declarationMap: true,
             sourceMap: true,
             removeComments: true,
-            outDir: './dist',
-            rootDir: './src'
+            outDir: "./dist",
+            rootDir: "./src",
         },
-        include: ['src/**/*'],
-        exclude: ['node_modules', 'dist']
+        include: ["src/**/*"],
+        exclude: ["node_modules", "dist"],
     };
-    await writeFile(path.join(projectPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
-    let databaseUrl = '';
-    let dbEnvVars = '';
-    if (config.database === 'postgresql' && config.dbConfig) {
+    await writeFile(path.join(projectPath, "tsconfig.json"), JSON.stringify(tsConfig, null, 2));
+    let databaseUrl = "";
+    let dbEnvVars = "";
+    if (config.database === "postgresql" && config.dbConfig) {
         const { host, port, user, password, database } = config.dbConfig;
         databaseUrl = `DATABASE_URL=postgresql://${user}:${password}@${host}:${port}/${database}`;
         dbEnvVars = `DB_HOST=${host}
@@ -449,7 +514,7 @@ DB_NAME=${database}
 DB_USER=${user}
 DB_PASSWORD=${password}`;
     }
-    else if (config.database === 'mysql' && config.dbConfig) {
+    else if (config.database === "mysql" && config.dbConfig) {
         const { host, port, user, password, database } = config.dbConfig;
         databaseUrl = `DATABASE_URL=mysql://${user}:${password}@${host}:${port}/${database}`;
         dbEnvVars = `DB_HOST=${host}
@@ -458,7 +523,7 @@ DB_NAME=${database}
 DB_USER=${user}
 DB_PASSWORD=${password}`;
     }
-    else if (config.database === 'mongodb' && config.dbConfig) {
+    else if (config.database === "mongodb" && config.dbConfig) {
         const { host, port, database, user, password } = config.dbConfig;
         if (user && password) {
             databaseUrl = `DATABASE_URL=mongodb://${user}:${password}@${host}:${port}/${database}`;
@@ -475,11 +540,11 @@ DB_PORT=${port}
 DB_NAME=${database}`;
         }
     }
-    let jwtConfig = '';
-    if (config.authentication === 'jwt') {
+    let jwtConfig = "";
+    if (config.authentication === "jwt") {
         if (generateJwtSecrets) {
-            const jwtSecret = crypto.randomBytes(64).toString('hex');
-            const jwtRefreshSecret = crypto.randomBytes(64).toString('hex');
+            const jwtSecret = crypto.randomBytes(64).toString("hex");
+            const jwtRefreshSecret = crypto.randomBytes(64).toString("hex");
             jwtConfig = `JWT_SECRET=${jwtSecret}
 JWT_EXPIRES_IN=24h
 JWT_REFRESH_SECRET=${jwtRefreshSecret}
@@ -492,6 +557,16 @@ JWT_REFRESH_SECRET=your-refresh-secret-here
 JWT_REFRESH_EXPIRES_IN=7d`;
         }
     }
+    let redisEnvVars = "";
+    if (config.useRedis && config.redisConfig) {
+        const { host, port, password, db } = config.redisConfig;
+        redisEnvVars = `
+# Redis Configuration
+REDIS_HOST=${host || 'localhost'}
+REDIS_PORT=${port || '6379'}
+REDIS_PASSWORD=${password || ''}
+REDIS_DB=${db || '0'}`;
+    }
     const envContent = `# Server Configuration
 PORT=${config.port}
 NODE_ENV=development
@@ -499,16 +574,15 @@ LOG_LEVEL=info
 
 # CORS Configuration
 ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173
-
+${config.database !== "none" ? `
 # Database Configuration
-  ${databaseUrl}
-  ${dbEnvVars ? '\n# DB connection variables for pool\n' + dbEnvVars : ''}
-
-# JWT Configuration
-${jwtConfig}
+${databaseUrl}
+${dbEnvVars ? "\n# DB connection variables for pool\n" + dbEnvVars : ""}` : ""}
+${redisEnvVars}
+${config.authentication === "jwt" ? `\n# JWT Configuration\n${jwtConfig}` : ""}
 `;
-    await writeFile(path.join(projectPath, '.env.example'), envContent);
-    await writeFile(path.join(projectPath, '.env'), envContent);
+    await writeFile(path.join(projectPath, ".env.example"), envContent);
+    await writeFile(path.join(projectPath, ".env"), envContent);
     const gitignoreContent = `node_modules/
 dist/
 .env
@@ -517,7 +591,7 @@ dist/
 coverage/
 .vscode/
 `;
-    await writeFile(path.join(projectPath, '.gitignore'), gitignoreContent);
+    await writeFile(path.join(projectPath, ".gitignore"), gitignoreContent);
     const gitattributesContent = `# Auto normalize line endings to LF on checkout (critical for Ubuntu deployment)
 * text=auto eol=lf
 
@@ -537,8 +611,66 @@ coverage/
 *.ico binary
 *.pdf binary
 `;
-    await writeFile(path.join(projectPath, '.gitattributes'), gitattributesContent);
-    const indexContent = `import app from './app.js';
+    await writeFile(path.join(projectPath, ".gitattributes"), gitattributesContent);
+    let indexContent;
+    if (config.useKataxServiceManager) {
+        const dbInitCode = config.database !== "none" ? `
+  // Initialize database
+  await katax.database({
+    name: 'main',
+    type: '${config.database}',
+    connection: {
+      host: katax.envRequired('DB_HOST'),
+      port: parseInt(katax.env('DB_PORT', '${config.database === 'postgresql' ? '5432' : config.database === 'mysql' ? '3306' : '27017'}')),
+      database: katax.envRequired('DB_NAME'),
+      user: katax.envRequired('DB_USER'),
+      password: katax.envRequired('DB_PASSWORD'),
+    }
+  });
+` : '';
+        const cacheInitCode = config.useRedis ? `
+  // Initialize Redis cache
+  await katax.cache({
+    name: 'main',
+    host: katax.env('REDIS_HOST', 'localhost'),
+    port: parseInt(katax.env('REDIS_PORT', '6379')),
+    password: katax.env('REDIS_PASSWORD'),
+    db: parseInt(katax.env('REDIS_DB', '0')),
+  });
+` : '';
+        indexContent = `import { katax } from 'katax-service-manager';
+import app from './app.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+// Initialize katax and start server
+katax.init({
+  logger: {
+    level: katax.env('LOG_LEVEL', 'info') as 'info' | 'debug' | 'warn' | 'error',
+    prettyPrint: katax.isDev,
+  }
+}).then(async () => {
+${dbInitCode}${cacheInitCode}
+  const PORT = katax.env('PORT', '${config.port}');
+
+  app.listen(PORT, () => {
+    katax.logger.info({ message: \`Server running on http://localhost:\${PORT}\` });
+    katax.logger.info({ message: \`API endpoints available at http://localhost:\${PORT}/api\` });
+    katax.logger.info({ message: \`Health check: http://localhost:\${PORT}/api/health\` });
+  });
+
+  // Graceful shutdown
+  process.on('SIGTERM', async () => {
+    katax.logger.info({ message: 'SIGTERM received, shutting down...' });
+    await katax.shutdown();
+    process.exit(0);
+  });
+});
+`;
+    }
+    else {
+        indexContent = `import app from './app.js';
 import dotenv from 'dotenv';
 import { logger } from './shared/logger.utils.js';
 import { validateEnvironment } from './config/env.validator.js';
@@ -556,13 +688,14 @@ app.listen(PORT, () => {
   logger.info(\`Health check: http://localhost:\${PORT}/api/health\`);
 });
 `;
-    await writeFile(path.join(projectPath, 'src/index.ts'), indexContent);
+    }
+    await writeFile(path.join(projectPath, "src/index.ts"), indexContent);
     const appContent = `import express from 'express';
 import cors from 'cors';
 import router from './api/routes.js';
 import { errorMiddleware } from './middleware/error.middleware.js';
 import { requestLogger } from './middleware/logger.middleware.js';
-import { corsOptions } from './config/cors.config.js';
+import { corsOptions } from './config/cors.config.js';${config.swagger ? "\nimport { setupSwagger } from './config/swagger.config.js';" : ""}
 
 const app = express();
 
@@ -572,13 +705,13 @@ app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 app.use(requestLogger);
 
-// Routes
+${config.swagger ? "// API Documentation\nsetupSwagger(app);\n\n" : ""}// Routes
 app.get('/', (req, res) => {
   res.json({
     message: 'Welcome to ${config.name} API',
     version: '1.0.0',
     endpoints: '/api',
-    health: '/api/health'
+    health: '/api/health'${config.swagger ? ",\n    docs: '/docs'" : ""}
   });
 });
 
@@ -589,7 +722,7 @@ app.use(errorMiddleware);
 
 export default app;
 `;
-    await writeFile(path.join(projectPath, 'src/app.ts'), appContent);
+    await writeFile(path.join(projectPath, "src/app.ts"), appContent);
     const routesContent = `import { Router } from 'express';
 import helloRouter from './hello/hello.routes.js';
 import { healthCheckHandler } from './health/health.handler.js';
@@ -604,7 +737,7 @@ router.use('/hello', helloRouter);
 
 export default router;
 `;
-    await writeFile(path.join(projectPath, 'src/api/routes.ts'), routesContent);
+    await writeFile(path.join(projectPath, "src/api/routes.ts"), routesContent);
     const errorMiddlewareContent = `import { Request, Response, NextFunction } from 'express';
 import { logger } from '../shared/logger.utils.js';
 
@@ -638,11 +771,11 @@ export function errorMiddleware(
   });
 }
 `;
-    await writeFile(path.join(projectPath, 'src/middleware/error.middleware.ts'), errorMiddlewareContent);
-    if (config.database !== 'none') {
+    await writeFile(path.join(projectPath, "src/middleware/error.middleware.ts"), errorMiddlewareContent);
+    if (config.database !== "none" && !config.useKataxServiceManager) {
         await createDatabaseConnection(projectPath, config);
     }
-    if (config.validation === 'katax-core') {
+    if (config.validation === "katax-core") {
         const apiUtilsContent = `import { Request, Response } from 'express';
 import { logger } from './logger.utils.js';
 
@@ -741,9 +874,9 @@ export async function sendResponse<TValidation = any, TResponse = any>(
   }
 }
 `;
-        await writeFile(path.join(projectPath, 'src/shared/api.utils.ts'), apiUtilsContent);
+        await writeFile(path.join(projectPath, "src/shared/api.utils.ts"), apiUtilsContent);
     }
-    if (config.authentication === 'jwt') {
+    if (config.authentication === "jwt") {
         const jwtUtilsContent = `import jwt from 'jsonwebtoken';
 import { Request, Response, NextFunction } from 'express';
 
@@ -897,9 +1030,66 @@ export function requireRole(...roles: string[]) {
   };
 }
 `;
-        await writeFile(path.join(projectPath, 'src/shared/jwt.utils.ts'), jwtUtilsContent);
+        await writeFile(path.join(projectPath, "src/shared/jwt.utils.ts"), jwtUtilsContent);
     }
-    const loggerUtilsContent = `import pino from 'pino';
+    let loggerUtilsContent;
+    if (config.useKataxServiceManager) {
+        loggerUtilsContent = `import { katax } from 'katax-service-manager';
+
+/**
+ * Re-export katax logger for convenience
+ * Uses katax-service-manager's built-in pino logger
+ */
+export const logger = katax.logger;
+
+/**
+ * Log HTTP request
+ */
+export function logRequest(method: string, url: string, statusCode: number, duration: number): void {
+  katax.logger.info({
+    message: \`\${method} \${url} - \${statusCode} (\${duration}ms)\`,
+    method,
+    url,
+    statusCode,
+    duration: \`\${duration}ms\`
+  });
+}
+
+/**
+ * Log error with context
+ */
+export function logError(error: Error, context?: Record<string, any>): void {
+  katax.logger.error({
+    message: error.message,
+    err: error,
+    ...context
+  });
+}
+
+/**
+ * Log info message
+ */
+export function logInfo(message: string, data?: Record<string, any>): void {
+  katax.logger.info({ message, ...data });
+}
+
+/**
+ * Log warning message
+ */
+export function logWarning(message: string, data?: Record<string, any>): void {
+  katax.logger.warn({ message, ...data });
+}
+
+/**
+ * Log debug message
+ */
+export function logDebug(message: string, data?: Record<string, any>): void {
+  katax.logger.debug({ message, ...data });
+}
+`;
+    }
+    else {
+        loggerUtilsContent = `import pino from 'pino';
 
 const isDevelopment = process.env.NODE_ENV !== 'production';
 
@@ -970,7 +1160,8 @@ export function logDebug(message: string, data?: Record<string, any>): void {
   logger.debug(data, message);
 }
 `;
-    await writeFile(path.join(projectPath, 'src/shared/logger.utils.ts'), loggerUtilsContent);
+    }
+    await writeFile(path.join(projectPath, "src/shared/logger.utils.ts"), loggerUtilsContent);
     const loggerMiddlewareContent = `import { Request, Response, NextFunction } from 'express';
 import { logRequest } from '../shared/logger.utils.js';
 
@@ -989,7 +1180,7 @@ export function requestLogger(req: Request, res: Response, next: NextFunction):
   next();
 }
 `;
-    await writeFile(path.join(projectPath, 'src/middleware/logger.middleware.ts'), loggerMiddlewareContent);
+    await writeFile(path.join(projectPath, "src/middleware/logger.middleware.ts"), loggerMiddlewareContent);
     const corsConfigContent = `import { CorsOptions } from 'cors';
 
 const allowedOrigins = process.env.ALLOWED_ORIGINS
@@ -1013,7 +1204,7 @@ export const corsOptions: CorsOptions = {
   allowedHeaders: ['Content-Type', 'Authorization']
 };
 `;
-    await writeFile(path.join(projectPath, 'src/config/cors.config.ts'), corsConfigContent);
+    await writeFile(path.join(projectPath, "src/config/cors.config.ts"), corsConfigContent);
     const envValidatorContent = `import { logger } from '../shared/logger.utils.js';
 
 interface RequiredEnvVars {
@@ -1029,7 +1220,7 @@ export function validateEnvironment(): void {
     NODE_ENV: process.env.NODE_ENV || ''
   };
 
-${config.database !== 'none' ? `  // Database variables\n  required.DATABASE_URL = process.env.DATABASE_URL || '';\n` : ''}${config.authentication === 'jwt' ? `  // JWT variables\n  required.JWT_SECRET = process.env.JWT_SECRET || '';\n  required.JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET || '';\n` : ''}
+${config.database !== "none" ? `  // Database variables\n  required.DATABASE_URL = process.env.DATABASE_URL || '';\n` : ""}${config.authentication === "jwt" ? `  // JWT variables\n  required.JWT_SECRET = process.env.JWT_SECRET || '';\n  required.JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET || '';\n` : ""}
   const missing: string[] = [];
 
   for (const [key, value] of Object.entries(required)) {
@@ -1047,7 +1238,78 @@ ${config.database !== 'none' ? `  // Database variables\n  required.DATABASE_URL
   logger.info('Environment variables validated successfully');
 }
 `;
-    await writeFile(path.join(projectPath, 'src/config/env.validator.ts'), envValidatorContent);
+    await writeFile(path.join(projectPath, "src/config/env.validator.ts"), envValidatorContent);
+    if (config.swagger) {
+        await writeFile(path.join(projectPath, "src/config/swagger.config.ts"), generateSwaggerSetup());
+        const initialOpenAPISpec = {
+            openapi: "3.0.0",
+            info: {
+                title: config.name,
+                version: "1.0.0",
+                description: config.description || "API Documentation",
+            },
+            servers: [
+                {
+                    url: `http://localhost:${config.port}`,
+                    description: "Development server",
+                },
+            ],
+            paths: {
+                "/": {
+                    get: {
+                        tags: ["General"],
+                        summary: "Welcome endpoint",
+                        responses: {
+                            "200": {
+                                description: "Welcome message",
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object",
+                                            properties: {
+                                                message: { type: "string" },
+                                                version: { type: "string" },
+                                                endpoints: { type: "string" },
+                                                health: { type: "string" },
+                                                docs: { type: "string" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                "/api/health": {
+                    get: {
+                        tags: ["Health"],
+                        summary: "Health check endpoint",
+                        responses: {
+                            "200": {
+                                description: "Health status",
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object",
+                                            properties: {
+                                                status: { type: "string" },
+                                                timestamp: { type: "string" },
+                                                uptime: { type: "number" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            components: {
+                schemas: {},
+            },
+        };
+        await writeFile(path.join(projectPath, "src/openapi.json"), JSON.stringify(initialOpenAPISpec, null, 2));
+    }
     const healthHandlerContent = `import { Request, Response } from 'express';
 import os from 'os';
 
@@ -1120,8 +1382,8 @@ function formatBytes(bytes: number): string {
   return \`\${size.toFixed(2)} \${units[unitIndex]}\`;
 }
 `;
-    await ensureDir(path.join(projectPath, 'src/api/health'));
-    await writeFile(path.join(projectPath, 'src/api/health/health.handler.ts'), healthHandlerContent);
+    await ensureDir(path.join(projectPath, "src/api/health"));
+    await writeFile(path.join(projectPath, "src/api/health/health.handler.ts"), healthHandlerContent);
     const readmeContent = `# ${config.name}
 
 ${config.description}
@@ -1157,15 +1419,15 @@ src/
 
 - **Express** - Web framework
 - **TypeScript** - Type safety
-${config.validation === 'katax-core' ? '- **katax-core** - Schema validation\n' : ''}${config.authentication === 'jwt' ? '- **JWT** - Authentication\n' : ''}${config.database !== 'none' ? `- **${config.database}** - Database\n` : ''}
+${config.validation === "katax-core" ? "- **katax-core** - Schema validation\n" : ""}${config.authentication === "jwt" ? "- **JWT** - Authentication\n" : ""}${config.swagger ? "- **Swagger** - API Documentation\n" : ""}${config.database !== "none" ? `- **${config.database}** - Database\n` : ""}
 ## 📚 API Documentation
 
 Server runs on \`http://localhost:${config.port}\`
-
+${config.swagger ? `\n### Interactive Documentation\n\nSwagger UI is available at: **http://localhost:${config.port}/docs**\n\n- View all endpoints\n- Test API calls directly\n- See request/response schemas\n- Auto-updated when you add endpoints\n\n` : ""}
 ### Endpoints
 
 - \`GET /\` - Welcome message
-- \`GET /api/health\` - Health check
+- \`GET /api/health\` - Health check${config.swagger ? "\n- `GET /docs` - Swagger UI\n- `GET /openapi.json` - OpenAPI Specification" : ""}
 
 ## 🔧 Development
 
@@ -1183,11 +1445,11 @@ katax generate crud products
 
 MIT
 `;
-    await writeFile(path.join(projectPath, 'README.md'), readmeContent);
+    await writeFile(path.join(projectPath, "README.md"), readmeContent);
     await createHelloEndpoint(projectPath, config);
 }
 async function createHelloEndpoint(projectPath, config) {
-    const helloPath = path.join(projectPath, 'src/api/hello');
+    const helloPath = path.join(projectPath, "src/api/hello");
     const controllerContent = [
         "import { ControllerResult, createSuccessResult, createErrorResult } from '../../shared/api.utils.js';",
         "import { HelloQuery } from './hello.validator.js';",
@@ -1216,9 +1478,9 @@ async function createHelloEndpoint(projectPath, config) {
         "      500",
         "    );",
         "  }",
-        "}"
-    ].join('\n');
-    await writeFile(path.join(helloPath, 'hello.controller.ts'), controllerContent);
+        "}",
+    ].join("\n");
+    await writeFile(path.join(helloPath, "hello.controller.ts"), controllerContent);
     const handlerContent = [
         "import { Request, Response } from 'express';",
         "import { getHello } from './hello.controller.js';",
@@ -1240,9 +1502,9 @@ async function createHelloEndpoint(projectPath, config) {
         "    // validData is automatically: HelloQuery (not any)",
         "    (validData) => getHello(validData)",
         "  );",
-        "}"
-    ].join('\n');
-    await writeFile(path.join(helloPath, 'hello.handler.ts'), handlerContent);
+        "}",
+    ].join("\n");
+    await writeFile(path.join(helloPath, "hello.handler.ts"), handlerContent);
     const routesContent = [
         "import { Router } from 'express';",
         "import { getHelloHandler } from './hello.handler.js';",
@@ -1257,10 +1519,10 @@ async function createHelloEndpoint(projectPath, config) {
         " */",
         "router.get('/', getHelloHandler);",
         "",
-        "export default router;"
-    ].join('\n');
-    await writeFile(path.join(helloPath, 'hello.routes.ts'), routesContent);
-    if (config.validation === 'katax-core') {
+        "export default router;",
+    ].join("\n");
+    await writeFile(path.join(helloPath, "hello.routes.ts"), routesContent);
+    if (config.validation === "katax-core") {
         const validatorContent = [
             "import { k, kataxInfer } from 'katax-core';",
             "import type { ValidationResult } from '../../shared/api.utils.js';",
@@ -1301,9 +1563,9 @@ async function createHelloEndpoint(projectPath, config) {
             "    isValid: true,",
             "    data: result.data",
             "  };",
-            "}"
-        ].join('\n');
-        await writeFile(path.join(helloPath, 'hello.validator.ts'), validatorContent);
+            "}",
+        ].join("\n");
+        await writeFile(path.join(helloPath, "hello.validator.ts"), validatorContent);
     }
 }
 //# sourceMappingURL=init.js.map