bs9 1.0.0 → 1.3.0

package/src/database/pool.ts

@@ -0,0 +1,335 @@
+#!/usr/bin/env bun
+
+// Security: Input validation functions
+function isValidHost(host: string): boolean {
+  const hostnameRegex = /^[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?)*$/;
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  const localhostRegex = /^(localhost|127\.0\.0\.1)$/;
+  
+  return hostnameRegex.test(host) && host.length <= 253 || 
+         ipv4Regex.test(host) || 
+         localhostRegex.test(host);
+}
+
+function isValidDatabaseName(name: string): boolean {
+  // Allow alphanumeric, underscores, and hyphens only
+  return /^[a-zA-Z0-9_-]+$/.test(name) && name.length <= 64;
+}
+
+function isValidUsername(username: string): boolean {
+  // Allow alphanumeric, underscores, and hyphens only
+  return /^[a-zA-Z0-9_-]+$/.test(username) && username.length <= 32;
+}
+
+function sanitizeSQL(sql: string): string {
+  // Basic SQL injection prevention
+  const dangerousPatterns = [
+    /drop\s+table/i,
+    /delete\s+from/i,
+    /truncate\s+table/i,
+    /exec\s*\(/i,
+    /xp_cmdshell/i,
+    /sp_executesql/i,
+    /union\s+select/i,
+    /insert\s+into/i,
+    /update\s+set/i
+  ];
+  
+  for (const pattern of dangerousPatterns) {
+    if (pattern.test(sql)) {
+      throw new Error(`❌ Security: Dangerous SQL pattern detected`);
+    }
+  }
+  
+  return sql.trim();
+}
+
+interface DatabaseConnection {
+  id: string;
+  created: number;
+  lastUsed: number;
+  inUse: boolean;
+  host: string;
+  port: number;
+  database: string;
+  username: string;
+  checkedOut: boolean;
+  query: (sql: string, params?: any[]) => Promise<any[]>;
+  close: () => Promise<void>;
+}
+
+interface DatabaseConfig {
+  host: string;
+  port: number;
+  database: string;
+  username: string;
+  password: string;
+  ssl?: boolean;
+  maxConnections?: number;
+  minConnections?: number;
+  acquireTimeoutMillis?: number;
+  idleTimeoutMillis?: number;
+  reapIntervalMillis?: number;
+}
+
+interface PoolStats {
+  totalConnections: number;
+  activeConnections: number;
+  idleConnections: number;
+  waitingClients: number;
+  maxConnections: number;
+}
+
+class DatabasePool {
+  private config: DatabaseConfig;
+  private connections: DatabaseConnection[] = [];
+  private waitingQueue: Array<{
+    resolve: (connection: DatabaseConnection) => void;
+    reject: (error: Error) => void;
+    timestamp: number;
+  }> = [];
+  private reapingInterval?: NodeJS.Timeout;
+  
+  constructor(config: DatabaseConfig) {
+    // Security: Validate configuration
+    if (!isValidHost(config.host)) {
+      throw new Error(`❌ Security: Invalid database host: ${config.host}`);
+    }
+    
+    if (!isValidDatabaseName(config.database)) {
+      throw new Error(`❌ Security: Invalid database name: ${config.database}`);
+    }
+    
+    if (!isValidUsername(config.username)) {
+      throw new Error(`❌ Security: Invalid database username: ${config.username}`);
+    }
+    
+    const portNum = Number(config.port);
+    if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+      throw new Error(`❌ Security: Invalid port number: ${config.port}`);
+    }
+    
+    this.config = {
+      maxConnections: 10,
+      minConnections: 2,
+      acquireTimeoutMillis: 30000,
+      idleTimeoutMillis: 30000,
+      reapIntervalMillis: 1000,
+      ...config,
+    };
+    
+    this.startReaper();
+  }
+  
+  private async createConnection(): Promise<DatabaseConnection> {
+    const id = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const now = Date.now();
+    
+    // Simulate database connection
+    await new Promise(resolve => setTimeout(resolve, 100));
+    
+    return {
+      id,
+      created: now,
+      lastUsed: now,
+      inUse: false,
+      host: this.config.host,
+      port: this.config.port,
+      database: this.config.database,
+      username: this.config.username,
+      checkedOut: false,
+      query: async (sql: string, params?: any[]) => {
+        await new Promise(resolve => setTimeout(resolve, Math.random() * 50 + 10));
+        return [{ id: 1, data: 'mock_result' }];
+      },
+      close: async () => {
+        await new Promise(resolve => setTimeout(resolve, 10));
+      },
+    };
+  }
+  
+  async acquire(): Promise<DatabaseConnection> {
+    const now = Date.now();
+    
+    const availableConnection = this.connections.find(conn => !conn.inUse);
+    if (availableConnection) {
+      availableConnection.inUse = true;
+      availableConnection.lastUsed = now;
+      return availableConnection;
+    }
+    
+    if (this.connections.length < this.config.maxConnections!) {
+      const newConnection = await this.createConnection();
+      newConnection.inUse = true;
+      this.connections.push(newConnection);
+      return newConnection;
+    }
+    
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const index = this.waitingQueue.findIndex(item => item.resolve === resolve);
+        if (index !== -1) {
+          this.waitingQueue.splice(index, 1);
+        }
+        reject(new Error('Connection acquire timeout'));
+      }, this.config.acquireTimeoutMillis);
+      
+      this.waitingQueue.push({
+        resolve: (connection) => {
+          clearTimeout(timeoutId);
+          resolve(connection);
+        },
+        reject: (error) => {
+          clearTimeout(timeoutId);
+          reject(error);
+        },
+        timestamp: now,
+      });
+    });
+  }
+  
+  async release(connection: DatabaseConnection): Promise<void> {
+    connection.inUse = false;
+    connection.lastUsed = Date.now();
+    
+    const waiting = this.waitingQueue.shift();
+    if (waiting) {
+      connection.inUse = true;
+      waiting.resolve(connection);
+    }
+  }
+  
+  private async startReaper(): Promise<void> {
+    this.reapingInterval = setInterval(async () => {
+      await this.reapIdleConnections();
+    }, this.config.reapIntervalMillis);
+  }
+  
+  private async reapIdleConnections(): Promise<void> {
+    const now = Date.now();
+    const minConnections = this.config.minConnections!;
+    
+    const idleConnections = this.connections.filter(conn => 
+      !conn.inUse && 
+      now - conn.lastUsed > this.config.idleTimeoutMillis! &&
+      this.connections.length > minConnections
+    );
+    
+    for (const conn of idleConnections) {
+      const index = this.connections.indexOf(conn);
+      if (index !== -1) {
+        await conn.close();
+        this.connections.splice(index, 1);
+      }
+    }
+  }
+  
+  getStats(): PoolStats {
+    const activeConnections = this.connections.filter(conn => conn.inUse).length;
+    const idleConnections = this.connections.filter(conn => !conn.inUse).length;
+    
+    return {
+      totalConnections: this.connections.length,
+      activeConnections,
+      idleConnections,
+      waitingClients: this.waitingQueue.length,
+      maxConnections: this.config.maxConnections!,
+    };
+  }
+  
+  async close(): Promise<void> {
+    if (this.reapingInterval) {
+      clearInterval(this.reapingInterval);
+    }
+    
+    const closePromises = this.connections.map(conn => conn.close());
+    await Promise.all(closePromises);
+    this.connections = [];
+    
+    for (const waiting of this.waitingQueue) {
+      waiting.reject(new Error('Pool is closing'));
+    }
+    this.waitingQueue = [];
+  }
+  
+  async testConnection(): Promise<boolean> {
+    try {
+      const conn = await this.acquire();
+      await conn.query('SELECT 1');
+      await this.release(conn);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export async function dbpoolCommand(action: string, options: any): Promise<void> {
+  console.log('🗄️  BS9 Database Connection Pool Management');
+  console.log('='.repeat(80));
+  
+  const config: DatabaseConfig = {
+    host: options.host || 'localhost',
+    port: parseInt(options.port) || 5432,
+    database: options.database || 'testdb',
+    username: options.username || 'user',
+    password: options.password || 'password',
+    maxConnections: parseInt(options.maxConnections) || 10,
+    minConnections: parseInt(options.minConnections) || 2,
+  };
+  
+  try {
+    switch (action) {
+      case 'start':
+        console.log(`🚀 Starting database pool...`);
+        console.log(`   Host: ${config.host}:${config.port}`);
+        console.log(`   Database: ${config.database}`);
+        console.log(`   Max Connections: ${config.maxConnections}`);
+        console.log(`   Min Connections: ${config.minConnections}`);
+        
+        const pool = new DatabasePool(config);
+        const isConnected = await pool.testConnection();
+        
+        if (isConnected) {
+          console.log('✅ Database pool started successfully');
+          const stats = pool.getStats();
+          console.log(`📊 Initial Stats: ${stats.totalConnections} connections`);
+          console.log('✅ Pool management commands ready');
+        } else {
+          console.error('❌ Failed to connect to database');
+          process.exit(1);
+        }
+        break;
+        
+      case 'test':
+        console.log('🧪 Testing database pool...');
+        const testPool = new DatabasePool(config);
+        const connected = await testPool.testConnection();
+        console.log(connected ? '✅ Connection test passed' : '❌ Connection test failed');
+        await testPool.close();
+        break;
+        
+      case 'stats':
+        console.log('📊 Database Pool Statistics');
+        console.log('-'.repeat(40));
+        const statsPool = new DatabasePool(config);
+        const stats = statsPool.getStats();
+        console.log(`Total Connections: ${stats.totalConnections}`);
+        console.log(`Active Connections: ${stats.activeConnections}`);
+        console.log(`Idle Connections: ${stats.idleConnections}`);
+        console.log(`Waiting Clients: ${stats.waitingClients}`);
+        console.log(`Max Connections: ${stats.maxConnections}`);
+        console.log(`Pool Utilization: ${((stats.activeConnections / stats.maxConnections) * 100).toFixed(1)}%`);
+        await statsPool.close();
+        break;
+        
+      default:
+        console.error(`❌ Unknown action: ${action}`);
+        console.log('Available actions: start, test, stats');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`❌ Failed to ${action} pool: ${error}`);
+    process.exit(1);
+  }
+}

package/src/discovery/consul.ts

@@ -0,0 +1,285 @@
+#!/usr/bin/env bun
+
+import { execSync } from "node:child_process";
+
+interface ConsulService {
+  ID: string;
+  Name: string;
+  Tags: string[];
+  Address: string;
+  Port: number;
+  EnableTagOverride: boolean;
+  Meta: Record<string, string>;
+}
+
+interface ConsulHealthCheck {
+  HTTP?: string;
+  TCP?: string;
+  Interval: string;
+  Timeout: string;
+  DeregisterCriticalServiceAfter: string;
+}
+
+interface ConsulRegistration {
+  Name: string;
+  ID: string;
+  Tags: string[];
+  Address: string;
+  Port: number;
+  EnableTagOverride: boolean;
+  Check: ConsulHealthCheck;
+  Meta?: Record<string, string>;
+}
+
+class ConsulServiceDiscovery {
+  private consulUrl: string;
+  private serviceName: string = '';
+  private serviceId: string = '';
+  private registeredServices: Map<string, ConsulService> = new Map();
+  
+  constructor(consulUrl: string = 'http://localhost:8500') {
+    this.consulUrl = consulUrl;
+  }
+  
+  async registerService(config: {
+    name: string;
+    id: string;
+    address: string;
+    port: number;
+    tags?: string[];
+    healthCheck?: string;
+    meta?: Record<string, string>;
+  }): Promise<void> {
+    const registration: ConsulRegistration = {
+      Name: config.name,
+      ID: config.id,
+      Tags: config.tags || ['bs9', 'service'],
+      Address: config.address,
+      Port: config.port,
+      EnableTagOverride: false,
+      Check: {
+        HTTP: config.healthCheck || `http://${config.address}:${config.port}/healthz`,
+        Interval: '10s',
+        Timeout: '5s',
+        DeregisterCriticalServiceAfter: '30s'
+      },
+      Meta: config.meta || {}
+    };
+    
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/agent/service/register`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(registration)
+      });
+      
+      if (response.ok) {
+        console.log(`✅ Service ${config.name} registered with Consul`);
+        this.registeredServices.set(config.id, {
+          ID: config.id,
+          Name: config.name,
+          Tags: registration.Tags,
+          Address: config.address,
+          Port: config.port,
+          EnableTagOverride: registration.EnableTagOverride,
+          Meta: registration.Meta || {}
+        });
+      } else {
+        throw new Error(`Failed to register service: ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error(`❌ Consul registration failed: ${error}`);
+      throw error;
+    }
+  }
+  
+  async deregisterService(serviceId: string): Promise<void> {
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/agent/service/deregister/${serviceId}`, {
+        method: 'PUT'
+      });
+      
+      if (response.ok) {
+        console.log(`✅ Service ${serviceId} deregistered from Consul`);
+        this.registeredServices.delete(serviceId);
+      } else {
+        throw new Error(`Failed to deregister service: ${response.statusText}`);
+      }
+    } catch (error) {
+      console.error(`❌ Consul deregistration failed: ${error}`);
+      throw error;
+    }
+  }
+  
+  async discoverServices(serviceName?: string): Promise<ConsulService[]> {
+    try {
+      let url = `${this.consulUrl}/v1/agent/services`;
+      if (serviceName) {
+        url += `?service=${serviceName}`;
+      }
+      
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to discover services: ${response.statusText}`);
+      }
+      
+      const services: Record<string, ConsulService> = await response.json();
+      return Object.values(services).filter(service => 
+        service.Tags.includes('bs9')
+      );
+    } catch (error) {
+      console.error(`❌ Service discovery failed: ${error}`);
+      return [];
+    }
+  }
+  
+  async getServiceHealth(serviceName: string): Promise<any[]> {
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/health/service/${serviceName}`);
+      if (!response.ok) {
+        throw new Error(`Failed to get service health: ${response.statusText}`);
+      }
+      
+      return await response.json();
+    } catch (error) {
+      console.error(`❌ Health check failed: ${error}`);
+      return [];
+    }
+  }
+  
+  async watchService(serviceName: string, callback: (services: ConsulService[]) => void): Promise<void> {
+    let lastServices: ConsulService[] = [];
+    
+    const checkServices = async () => {
+      try {
+        const services = await this.discoverServices(serviceName);
+        
+        // Check if services have changed
+        const servicesChanged = JSON.stringify(services) !== JSON.stringify(lastServices);
+        
+        if (servicesChanged) {
+          callback(services);
+          lastServices = services;
+        }
+      } catch (error) {
+        console.error(`❌ Service watch error: ${error}`);
+      }
+    };
+    
+    // Initial check
+    await checkServices();
+    
+    // Set up periodic checking
+    setInterval(checkServices, 5000);
+  }
+  
+  getRegisteredServices(): ConsulService[] {
+    return Array.from(this.registeredServices.values());
+  }
+  
+  async isConsulAvailable(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.consulUrl}/v1/status/leader`);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export async function consulCommand(action: string, options: any): Promise<void> {
+  const consul = new ConsulServiceDiscovery(options.consulUrl);
+  
+  try {
+    switch (action) {
+      case 'register':
+        if (!options.name || !options.id || !options.address || !options.port) {
+          console.error('❌ --name, --id, --address, and --port are required for register');
+          process.exit(1);
+        }
+        
+        await consul.registerService({
+          name: options.name,
+          id: options.id,
+          address: options.address,
+          port: parseInt(options.port),
+          tags: options.tags ? options.tags.split(',') : undefined,
+          healthCheck: options.healthCheck,
+          meta: options.meta ? JSON.parse(options.meta) : undefined
+        });
+        break;
+        
+      case 'deregister':
+        if (!options.id) {
+          console.error('❌ --id is required for deregister');
+          process.exit(1);
+        }
+        await consul.deregisterService(options.id);
+        break;
+        
+      case 'discover':
+        const services = await consul.discoverServices(options.service);
+        console.log('🔍 Discovered Services:');
+        console.log('='.repeat(50));
+        
+        if (services.length === 0) {
+          console.log('No BS9 services found in Consul');
+        } else {
+          services.forEach(service => {
+            console.log(`📦 ${service.Name} (${service.ID})`);
+            console.log(`   Address: ${service.Address}:${service.Port}`);
+            console.log(`   Tags: ${service.Tags.join(', ')}`);
+            console.log(`   Health: ${service.Meta?.health || 'unknown'}`);
+            console.log('');
+          });
+        }
+        break;
+        
+      case 'health':
+        if (!options.service) {
+          console.error('❌ --service is required for health check');
+          process.exit(1);
+        }
+        
+        const health = await consul.getServiceHealth(options.service);
+        console.log(`🏥 Health Status for ${options.service}:`);
+        console.log('='.repeat(50));
+        
+        if (health.length === 0) {
+          console.log('No health information available');
+        } else {
+          health.forEach(check => {
+            const status = check.Checks?.[0]?.Status || 'unknown';
+            const output = check.Checks?.[0]?.Output || 'No output';
+            
+            console.log(`📦 ${check.Service.ID}`);
+            console.log(`   Status: ${status}`);
+            console.log(`   Node: ${check.Node.Node}`);
+            console.log(`   Address: ${check.Service.Address}:${check.Service.Port}`);
+            console.log(`   Output: ${output}`);
+            console.log('');
+          });
+        }
+        break;
+        
+      case 'status':
+        const available = await consul.isConsulAvailable();
+        if (available) {
+          console.log('✅ Consul is available');
+          console.log(`   URL: ${options.consulUrl || 'http://localhost:8500'}`);
+        } else {
+          console.log('❌ Consul is not available');
+          console.log(`   URL: ${options.consulUrl || 'http://localhost:8500'}`);
+        }
+        break;
+        
+      default:
+        console.error(`❌ Unknown action: ${action}`);
+        console.log('Available actions: register, deregister, discover, health, status');
+        process.exit(1);
+    }
+  } catch (error) {
+    console.error(`❌ Consul command failed: ${error}`);
+    process.exit(1);
+  }
+}