vasuzex 2.1.2 → 2.1.4

package/framework/Config/DatabaseConfigServiceProvider.js

@@ -0,0 +1,69 @@
+/**
+ * DatabaseConfigServiceProvider
+ * Service provider for database-driven configuration
+ * 
+ * Loads configurations from database (app_configs and system_configs)
+ * and merges them into the ConfigRepository during boot phase
+ * 
+ * @example
+ * // In app.js
+ * import { DatabaseConfigServiceProvider } from '#framework/Config/DatabaseConfigServiceProvider.js';
+ * 
+ * const providers = [
+ *   DatabaseConfigServiceProvider,
+ *   // ... other providers
+ * ];
+ */
+
+import { ServiceProvider } from '../Foundation/ServiceProvider.js';
+import { DatabaseConfigService } from './DatabaseConfigService.js';
+
+export class DatabaseConfigServiceProvider extends ServiceProvider {
+  /**
+   * Register services in the container
+   */
+  register() {
+    // Register DatabaseConfigService as singleton
+    this.singleton('db.config', (app) => {
+      const environment = process.env.NODE_ENV || 'development';
+      
+      return new DatabaseConfigService(app, {
+        environment,
+        cacheDuration: 5 * 60 * 1000, // 5 minutes
+      });
+    });
+
+    // Create alias for convenience
+    this.alias('database.config', 'db.config');
+  }
+
+  /**
+   * Bootstrap services
+   * Load database configs and merge into ConfigRepository
+   */
+  async boot() {
+    try {
+      const dbConfigService = this.make('db.config');
+      
+      // Load configs from database
+      await dbConfigService.load();
+      
+      console.log('[DatabaseConfigServiceProvider] Database configs loaded');
+      
+      // Log cache stats in debug mode
+      if (this.config('app.debug', false)) {
+        const stats = dbConfigService.getCacheStats();
+        console.log('[DatabaseConfigServiceProvider] Cache stats:', {
+          appConfigs: stats.appConfigsCount,
+          systemConfigs: stats.systemConfigsCount,
+          cacheValid: stats.isValid,
+        });
+      }
+    } catch (error) {
+      console.error('[DatabaseConfigServiceProvider] Failed to load database configs:', error.message);
+      // Don't throw - app should continue with file-based configs
+    }
+  }
+}
+
+export default DatabaseConfigServiceProvider;

package/framework/Console/Commands/generate-app.js

@@ -5,6 +5,8 @@
  */
 
 import { join } from 'path';
