vasuzex 2.1.2 → 2.1.4

package/bin/create-vasuzex.js

@@ -368,8 +368,6 @@ async function generateEnvFile(projectName, answers, targetDir, spinner) {
   let envContent = `# Application
 APP_NAME=${projectName}
 APP_ENV=development
-APP_PORT=3000
-APP_URL=http://localhost:3000
 
 # Database
 DB_CONNECTION=${answers.database.toLowerCase() === 'postgresql' ? 'postgresql' : answers.database.toLowerCase()}
@@ -406,6 +404,11 @@ CACHE_DRIVER=memory
 # Session
 SESSION_DRIVER=memory
 
+# CORS (will be overridden by app-specific .env files)
+CORS_ORIGIN=*
+CORS_METHODS=GET,HEAD,PUT,PATCH,POST,DELETE
+CORS_CREDENTIALS=true
+
 # Logging
 LOG_LEVEL=debug
 LOG_FILE=storage/logs/app.log

package/examples/runtime-config-examples.js

@@ -0,0 +1,309 @@
+/**
+ * Runtime Config Examples (Laravel-Style)
+ * On-the-fly config get/set in Vasuzex-v2
+ * 
+ * EXACTLY like Laravel's Config facade!
+ */
+
+import { Application } from '../framework/Foundation/Application.js';
+
+/**
+ * Example 1: Basic Get/Set
+ */
+async function example1_basicGetSet() {
+  console.log('\n=== Example 1: Basic Get/Set ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  
+  // Laravel: Config::get('app.name')
+  console.log('Original app name:', app.config('app.name'));
+  
+  // Laravel: Config::set('app.name', 'New Name')
+  const config = app.make('config');
+  config.set('app.name', 'Neastore Runtime Update!');
+  
+  console.log('Updated app name:', app.config('app.name'));
+  
+  // Set with dot notation
+  config.set('app.custom_setting', 'My Custom Value');
+  console.log('Custom setting:', app.config('app.custom_setting'));
+}
+
+/**
+ * Example 2: Nested Config Updates
+ */
+async function example2_nestedConfig() {
+  console.log('\n=== Example 2: Nested Config Updates ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Original database config
+  console.log('Original DB host:', app.config('database.connections.postgresql.host'));
+  
+  // Update nested value
+  config.set('database.connections.postgresql.host', 'db.example.com');
+  config.set('database.connections.postgresql.port', 5433);
+  
+  console.log('Updated DB host:', app.config('database.connections.postgresql.host'));
+  console.log('Updated DB port:', app.config('database.connections.postgresql.port'));
+  
+  // Add new connection on-the-fly
+  config.set('database.connections.mongodb', {
+    driver: 'mongodb',
+    host: 'localhost',
+    port: 27017,
+    database: 'neastore'
+  });
+  
+  console.log('New MongoDB config:', app.config('database.connections.mongodb'));
+}
+
+/**
+ * Example 3: Bulk Updates
+ */
+async function example3_bulkUpdates() {
+  console.log('\n=== Example 3: Bulk Config Updates ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Laravel: Config::set(['key1' => 'val1', 'key2' => 'val2'])
+  config.set({
+    'app.debug': false,
+    'app.timezone': 'Asia/Kolkata',
+    'app.locale': 'hi',
+    'cache.default': 'redis'
+  });
+  
+  console.log('Debug mode:', app.config('app.debug'));
+  console.log('Timezone:', app.config('app.timezone'));
+  console.log('Locale:', app.config('app.locale'));
+  console.log('Cache driver:', app.config('cache.default'));
+}
+
+/**
+ * Example 4: Array Operations
+ */
+async function example4_arrayOperations() {
+  console.log('\n=== Example 4: Array Operations ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Create array config
+  config.set('app.allowed_hosts', ['localhost', '127.0.0.1']);
+  console.log('Initial hosts:', app.config('app.allowed_hosts'));
+  
+  // Push new value (Laravel: Config::push())
+  config.push('app.allowed_hosts', 'example.com');
+  console.log('After push:', app.config('app.allowed_hosts'));
+  
+  // Prepend value (Laravel: Config::prepend())
+  config.prepend('app.allowed_hosts', 'app.local');
+  console.log('After prepend:', app.config('app.allowed_hosts'));
+}
+
+/**
+ * Example 5: Runtime Feature Flags
+ */
+async function example5_featureFlags() {
+  console.log('\n=== Example 5: Runtime Feature Flags ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Enable/disable features at runtime
+  config.set('features.new_checkout', true);
+  config.set('features.beta_ui', false);
+  config.set('features.payment_gateway_v2', true);
+  
+  // Use in code
+  if (app.config('features.new_checkout')) {
+    console.log('✅ New checkout enabled');
+  }
+  
+  if (!app.config('features.beta_ui')) {
+    console.log('❌ Beta UI disabled');
+  }
+  
+  console.log('All features:', app.config('features'));
+}
+
+/**
+ * Example 6: API/Controller Usage
+ */
+async function example6_controllerUsage() {
+  console.log('\n=== Example 6: Controller Usage ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  
+  // Simulate controller/service accessing config
+  class UserService {
+    constructor(app) {
+      this.app = app;
+      this.config = app.make('config');
+    }
+    
+    getMaxLoginAttempts() {
+      // Get with default
+      return this.app.config('auth.max_login_attempts', 5);
+    }
+    
+    setMaxLoginAttempts(attempts) {
+      this.config.set('auth.max_login_attempts', attempts);
+    }
+    
+    enableTwoFactor() {
+      this.config.set('auth.two_factor_enabled', true);
+      console.log('✅ Two-factor authentication enabled');
+    }
+  }
+  
+  const userService = new UserService(app);
+  
+  console.log('Max login attempts:', userService.getMaxLoginAttempts());
+  
+  userService.setMaxLoginAttempts(3);
+  console.log('Updated max attempts:', userService.getMaxLoginAttempts());
+  
+  userService.enableTwoFactor();
+  console.log('2FA enabled:', app.config('auth.two_factor_enabled'));
+}
+
+/**
+ * Example 7: Check if Config Exists
+ */
+async function example7_checkExists() {
+  console.log('\n=== Example 7: Check Config Exists ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Laravel: Config::has('key')
+  console.log('Has app.name?', config.has('app.name'));
+  console.log('Has app.nonexistent?', config.has('app.nonexistent'));
+  
+  // Set and check
+  config.set('temp.test', 'value');
+  console.log('Has temp.test?', config.has('temp.test'));
+}
+
+/**
+ * Example 8: Get All Config
+ */
+async function example8_getAllConfig() {
+  console.log('\n=== Example 8: Get All Config ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Laravel: Config::all()
+  const allConfig = config.all();
+  console.log('All config keys:', Object.keys(allConfig));
+  
+  // Get multiple values
+  const values = config.get(['app.name', 'app.env', 'app.debug']);
+  console.log('Multiple values:', values);
+}
+
+/**
+ * Example 9: Merge Config
+ */
+async function example9_mergeConfig() {
+  console.log('\n=== Example 9: Merge Config ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Merge new config section
+  config.merge({
+    payment: {
+      gateway: 'razorpay',
+      key: 'rzp_test_xxx',
+      webhook_secret: 'whsec_xxx'
+    }
+  });
+  
+  console.log('Payment config:', app.config('payment'));
+  console.log('Payment gateway:', app.config('payment.gateway'));
+}
+
+/**
+ * Example 10: Real-World - Dynamic CORS Update
+ */
+async function example10_dynamicCORS() {
+  console.log('\n=== Example 10: Dynamic CORS Update ===\n');
+  
+  const app = new Application(process.cwd());
+  await app.bootstrap();
+  const config = app.make('config');
+  
+  // Original CORS origin
+  console.log('Original CORS:', app.config('cors.origin'));
+  
+  // Add new allowed origin at runtime
+  const currentOrigins = app.config('cors.origin', []);
+  const newOrigins = Array.isArray(currentOrigins) 
+    ? currentOrigins 
+    : [currentOrigins];
+  
+  newOrigins.push('https://admin.example.com');
+  config.set('cors.origin', newOrigins);
+  
+  console.log('Updated CORS origins:', app.config('cors.origin'));
+  
+  // Update methods
+  config.set('cors.methods', 'GET,POST,PUT,DELETE,OPTIONS,PATCH');
+  console.log('Updated methods:', app.config('cors.methods'));
+}
+
+/**
+ * Run all examples
+ */
+async function runAllExamples() {
+  try {
+    await example1_basicGetSet();
+    await example2_nestedConfig();
+    await example3_bulkUpdates();
+    await example4_arrayOperations();
+    await example5_featureFlags();
+    await example6_controllerUsage();
+    await example7_checkExists();
+    await example8_getAllConfig();
+    await example9_mergeConfig();
+    await example10_dynamicCORS();
+    
+    console.log('\n✅ All examples completed successfully!\n');
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    console.error(error.stack);
+  }
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runAllExamples();
+}
+
+export {
+  example1_basicGetSet,
+  example2_nestedConfig,
+  example3_bulkUpdates,
+  example4_arrayOperations,
+  example5_featureFlags,
+  example6_controllerUsage,
+  example7_checkExists,
+  example8_getAllConfig,
+  example9_mergeConfig,
+  example10_dynamicCORS
+};

package/framework/Config/DatabaseConfigService.js

@@ -0,0 +1,348 @@
+/**
+ * DatabaseConfigService
+ * Loads runtime configurations from database (app_configs and system_configs tables)
+ * and merges them into the ConfigRepository
+ * 
+ * Similar to Laravel's database-driven config but integrated with Vasuzex's ConfigRepository
+ * 
+ * @example
+ * import { DatabaseConfigService } from '#framework/Config/DatabaseConfigService.js';
+ * 
+ * const dbConfigService = new DatabaseConfigService(app);
+ * await dbConfigService.load();
+ * 
+ * // Now access via config()
+ * app.config('phonepe.merchantId'); // From database
+ * app.config('app.name'); // From file-based config
+ */
+
+export class DatabaseConfigService {
+  /**
+   * Application instance
+   * @private
+   */
+  #app = null;
+
+  /**
+   * Cache for database configs
+   * @private
+   */
+  #cache = {
+    appConfigs: null,
+    systemConfigs: null,
+    lastLoadTime: null,
+  };
+
+  /**
+   * Cache duration in milliseconds (5 minutes)
+   * @private
+   */
+  #cacheDuration = 5 * 60 * 1000;
+
+  /**
+   * Current environment
+   * @private
+   */
+  #environment = 'all';
+
+  /**
+   * Create a new database config service
+   * @param {Application} app - Application instance
+   * @param {Object} options - Service options
+   */
+  constructor(app, options = {}) {
+    this.#app = app;
+    this.#environment = options.environment || process.env.NODE_ENV || 'development';
+    this.#cacheDuration = options.cacheDuration || this.#cacheDuration;
+  }
+
+  /**
+   * Load database configs and merge into ConfigRepository
+   * @returns {Promise<void>}
+   */
+  async load() {
+    try {
+      // Check if cache is valid
+      if (this.#isCacheValid()) {
+        console.log('[DatabaseConfigService] Using cached configs');
+        this.#mergeIntoConfigRepository();
+        return;
+      }
+
+      console.log('[DatabaseConfigService] Loading configs from database...');
+
+      // Load configs from database
+      await this.#loadAppConfigs();
+      await this.#loadSystemConfigs();
+
+      // Update cache timestamp
+      this.#cache.lastLoadTime = Date.now();
+
+      // Merge into ConfigRepository
+      this.#mergeIntoConfigRepository();
+
+      console.log('[DatabaseConfigService] Configs loaded successfully');
+    } catch (error) {
+      console.error('[DatabaseConfigService] Failed to load configs:', error.message);
+      // Don't throw - app should still work with file-based configs
+    }
+  }
+
+  /**
+   * Reload configs from database (bypass cache)
+   * @returns {Promise<void>}
+   */
+  async reload() {
+    this.#cache.lastLoadTime = null;
+    await this.load();
+  }
+
+  /**
+   * Get config value directly from database (bypass ConfigRepository)
+   * @param {string} key - Config key
+   * @param {*} defaultValue - Default value
+   * @returns {Promise<*>}
+   */
+  async getDirect(key, defaultValue = null) {
+    // Try app_configs first
+    const AppConfig = await this.#getModel('AppConfig');
+    if (AppConfig) {
+      const value = await AppConfig.getValue(key, this.#environment, null);
+      if (value !== null) {
+        return value;
+      }
+    }
+
+    // Try system_configs
+    const SystemConfig = await this.#getModel('SystemConfig');
+    if (SystemConfig) {
+      const value = await SystemConfig.getValue(key, this.#environment, null);
+      if (value !== null) {
+        return value;
+      }
+    }
+
+    return defaultValue;
+  }
+
+  /**
+   * Set config value in database
+   * @param {string} key - Config key
+   * @param {*} value - Config value
+   * @param {Object} options - Additional options (category, description, etc.)
+   * @returns {Promise<void>}
+   */
+  async set(key, value, options = {}) {
+    const {
+      type = 'app', // 'app' or 'system'
+      category = 'app',
+      description = '',
+      is_public = false,
+      is_active = true,
+      environment = this.#environment,
+    } = options;
+
+    const Model = await this.#getModel(type === 'app' ? 'AppConfig' : 'SystemConfig');
+
+    if (!Model) {
+      throw new Error(`Model not found for type: ${type}`);
+    }
+
+    await Model.setValue(key, value, {
+      category,
+      description,
+      is_public,
+      is_active,
+      environment,
+    });
+
+    // Invalidate cache
+    this.#cache.lastLoadTime = null;
+
+    // Reload configs
+    await this.load();
+  }
+
+  /**
+   * Delete config from database
+   * @param {string} key - Config key
+   * @param {string} type - Config type ('app' or 'system')
+   * @returns {Promise<boolean>}
+   */
+  async delete(key, type = 'app') {
+    const Model = await this.#getModel(type === 'app' ? 'AppConfig' : 'SystemConfig');
+
+    if (!Model) {
+      return false;
+    }
+
+    const result = await Model.deleteByKey(key, this.#environment);
+
+    // Invalidate cache
+    this.#cache.lastLoadTime = null;
+
+    return result;
+  }
+
+  /**
+   * Get all database configs as object
+   * @returns {Object}
+   */
+  getAllDatabaseConfigs() {
+    return {
+      app: this.#cache.appConfigs || {},
+      system: this.#cache.systemConfigs || {},
+    };
+  }
+
+  /**
+   * Load app_configs from database
+   * @private
+   */
+  async #loadAppConfigs() {
+    const AppConfig = await this.#getModel('AppConfig');
+
+    if (!AppConfig) {
+      console.warn('[DatabaseConfigService] AppConfig model not found');
+      this.#cache.appConfigs = {};
+      return;
+    }
+
+    const configs = await AppConfig.getAllAsObject(this.#environment);
+    this.#cache.appConfigs = configs;
+  }
+
+  /**
+   * Load system_configs from database
+   * @private
+   */
+  async #loadSystemConfigs() {
+    const SystemConfig = await this.#getModel('SystemConfig');
+
+    if (!SystemConfig) {
+      console.warn('[DatabaseConfigService] SystemConfig model not found');
+      this.#cache.systemConfigs = {};
+      return;
+    }
+
+    const configs = await SystemConfig.getAllAsObject(this.#environment);
+    this.#cache.systemConfigs = configs;
+  }
+
+  /**
+   * Merge database configs into ConfigRepository
+   * @private
+   */
+  #mergeIntoConfigRepository() {
+    const config = this.#app.make('config');
+
+    if (!config) {
+      throw new Error('[DatabaseConfigService] ConfigRepository not found in container');
+    }
+
+    // Merge app_configs
+    if (this.#cache.appConfigs) {
+      for (const [key, value] of Object.entries(this.#cache.appConfigs)) {
+        config.set(key, value);
+      }
+    }
+
+    // Merge system_configs
+    if (this.#cache.systemConfigs) {
+      for (const [key, value] of Object.entries(this.#cache.systemConfigs)) {
+        config.set(key, value);
+      }
+    }
+  }
+
+  /**
+   * Check if cache is still valid
+   * @private
+   */
+  #isCacheValid() {
+    if (!this.#cache.lastLoadTime) {
+      return false;
+    }
+
+    const elapsed = Date.now() - this.#cache.lastLoadTime;
+    return elapsed < this.#cacheDuration;
+  }
+
+  /**
+   * Get model from container or require it
+   * @private
+   */
+  async #getModel(modelName) {
+    try {
+      // Try to get from container first
+      if (this.#app.has(modelName)) {
+        return this.#app.make(modelName);
+      }
+
+      // Dynamic import needs path module
+      const path = await import('path');
+      const { fileURLToPath } = await import('url');
+      
+      // Try to require dynamically from project's database/models/
+      const cwd = process.cwd();
+      
+      // Try multiple paths to find models
+      const possiblePaths = [
+        path.default.join(cwd, 'database', 'models', `${modelName}.js`), // If cwd is monorepo root
+        path.default.join(cwd, '..', '..', '..', 'database', 'models', `${modelName}.js`), // If cwd is apps/*/api
+        path.default.join(cwd, '..', '..', 'database', 'models', `${modelName}.js`), // If cwd is apps/*
+      ];
+      
+      let Model = null;
+      for (const modelPath of possiblePaths) {
+        try {
+          const module = await import(modelPath);
+          Model = module.default || module[modelName];
+          if (Model) {
+            console.log(`[DatabaseConfigService] Loaded ${modelName} from ${modelPath}`);
+            break;
+          }
+        } catch (err) {
+          // Try next path
+        }
+      }
+      
+      if (!Model) {
+        throw new Error(`Model ${modelName} not found in paths: ${possiblePaths.join(', ')}`);
+      }
+      
+      return Model;
+    } catch (error) {
+      console.warn(`[DatabaseConfigService] Could not load model ${modelName}:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.#cache = {
+      appConfigs: null,
+      systemConfigs: null,
+      lastLoadTime: null,
+    };
+  }
+
+  /**
+   * Get cache statistics
+   * @returns {Object}
+   */
+  getCacheStats() {
+    return {
+      isValid: this.#isCacheValid(),
+      lastLoadTime: this.#cache.lastLoadTime,
+      appConfigsCount: Object.keys(this.#cache.appConfigs || {}).length,
+      systemConfigsCount: Object.keys(this.#cache.systemConfigs || {}).length,
+      cacheAge: this.#cache.lastLoadTime ? Date.now() - this.#cache.lastLoadTime : null,
+      cacheDuration: this.#cacheDuration,
+    };
+  }
+}
+
+export default DatabaseConfigService;