@morojs/cli 1.0.0 → 1.2.0

package/dist/commands/init.js

@@ -15,6 +15,9 @@ const ora_1 = __importDefault(require("ora"));
 const boxen_1 = __importDefault(require("boxen"));
 const figlet_1 = __importDefault(require("figlet"));
 const terminal_1 = require("../utils/terminal");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
 class ProjectInitializer {
     constructor() {
         this.logger = (0, logger_1.createFrameworkLogger)('ProjectInitializer');
@@ -148,16 +151,16 @@ class ProjectInitializer {
                 name: 'features',
                 message: 'Select features to include:',
                 choices: [
-                    { name: 'Authentication & Authorization', value: 'auth', checked: true },
+                    { name: 'Authentication & Authorization', value: 'auth' },
                     { name: ' CORS & Security Headers', value: 'cors', checked: true },
                     { name: ' Compression & Performance', value: 'compression', checked: true },
                     { name: 'WebSocket Support', value: 'websocket' },
-                    { name: 'API Documentation (OpenAPI)', value: 'docs', checked: true },
-                    { name: 'Rate Limiting', value: 'rate-limit', checked: true },
+                    { name: 'API Documentation (OpenAPI)', value: 'docs' },
+                    { name: 'Rate Limiting', value: 'rate-limit' },
                     { name: 'Caching Layer', value: 'cache' },
                     { name: 'Circuit Breaker', value: 'circuit-breaker' },
                     { name: 'Monitoring & Metrics', value: 'monitoring' },
-                    { name: 'Testing Setup', value: 'testing', checked: true },
+                    { name: 'Testing Setup', value: 'testing' },
                 ],
             });
         }
@@ -176,12 +179,12 @@ class ProjectInitializer {
             name: projectName,
             version: '1.0.0',
             description: `MoroJS ${config.template} project`,
-            main: 'dist/index.js',
             type: 'module',
+            main: 'dist/src/index.js',
             scripts: {
-                dev: 'morojs-cli dev',
-                build: 'morojs-cli build',
-                start: 'node dist/index.js',
+                dev: 'tsx src/index.ts',
+                build: 'tsc',
+                start: 'node dist/src/index.js',
                 test: 'morojs-cli test',
                 lint: 'morojs-cli lint',
                 'db:migrate': 'morojs-cli db migrate --up',
@@ -193,7 +196,7 @@ class ProjectInitializer {
                 }),
             },
             dependencies: {
-                '@morojs/moro': '^1.0.0',
+                '@morojs/moro': await this.getLatestPackageVersion('@morojs/moro'),
                 ...(config.database === 'postgresql' && { pg: '^8.11.3', '@types/pg': '^8.10.9' }),
                 ...(config.database === 'mysql' && { mysql2: '^3.6.5' }),
                 ...(config.database === 'mongodb' && { mongodb: '^6.3.0' }),
@@ -202,13 +205,22 @@ class ProjectInitializer {
                     'drizzle-orm': '^0.29.1',
                     'drizzle-kit': '^0.20.6',
                 }),
