katax-cli 1.4.2 → 1.4.4

package/dist/commands/init.js

@@ -8,6 +8,46 @@ import { directoryExists, ensureDir, writeFile, } from "../utils/file-utils.js";
 import { generateSwaggerSetup } from "../templates/generators/swagger-template.js";
 import { generateStreamUtils } from "../templates/generators/stream-utils-template.js";
 import { generateAuthUtils } from "../templates/generators/auth-utils-template.js";
+const KATAX_SERVICE_MANAGER_PEERS = [
+    "dotenv",
+    "mongodb",
+    "mysql2",
+    "node-cron",
+    "pg",
+    "pino-pretty",
+    "redis",
+    "socket.io",
+];
+function getPackageManager(pm) {
+    return pm === "npm" ? "npm" : "pnpm";
+}
+function getInstallCommand(packageManager, packages = [], ignoreScripts = false) {
+    const args = [];
+    if (packageManager === "pnpm") {
+        if (packages.length > 0) {
+            args.push("add", ...packages);
+        }
+        else {
+            args.push("install");
+        }
+    }
+    else {
+        args.push("install", ...packages);
+    }
+    if (ignoreScripts) {
+        args.push("--ignore-scripts");
+    }
+    return { cmd: packageManager, args };
+}
+async function writeIgnoreScriptsNpmrc(projectPath) {
+    const npmrcContent = [
+        "# Generated by katax-cli",
+        "# Prevent lifecycle scripts during install for safer bootstrapping",
+        "ignore-scripts=true",
+        "",
+    ].join("\n");
+    await writeFile(path.join(projectPath, ".npmrc"), npmrcContent);
+}
 export async function initCommand(projectName, options = {}) {
     title("🚀 Katax CLI - Initialize API Project");
     let finalProjectName = projectName || "";
@@ -146,6 +186,21 @@ export async function initCommand(projectName, options = {}) {
             default: false,
             when: (answers) => answers.useKataxServiceManager,
         },
+        {
+            type: "list",
+            name: "peerDependenciesMode",
+            message: "Install katax-service-manager peer dependencies now?",
+            choices: [
+                { name: "No (install later as needed)", value: "none" },
+                {
+                    name: "Yes, install peers for selected integrations",
+                    value: "selected",
+                },
+                { name: "Yes, install all optional peers", value: "all" },
+            ],
+            default: "selected",
+            when: (answers) => answers.useKataxServiceManager,
+        },
         {
             type: "confirm",
             name: "useSeparateSocketPort",
@@ -186,6 +241,29 @@ export async function initCommand(projectName, options = {}) {
             message: "Initialize git repository?",
             default: true,
         },
+        {
+            type: "list",
+            name: "packageManager",
+            message: "Package manager for install commands:",
+            choices: [
+                { name: "npm", value: "npm" },
+                { name: "pnpm", value: "pnpm" },
+            ],
+            default: getPackageManager(options.pm),
+        },
+        {
+            type: "confirm",
+            name: "ignoreScripts",
+            message: "Install dependencies with --ignore-scripts?",
+            default: options.ignoreScripts ?? false,
+        },
+        {
+            type: "confirm",
+            name: "writeNpmrc",
+            message: "Create .npmrc with ignore-scripts=true?",
+            default: options.writeNpmrc ?? true,
+            when: (answers) => answers.ignoreScripts,
+        },
     ]);
     let dbConfig = {};
     if (answers.database !== "none") {
@@ -310,7 +388,15 @@ export async function initCommand(projectName, options = {}) {
         useRegistry: answers.useRegistry || false,
         registryMode: answers.useRegistry ? answers.registryMode || "url" : "none",
         registryUrl: answers.registryUrl,
+        peerDependenciesMode: answers.useKataxServiceManager
+            ? answers.peerDependenciesMode || "selected"
+            : "none",
         useLifecycleHooks: answers.useLifecycleHooks || false,
+        packageManager: getPackageManager(answers.packageManager),
+        ignoreInstallScripts: answers.ignoreScripts || false,
+        createNpmrcForIgnoreScripts: answers.ignoreScripts
+            ? (answers.writeNpmrc ?? true)
+            : false,
         initGit: answers.initGit,
         redisConfig,
         dbConfig,
@@ -337,19 +423,30 @@ export async function initCommand(projectName, options = {}) {
     if (config.useKataxServiceManager) {
         gray(`  Katax Mode: ${config.kataxMode === "instance" ? "Instance (new Katax())" : "Singleton"}`);
         gray(`  Registry: ${config.useRegistry ? (config.registryMode === "url" ? `URL (${config.registryUrl})` : "Callback handler") : "No"}`);
+        gray(`  Peer Deps: ${config.peerDependenciesMode || "none"}`);
         gray(`  Lifecycle Hooks: ${config.useLifecycleHooks ? "Yes" : "No"}`);
         gray(`  Redis Cache: ${config.useRedis ? "Yes" : "No"}`);
         gray(`  WebSocket: ${config.useWebSocket ? (config.useSeparateSocketPort ? `Yes (port ${config.socketPort})` : "Yes (shared port)") : "No"}`);
     }
     gray(`  Git: ${config.initGit ? "Yes" : "No"}`);
+    gray(`  Package Manager: ${config.packageManager}`);
+    gray(`  Ignore Install Scripts: ${config.ignoreInstallScripts ? "Yes" : "No"}`);
+    gray(`  Write .npmrc: ${config.createNpmrcForIgnoreScripts ? "Yes" : "No"}`);
     gray(`  Port: ${config.port}\n`);
     const spinner = ora("Creating project structure...").start();
     try {
         await createProjectStructure(projectPath, config, generateJwtSecrets);
         spinner.succeed("Project structure created");
+        if (config.createNpmrcForIgnoreScripts) {
+            spinner.start("Writing .npmrc...");
+            await writeIgnoreScriptsNpmrc(projectPath);
+            spinner.succeed(".npmrc created (ignore-scripts=true)");
+        }
         spinner.start("Installing dependencies...");
-        await installDependencies(projectPath);
-        spinner.succeed("Dependencies installed");
+        const installedPeerDeps = await installDependencies(projectPath, config);
+        spinner.succeed(installedPeerDeps.length > 0
+            ? `Dependencies installed (+ ${installedPeerDeps.length} peer deps)`
+            : "Dependencies installed");
         if (config.initGit) {
             spinner.start("Initializing git repository...");
             await initGitRepository(projectPath);
@@ -358,11 +455,16 @@ export async function initCommand(projectName, options = {}) {
         success(`\n✨ Project "${finalProjectName}" created successfully!\n`);
         info("Next steps:");
         gray(`  cd ${finalProjectName}`);
-        gray(`  npm run dev\n`);
+        gray(`  ${config.packageManager === "pnpm" ? "pnpm install" : "npm install"}`);
+        gray(`  ${config.packageManager === "pnpm" ? "pnpm dev" : "npm run dev"}\n`);
         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 (installedPeerDeps.length > 0) {
+            info("Installed peer dependencies:");
+            gray(`  ${installedPeerDeps.join(", ")}\n`);
+        }
         if (config.swagger) {
             info("📖 API Documentation:");
             gray(`  Open http://localhost:${config.port}/docs after starting the server`);
@@ -375,11 +477,44 @@ export async function initCommand(projectName, options = {}) {
         process.exit(1);
     }
 }
-async function installDependencies(projectPath) {
-    await execa("npm", ["install"], {
+async function installDependencies(projectPath, config) {
+    const packageManager = config.packageManager || "npm";
+    const ignoreScripts = config.ignoreInstallScripts || false;
+    const baseInstall = getInstallCommand(packageManager, [], ignoreScripts);
+    await execa(baseInstall.cmd, baseInstall.args, {
         cwd: projectPath,
         stdio: "ignore",
     });
+    const peers = resolvePeerDependencies(config);
+    if (peers.length === 0) {
+        return [];
+    }
+    const peerInstall = getInstallCommand(packageManager, peers, ignoreScripts);
+    await execa(peerInstall.cmd, peerInstall.args, {
+        cwd: projectPath,
+        stdio: "ignore",
+    });
+    return peers;
+}
+function resolvePeerDependencies(config) {
+    if (!config.useKataxServiceManager) {
+        return [];
+    }
+    const mode = config.peerDependenciesMode || "none";
+    if (mode === "none") {
+        return [];
+    }
+    if (mode === "all") {
+        return [...KATAX_SERVICE_MANAGER_PEERS];
+    }
+    const selected = new Set();
+    if (config.useRedis) {
+        selected.add("redis");
+    }
+    if (config.useWebSocket) {
+        selected.add("socket.io");
+    }
+    return [...selected];
 }
 async function initGitRepository(projectPath) {
     await execa("git", ["init"], {
@@ -567,9 +702,12 @@ async function createProjectStructure(projectPath, config, generateJwtSecrets) {
         dependencies: {
             express: "^4.18.2",
             cors: "^2.8.5",
+            helmet: "^8.1.0",
+            "cookie-parser": "^1.4.7",
+            "express-rate-limit": "^8.3.2",
             dotenv: "^16.3.1",
             ...(config.useKataxServiceManager
-                ? { "katax-service-manager": "^0.3.3", "pino-pretty": "^10.3.1" }
+                ? { "katax-service-manager": "latest", "pino-pretty": "^10.3.1" }
                 : { pino: "^8.17.2", "pino-pretty": "^10.3.1" }),
             ...(config.validation === "katax-core" && { "katax-core": "latest" }),
             ...(config.authentication === "jwt" && {
@@ -585,6 +723,7 @@ async function createProjectStructure(projectPath, config, generateJwtSecrets) {
         devDependencies: {
             "@types/express": "^4.17.21",
             "@types/cors": "^2.8.17",
+            "@types/cookie-parser": "^1.4.9",
             "@types/node": "^22.10.5",
             ...(config.authentication === "jwt" && {
                 "@types/jsonwebtoken": "^9.0.5",
@@ -607,7 +746,7 @@ async function createProjectStructure(projectPath, config, generateJwtSecrets) {
             target: "ES2022",
             module: "ESNext",
             lib: ["ES2022"],
-            moduleResolution: "node",
+            moduleResolution: "bundler",
             esModuleInterop: true,
             allowSyntheticDefaultImports: true,
             forceConsistentCasingInFileNames: true,
@@ -921,7 +1060,7 @@ ${listenCode}
 
     // Register custom shutdown hooks (optional)
     katax.onShutdown(async () => {
-      katax.logger.info('Running custom cleanup...');
+      katax.logger.info({ message: 'Running custom cleanup...' });
       // Add your custom cleanup logic here
     });
 
@@ -949,19 +1088,19 @@ validateEnvironment();
 const PORT = process.env.PORT || ${config.port};
 
 app.listen(PORT, () => {
-  logger.info(\`Server running on http://localhost:\${PORT}\`);
-  logger.info(\`API endpoints available at http://localhost:\${PORT}/api\`);
-  logger.info(\`Health check: http://localhost:\${PORT}/api/health\`);
+  logger.info({ message: \`Server running on http://localhost:\${PORT}\` });
+  logger.info({ message: \`API endpoints available at http://localhost:\${PORT}/api\` });
+  logger.info({ message: \`Health check: http://localhost:\${PORT}/api/health\` });
 });
 
 // Graceful shutdown handlers
 process.on('SIGTERM', () => {
-  logger.info('SIGTERM received, shutting down...');
+  logger.info({ message: 'SIGTERM received, shutting down...' });
   process.exit(0);
 });
 
 process.on('SIGINT', () => {
-  logger.info('SIGINT received, shutting down...');
+  logger.info({ message: 'SIGINT received, shutting down...' });
   process.exit(0);
 });
 `;
@@ -976,6 +1115,9 @@ export const katax = new Katax();
     }
     const appContent = `import express from 'express';
 import cors from 'cors';
+import helmet from 'helmet';
+import cookieParser from 'cookie-parser';
+import { rateLimit } from 'express-rate-limit';
 import router from './api/routes.js';
 import { errorMiddleware } from './middleware/error.middleware.js';
 import { requestLogger } from './middleware/logger.middleware.js';
@@ -983,10 +1125,24 @@ import { corsOptions } from './config/cors.config.js';${config.swagger ? "\nimpo
 
 const app = express();
 
+const apiLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000,
+  max: 200,
+  standardHeaders: true,
+  legacyHeaders: false,
+  message: {
+    success: false,
+    message: 'Too many requests, please try again later.',
+    error: 'RATE_LIMIT_EXCEEDED'
+  }
+});
+
 // Middleware
+app.use(helmet());
 app.use(cors(corsOptions));
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
+app.use(cookieParser());
+app.use(express.json({ limit: '1mb' }));
+app.use(express.urlencoded({ extended: true, limit: '1mb' }));
 app.use(requestLogger);
 
 ${config.swagger ? "// API Documentation\nsetupSwagger(app);\n\n" : ""}// Routes
@@ -999,6 +1155,7 @@ app.get('/', (req, res) => {
   });
 });
 
+app.use('/api', apiLimiter);
 app.use('/api', router);
 
 // Error handling
@@ -1022,7 +1179,42 @@ router.use('/hello', helloRouter);
 export default router;
 `;
     await writeFile(path.join(projectPath, "src/api/routes.ts"), routesContent);
-    const errorMiddlewareContent = `import { Request, Response, NextFunction } from 'express';
+    const errorMiddlewareContent = config.useKataxServiceManager
+        ? `import { Request, Response, NextFunction } from 'express';
+import { katax } from '${kataxImportSourceShared}';
+
+export interface ApiError extends Error {
+  statusCode?: number;
+}
+
+export function errorMiddleware(
+  err: ApiError,
+  req: Request,
+  res: Response,
+  next: NextFunction
+): void {
+  const statusCode = err.statusCode || 500;
+  const message = err.message || 'Internal Server Error';
+
+  katax.logger.error({
+    err,
+    req: {
+      method: req.method,
+      url: req.url,
+      headers: req.headers
+    },
+    statusCode,
+    message
+  });
+
+  res.status(statusCode).json({
+    success: false,
+    message,
+    ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
+  });
+}
+`
+        : `import { Request, Response, NextFunction } from 'express';
 import { logger } from '../shared/logger.utils.js';
 
 export interface ApiError extends Error {
@@ -1061,14 +1253,24 @@ export function errorMiddleware(
         await createDatabaseConnection(projectPath, config);
     }
     if (config.validation === "katax-core") {
+        const apiUtilsLoggerImport = config.useKataxServiceManager
+            ? `import { katax } from '${kataxImportSourceShared}';`
+            : "import { logger } from './logger.utils.js';";
+        const apiUtilsWarnLogger = config.useKataxServiceManager
+            ? "katax.logger.warn"
+            : "logger.warn";
+        const apiUtilsErrorLogger = config.useKataxServiceManager
+            ? "katax.logger.error"
+            : "logger.error";
         const apiUtilsContent = `import { Request, Response } from 'express';
-import { logger } from './logger.utils.js';
+${apiUtilsLoggerImport}
 
 export interface ControllerResult<T = any> {
   success: boolean;
   message: string;
   data?: T;
   error?: string;
+  details?: unknown;
   statusCode?: number;
   currentPage?: number;
   totalPages?: number;
@@ -1077,6 +1279,93 @@ export interface ControllerResult<T = any> {
   hasMorePages?: boolean;
 }
 
+type PaginationMeta = Pick<
+  ControllerResult,
+  'currentPage' | 'totalPages' | 'totalItems' | 'totalCount' | 'hasMorePages'
+>;
+
+export const createResponse = {
+  success<T>(
+    message: string,
+    data?: T,
+    statusCode = 200,
+    pagination?: PaginationMeta
+  ): ControllerResult<T> {
+    return {
+      success: true,
+      message,
+      statusCode,
+      ...(pagination ?? {}),
+      data
+    };
+  },
+
+  error(
+    message: string,
+    error: string = 'Request error',
+    statusCode = 400,
+    details?: unknown
+  ): ControllerResult {
+    return {
+      success: false,
+      message,
+      error,
+      statusCode,
+      details
+    };
+  },
+
+  unauthorized(
+    message = 'Unauthorized',
+    error = 'Authentication required'
+  ): ControllerResult {
+    return {
+      success: false,
+      message,
+      error,
+      statusCode: 401
+    };
+  },
+
+  forbidden(
+    message = 'Forbidden',
+    error = 'Insufficient permissions'
+  ): ControllerResult {
+    return {
+      success: false,
+      message,
+      error,
+      statusCode: 403
+    };
+  },
+
+  notFound(resource = 'Resource'): ControllerResult {
+    return {
+      success: false,
+      message: resource + ' not found',
+      error: 'NOT_FOUND',
+      statusCode: 404
+    };
+  },
+
+  validation(
+    errors: ValidationError[] = [],
+    message = 'Validation failed'
+  ): ControllerResult {
+    return {
+      success: false,
+      message,
+      error: 'VALIDATION_ERROR',
+      statusCode: 422,
+      details: errors
+    };
+  },
+
+  custom<T>(result: ControllerResult<T>): ControllerResult<T> {
+    return result;
+  }
+};
+
 export function createSuccessResult<T>(
   message: string,
   data?: T,
@@ -1088,18 +1377,19 @@ export function createSuccessResult<T>(
   totalCount?: number,
   hasMorePages?: boolean
 ): ControllerResult<T> {
-  return {
-    success: true,
-    message,
-    error,
-    statusCode,
+  const response = createResponse.success(message, data, statusCode, {
     currentPage,
     totalPages,
     totalItems,
     totalCount,
-    hasMorePages,
-    data
-  };
+    hasMorePages
+  });
+
+  if (error) {
+    response.error = error;
+  }
+
+  return response;
 }
 
 export function createErrorResult(
@@ -1107,13 +1397,34 @@ export function createErrorResult(
   error?: string,
   statusCode = 400
 ): ControllerResult {
-  return { success: false, message, error, statusCode };
+  return createResponse.error(message, error, statusCode);
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
 }
 
-export interface ValidationResult<T = any> {
+export interface ValidationResult<T = unknown> {
   isValid: boolean;
   data?: T;
-  errors?: any[];
+  errors?: ValidationError[];
+}
+
+type KataxIssue = {
+  path: (string | number)[];
+  message: string;
+};
+
+type KataxSafeParseResult<T> =
+  | { success: true; data: T }
+  | { success: false; issues: KataxIssue[] };
+
+export interface KataxSchema<T = unknown> {
+  safeParse(input: unknown): KataxSafeParseResult<T>;
+  safeParseAsync(input: unknown): Promise<KataxSafeParseResult<T>>;
+  hasAsyncValidation?: () => boolean;
+  _asyncValidators?: unknown[];
 }
 
 /**
@@ -1125,13 +1436,16 @@ export interface ValidationResult<T = any> {
  * @returns ValidationResult con datos validados o errores
  */
 export async function validateSchema<T>(
-  schema: any,
+  schema: KataxSchema<T>,
   data: unknown
 ): Promise<ValidationResult<T>> {
   // Detectar si el schema tiene validadores asíncronos
-  const hasAsyncValidators = schema._def?.async || false;
+  const hasAsyncValidators =
+    typeof schema.hasAsyncValidation === 'function'
+      ? schema.hasAsyncValidation()
+      : !!(schema._asyncValidators && schema._asyncValidators.length > 0);
 
-  let result: any;
+  let result: KataxSafeParseResult<T>;
 
   try {
     if (hasAsyncValidators) {
@@ -1155,10 +1469,10 @@ export async function validateSchema<T>(
   }
 
   if (!result.success) {
-    const errors = result.issues?.map((issue: any) => ({
+    const errors = result.issues.map((issue) => ({
       field: issue.path.join('.') || 'root',
       message: issue.message
-    })) || [];
+    }));
 
     return {
       isValid: false,
@@ -1172,7 +1486,7 @@ export async function validateSchema<T>(
   };
 }
 
-export async function sendResponse<TValidation = any, TResponse = any>(
+export async function sendResponse<TValidation = unknown, TResponse = unknown>(
   req: Request,
   res: Response,
   validator: () => Promise<ValidationResult<TValidation>>,
@@ -1184,19 +1498,18 @@ export async function sendResponse<TValidation = any, TResponse = any>(
     
     if (!validationResult.isValid) {
       // Validation error
-      logger.warn({
+      ${apiUtilsWarnLogger}({
         method: req.method,
         path: req.path,
         errors: validationResult.errors, 
         message:'Validation failed'}
       );
-      
-      res.status(400).json({
-        success: false,
-        message: 'Invalid data',
-        error: 'Validation failed',
-        details: validationResult.errors
-      });
+
+      const validationResponse = createResponse.validation(
+        validationResult.errors || [],
+        'Invalid data'
+      );
+      res.status(validationResponse.statusCode || 422).json(validationResponse);
       return;
     }
 
@@ -1206,7 +1519,18 @@ export async function sendResponse<TValidation = any, TResponse = any>(
     // 3. Build HTTP response
     const statusCode = controllerResult.statusCode || (controllerResult.success ? 200 : 400);
 
-    const response: any = {
+    interface ResponsePayload {
+      success: boolean;
+      message: string;
+      error?: string;
+      totalItems?: number;
+      currentPage?: number;
+      totalPages?: number;
+      hasMorePages?: boolean;
+      data?: TResponse;
+    }
+
+    const response: ResponsePayload = {
       success: controllerResult.success,
       message: controllerResult.message
     };
@@ -1239,7 +1563,7 @@ export async function sendResponse<TValidation = any, TResponse = any>(
 
   } catch (error) {
     // Internal server error
-    logger.error({
+    ${apiUtilsErrorLogger}({
       err: error,
       method: req.method,
       path: req.path, 
@@ -1247,9 +1571,11 @@ export async function sendResponse<TValidation = any, TResponse = any>(
     });
     
     res.status(500).json({
-      success: false,
-      message: 'Internal server error',
-      error: error instanceof Error ? error.message : 'Unknown error'
+      ...createResponse.error(
+        'Internal server error',
+        error instanceof Error ? error.message : 'Unknown error',
+        500
+      )
     });
   }
 }
@@ -1258,13 +1584,14 @@ export async function sendResponse<TValidation = any, TResponse = any>(
     }
     if (config.authentication === "jwt") {
         const jwtUtilsContent = `import jwt from 'jsonwebtoken';
+import type { SignOptions } from 'jsonwebtoken';
 import { Request, Response, NextFunction } from 'express';
 
 const JWT_SECRET = process.env.JWT_SECRET || 'your-super-secret-jwt-key-change-in-production';
 const JWT_REFRESH_SECRET = process.env.JWT_REFRESH_SECRET || 'your-refresh-secret-key';
 
-const ACCESS_TOKEN_EXPIRY = '15m';  // 15 minutes
-const REFRESH_TOKEN_EXPIRY = '7d';  // 7 days
+const ACCESS_TOKEN_EXPIRY = (process.env.JWT_EXPIRES_IN || '15m') as SignOptions['expiresIn'];
+const REFRESH_TOKEN_EXPIRY = (process.env.JWT_REFRESH_EXPIRES_IN || '7d') as SignOptions['expiresIn'];
 
 // ==================== INTERFACES ====================
 
@@ -1413,33 +1740,8 @@ export function requireRole(...roles: string[]) {
         await writeFile(path.join(projectPath, "src/shared/jwt.utils.ts"), jwtUtilsContent);
         await writeFile(path.join(projectPath, "src/shared/auth.utils.ts"), generateAuthUtils());
     }
-    let loggerUtilsContent;
-    if (config.useKataxServiceManager) {
-        loggerUtilsContent = `import { katax } from '${kataxImportSourceShared}';
-
-/**
- * Re-export logger for convenience
- * katax.logger is always available (creates a default logger if not initialized)
- * Advanced features (broadcast, transports) require katax.init()
- */
-export const logger = katax.logger;
-
-/**
- * Log HTTP request helper
- */
-export function logRequest(method: string, url: string, statusCode: number, duration: number): void {
-  logger.info({
-    message: \`\${method} \${url} - \${statusCode} (\${duration}ms)\`,
-    method,
-    url,
-    statusCode,
-    duration: \`\${duration}ms\`
-  });
-}
-`;
-    }
-    else {
-        loggerUtilsContent = `import pino from 'pino';
+    if (!config.useKataxServiceManager) {
+        const loggerUtilsContent = `import pino from 'pino';
 
 const isDevelopment = process.env.NODE_ENV !== 'production';
 
@@ -1482,38 +1784,68 @@ export function logRequest(method: string, url: string, statusCode: number, dura
 /**
  * Log error with context
  */
-export function logError(error: Error, context?: Record<string, any>): void {
+export function logError(error: Error, context?: Record<string, unknown>): void {
   logger.error({
+    message: error.message,
     err: error,
     ...context
-  }, error.message);
+  });
 }
 
 /**
  * Log info message
  */
-export function logInfo(message: string, data?: Record<string, any>): void {
-  logger.info(data, message);
+export function logInfo(message: string, data?: Record<string, unknown>): void {
+  logger.info({ message, ...(data || {}) });
 }
 
 /**
  * Log warning message
  */
-export function logWarning(message: string, data?: Record<string, any>): void {
-  logger.warn(data, message);
+export function logWarning(message: string, data?: Record<string, unknown>): void {
+  logger.warn({ message, ...(data || {}) });
 }
 
 /**
  * Log debug message (only in development)
  */
-export function logDebug(message: string, data?: Record<string, any>): void {
-  logger.debug(data, message);
+export function logDebug(message: string, data?: Record<string, unknown>): void {
+  logger.debug({ message, ...(data || {}) });
 }
 `;
+        await writeFile(path.join(projectPath, "src/shared/logger.utils.ts"), loggerUtilsContent);
     }
-    await writeFile(path.join(projectPath, "src/shared/logger.utils.ts"), loggerUtilsContent);
     await writeFile(path.join(projectPath, "src/shared/stream.utils.ts"), generateStreamUtils());
-    const loggerMiddlewareContent = `import { Request, Response, NextFunction } from 'express';
+    const loggerMiddlewareContent = config.useKataxServiceManager
+        ? `import { Request, Response, NextFunction } from 'express';
+import { katax } from '${kataxImportSourceShared}';
+
+function logRequest(method: string, url: string, statusCode: number, duration: number): void {
+  katax.logger.info({
+    message: \`\${method} \${url} - \${statusCode} (\${duration}ms)\`,
+    method,
+    url,
+    statusCode,
+    duration
+  });
+}
+
+/**
+ * Express middleware to log all HTTP requests
+ */
+export function requestLogger(req: Request, res: Response, next: NextFunction): void {
+  const startTime = Date.now();
+
+  // Log response when it finishes
+  res.on('finish', () => {
+    const duration = Date.now() - startTime;
+    logRequest(req.method, req.url, res.statusCode, duration);
+  });
+
+  next();
+}
+`
+        : `import { Request, Response, NextFunction } from 'express';
 import { logRequest } from '../shared/logger.utils.js';
 
 /**
@@ -1557,7 +1889,16 @@ export const corsOptions: CorsOptions = {
 };
 `;
     await writeFile(path.join(projectPath, "src/config/cors.config.ts"), corsConfigContent);
-    const envValidatorContent = `import { logger } from '../shared/logger.utils.js';
+    const envLoggerImport = config.useKataxServiceManager
+        ? `import { katax } from '${kataxImportSourceShared}';`
+        : "import { logger } from '../shared/logger.utils.js';";
+    const envErrorLogger = config.useKataxServiceManager
+        ? "katax.logger.error"
+        : "logger.error";
+    const envInfoLogger = config.useKataxServiceManager
+        ? "katax.logger.info"
+        : "logger.info";
+    const envValidatorContent = `${envLoggerImport}
 
 interface RequiredEnvVars {
   [key: string]: string;
@@ -1582,11 +1923,11 @@ ${config.database !== "none" ? `  // Database variables\n  required.DATABASE_URL
   }
 
   if (missing.length > 0) {
-    logger.error({message:\`Missing required environment variables: \${missing.join(', ')}\`});
-    logger.error({message:'Please check your .env file'});
+    ${envErrorLogger}({message:\`Missing required environment variables: \${missing.join(', ')}\`});
+    ${envErrorLogger}({message:'Please check your .env file'});
   }
 
-  logger.info({message:'Environment variables validated successfully'});
+  ${envInfoLogger}({message:'Environment variables validated successfully'});
 }
 `;
     await writeFile(path.join(projectPath, "src/config/env.validator.ts"), envValidatorContent);
@@ -1839,10 +2180,21 @@ MIT
 }
 async function createHelloEndpoint(projectPath, config) {
     const helloPath = path.join(projectPath, "src/api/hello");
+    const helloLoggerImport = config.useKataxServiceManager
+        ? config.kataxMode === "instance"
+            ? "import { katax } from '../../config/katax.instance.js';"
+            : "import { katax } from 'katax-service-manager';"
+        : "import { logger } from '../../shared/logger.utils.js';";
+    const helloDebugLogger = config.useKataxServiceManager
+        ? "katax.logger.debug"
+        : "logger.debug";
+    const helloErrorLogger = config.useKataxServiceManager
+        ? "katax.logger.error"
+        : "logger.error";
     const controllerContent = [
-        "import { ControllerResult, createSuccessResult, createErrorResult } from '../../shared/api.utils.js';",
+        "import { ControllerResult, createResponse } from '../../shared/api.utils.js';",
         "import { HelloQuery } from './hello.validator.js';",
-        "import { logger } from '../../shared/logger.utils.js';",
+        helloLoggerImport,
         "",
         "/**",
         " * Get hello message",
@@ -1850,9 +2202,9 @@ async function createHelloEndpoint(projectPath, config) {
         "export async function getHello(queryData: HelloQuery): Promise<ControllerResult<{ message: string; timestamp: string }>> {",
         "  try {",
         "    const name = queryData.name || 'World';",
-        "    logger.debug({ name, message: 'Processing hello request' });",
+        `    ${helloDebugLogger}({ name, message: 'Processing hello request' });`,
         "    ",
-        "    return createSuccessResult(",
+        "    return createResponse.success(",
         "      'Hello endpoint working!',",
         "      {",
         "        message: `Hello ${name}! Welcome to your API 🚀`,",
@@ -1860,8 +2212,8 @@ async function createHelloEndpoint(projectPath, config) {
         "      }",
         "    );",
         "  } catch (error) {",
-        "    logger.error({ err: error, message: 'Error in getHello controller' });",
-        "    return createErrorResult(",
+        `    ${helloErrorLogger}({ err: error, message: 'Error in getHello controller' });`,
+        "    return createResponse.error(",
         "      'Failed to get hello message',",
         "      error instanceof Error ? error.message : 'Unknown error',",
         "      500",
@@ -1914,6 +2266,7 @@ async function createHelloEndpoint(projectPath, config) {
     if (config.validation === "katax-core") {
         const validatorContent = [
             "import { k, kataxInfer } from 'katax-core';",
+            "import { validateSchema } from '../../shared/api.utils.js';",
             "import type { ValidationResult } from '../../shared/api.utils.js';",
             "",
             "// ==================== SCHEMAS ====================",
@@ -1934,27 +2287,16 @@ async function createHelloEndpoint(projectPath, config) {
             " * Validate hello query params",
             " */",
             "export async function validateHelloQuery(data: unknown): Promise<ValidationResult<HelloQuery>> {",
-            "  const result = helloQuerySchema.safeParse(data);",
-            "",
-            "  if (!result.success) {",
-            "    const errors = result.issues.map(issue => ({",
-            "      field: issue.path.join('.'),",
-            "      message: issue.message",
-            "    }));",
-            "",
-            "    return {",
-            "      isValid: false,",
-            "      errors",
-            "    };",
-            "  }",
-            "",
-            "  return {",
-            "    isValid: true,",
-            "    data: result.data",
-            "  };",
+            "  return validateSchema(helloQuerySchema, data);",
             "}",
         ].join("\n");
         await writeFile(path.join(helloPath, "hello.validator.ts"), validatorContent);
     }
 }
+export const __initTestUtils = {
+    getPackageManager,
+    getInstallCommand,
+    resolvePeerDependencies,
+    KATAX_SERVICE_MANAGER_PEERS,
+};
 //# sourceMappingURL=init.js.map