+import { readdirSync, existsSync, readFileSync } from 'fs';
+import { GENERATOR_CONFIG } from '../config/generator.config.js';
 import {
   // File Operations
   getAppPath,
@@ -38,6 +40,62 @@ import {
   displayWebNextSteps,
 } from './utils/index.js';
 
+/**
+ * Get next available port for app type by checking existing apps
+ * API apps: start from 3000 and increment (3000, 3001, 3002...)
+ * Web apps: start from 4000 and increment (4000, 4001, 4002...)
+ */
+function getNextAvailablePort(type) {
+  const projectRoot = process.cwd();
+  const appsDir = join(projectRoot, 'apps');
+  
+  // Starting ports based on type
+  const startPort = type === 'api' ? GENERATOR_CONFIG.ports.apiStart : GENERATOR_CONFIG.ports.webStart;
+  
+  // If apps directory doesn't exist, return start port
+  if (!existsSync(appsDir)) {
+    return startPort;
+  }
+  
+  // Get all existing apps and their ports
+  const usedPorts = new Set();
+  
+  try {
+    const appFolders = readdirSync(appsDir, { withFileTypes: true })
+      .filter(dirent => dirent.isDirectory())
+      .map(dirent => dirent.name);
+    
+    // Check each app folder for app type subdirectories
+    for (const appFolder of appFolders) {
+      const appTypePath = join(appsDir, appFolder, type);
+      const envPath = join(appTypePath, '.env');
+      
+      if (existsSync(envPath)) {
+        try {
+          const envContent = readFileSync(envPath, 'utf8');
+          const portMatch = envContent.match(/APP_PORT=(\d+)/);
+          if (portMatch) {
+            usedPorts.add(parseInt(portMatch[1]));
+          }
+        } catch (err) {
+          // Skip if can't read file
+        }
+      }
+    }
+  } catch (err) {
+    // If can't read apps directory, return start port
+    return startPort;
+  }
+  
+  // Find next available port starting from startPort
+  let nextPort = startPort;
+  while (usedPorts.has(nextPort)) {
+    nextPort++;
+  }
+  
+  return nextPort;
+}
+
 /**
  * Main generate app function
  */
@@ -163,8 +221,8 @@ async function generateWebApp(name, targetDir, framework) {
 }
 
 /**
- * Generate common files (package.json, README, .gitignore)
- * NO .env files at app level - all config is centralized at root!
+ * Generate common files (package.json, README, .gitignore, .env)
+ * App-specific .env with APP_PORT/APP_URL based on app type
  */
 async function generateCommonFiles(name, type, targetDir, framework) {
   // package.json
@@ -184,6 +242,41 @@ async function generateCommonFiles(name, type, targetDir, framework) {
     generateGitignoreTemplate()
   );
   
-  // NOTE: NO .env files here!
-  // All configuration is in root .env file (Laravel monorepo style)
+  // App-specific .env file with correct port from GENERATOR_CONFIG
+  await generateAppEnvFile(name, type, targetDir);
+}
+
+/**
+ * Generate app-specific .env file with APP_PORT and APP_URL
+ * Automatically finds next available port for the app type
+ */
+async function generateAppEnvFile(name, type, targetDir) {
+  // Get next available port based on app type (auto-increment)
+  const port = getNextAvailablePort(type);
+  
+  console.log(`📌 Assigning port ${port} to ${name} ${type}`);
+  
+  let envContent = `# ${name.toUpperCase()} ${type.toUpperCase()} Configuration
+APP_PORT=${port}
+APP_URL=http://localhost:${port}
+`;
+  
+  // For API apps, add CORS_ORIGIN pointing to corresponding web app port
+  if (type === 'api') {
+    const webPort = getNextAvailablePort('web');
+    envContent += `
+# CORS Configuration
+CORS_ORIGIN=http://localhost:${webPort}
+`;
+  }
+  
+  await writeFileContent(
+    join(targetDir, '.env'),
+    envContent
+  );
+  
+  await writeFileContent(
+    join(targetDir, '.env.example'),
+    envContent
+  );
 }

package/framework/Console/Commands/generate-media-server.js

@@ -4,6 +4,7 @@
  */
 
 import { join } from 'path';
+import { GENERATOR_CONFIG } from '../config/generator.config.js';
 import {
   // File Operations
   getProjectRoot,
@@ -36,7 +37,7 @@ import {
  * Main generate media server function
  */
 export async function generateMediaServer(options) {
-  const port = options.port || '4003';
+  const port = options.port || '5000'; // Media server is static service, hard-coded port
   const targetDir = join(getProjectRoot(), 'apps', 'media-server');
 
   console.log('🖼️  Generating Media Server...\n');

package/framework/Console/Commands/utils/mediaServerTemplates.js

@@ -9,7 +9,7 @@
 export function generateMediaServerConfigTemplate(port) {
   return `module.exports = {
   name: 'media-server',
-  port: process.env.MEDIA_SERVER_PORT || ${port},
+  port: process.env.APP_PORT || ${port},
   env: process.env.NODE_ENV || 'development',
   debug: process.env.NODE_ENV !== 'production',
 };
@@ -21,7 +21,8 @@ export function generateMediaServerConfigTemplate(port) {
  */
 export function generateMediaServerEnvTemplate(port) {
   return `# Media Server Configuration
-MEDIA_SERVER_PORT=${port}
+APP_PORT=${port}
+APP_URL=http://localhost:${port}
 
 # Storage Configuration (uses framework's storage config)
 STORAGE_DRIVER=local

package/framework/Console/Commands/utils/webStructure.js

@@ -135,44 +135,53 @@ export async function generateSvelteApp(targetDir, appName) {
  */
 function generateViteConfig(framework) {
   if (framework === 'react') {
-    return `import { defineConfig } from 'vite';
+    return `import { defineConfig, loadEnv } from 'vite';
 import react from '@vitejs/plugin-react';
 import path from 'path';
 
-export default defineConfig({
-  plugins: [react()],
-  cacheDir: path.resolve(__dirname, '../../../node_modules/.vite'),
-  server: {
-    port: 3001,
-  },
+export default defineConfig(({ mode }) => {
+  const env = loadEnv(mode, process.cwd(), '');
+  return {
+    plugins: [react()],
+    cacheDir: path.resolve(__dirname, '../../../node_modules/.vite'),
+    server: {
+      port: parseInt(env.APP_PORT) || 4000,
+    },
+  };
 });`;
   }
   
   if (framework === 'vue') {
-    return `import { defineConfig } from 'vite';
+    return `import { defineConfig, loadEnv } from 'vite';
 import vue from '@vitejs/plugin-vue';
 import path from 'path';
 
-export default defineConfig({
-  plugins: [vue()],
-  cacheDir: path.resolve(__dirname, '../../../node_modules/.vite'),
-  server: {
-    port: 3001,
-  },
+export default defineConfig(({ mode }) => {
+  const env = loadEnv(mode, process.cwd(), '');
+  return {
+    plugins: [vue()],
+    cacheDir: path.resolve(__dirname, '../../../node_modules/.vite'),
+    server: {
+      port: parseInt(env.APP_PORT) || 4000,
+    },
+  };
 });`;
   }
   
   if (framework === 'svelte') {
-    return `import { defineConfig } from 'vite';
+    return `import { defineConfig, loadEnv } from 'vite';
 import { svelte } from '@sveltejs/vite-plugin-svelte';
 import path from 'path';
 
-export default defineConfig({
-  plugins: [svelte()],
-  cacheDir: path.resolve(__dirname, '../../../node_modules/.vite'),
-  server: {
-    port: 3001,
-  },
+export default defineConfig(({ mode }) => {
+  const env = loadEnv(mode, process.cwd(), '');
+  return {
+    plugins: [svelte()],
+    cacheDir: path.resolve(__dirname, '../../../node_modules/.vite'),
+    server: {
+      port: parseInt(env.APP_PORT) || 4000,
+    },
+  };
 });`;
   }
   

package/framework/Console/config/generator.config.js

@@ -19,9 +19,9 @@ export const GENERATOR_CONFIG = {
 
   // Default Ports
   ports: {
-    api: 3000,
-    web: 3001,
-    mediaServer: 4003,
+    apiStart: 3000,      // API apps start from 3000 and auto-increment
+    webStart: 4000,      // Web apps start from 4000 and auto-increment  
+    mediaServer: 5000,   // Media server is static service (hard-coded)
   },
 
   // Database Defaults

package/framework/Console/plopfile.js

@@ -113,14 +113,6 @@ export default function (plop) {
         skipIfExists: true
       });
       
-      // Config
-      actions.push({
-        type: 'add',
-        path: `${basePath}/src/config/database.js`,
-        templateFile: 'templates/api/config/database.js.hbs',
-        skipIfExists: true
-      });
-      
       // Main app files
       actions.push({
         type: 'add',

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

@@ -14,10 +14,11 @@ import { getAllRoutes } from './routes/index.js';
  * Organized and maintainable Express app configuration
  */
 class {{pascalCase appName}}App extends BaseApp {
-  constructor() {
+  constructor(projectRoot) {
     super({
       serviceName: process.env.APP_NAME || '{{appName}}-api',
-      corsOrigin: env('CORS_ORIGIN', 'http://localhost:3001')
+      corsOrigin: env('CORS_ORIGIN', '*'),
+      projectRoot: projectRoot
     });
     
     // Register service providers
@@ -65,7 +66,7 @@ class {{pascalCase appName}}App extends BaseApp {
 /**
  * Create and configure the Express app
  */
-export function createApp() {
-  const app = new {{pascalCase appName}}App();
+export function createApp(projectRoot) {
+  const app = new {{pascalCase appName}}App(projectRoot);
   return app;
 }

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

@@ -9,9 +9,15 @@ import { createApp as buildApp } from './app.js';
 
 // Import centralized database (triggers connection automatically)
 import '@{{projectName}}/database';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get monorepo root (3 levels up from apps/{{appName}}/api)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..', '..', '..', '..');
 
 // Load root .env file
-const projectRoot = process.cwd();
 dotenv.config({ path: `${projectRoot}/.env` });
 
 /**
@@ -59,7 +65,7 @@ class {{pascalCase appName}}Server extends BaseServer {
    * Create Express app
    */
   createApp() {
-    return buildApp();
+    return buildApp(this.projectRoot);
   }
 
   /**

package/framework/Database/DatabaseServiceProvider.js

@@ -3,7 +3,7 @@
  * Registers database services and model components
  */
 
-import ServiceProvider from '../Support/ServiceProvider.js';
+import ServiceProvider from '../Foundation/ServiceProvider.js';
 import Model from './Model.js';
 
 export class DatabaseServiceProvider extends ServiceProvider {

package/framework/Database/Model.js

@@ -410,6 +410,15 @@ export class Model extends GuruORMModel {
       dirty[this.constructor.updatedAt] = this.attributes[this.constructor.updatedAt];
     }
 
+    // Filter out internal tracking properties before update
+    delete dirty.isDirtyFlag;  // Remove internal tracking fields
+    delete dirty.pendingMutators;  // Remove async mutator tracking
+    delete dirty.isHydrating;  // Remove hydration flag
+    delete dirty.exists;  // Remove exists flag
+    delete dirty.wasRecentlyCreated;  // Remove recently created flag
+    delete dirty.original;  // Remove original tracking
+    delete dirty.relations;  // Remove relations (handled separately)
+
     const pk = this.constructor.primaryKey || 'id';
     
     // Use GuruORM's update

package/framework/Exceptions/index.js

@@ -20,4 +20,5 @@ export {
   AuthorizationError,
 } from './ErrorTypes.js';
 export { ExceptionHandler, createExceptionHandler } from './Handler.js';
-export { asyncHandler, asyncMiddleware, catchAsync } from './asyncHandler.js';
+// asyncHandler moved to Http module - import from 'vasuzex/Http' instead
+export { asyncMiddleware, catchAsync } from './asyncHandler.js';

package/framework/Foundation/BaseApp.js

@@ -1,6 +1,10 @@
 import express from 'express';
 import { Application } from './Application.js';
 import { applySecurityMiddleware } from '../Http/Middleware/SecurityMiddleware.js';
+import { LogServiceProvider } from '../Services/Log/LogServiceProvider.js';
+import { HashServiceProvider } from './Providers/HashServiceProvider.js';
+import { ValidationServiceProvider } from './Providers/ValidationServiceProvider.js';
+import { EncryptionServiceProvider } from './Providers/EncryptionServiceProvider.js';
 
 /**
  * BaseApp - Base class for application-level apps (Express apps)
@@ -19,6 +23,21 @@ export class BaseApp extends Application {
     this.middlewareSetup = false;
     this.routesSetup = false;
     this.securitySetup = false;
+    
+    // Register core service providers automatically
+    this.registerCoreServiceProviders();
+  }
+  
+  /**
+   * Register core framework service providers
+   * These are registered automatically for all apps
+   */
+  registerCoreServiceProviders() {
+    // Core services that every app needs
+    this.register(LogServiceProvider);
+    this.register(HashServiceProvider);
+    this.register(ValidationServiceProvider);
+    this.register(EncryptionServiceProvider);
   }
 
   /**

package/framework/Foundation/BaseService.js

@@ -19,6 +19,101 @@ export class BaseService {
     this.sortableFields = ['id', 'created_at', 'updated_at'];
     this.defaultPerPage = 15;
     this.maxPerPage = 100;
+    this.request = null; // Will be set from controller
+  }
+
+  /**
+   * Convert camelCase to snake_case for PostgreSQL column names
+   * PostgreSQL convention uses snake_case
+   * @param {string} str - camelCase string
+   * @returns {string} snake_case string
+   */
+  toSnakeCase(str) {
+    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+  }
+
+  /**
+   * Set request context (call from controller before service methods)
+   * @param {Object} req - Express request object
+   * @returns {this} For chaining
+   */
+  setContext(req) {
+    this.request = req;
+    return this;
+  }
+
+  /**
+   * Get query options from request
+   * Standardizes pagination, search, sort, filters from req.query
+   * @returns {Object} Standardized query options
+   */
+  getQueryOptions() {
+    if (!this.request) {
+      return {};
+    }
+
+    const { query } = this.request;
+    const columnSearch = this.extractColumnSearch(query);
+
+    return {
+      page: parseInt(query.page) || 1,
+      limit: parseInt(query.limit) || 10,
+      search: query.search || '',
+      sortBy: query.sortBy || query.sort_by || 'created_at',
+      sortOrder: query.sortOrder || query.sort_order || 'desc',
+      filters: this.extractFilters(query),
+      columnSearch: columnSearch,
+      relations: query.with ? query.with.split(',') : []
+    };
+  }
+
+  /**
+   * Extract column-specific search from query params
+   * Frontend sends: columnSearch[name]=john&columnSearch[email]=test
+   * Backend receives as: req.query['columnSearch[name]'] = 'john'
+   * This method parses them into: {name: 'john', email: 'test'}
+   * @param {Object} query - Request query params
+   * @returns {Object} Column search object
+   */
+  extractColumnSearch(query) {
+    const columnSearch = {};
+    const columnSearchPattern = /^columnSearch\[(.+)\]$/;
+
+    Object.keys(query).forEach(key => {
+      const match = key.match(columnSearchPattern);
+      if (match && query[key]) {
+        const fieldName = match[1];
+        columnSearch[fieldName] = query[key];
+      }
+    });
+
+    return columnSearch;
+  }
+
+  /**
+   * Extract filters from query params
+   * Override in child services for custom filter extraction
+   * @param {Object} query - Request query params
+   * @returns {Object} Filters object
+   */
+  extractFilters(query) {
+    const filters = {};
+    const excludedKeys = ['page', 'limit', 'search', 'sortBy', 'sort_by', 'sortOrder', 'sort_order', 'with'];
+    const columnSearchPattern = /^columnSearch\[(.+)\]$/;
+
+    Object.keys(query).forEach(key => {
+      // Skip excluded keys and columnSearch params
+      if (excludedKeys.includes(key) || columnSearchPattern.test(key)) {
+        return;
+      }
+
+      const value = query[key];
+      if (value !== undefined && value !== null && value !== '') {
+        filters[key] = value;
+      }
+    });
+
+    return filters;
   }
 
   /**

package/framework/Foundation/Container.js

@@ -58,9 +58,24 @@ export class Container {
       throw new Error(`No binding found for "${abstract}"`);
     }
 
-    const instance = typeof concrete === 'function' 
-      ? new concrete() 
-      : concrete;
+    // Handle factory functions vs constructors
+    let instance;
+    if (typeof concrete === 'function') {
+      // Check if it's a factory function (arrow function or function that takes app parameter)
+      // Factory functions receive the app instance as parameter
+      const isFactory = concrete.length > 0 || concrete.toString().includes('=>');
+      
+      if (isFactory) {
+        // Call factory function with app instance
+        instance = concrete(this);
+      } else {
+        // Call as constructor
+        instance = new concrete();
+      }
+    } else {
+      // Direct value
+      instance = concrete;
+    }
 
     if (this.singletons.has(key)) {
       this.instances.set(key, instance);

package/framework/Foundation/Providers/index.js

@@ -4,7 +4,6 @@ export { NotificationServiceProvider } from './NotificationServiceProvider.js';
 export { HashServiceProvider } from './HashServiceProvider.js';
 export { ValidationServiceProvider } from './ValidationServiceProvider.js';
 export { EventServiceProvider } from './EventServiceProvider.js';
-export { LogServiceProvider } from './LogServiceProvider.js';
 export { EncryptionServiceProvider } from './EncryptionServiceProvider.js';
 export { CookieServiceProvider } from './CookieServiceProvider.js';
 export { SessionServiceProvider } from './SessionServiceProvider.js';

package/framework/Foundation/ServiceProvider.js

@@ -22,6 +22,48 @@ export class ServiceProvider {
   boot() {
     // Override in subclass
   }
+
+  /**
+   * Bind a service to the container
+   */
+  bind(abstract, concrete, singleton = false) {
+    return this.app.bind(abstract, concrete, singleton);
+  }
+
+  /**
+   * Bind a singleton to the container
+   */
+  singleton(abstract, concrete) {
+    return this.app.singleton(abstract, concrete);
+  }
+
+  /**
+   * Bind an instance to the container
+   */
+  instance(abstract, instance) {
+    return this.app.instance(abstract, instance);
+  }
+
+  /**
+   * Create an alias
+   */
+  alias(alias, abstract) {
+    return this.app.alias(alias, abstract);
+  }
+
+  /**
+   * Resolve a service from the container
+   */
+  make(abstract) {
+    return this.app.make(abstract);
+  }
+
+  /**
+   * Get configuration value
+   */
+  config(key, defaultValue = null) {
+    return this.app.config(key, defaultValue);
+  }
 }
 
 export default ServiceProvider;

package/framework/Http/asyncHandler.js

@@ -0,0 +1,26 @@
+/**
+ * Async Handler Middleware
+ * Wraps async controller methods to catch errors automatically
+ * Laravel-style error handling for Express async routes
+ * 
+ * @example
+ * import { asyncHandler } from 'vasuzex/Http';
+ * 
+ * router.get('/users', asyncHandler(async (req, res) => {
+ *   const users = await User.all();
+ *   res.json(users);
+ * }));
+ */
+
+/**
+ * Wrap an async function to catch errors
+ * @param {Function} fn - Async function to wrap
+ * @returns {Function} Express middleware function
+ */
+export function asyncHandler(fn) {
+  return (req, res, next) => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+}
+
+export default asyncHandler;