vasuzex 2.1.2 → 2.1.4

package/framework/Http/index.js

@@ -3,6 +3,7 @@ export { Response } from './Response.js';
 export { Controller } from './Controller.js';
 export { FormRequest } from './Requests/index.js';
 export { ClientConfigGenerator } from './ClientConfigGenerator.js';
+export { asyncHandler } from './asyncHandler.js';
 export { requestResponseMiddleware } from './Middleware/RequestResponseMiddleware.js';
 export { SecurityMiddleware, createSecurityMiddleware, applySecurityMiddleware } from './Middleware/SecurityMiddleware.js';
 export { MediaServerMiddleware, mediaServer } from './Middleware/MediaServerMiddleware.js';

package/framework/Services/Log/LogManager.js

@@ -156,25 +156,46 @@ export class LogManager {
     return str.charAt(0).toUpperCase() + str.slice(1);
   }
 
+  /**
+   * Filter context based on debug mode
+   * Remove stack trace in production
+   */
+  filterContext(context = {}) {
+    const debugValue = this.app.config('app.debug', false);
+    // Handle string 'false' or 'true' from env
+    const isDebug = debugValue === true || debugValue === 'true';
+    
+    // In debug mode, return full context
+    if (isDebug) {
+      return context;
+    }
+    
+    // In production, remove stack trace
+    const filtered = { ...context };
+    delete filtered.stack;
+    
+    return filtered;
+  }
+
   // Proxy PSR-3 methods to default channel
   emergency(message, context = {}) {
-    return this.channel().emergency(message, context);
+    return this.channel().emergency(message, this.filterContext(context));
   }
 
   alert(message, context = {}) {
-    return this.channel().alert(message, context);
+    return this.channel().alert(message, this.filterContext(context));
   }
 
   critical(message, context = {}) {
-    return this.channel().critical(message, context);
+    return this.channel().critical(message, this.filterContext(context));
   }
 
   error(message, context = {}) {
-    return this.channel().error(message, context);
+    return this.channel().error(message, this.filterContext(context));
   }
 
   warning(message, context = {}) {
-    return this.channel().warning(message, context);
+    return this.channel().warning(message, this.filterContext(context));
   }
 
   notice(message, context = {}) {

package/framework/Services/Log/LogServiceProvider.js

@@ -0,0 +1,48 @@
+import { ServiceProvider } from '../../Foundation/ServiceProvider.js';
+import { LogManager } from './LogManager.js';
+
+/**
+ * Log Service Provider
+ * 
+ * Registers Log service in the application container.
+ * Provides logging capabilities via multiple channels (Console, File, Syslog, Stack).
+ */
+export class LogServiceProvider extends ServiceProvider {
+  /**
+   * Register the service
+   */
+  async register() {
+    this.singleton('log', (app) => {
+      return new LogManager(app);
+    });
+
+    // Create aliases
+    this.alias('logger', 'log');
+    this.alias('Logger', 'log');
+  }
+
+  /**
+   * Bootstrap the service
+   */
+  async boot() {
+    // Initialize default log channel only if config is loaded
+    try {
+      const defaultChannel = this.config('logging.default');
+      if (defaultChannel) {
+        const log = this.make('log');
+        
+        // Pre-create default channel to verify configuration
+        try {
+          log.driver(defaultChannel);
+        } catch (error) {
+          console.error(`[LogServiceProvider] Failed to initialize log channel [${defaultChannel}]:`, error.message);
+        }
+      }
+    } catch (error) {
+      // Config might not be loaded yet - skip initialization
+      // This is fine, log will be initialized on first use
+    }
+  }
+}
+
+export default LogServiceProvider;

package/framework/Services/Log/index.js

@@ -1,4 +1,5 @@
 export { LogManager } from './LogManager.js';
+export { LogServiceProvider } from './LogServiceProvider.js';
 export { Logger } from './Logger.js';
 export { ConsoleLogger } from './Drivers/ConsoleLogger.js';
 export { FileLogger } from './Drivers/FileLogger.js';

package/framework/Services/Mail/MailServiceProvider.js

@@ -0,0 +1,36 @@
+import { ServiceProvider } from '../../Foundation/ServiceProvider.js';
+import { MailManager } from './MailManager.js';
+
+/**
+ * Mail Service Provider
+ * 
+ * Registers Mail service in the application container.
+ * Provides email sending capabilities via multiple drivers (SMTP, SendGrid, SES).
+ */
+export class MailServiceProvider extends ServiceProvider {
+  /**
+   * Register the service
+   */
+  async register() {
+    this.singleton('mail', (app) => {
+      return new MailManager(app);
+    });
+
+    // Create aliases
+    this.alias('mailer', 'mail');
+    this.alias('Mail', 'mail');
+  }
+
+  /**
+   * Bootstrap the service
+   */
+  async boot() {
+    // Mail service is ready to use
+    if (this.config('mail.default')) {
+      const mail = this.make('mail');
+      console.log(`[MailServiceProvider] Mail service initialized with driver: ${this.config('mail.default')}`);
+    }
+  }
+}
+
+export default MailServiceProvider;

package/framework/Services/Mail/index.js

@@ -1 +1,2 @@
 export { MailManager } from './MailManager.js';
+export { MailServiceProvider } from './MailServiceProvider.js';

package/framework/Services/Media/MediaServiceProvider.js

@@ -11,7 +11,7 @@ export class MediaServiceProvider extends ServiceProvider {
    * Register the service provider
    */
   register() {
-    this.app.singleton('media', (app) => {
+    this.singleton('media', (app) => {
       return new MediaManager(app);
     });
   }
@@ -21,7 +21,7 @@ export class MediaServiceProvider extends ServiceProvider {
    */
   boot() {
     // Ensure cache directory exists
-    const media = this.app.make('media');
+    const media = this.make('media');
     
     if (!existsSync(media.cacheDir)) {
       mkdirSync(media.cacheDir, { recursive: true });

package/framework/Services/Payment/PaymentServiceProvider.js

@@ -0,0 +1,35 @@
+import { ServiceProvider } from '../../Foundation/ServiceProvider.js';
+import { PaymentManager } from './PaymentManager.js';
+
+/**
+ * Payment Service Provider
+ * 
+ * Registers Payment service in the application container.
+ * Provides payment gateway capabilities (PhonePe, Razorpay, Stripe).
+ */
+export class PaymentServiceProvider extends ServiceProvider {
+  /**
+   * Register the service
+   */
+  async register() {
+    this.singleton('payment', (app) => {
+      return new PaymentManager(app);
+    });
+
+    // Create aliases
+    this.alias('Payment', 'payment');
+  }
+
+  /**
+   * Bootstrap the service
+   */
+  async boot() {
+    // Payment service is ready to use
+    if (this.config('payment.default')) {
+      const payment = this.make('payment');
+      console.log(`[PaymentServiceProvider] Payment service initialized with gateway: ${this.config('payment.default')}`);
+    }
+  }
+}
+
+export default PaymentServiceProvider;

package/framework/Services/Payment/index.js

@@ -1,5 +1,6 @@
 export { PaymentManager } from "./PaymentManager.js";
 export { PaymentGateway } from "./PaymentGateway.js";
+export { PaymentServiceProvider } from "./PaymentServiceProvider.js";
 export { PhonePeGateway } from "./Gateways/PhonePeGateway.js";
 export { RazorpayGateway } from "./Gateways/RazorpayGateway.js";
 export { StripeGateway } from "./Gateways/StripeGateway.js";

package/framework/Services/Security/SecurityService.js

@@ -0,0 +1,253 @@
+/**
+ * Security Service
+ * Handles JWT, OTP, hashing, and other security-related operations
+ * Laravel-inspired security utilities for Node.js
+ */
+
+import jwt from 'jsonwebtoken';
+import bcrypt from 'bcryptjs';
+import crypto from 'crypto';
+
+export class SecurityService {
+  constructor(config = {}) {
+    this.jwtSecret = config.jwtSecret || process.env.JWT_SECRET || 'your-secret-key';
+    this.jwtExpiresIn = config.jwtExpiresIn || process.env.JWT_EXPIRES_IN || '7d';
+    this.otpLength = config.otpLength || 6;
+    this.otpExpiryMinutes = config.otpExpiryMinutes || 10;
+    this.bcryptRounds = config.bcryptRounds || 10;
+  }
+
+  /**
+   * Generate JWT token
+   * @param {Object} payload - Data to encode in token
+   * @param {string} secret - Optional JWT secret (uses config if not provided)
+   * @param {string|number} expiresIn - Optional expiry time (uses config if not provided)
+   * @returns {string} JWT token
+   */
+  generateToken(payload, secret = null, expiresIn = null) {
+    const jwtSecret = secret || this.jwtSecret;
+    const jwtExpiresIn = expiresIn || this.jwtExpiresIn;
+
+    return jwt.sign(payload, jwtSecret, { expiresIn: jwtExpiresIn });
+  }
+
+  /**
+   * Verify JWT token
+   * @param {string} token - JWT token to verify
+   * @param {string} secret - Optional JWT secret (uses config if not provided)
+   * @returns {Object|null} Decoded payload or null if invalid
+   */
+  verifyToken(token, secret = null) {
+    const jwtSecret = secret || this.jwtSecret;
+    try {
+      return jwt.verify(token, jwtSecret);
+    } catch (error) {
+      console.error('JWT verification failed:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Decode JWT token without verification
+   * @param {string} token - JWT token to decode
+   * @returns {Object|null} Decoded payload or null if invalid
+   */
+  decodeToken(token) {
+    try {
+      return jwt.decode(token);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Generate numeric OTP
+   * @param {number} length - OTP length (default: 6)
+   * @returns {string} OTP code
+   */
+  generateOtp(length = this.otpLength) {
+    const min = Math.pow(10, length - 1);
+    const max = Math.pow(10, length) - 1;
+    return Math.floor(min + Math.random() * (max - min + 1)).toString();
+  }
+
+  /**
+   * Generate alphanumeric OTP
+   * @param {number} length - OTP length
+   * @returns {string} Alphanumeric OTP
+   */
+  generateAlphanumericOtp(length = this.otpLength) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    let otp = '';
+    for (let i = 0; i < length; i++) {
+      otp += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return otp;
+  }
+
+  /**
+   * Hash password using bcrypt
+   * @param {string} password - Plain text password
+   * @returns {Promise<string>} Hashed password
+   */
+  async hashPassword(password) {
+    return await bcrypt.hash(password, this.bcryptRounds);
+  }
+
+  /**
+   * Verify password against hash
+   * @param {string} password - Plain text password
+   * @param {string} hash - Hashed password
+   * @returns {Promise<boolean>} Match result
+   */
+  async verifyPassword(password, hash) {
+    return await bcrypt.compare(password, hash);
+  }
+
+  /**
+   * Generate random string
+   * @param {number} length - String length
+   * @returns {string} Random string
+   */
+  generateRandomString(length = 32) {
+    return crypto.randomBytes(length).toString('hex').substring(0, length);
+  }
+
+  /**
+   * Generate UUID v4
+   * @returns {string} UUID
+   */
+  generateUuid() {
+    return crypto.randomUUID();
+  }
+
+  /**
+   * Hash string using SHA256
+   * @param {string} data - Data to hash
+   * @returns {string} Hash
+   */
+  hash(data) {
+    return crypto.createHash('sha256').update(data).digest('hex');
+  }
+
+  /**
+   * Hash string using MD5
+   * @param {string} data - Data to hash
+   * @returns {string} Hash
+   */
+  md5(data) {
+    return crypto.createHash('md5').update(data).digest('hex');
+  }
+
+  /**
+   * Create HMAC signature
+   * @param {string} data - Data to sign
+   * @param {string} secret - Secret key
+   * @param {string} algorithm - Hash algorithm (default: sha256)
+   * @returns {string} Signature
+   */
+  createHmac(data, secret, algorithm = 'sha256') {
+    return crypto.createHmac(algorithm, secret).update(data).digest('hex');
+  }
+
+  /**
+   * Verify HMAC signature
+   * @param {string} data - Original data
+   * @param {string} signature - Signature to verify
+   * @param {string} secret - Secret key
+   * @param {string} algorithm - Hash algorithm
+   * @returns {boolean} Verification result
+   */
+  verifyHmac(data, signature, secret, algorithm = 'sha256') {
+    const expectedSignature = this.createHmac(data, secret, algorithm);
+    return crypto.timingSafeEqual(
+      Buffer.from(signature),
+      Buffer.from(expectedSignature)
+    );
+  }
+
+  /**
+   * Encrypt data using AES-256-CBC
+   * @param {string} data - Data to encrypt
+   * @param {string} key - Encryption key (32 bytes)
+   * @returns {string} Encrypted data (iv:encrypted format)
+   */
+  encrypt(data, key) {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key.padEnd(32, '0').slice(0, 32)), iv);
+    let encrypted = cipher.update(data, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+  }
+
+  /**
+   * Decrypt data using AES-256-CBC
+   * @param {string} encrypted - Encrypted data (iv:encrypted format)
+   * @param {string} key - Encryption key (32 bytes)
+   * @returns {string} Decrypted data
+   */
+  decrypt(encrypted, key) {
+    const parts = encrypted.split(':');
+    const iv = Buffer.from(parts[0], 'hex');
+    const encryptedData = parts[1];
+    const decipher = crypto.createDecipheriv('aes-256-cbc', Buffer.from(key.padEnd(32, '0').slice(0, 32)), iv);
+    let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+  }
+
+  /**
+   * Mask phone number for display
+   * @param {string} phone - Phone number
+   * @returns {string} Masked phone
+   */
+  maskPhone(phone) {
+    if (phone.length !== 10) return phone;
+    return phone.replace(/(\d{3})\d{4}(\d{3})/, '$1****$2');
+  }
+
+  /**
+   * Mask email for display
+   * @param {string} email - Email address
+   * @returns {string} Masked email
+   */
+  maskEmail(email) {
+    const [username, domain] = email.split('@');
+    if (!username || !domain) return email;
+
+    const maskedUsername =
+      username.length > 2
+        ? `${username[0]}${'*'.repeat(username.length - 2)}${username[username.length - 1]}`
+        : username;
+
+    return `${maskedUsername}@${domain}`;
+  }
+
+  /**
+   * Generate OTP with expiry timestamp
+   * @param {number} length - OTP length
+   * @returns {Object} {otp, expiresAt}
+   */
+  generateOtpWithExpiry(length = this.otpLength) {
+    const otp = this.generateOtp(length);
+    const expiresAt = new Date(Date.now() + this.otpExpiryMinutes * 60 * 1000);
+    return { otp, expiresAt };
+  }
+
+  /**
+   * Verify OTP with expiry check
+   * @param {string} inputOtp - User input OTP
+   * @param {string} storedOtp - Stored OTP
+   * @param {Date} expiresAt - Expiry timestamp
+   * @returns {Object} {valid, expired}
+   */
+  verifyOtp(inputOtp, storedOtp, expiresAt) {
+    const now = new Date();
+    const expired = now > new Date(expiresAt);
+    const valid = inputOtp === storedOtp;
+
+    return { valid: valid && !expired, expired };
+  }
+}
+
+export default SecurityService;

package/framework/Services/Security/SecurityServiceProvider.js

@@ -0,0 +1,33 @@
+/**
+ * Security Service Provider
+ * Registers security service in the application container
+ */
+
+import { ServiceProvider } from '../../Foundation/ServiceProvider.js';
+import { SecurityService } from './SecurityService.js';
+
+export class SecurityServiceProvider extends ServiceProvider {
+  /**
+   * Register security service
+   */
+  async register() {
+    this.app.singleton('security', () => {
+      return new SecurityService({
+        jwtSecret: this.app.config('app.key') || this.app.config('security.jwt.secret'),
+        jwtExpiresIn: this.app.config('security.jwt.expiresIn') || '7d',
+        otpLength: this.app.config('security.otp.length') || 6,
+        otpExpiryMinutes: this.app.config('security.otp.expiryMinutes') || 10,
+        bcryptRounds: this.app.config('security.bcrypt.rounds') || 10,
+      });
+    });
+  }
+
+  /**
+   * Boot security service
+   */
+  async boot() {
+    // Security service is ready
+  }
+}
+
+export default SecurityServiceProvider;

package/framework/Services/Security/index.js

@@ -0,0 +1,9 @@
+/**
+ * Security Service Module
+ * JWT, OTP, Hashing, and Security utilities
+ */
+
+export { SecurityService } from './SecurityService.js';
+export { SecurityServiceProvider } from './SecurityServiceProvider.js';
+import { SecurityService } from './SecurityService.js';
+export default SecurityService;

package/framework/Services/Storage/StorageManager.js

@@ -24,6 +24,7 @@
 
 import { LocalStorageProvider } from './Providers/LocalStorageProvider.js';
 import { S3StorageProvider } from './Providers/S3StorageProvider.js';
+import path from 'path';
 
 export class StorageManager {
   /**
@@ -93,7 +94,12 @@ export class StorageManager {
    * @private
    */
   createLocalDriver(config) {
-    return new LocalStorageProvider(config);
+    // Resolve root path relative to app's rootDir
+    const resolvedConfig = { ...config };
+    if (config.root && !path.isAbsolute(config.root)) {
+      resolvedConfig.root = path.resolve(this.app.rootDir, config.root);
+    }
+    return new LocalStorageProvider(resolvedConfig);
   }
 
   /**

package/framework/Services/Storage/StorageServiceProvider.js

@@ -0,0 +1,36 @@
+import { ServiceProvider } from '../../Foundation/ServiceProvider.js';
+import { StorageManager } from './StorageManager.js';
+
+/**
+ * Storage Service Provider
+ * 
+ * Registers Storage service in the application container.
+ * Provides file storage capabilities via multiple drivers (Local, S3, MinIO).
+ */
+export class StorageServiceProvider extends ServiceProvider {
+  /**
+   * Register the service
+   */
+  async register() {
+    this.singleton('storage', (app) => {
+      return new StorageManager(app);
+    });
+
+    // Create aliases
+    this.alias('filesystem', 'storage');
+    this.alias('Storage', 'storage');
+  }
+
+  /**
+   * Bootstrap the service
+   */
+  async boot() {
+    // Storage service is ready to use
+    if (this.config('filesystems.default')) {
+      const storage = this.make('storage');
+      console.log(`[StorageServiceProvider] Storage service initialized with driver: ${this.config('filesystems.default')}`);
+    }
+  }
+}
+
+export default StorageServiceProvider;

package/framework/Services/Storage/index.js

@@ -1,2 +1,3 @@
 export { StorageManager } from './StorageManager.js';
+export { StorageServiceProvider } from './StorageServiceProvider.js';
 export * from './Providers/index.js';