vasuzex 2.0.13 → 2.0.15

package/{apps/pilot-test/api → framework/Console}/src/app.js

@@ -1,5 +1,5 @@
 /**
- * Pilot-test API Application
+ * Blog API Application
  * Extends BaseApp from framework for clean architecture
  */
 
@@ -9,25 +9,17 @@ import { errorHandler, notFoundHandler } from './middleware/errorHandler.js';
 import { getAllRoutes } from './routes/index.js';
 
 /**
- * PilotTestApp - Extends BaseApp
+ * BlogApp - Extends BaseApp
  * Organized and maintainable Express app configuration
  */
-class PilotTestApp extends BaseApp {
+class BlogApp extends BaseApp {
   constructor() {
     super({
-      serviceName: process.env.APP_NAME || 'pilot-test-api',
+      serviceName: process.env.APP_NAME || 'blog-api',
       corsOrigin: env('CORS_ORIGIN', 'http://localhost:3001')
     });
   }
 
-  /**
-   * Override security middleware setup to bypass config service
-   */
-  setupSecurityMiddleware() {
-    // Skip security middleware for pilot test
-    // In production, load actual security config
-  }
-
   /**
    * Setup custom middleware (after body parsers, before routes)
    */
@@ -62,6 +54,6 @@ class PilotTestApp extends BaseApp {
  * Create and configure the Express app
  */
 export function createApp() {
-  const app = new PilotTestApp();
+  const app = new BlogApp();
   return app.build();
 }

package/framework/Console/src/config/database.js

@@ -0,0 +1,53 @@
+/**
+ * Database Configuration
+ * Database connection configuration
+ */
+
+import { env } from '../helpers/env.js';
+
+export const databaseConfig = {
+  connection: env('DB_CONNECTION', 'postgresql'),
+  
+  connections: {
+    postgresql: {
+      client: 'pg',
+      connection: {
+        host: env('POSTGRES_HOST', 'localhost'),
+        port: parseInt(env('POSTGRES_PORT', '5432')),
+        database: env('POSTGRES_DB', 'test-project'),
+        user: env('POSTGRES_USER', 'postgres'),
+        password: env('POSTGRES_PASSWORD', ''),
+      },
+      pool: {
+        min: 2,
+        max: 10,
+      },
+      migrations: {
+        tableName: 'migrations',
+      },
+    },
+    
+    mysql: {
+      client: 'mysql2',
+      connection: {
+        host: env('DB_HOST', 'localhost'),
+        port: parseInt(env('DB_PORT', '3306')),
+        database: env('DB_DATABASE', 'test-project'),
+        user: env('DB_USERNAME', 'root'),
+        password: env('DB_PASSWORD', ''),
+      },
+      pool: {
+        min: 2,
+        max: 10,
+      },
+    },
+    
+    sqlite: {
+      client: 'sqlite3',
+      connection: {
+        filename: env('DB_DATABASE', './database/test-project.sqlite'),
+      },
+      useNullAsDefault: true,
+    },
+  },
+};

package/framework/Console/src/helpers/env.js

@@ -0,0 +1,8 @@
+/**
+ * Environment Helper
+ * Laravel-style env() helper for accessing environment variables
+ */
+
+export function env(key, defaultValue = null) {
+  return process.env[key] !== undefined ? process.env[key] : defaultValue;
+}

package/{apps/pilot-test/api → framework/Console}/src/index.js

@@ -1,5 +1,5 @@
 /**
- * Pilot-test Server
+ * Blog Server
  * Extends BaseServer from framework with database support
  */
 
@@ -13,15 +13,15 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 /**
- * PilotTestServer - Extends BaseServer
+ * BlogServer - Extends BaseServer
  */
-class PilotTestServer extends BaseServer {
+class BlogServer extends BaseServer {
   constructor() {
     // Get project root (2 levels up from apps/{name}/{type})
     const projectRoot = path.resolve(process.cwd(), '../..');
     
     super({
-      appName: process.env.APP_NAME || 'pilot-test-api',
+      appName: process.env.APP_NAME || 'blog-api',
       projectRoot: projectRoot
     });
     
@@ -42,7 +42,7 @@ class PilotTestServer extends BaseServer {
   async initializeDatabase() {
     try {
       // Use root config (centralized)
-      const dbUrl = process.env.DATABASE_URL || 'postgresql://postgres@localhost:5432/pilot-test_db';
+      const dbUrl = process.env.DATABASE_URL || 'postgresql://postgres@localhost:5432/blog_db';
       
       // Create capsule instance (GuruORM)
       const capsule = new Capsule();
@@ -52,7 +52,7 @@ class PilotTestServer extends BaseServer {
         driver: 'pgsql',
         host: process.env.POSTGRES_HOST || 'localhost',
         port: parseInt(process.env.POSTGRES_PORT) || 5432,
-        database: process.env.POSTGRES_DB || 'pilot-test_db',
+        database: process.env.POSTGRES_DB || 'blog_db',
         username: process.env.POSTGRES_USER || 'postgres',
         password: process.env.POSTGRES_PASSWORD || '',
         charset: 'utf8',
@@ -79,15 +79,15 @@ class PilotTestServer extends BaseServer {
       // Set facade application
       Facade.setFacadeApplication(container);
       
-      console.log('[Pilot-testAPI] 🗄️  Database connected');
+      console.log('[BlogAPI] 🗄️  Database connected');
     } catch (error) {
-      console.error('[Pilot-testAPI] ❌ Database connection failed:', error.message);
+      console.error('[BlogAPI] ❌ Database connection failed:', error.message);
       throw error;
     }
   }
 
   /**
-   * Initialize pilot-test-specific services
+   * Initialize blog-specific services
    */
   async initializeServices() {
     // Initialize database first
@@ -95,7 +95,7 @@ class PilotTestServer extends BaseServer {
     
     // Initialize your other services here
     // Example: await initializeStorageService();
-    console.log('[Pilot-testAPI] 📦 Services initialized');
+    console.log('[BlogAPI] 📦 Services initialized');
   }
 
   /**
@@ -108,5 +108,5 @@ class PilotTestServer extends BaseServer {
 }
 
 // Start the server
-const server = new PilotTestServer();
+const server = new BlogServer();
 server.start();

package/{apps/pilot-test/api → framework/Console}/src/middleware/authMiddleware.js

@@ -4,7 +4,7 @@
  */
 
 import { AuthService } from '../services/AuthService.js';
-import { User } from '../models/User.js';
+import { User } from '@test-project/database';
 
 export async function authMiddleware(req, res, next) {
   try {

package/framework/Console/src/routes/index.js

@@ -0,0 +1,16 @@
+/**
+ * Routes Index
+ * Central export for all routes
+ */
+
+import { authRoutes } from './auth.js';
+
+/**
+ * Get all API routes
+ * Returns array of { path, router } objects
+ */
+export function getAllRoutes() {
+  return [
+    { path: '/api/auth', router: authRoutes },
+  ];
+}

package/{apps/pilot-test/api → framework/Console}/src/services/AuthService.js

@@ -5,7 +5,7 @@
 
 import bcrypt from 'bcryptjs';
 import jwt from 'jsonwebtoken';
-import { User } from '../models/User.js';
+import { User } from '@test-project/database';
 
 export class AuthService {
   /**

package/framework/Console/templates/api/app.js.hbs

@@ -0,0 +1,59 @@
+/**
+ * {{pascalCase appName}} API Application
+ * Extends BaseApp from framework for clean architecture
+ */
+
+import { BaseApp } from 'vasuzex';
+import { env } from './helpers/env.js';
+import { errorHandler, notFoundHandler } from './middleware/errorHandler.js';
+import { getAllRoutes } from './routes/index.js';
+
+/**
+ * {{pascalCase appName}}App - Extends BaseApp
+ * Organized and maintainable Express app configuration
+ */
+class {{pascalCase appName}}App extends BaseApp {
+  constructor() {
+    super({
+      serviceName: process.env.APP_NAME || '{{appName}}-api',
+      corsOrigin: env('CORS_ORIGIN', 'http://localhost:3001')
+    });
+  }
+
+  /**
+   * Setup custom middleware (after body parsers, before routes)
+   */
+  setupCustomMiddleware() {
+    // Add your custom middleware here
+    // Example: app.use(requestLogger());
+  }
+
+  /**
+   * Setup API routes
+   */
+  setupRoutes() {
+    const routes = getAllRoutes();
+    routes.forEach(({ path, router, handler }) => {
+      if (handler) {
+        this.express.get(path, handler);
+      } else if (router) {
+        this.registerRoute(path, router);
+      }
+    });
+  }
+
+  /**
+   * Get error handlers
+   */
+  getErrorHandlers() {
+    return { errorHandler, notFoundHandler };
+  }
+}
+
+/**
+ * Create and configure the Express app
+ */
+export function createApp() {
+  const app = new {{pascalCase appName}}App();
+  return app.build();
+}

package/framework/Console/templates/api/config/database.js.hbs

@@ -0,0 +1,53 @@
+/**
+ * Database Configuration
+ * Database connection configuration
+ */
+
+import { env } from '../helpers/env.js';
+
+export const databaseConfig = {
+  connection: env('DB_CONNECTION', 'postgresql'),
+  
+  connections: {
+    postgresql: {
+      client: 'pg',
+      connection: {
+        host: env('POSTGRES_HOST', 'localhost'),
+        port: parseInt(env('POSTGRES_PORT', '5432')),
+        database: env('POSTGRES_DB', '{{projectName}}'),
+        user: env('POSTGRES_USER', 'postgres'),
+        password: env('POSTGRES_PASSWORD', ''),
+      },
+      pool: {
+        min: 2,
+        max: 10,
+      },
+      migrations: {
+        tableName: 'migrations',
+      },
+    },
+    
+    mysql: {
+      client: 'mysql2',
+      connection: {
+        host: env('DB_HOST', 'localhost'),
+        port: parseInt(env('DB_PORT', '3306')),
+        database: env('DB_DATABASE', '{{projectName}}'),
+        user: env('DB_USERNAME', 'root'),
+        password: env('DB_PASSWORD', ''),
+      },
+      pool: {
+        min: 2,
+        max: 10,
+      },
+    },
+    
+    sqlite: {
+      client: 'sqlite3',
+      connection: {
+        filename: env('DB_DATABASE', './database/{{projectName}}.sqlite'),
+      },
+      useNullAsDefault: true,
+    },
+  },
+};

package/framework/Console/templates/api/controllers/AuthController.js.hbs

@@ -0,0 +1,90 @@
+/**
+ * Authentication Controller
+ * Handles user registration, login, and authentication
+ */
+
+import { BaseController } from './BaseController.js';
+import { AuthService } from '../services/AuthService.js';
+import { LoginRequest, RegisterRequest } from '../requests/AuthRequests.js';
+
+export class AuthController extends BaseController {
+  constructor() {
+    super();
+    this.authService = new AuthService();
+  }
+
+  /**
+   * POST /api/auth/register
+   * Register a new user
+   */
+  register = async (req, res) => {
+    try {
+      // Validate request
+      const { error, value } = RegisterRequest.validate(req.body);
+      if (error) {
+        return this.validationError(res, error.details);
+      }
+
+      // Register user
+      const result = await this.authService.register(value);
+
+      return this.success(res, result, 'Registration successful', 201);
+    } catch (error) {
+      console.error('Registration error:', error);
+      return this.error(res, error.message, 400);
+    }
+  };
+
+  /**
+   * POST /api/auth/login
+   * Login user
+   */
+  login = async (req, res) => {
+    try {
+      // Validate request
+      const { error, value } = LoginRequest.validate(req.body);
+      if (error) {
+        return this.validationError(res, error.details);
+      }
+
+      // Login user
+      const result = await this.authService.login(value.email, value.password);
+
+      return this.success(res, result, 'Login successful');
+    } catch (error) {
+      console.error('Login error:', error);
+      return this.unauthorized(res, error.message);
+    }
+  };
+
+  /**
+   * GET /api/auth/me
+   * Get current user
+   */
+  me = async (req, res) => {
+    try {
+      const user = req.user; // Set by auth middleware
+
+      return this.success(res, user, 'User retrieved successfully');
+    } catch (error) {
+      console.error('Get user error:', error);
+      return this.error(res, error.message);
+    }
+  };
+
+  /**
+   * POST /api/auth/logout
+   * Logout user
+   */
+  logout = async (req, res) => {
+    try {
+      // In JWT, logout is handled client-side by removing the token
+      // Here you can add token to blacklist if needed
+
+      return this.success(res, null, 'Logged out successfully');
+    } catch (error) {
+      console.error('Logout error:', error);
+      return this.error(res, error.message);
+    }
+  };
+}

package/framework/Console/templates/api/controllers/BaseController.js.hbs

@@ -0,0 +1,25 @@
+/**
+ * Base Controller
+ * Extends framework Controller with app-specific helpers
+ */
+
+import { Controller } from 'vasuzex';
+
+export class BaseController extends Controller {
+  /**
+   * Paginate response helper
+   */
+  paginate(res, data, total, page = 1, perPage = 15) {
+    const lastPage = Math.ceil(total / perPage);
+    return this.success(res, {
+      items: data,
+      pagination: {
+        total,
+        perPage,
+        currentPage: page,
+        lastPage,
+        hasMore: page < lastPage,
+      },
+    });
+  }
+}

package/framework/Console/templates/api/helpers/env.js.hbs

@@ -0,0 +1,8 @@
+/**
+ * Environment Helper
+ * Laravel-style env() helper for accessing environment variables
+ */
+
+export function env(key, defaultValue = null) {
+  return process.env[key] !== undefined ? process.env[key] : defaultValue;
+}

package/framework/Console/templates/api/middleware/authMiddleware.js.hbs

@@ -0,0 +1,48 @@
+/**
+ * Authentication Middleware
+ * Verify JWT token and attach user to request
+ */
+
+import { AuthService } from '../services/AuthService.js';
+import { User } from '@{{projectName}}/database';
+
+export async function authMiddleware(req, res, next) {
+  try {
+    // Get token from header
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return res.status(401).json({
+        success: false,
+        message: 'No token provided',
+      });
+    }
+
+    const token = authHeader.substring(7); // Remove 'Bearer '
+
+    // Verify token
+    const authService = new AuthService();
+    const decoded = authService.verifyToken(token);
+
+    // Get user
+    const user = await User.findById(decoded.id);
+    if (!user) {
+      return res.status(401).json({
+        success: false,
+        message: 'User not found',
+      });
+    }
+
+    // Remove password
+    delete user.password;
+
+    // Attach user to request
+    req.user = user;
+
+    next();
+  } catch (error) {
+    return res.status(401).json({
+      success: false,
+      message: 'Invalid token',
+    });
+  }
+}

package/framework/Console/templates/api/middleware/errorHandler.js.hbs

@@ -0,0 +1,30 @@
+/**
+ * Global Error Handlers
+ */
+
+/**
+ * 404 Not Found Handler
+ */
+export function notFoundHandler(req, res, next) {
+  res.status(404).json({
+    success: false,
+    message: 'Route not found',
+    path: req.path,
+  });
+}
+
+/**
+ * Global Error Handler
+ */
+export function errorHandler(err, req, res, next) {
+  console.error('Error:', err);
+
+  const statusCode = err.statusCode || err.status || 500;
+  const message = err.message || 'Internal server error';
+
+  res.status(statusCode).json({
+    success: false,
+    message,
+    ...(process.env.APP_ENV === 'development' && { stack: err.stack }),
+  });
+}

package/framework/Console/templates/api/requests/AuthRequests.js.hbs

@@ -0,0 +1,16 @@
+/**
+ * Authentication Request Validators
+ */
+
+import Joi from 'joi';
+
+export const RegisterRequest = Joi.object({
+  name: Joi.string().min(2).max(100).required(),
+  email: Joi.string().email({ tlds: { allow: false } }).required(),
+  password: Joi.string().min(6).required(),
+});
+
+export const LoginRequest = Joi.object({
+  email: Joi.string().email({ tlds: { allow: false } }).required(),
+  password: Joi.string().required(),
+});

package/framework/Console/templates/api/routes/auth.js.hbs

@@ -0,0 +1,20 @@
+/**
+ * Authentication Routes
+ */
+
+import express from 'express';
+import { AuthController } from '../controllers/AuthController.js';
+import { authMiddleware } from '../middleware/authMiddleware.js';
+
+const router = express.Router();
+const authController = new AuthController();
+
+// Public routes
+router.post('/register', authController.register);
+router.post('/login', authController.login);
+
+// Protected routes
+router.get('/me', authMiddleware, authController.me);
+router.post('/logout', authMiddleware, authController.logout);
+
+export const authRoutes = router;

package/framework/Console/templates/api/routes/index.js.hbs

@@ -0,0 +1,16 @@
+/**
+ * Routes Index
+ * Central export for all routes
+ */
+
+import { authRoutes } from './auth.js';
+
+/**
+ * Get all API routes
+ * Returns array of { path, router } objects
+ */
+export function getAllRoutes() {
+  return [
+    { path: '/api/auth', router: authRoutes },
+  ];
+}