-                ...(config.features.includes('auth') && { jsonwebtoken: '^9.0.2', bcryptjs: '^2.4.3' }),
+                ...(config.features.includes('auth') && {
+                    bcryptjs: '^2.4.3',
+                }),
+                ...(config.features.includes('docs') && {
+                    'swagger-ui-dist': '^5.11.0',
+                }),
                 zod: '^3.22.4',
             },
             devDependencies: {
                 '@morojs/cli': '^1.0.0',
                 '@types/node': '^20.10.0',
                 typescript: '^5.3.2',
+                tsx: '^4.7.0',
+                ...(config.features.includes('auth') && {
+                    '@types/bcryptjs': '^2.4.0',
+                }),
                 ...(config.features.includes('testing') && {
                     jest: '^29.7.0',
                     '@types/jest': '^29.5.8',
@@ -234,7 +246,6 @@ class ProjectInitializer {
                 skipLibCheck: true,
                 forceConsistentCasingInFileNames: true,
                 outDir: './dist',
-                rootDir: './src',
                 declaration: true,
                 declarationMap: true,
                 sourceMap: true,
@@ -244,7 +255,7 @@ class ProjectInitializer {
                 resolveJsonModule: true,
                 allowSyntheticDefaultImports: true,
             },
-            include: ['src/**/*'],
+            include: ['src/**/*', 'moro.config.ts'],
             exclude: ['node_modules', 'dist', '**/*.test.ts', '**/*.spec.ts'],
         };
         await (0, promises_1.writeFile)((0, path_1.join)(projectPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
@@ -258,69 +269,188 @@ class ProjectInitializer {
             'cloudflare-workers': 'createAppWorker',
         };
         const appContent = `// ${config.template.toUpperCase()} MoroJS Application
-import { ${runtimeImports[config.runtime]}, logger } from '@morojs/moro';
-${config.database !== 'none' ? `import { setupDatabase } from './database';` : ''}
-${config.features.includes('auth') ? `import { setupAuth } from './middleware/auth';` : ''}
+import { ${runtimeImports[config.runtime]}, logger, initializeConfig } from '@morojs/moro';
+${config.database !== 'none' ? `import { setupDatabase } from './database/index.js';` : ''}
+${config.features.includes('auth') ? `import { setupAuth } from './middleware/auth.js';` : ''}
+
+// Initialize configuration from moro.config.js and environment variables
+const appConfig = initializeConfig();
 
 // Create MoroJS application with ${config.runtime} runtime
 const app = ${runtimeImports[config.runtime]}({
-  runtime: { type: '${config.runtime}' },
   ${config.features.includes('cors') ? `cors: true,` : ''}
   ${config.features.includes('compression') ? `compression: true,` : ''}
   logger: {
-    level: process.env.LOG_LEVEL || 'info',
-    format: 'pretty'
+    level: appConfig.logging?.level || 'info',
+    format: appConfig.logging?.format || 'pretty'
   }
 });
 
 // Database setup
 ${config.database !== 'none' ? `await setupDatabase(app);` : ''}
 
-// Middleware setup
+// Auth setup
 ${config.features.includes('auth') ? `await setupAuth(app);` : ''}
 
-// API Documentation
+// Health check endpoint
+app.get('/health')
+  .describe('Health check endpoint to verify API status')
+  .tag('System')
+  .handler(async (req: any, res: any) => {
+    return {
+      success: true,
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      runtime: '${config.runtime}',
+      version: '1.0.0'
+    };
+  });
+
+// Welcome endpoint
+app.get('/')
+  .describe('Welcome endpoint with API information and available routes')
+  .tag('General')
+  .handler(async (req: any, res: any) => {
+    return {
+      message: 'Welcome to your MoroJS ${config.template}!',
+      docs: '/docs',
+      health: '/health',
+      auth: {
+        login: '/auth/login',
+        register: '/auth/register',
+        profile: '/auth/profile'
+      }
+    };
+  });
+
+// Auth endpoints
+app.post('/auth/login')
+  .describe('Login with email and password')
+  .tag('Auth')
+  .handler(async (req: any, res: any) => {
+    const { email, password } = req.body;
+    if (!email || !password) {
+      res.status(400);
+      return {
+        success: false,
+        error: 'Email and password are required'
+      };
+    }
+
+    try {
+      console.log('Login attempt:', { email });
+      const result = await req.auth.signIn('credentials', { email, password });
+      console.log('Login result:', { success: !!result });
+
+      if (!result) {
+        res.status(401);
+        return {
+          success: false,
+          error: 'Invalid credentials'
+        };
+      }
+
+      const token = await req.auth.createToken(result);
+      await req.auth.setSession({ user: result, token });
+
+      return {
+        success: true,
+        data: {
+          user: result,
+          token
+        }
+      };
+    } catch (error) {
+      console.error('Auth error:', error);
+      res.status(401);
+      return {
+        success: false,
+        error: 'Authentication failed'
+      };
+    }
+  });
+
+app.post('/auth/register')
+  .describe('Register a new user')
+  .tag('Auth')
+  .handler(async (req: any, res: any) => {
+    const { email, password, name } = req.body;
+    if (!email || !password || !name) {
+      res.status(400);
+      return {
+        success: false,
+        error: 'Email, password, and name are required'
+      };
+    }
+
+    // In a real app, you would hash the password and store in a database
+    return {
+      success: true,
+      message: 'Registration successful. Please login.'
+    };
+  });
+
+app.get('/auth/profile')
+  .describe('Get authenticated user profile')
+  .tag('Auth')
+  .handler(async (req: any, res: any) => {
+    const user = await req.auth.getUser();
+    if (!user) {
+      res.status(401);
+      return {
+        success: false,
+        error: 'Not authenticated'
+      };
+    }
+
+    return {
+      success: true,
+      data: {
+        user,
+        session: req.auth.session
+      }
+    };
+  });
+
 ${config.features.includes('docs')
             ? `
+// API Documentation
 app.enableDocs({
   title: '${config.template.charAt(0).toUpperCase() + config.template.slice(1)} API',
   description: 'MoroJS ${config.template} application',
   version: '1.0.0',
-  basePath: '/docs'
-});`
-            : ''}
-
-// Health check endpoint
-app.get('/health', async (req, res) => {
-  return {
-    success: true,
-    status: 'healthy',
-    timestamp: new Date().toISOString(),
-    runtime: '${config.runtime}',
-    version: '1.0.0'
-  };
-});
-
-// Welcome endpoint
-app.get('/', async (req, res) => {
-  return {
-    message: 'Welcome to your MoroJS ${config.template}!',
-    docs: '/docs',
-    health: '/health'
-  };
+  basePath: '/docs',
+  swaggerUI: {
+    enableTryItOut: false,
+    enableFilter: false,
+    enableDeepLinking: false,
+    customCss: \`
+      .swagger-ui .topbar { display: none }
+      .swagger-ui .scheme-container { display: none }
+      .swagger-ui .info { margin: 20px 0 }
+      .swagger-ui .info .title { font-size: 24px }
+      .swagger-ui .info .title small { display: none }
+      .swagger-ui .info .title span { display: none }
+      .swagger-ui .information-container { padding: 0 }
+      .swagger-ui section.models { display: none }
+      .swagger-ui .auth-wrapper { display: none }
+      .swagger-ui .try-out { display: none }
+    \`
+  },
 });
-
+`
+            : ''}
 // Auto-discover and load modules
 // Modules will be automatically loaded from ./modules directory
 
 ${config.runtime === 'node'
             ? `
 // Start server (Node.js only)
-const PORT = process.env.PORT || 3000;
-const HOST = process.env.HOST || 'localhost';
+const PORT = appConfig.server?.port || 3000;
+const HOST = appConfig.server?.host || 'localhost';
 
 app.listen(PORT, HOST, () => {
-  logger.info(\`\${config.template.charAt(0).toUpperCase() + config.template.slice(1)} server running!\`);
+  logger.info(\`${config.template.charAt(0).toUpperCase() + config.template.slice(1)} server running!\`);
   logger.info(\`HTTP: http://\${HOST}:\${PORT}\`);
   ${config.features.includes('websocket') ? `logger.info(\`🔌 WebSocket: ws://\${HOST}:\${PORT}\`);` : ''}
   ${config.features.includes('docs') ? `logger.info(\`Docs: http://\${HOST}:\${PORT}/docs\`);` : ''}
@@ -407,64 +537,222 @@ CLOUDFLARE_API_TOKEN=`
     }
     async generateMoroConfig(projectPath, config) {
         const configContent = `// MoroJS Configuration
-import { z } from 'zod';
+// Generated based on selected features: ${config.features.join(', ')}
+// Reference: https://morojs.com/docs/configuration
 
-export default {
+export default async () => {
+  const os = await import('os');
+  return {
+  // Server Configuration
   server: {
-    port: parseInt(process.env.PORT || '3000'),
-    host: process.env.HOST || 'localhost',
-    environment: process.env.NODE_ENV || 'development'
-  },
-  
-  ${config.database !== 'none'
-            ? `database: {
-    ${config.database === 'postgresql' ? `url: process.env.DATABASE_URL` : ''}
-    ${config.database === 'mysql' ? `url: process.env.DATABASE_URL` : ''}
-    ${config.database === 'mongodb' ? `url: process.env.MONGODB_URI` : ''}
-    ${config.database === 'redis' ? `redis: { url: process.env.REDIS_URL }` : ''}
-  },`
+    port: parseInt(process.env.PORT || process.env.MORO_PORT || '3000'),
+    host: process.env.HOST || process.env.MORO_HOST || 'localhost',
+    environment: process.env.NODE_ENV || process.env.MORO_ENV || 'development'${config.runtime === 'node'
+            ? `,
+    maxConnections: parseInt(process.env.MAX_CONNECTIONS || process.env.MORO_MAX_CONNECTIONS || '1000'),
+    timeout: parseInt(process.env.REQUEST_TIMEOUT || process.env.MORO_TIMEOUT || '30000')`
             : ''}
-  
+  },
+
+${config.database !== 'none' && config.database !== 'sqlite'
+            ? `  // Database Configuration
+  database: {${config.database === 'postgresql'
+                ? `
+    url: process.env.DATABASE_URL || process.env.MORO_DATABASE_URL`
+                : ''}${config.database === 'mysql'
+                ? `
+    mysql: {
+      host: process.env.MYSQL_HOST || process.env.MORO_MYSQL_HOST || 'localhost',
+      port: parseInt(process.env.MYSQL_PORT || process.env.MORO_MYSQL_PORT || '3306'),
+      database: process.env.MYSQL_DATABASE || process.env.MORO_MYSQL_DB,
+      username: process.env.MYSQL_USERNAME || process.env.MORO_MYSQL_USER,
+      password: process.env.MYSQL_PASSWORD || process.env.MORO_MYSQL_PASS,
+      connectionLimit: parseInt(process.env.MYSQL_CONNECTION_LIMIT || process.env.MORO_MYSQL_CONNECTIONS || '10'),
+      acquireTimeout: parseInt(process.env.MYSQL_ACQUIRE_TIMEOUT || '60000'),
+      timeout: parseInt(process.env.MYSQL_TIMEOUT || '60000')
+    }`
+                : ''}${config.database === 'mongodb'
+                ? `
+    url: process.env.DATABASE_URL || process.env.MONGODB_URI || process.env.MORO_DATABASE_URL || 'mongodb://localhost:27017/database'`
+                : ''}${config.database === 'redis' || config.features.includes('cache')
+                ? `,
+    redis: {
+      url: process.env.REDIS_URL || process.env.MORO_REDIS_URL || 'redis://localhost:6379',
+      maxRetries: parseInt(process.env.REDIS_MAX_RETRIES || process.env.MORO_REDIS_RETRIES || '3'),
+      retryDelay: parseInt(process.env.REDIS_RETRY_DELAY || process.env.MORO_REDIS_DELAY || '1000'),
+      keyPrefix: process.env.REDIS_KEY_PREFIX || process.env.MORO_REDIS_PREFIX || 'moro:'
+    }`
+                : ''}
+  },
+
+`
+            : ''}  // Logging Configuration
   logging: {
-    level: process.env.LOG_LEVEL || 'info',
-    format: 'pretty',
-    enableColors: true,
-    enableTimestamp: true
+    level: process.env.LOG_LEVEL || process.env.MORO_LOG_LEVEL || 'info',
+    format: process.env.LOG_FORMAT || process.env.MORO_LOG_FORMAT || (process.env.NODE_ENV === 'production' ? 'json' : 'pretty'),
+    enableColors: process.env.LOG_COLORS !== 'false' && process.env.NO_COLOR !== '1' && process.env.NODE_ENV !== 'production',
+    enableTimestamp: process.env.LOG_TIMESTAMP !== 'false',
+    enableContext: process.env.LOG_CONTEXT !== 'false'${config.features.includes('monitoring')
+            ? `,
+    outputs: {
+      console: true,
+      file: {
+        enabled: process.env.LOG_FILE_ENABLED === 'true' || process.env.MORO_LOG_FILE === 'true' || process.env.NODE_ENV === 'production',
+        path: process.env.LOG_FILE_PATH || process.env.MORO_LOG_PATH || './logs/moro.log',
+        maxSize: '10MB',
+        maxFiles: 5
+      }${config.features.includes('webhook-logging')
+                ? `,
+      webhook: {
+        enabled: !!process.env.LOG_WEBHOOK_URL || !!process.env.MORO_LOG_WEBHOOK_URL,
+        url: process.env.LOG_WEBHOOK_URL || process.env.MORO_LOG_WEBHOOK_URL,
+        headers: {
+          'Authorization': process.env.LOG_WEBHOOK_AUTH,
+          'Content-Type': 'application/json'
+        }
+      }`
+                : ''}
+    }`
+            : ''}
   },
-  
+
+  // Security Configuration
   security: {
     cors: {
-      enabled: true,
-      origin: process.env.NODE_ENV === 'production' ? false : '*'
+      enabled: ${config.features.includes('cors') ? "process.env.CORS_ENABLED !== 'false'" : 'false'},${config.features.includes('cors')
+            ? `
+      origin: process.env.NODE_ENV === 'production'
+        ? (process.env.CORS_ORIGIN || process.env.MORO_CORS_ORIGIN || '*').split(',')
+        : '*',
+      methods: (process.env.CORS_METHODS || process.env.MORO_CORS_METHODS || 'GET,POST,PUT,DELETE,PATCH,OPTIONS').split(','),
+      allowedHeaders: (process.env.CORS_HEADERS || process.env.MORO_CORS_HEADERS || 'Content-Type,Authorization').split(','),
+      credentials: process.env.CORS_CREDENTIALS === 'true'`
+            : ''}
     },
     helmet: {
-      enabled: true
-    }
+      enabled: process.env.HELMET_ENABLED !== 'false',
+      contentSecurityPolicy: process.env.NODE_ENV === 'production',
+      hsts: process.env.NODE_ENV === 'production',
+      noSniff: true,
+      frameguard: true
+    }${config.features.includes('rate-limit')
+            ? `,
+    rateLimit: {
+      enabled: process.env.GLOBAL_RATE_LIMIT_ENABLED === 'true',
+      requests: parseInt(process.env.GLOBAL_RATE_LIMIT_REQUESTS || process.env.MORO_GLOBAL_RATE_REQUESTS || '1000'),
+      window: 60000 // 1 minute window
+    }`
+            : ''}
   },
-  
-  performance: {
+
+${config.features.includes('compression') ||
+            config.features.includes('circuit-breaker') ||
+            config.runtime === 'node'
+            ? `  // Performance Configuration
+  performance: {${config.features.includes('compression')
+                ? `
     compression: {
-      enabled: true,
-      level: 6
-    },
+      enabled: process.env.COMPRESSION_ENABLED !== 'false',
+      level: parseInt(process.env.COMPRESSION_LEVEL || process.env.MORO_COMPRESSION_LEVEL || '6'),
+      threshold: parseInt(process.env.COMPRESSION_THRESHOLD || process.env.MORO_COMPRESSION_THRESHOLD || '1024')
+    }${config.features.includes('circuit-breaker') || config.runtime === 'node' ? ',' : ''}`
+                : ''}${config.features.includes('circuit-breaker')
+                ? `
     circuitBreaker: {
-      enabled: ${config.features.includes('circuit-breaker')}
-    }
+      enabled: process.env.CIRCUIT_BREAKER_ENABLED !== 'false',
+      failureThreshold: parseInt(process.env.CIRCUIT_BREAKER_THRESHOLD || process.env.MORO_CB_THRESHOLD || '5'),
+      resetTimeout: parseInt(process.env.CIRCUIT_BREAKER_RESET_TIMEOUT || '60000'),
+      monitoringPeriod: parseInt(process.env.CIRCUIT_BREAKER_MONITORING_PERIOD || '10000')
+    }${config.runtime === 'node' ? ',' : ''}`
+                : ''}${config.runtime === 'node'
+                ? `
+    clustering: {
+      enabled: process.env.CLUSTERING_ENABLED === 'true',
+      workers: parseInt(process.env.CLUSTER_WORKERS || process.env.MORO_WORKERS || '0') || os.cpus().length
+    }`
+                : ''}
   },
-  
-  modules: {
+
+`
+            : ''}${config.features.some((f) => ['cache', 'rate-limit', 'validation'].includes(f))
+            ? `
+  // Module Configuration
+  modules: {${config.features.includes('cache')
+                ? `
     cache: {
-      enabled: ${config.features.includes('cache')},
-      defaultTtl: 300
-    },
+      enabled: process.env.CACHE_ENABLED !== 'false' || process.env.MORO_CACHE_ENABLED !== 'false',
+      defaultTtl: parseInt(process.env.DEFAULT_CACHE_TTL || process.env.MORO_CACHE_TTL || '300'),
+      maxSize: parseInt(process.env.CACHE_MAX_SIZE || process.env.MORO_CACHE_SIZE || '1000'),
+      strategy: process.env.CACHE_STRATEGY || process.env.MORO_CACHE_STRATEGY || 'lru'
+    }${config.features.includes('rate-limit') || config.features.includes('validation') ? ',' : ''}`
+                : ''}${config.features.includes('rate-limit')
+                ? `
     rateLimit: {
-      enabled: ${config.features.includes('rate-limit')},
-      defaultRequests: 100,
-      defaultWindow: 60000
-    }
-  }
+      enabled: process.env.RATE_LIMIT_ENABLED !== 'false' || process.env.MORO_RATE_LIMIT_ENABLED !== 'false',
+      defaultRequests: parseInt(process.env.DEFAULT_RATE_LIMIT_REQUESTS || process.env.MORO_RATE_LIMIT_REQUESTS || '100'),
+      defaultWindow: parseInt(process.env.DEFAULT_RATE_LIMIT_WINDOW || process.env.MORO_RATE_LIMIT_WINDOW || '60000'),
+      skipSuccessfulRequests: process.env.RATE_LIMIT_SKIP_SUCCESS === 'true',
+      skipFailedRequests: process.env.RATE_LIMIT_SKIP_FAILED === 'true'
+    }${config.features.includes('validation') ? ',' : ''}`
+                : ''}${config.features.includes('validation')
+                ? `
+    validation: {
+      enabled: process.env.VALIDATION_ENABLED !== 'false' || process.env.MORO_VALIDATION_ENABLED !== 'false',
+      stripUnknown: process.env.VALIDATION_STRIP_UNKNOWN !== 'false',
+      abortEarly: process.env.VALIDATION_ABORT_EARLY === 'true'
+    }`
+                : ''}
+  }`
+            : ''}${config.features.includes('service-discovery')
+            ? `,
+
+  // Service Discovery Configuration
+  serviceDiscovery: {
+    enabled: process.env.SERVICE_DISCOVERY_ENABLED === 'true' || process.env.MORO_SERVICE_DISCOVERY === 'true',
+    type: process.env.DISCOVERY_TYPE || process.env.MORO_DISCOVERY_TYPE || 'memory',
+    consulUrl: process.env.CONSUL_URL || process.env.MORO_CONSUL_URL || 'http://localhost:8500',
+    kubernetesNamespace: process.env.K8S_NAMESPACE || process.env.MORO_K8S_NAMESPACE || 'default',
+    healthCheckInterval: parseInt(process.env.HEALTH_CHECK_INTERVAL || process.env.MORO_HEALTH_INTERVAL || '30000'),
+    retryAttempts: parseInt(process.env.DISCOVERY_RETRY_ATTEMPTS || process.env.MORO_DISCOVERY_RETRIES || '3')
+  }`
+            : ''}${config.features.some((f) => ['stripe', 'paypal', 'smtp', 'email'].includes(f))
+            ? `,
+
+  // External Services Configuration
+  external: {${config.features.includes('stripe')
+                ? `
+    // Stripe Configuration (uncomment and configure)
+    // stripe: {
+    //   secretKey: process.env.STRIPE_SECRET_KEY || process.env.MORO_STRIPE_SECRET,
+    //   publishableKey: process.env.STRIPE_PUBLISHABLE_KEY || process.env.MORO_STRIPE_PUBLIC,
+    //   webhookSecret: process.env.STRIPE_WEBHOOK_SECRET || process.env.MORO_STRIPE_WEBHOOK,
+    //   apiVersion: process.env.STRIPE_API_VERSION || process.env.MORO_STRIPE_VERSION || '2023-10-16'
+    // }${config.features.includes('paypal') || config.features.includes('smtp') ? ',' : ''}`
+                : ''}${config.features.includes('paypal')
+                ? `
+    // PayPal Configuration (uncomment and configure)
+    // paypal: {
+    //   clientId: process.env.PAYPAL_CLIENT_ID || process.env.MORO_PAYPAL_CLIENT,
+    //   clientSecret: process.env.PAYPAL_CLIENT_SECRET || process.env.MORO_PAYPAL_SECRET,
+    //   webhookId: process.env.PAYPAL_WEBHOOK_ID,
+    //   environment: process.env.PAYPAL_ENVIRONMENT || process.env.MORO_PAYPAL_ENV || 'sandbox'
+    // }${config.features.includes('smtp') ? ',' : ''}`
+                : ''}${config.features.includes('smtp') || config.features.includes('email')
+                ? `
+    // SMTP Configuration (uncomment and configure)
+    // smtp: {
+    //   host: process.env.SMTP_HOST || process.env.MORO_SMTP_HOST,
+    //   port: parseInt(process.env.SMTP_PORT || process.env.MORO_SMTP_PORT || '587'),
+    //   secure: process.env.SMTP_SECURE === 'true',
+    //   username: process.env.SMTP_USERNAME || process.env.MORO_SMTP_USER,
+    //   password: process.env.SMTP_PASSWORD || process.env.MORO_SMTP_PASS
+    // }`
+                : ''}
+  }`
+            : ''}
+  };
 };`;
-        await (0, promises_1.writeFile)((0, path_1.join)(projectPath, 'moro.config.js'), configContent);
+        await (0, promises_1.writeFile)((0, path_1.join)(projectPath, 'moro.config.ts'), configContent);
     }
     async generateGitignore(projectPath) {
         const gitignoreContent = `# Dependencies
@@ -621,6 +909,28 @@ npm start
 - **Welcome**: \`GET /\`
 ${config.features.includes('docs') ? `- **API Docs**: \`GET /docs\`` : ''}
 
+## Configuration
+
+This project includes a comprehensive configuration system:
+
+- **\`moro.config.ts\`** - Feature-based configuration with production-ready defaults
+- **\`.env\`** - Environment variables for development
+- **\`.env.example\`** - Environment variables template
+
+### Production Setup
+
+1. Set up production environment variables:
+   \`\`\`bash
+   cp .env.example .env.production
+   # Edit .env.production with your production values
+   \`\`\`
+
+2. The configuration automatically adapts to production when \`NODE_ENV=production\`:
+   - **Performance**: Compression, clustering, circuit breakers
+   - **Security**: CORS, Helmet, rate limiting, SSL
+   - **Monitoring**: Structured logging, file outputs
+   - **Scalability**: Redis caching, connection pooling
+
 ## Database
 
 ${config.database !== 'none'
@@ -883,94 +1193,223 @@ volumes:
         }
     }
     async generateDatabaseSetup(projectPath, config) {
-        const dbSetupContent = `// Database Setup and Configuration
-import { ${config.database.charAt(0).toUpperCase() + config.database.slice(1)}Adapter } from '@morojs/moro';
+        // Fix the adapter name for PostgreSQL (should be PostgreSQLAdapter, not PostgresqlAdapter)
+        const getAdapterName = (dbType) => {
+            if (dbType === 'postgresql')
+                return 'PostgreSQLAdapter';
+            return dbType.charAt(0).toUpperCase() + dbType.slice(1) + 'Adapter';
+        };
+        const adapterName = getAdapterName(config.database);
+        const dbSetupContent = config.database === 'postgresql'
+            ? `// Database Setup and Configuration
+import pg from 'pg';
 import { createFrameworkLogger } from '@morojs/moro';
 
 const logger = createFrameworkLogger('Database');
 
 export async function setupDatabase(app: any): Promise<void> {
   try {
-    const adapter = new ${config.database.charAt(0).toUpperCase() + config.database.slice(1)}Adapter({
-      ${config.database === 'postgresql' || config.database === 'mysql'
-            ? `
-      url: process.env.DATABASE_URL,
-      host: process.env.${config.database.toUpperCase()}_HOST,
-      port: parseInt(process.env.${config.database.toUpperCase()}_PORT || '${config.database === 'postgresql' ? '5432' : '3306'}'),
-      username: process.env.${config.database.toUpperCase()}_USER,
-      password: process.env.${config.database.toUpperCase()}_PASSWORD,
-      database: process.env.${config.database.toUpperCase()}_${config.database === 'postgresql' ? 'DB' : 'DATABASE'}`
-            : ''}
-      ${config.database === 'mongodb'
-            ? `
-      url: process.env.MONGODB_URI`
-            : ''}
-      ${config.database === 'redis'
-            ? `
-      url: process.env.REDIS_URL,
-      host: process.env.REDIS_HOST,
-      port: parseInt(process.env.REDIS_PORT || '6379')`
-            : ''}
+    const pool = new pg.Pool({
+      host: process.env.POSTGRESQL_HOST || 'localhost',
+      port: parseInt(process.env.POSTGRESQL_PORT || '5432'),
+      user: process.env.POSTGRESQL_USER || 'postgres',
+      password: process.env.POSTGRESQL_PASSWORD || 'postgres',
+      database: process.env.POSTGRESQL_DATABASE || 'postgres'
     });
 
-    await adapter.connect();
-    app.database(adapter);
-    
+    await pool.connect();
+    app.database = pool;
+
     logger.info('✅ Database connected successfully', 'Database');
   } catch (error) {
-    logger.error('❌ Database connection failed:', error, 'Database');
-    throw error;
+    logger.error('❌ Database connection failed: ' + String(error), 'Database');
+    logger.warn('⚠️  App will continue without database connection', 'Database');
+    // Don't throw - let the app continue without database
   }
-}`;
+}`
+            : config.database === 'mysql'
+                ? `// Database Setup and Configuration
+import mysql from 'mysql2/promise';
+import { createFrameworkLogger } from '@morojs/moro';
+
+const logger = createFrameworkLogger('Database');
+
+export async function setupDatabase(app: any): Promise<void> {
+  try {
+    const pool = await mysql.createPool({
+      host: process.env.MYSQL_HOST || 'localhost',
+      port: parseInt(process.env.MYSQL_PORT || '3306'),
+      user: process.env.MYSQL_USER || 'mysql',
+      password: process.env.MYSQL_PASSWORD || 'mysql',
+      database: process.env.MYSQL_DATABASE || 'mysql'
+    });
+
+    app.database = pool;
+    logger.info('✅ Database connected successfully', 'Database');
+  } catch (error) {
+    logger.error('❌ Database connection failed: ' + String(error), 'Database');
+    logger.warn('⚠️  App will continue without database connection', 'Database');
+    // Don't throw - let the app continue without database
+  }
+}`
+                : config.database === 'mongodb'
+                    ? `// Database Setup and Configuration
+import { MongoClient } from 'mongodb';
+import { createFrameworkLogger } from '@morojs/moro';
+
+const logger = createFrameworkLogger('Database');
+
+export async function setupDatabase(app: any): Promise<void> {
+  try {
+    const client = new MongoClient(process.env.MONGODB_URI || 'mongodb://localhost:27017');
+    await client.connect();
+    app.database = client.db(process.env.MONGODB_DATABASE || 'test');
+    logger.info('✅ Database connected successfully', 'Database');
+  } catch (error) {
+    logger.error('❌ Database connection failed: ' + String(error), 'Database');
+    logger.warn('⚠️  App will continue without database connection', 'Database');
+    // Don't throw - let the app continue without database
+  }
+}`
+                    : '';
         await (0, promises_1.writeFile)((0, path_1.join)(projectPath, 'src', 'database', 'index.ts'), dbSetupContent);
     }
     async generateAuthMiddleware(projectPath) {
-        const authContent = `// Authentication Middleware
-import { auth } from '@morojs/moro';
-import jwt from 'jsonwebtoken';
+        const authContent = `// Authentication Middleware for MoroJS
 import bcrypt from 'bcryptjs';
 
-const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key';
+// Mock auth middleware that creates the auth object on requests
+function createAuthMiddleware() {
+  return (req: any, res: any, next: any) => {
+    // Initialize auth object
+    req.auth = {
+      isAuthenticated: false,
+      user: null,
+      session: null,
+      async getSession() {
+        return req.auth.session;
+      },
+      async getUser() {
+        return req.auth.user;
+      },
+      async signIn(provider: string, credentials: any) {
+        console.log(\`🔐 Sign in attempt with \${provider}:\`, { email: credentials.email });
+
+        // Mock authentication logic
+        if (provider === 'credentials') {
+          if (credentials.email === 'admin@example.com' && credentials.password === 'password') {
+            const user = {
+              id: '1',
+              name: 'Admin User',
+              email: 'admin@example.com',
+              role: 'admin'
+            };
+
+            req.auth.isAuthenticated = true;
+            req.auth.user = user;
+            req.auth.session = {
+              user,
+              expires: new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString(), // 8 hours
+              customData: {
+                lastActivity: new Date(),
+                sessionId: 'session_' + Math.random().toString(36).substr(2, 9),
+                provider: 'credentials',
+              },
+            };
 
-export async function setupAuth(app: any): Promise<void> {
-  // JWT Authentication middleware
-  app.use(auth({
-    secret: JWT_SECRET,
-    algorithms: ['HS256'],
-    optional: true // Make auth optional by default
-  }));
-
-  // Login endpoint
-  app.post('/auth/login', async (req: any, res: any) => {
-    const { email, password } = req.body;
-    
-    // TODO: Implement user lookup from database
-    // const user = await getUserByEmail(email);
-    // const isValid = await bcrypt.compare(password, user.password);
-    
-    // Mock implementation
-    if (email === 'admin@example.com' && password === 'password') {
-      const token = jwt.sign(
-        { userId: 1, email, roles: ['admin'] },
-        JWT_SECRET,
-        { expiresIn: process.env.JWT_EXPIRES_IN || '24h' }
-      );
-      
-      return { success: true, token, user: { id: 1, email, roles: ['admin'] } };
+            console.log('🔐 Authentication successful');
+            return user;
+          }
+        }
+
+        console.log('🔐 Authentication failed');
+        return null;
+      },
+      signOut(options?: any) {
+        console.log('🚪 Sign out initiated');
+        req.auth.isAuthenticated = false;
+        req.auth.user = null;
+        req.auth.session = null;
+        return { url: options?.callbackUrl || '/' };
+      },
+      createToken(user: any) {
+        // Mock token creation
+        return 'jwt_' + Math.random().toString(36).substr(2, 20);
+      },
+      setSession(sessionData: any) {
+        req.auth.session = sessionData.session || sessionData;
+        req.auth.user = sessionData.user;
+        req.auth.isAuthenticated = true;
+        return Promise.resolve();
+      }
+    };
+
+    // Check for existing authentication via Authorization header
+    const authHeader = req.headers.authorization;
+    if (authHeader?.startsWith('Bearer ')) {
+      const token = authHeader.split(' ')[1];
+
+      // Mock token validation
+      if (token.startsWith('jwt_') || token === 'admin-token') {
+        req.auth.isAuthenticated = true;
+        req.auth.user = {
+          id: '1',
+          name: 'Admin User',
+          email: 'admin@example.com',
+          role: 'admin'
+        };
+        req.auth.session = {
+          user: req.auth.user,
+          expires: new Date(Date.now() + 8 * 60 * 60 * 1000).toISOString(),
+          customData: {
+            lastActivity: new Date(),
+            sessionId: 'session_from_token',
+            provider: 'credentials',
+          },
+        };
+      }
     }
-    
+
+    next();
+  };
+}
+
+export async function setupAuth(app: any): Promise<void> {
+  // Install the auth middleware
+  app.use(createAuthMiddleware());
+
+  // Protected route example
+  app.get('/api/profile', async (req: any, res: any) => {
+    // Auth.js automatically adds auth object to request
+    if (!req.auth?.isAuthenticated) {
     res.status(401);
-    return { success: false, error: 'Invalid credentials' };
+      return { success: false, error: 'Authentication required' };
+    }
+
+    return {
+      success: true,
+      user: req.auth.user,
+      session: req.auth.session
+    };
   });
 
-  // Protected route example
-  app.get('/auth/profile', async (req: any, res: any) => {
-    if (!req.user) {
+  // Admin-only route example
+  app.get('/api/admin', async (req: any, res: any) => {
+    if (!req.auth?.isAuthenticated) {
       res.status(401);
       return { success: false, error: 'Authentication required' };
     }
-    
-    return { success: true, user: req.user };
+
+    if (req.auth.user?.role !== 'admin') {
+      res.status(403);
+      return { success: false, error: 'Admin access required' };
+    }
+
+    return {
+      success: true,
+      message: 'Admin access granted',
+      user: req.auth.user
+    };
   });
 }`;
         await (0, promises_1.writeFile)((0, path_1.join)(projectPath, 'src', 'middleware', 'auth.ts'), authContent);
@@ -1034,7 +1473,7 @@ Project Structure:
    │   └── types/            # TypeScript types
    ├── package.json
    ├── tsconfig.json
-   ├── moro.config.js
+   ├── moro.config.ts
    └── README.md
 
 Next Steps:
@@ -1056,6 +1495,24 @@ ${config.features.map((f) => `   • ${f}`).join('\n')}
             borderColor: 'green',
         }));
     }
+    /**
+     * Fetch the latest version of a package from NPM registry
+     */
+    async getLatestPackageVersion(packageName) {
+        try {
+            const { stdout } = await execAsync(`npm view ${packageName} version`);
+            const version = stdout.trim();
+            return `^${version}`;
+        }
+        catch (error) {
+            this.logger.warn(`Failed to fetch latest version for ${packageName}, using fallback`, 'Init');
+            // Fallback to a reasonable default if npm view fails
+            if (packageName === '@morojs/moro') {
+                return '^1.1.0';
+            }
+            return '^1.1.0';
+        }
+    }
 }
 exports.ProjectInitializer = ProjectInitializer;
 //# sourceMappingURL=init.js.map