@tamyla/clodo-framework 1.0.0

package/dist/shared/config/manager.js

@@ -0,0 +1,289 @@
+/**
+ * Configuration Manager Module
+ * Configuration file management and validation
+ * 
+ * Consolidates config management across 34+ scripts
+ */
+
+import { readFileSync, writeFileSync, existsSync, copyFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+export function updateWranglerConfig(updates, configPath = 'wrangler.toml') {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  let config = readFileSync(configPath, 'utf8');
+  let changesMade = [];
+
+  // Apply updates systematically
+  for (const [key, value] of Object.entries(updates)) {
+    switch (key) {
+      case 'workerName':
+        // Update main worker name
+        if (config.match(/^name = "[^"]*"/m)) {
+          config = config.replace(/^name = "[^"]*"/m, `name = "${value}"`);
+          changesMade.push(`Updated main worker name to: ${value}`);
+        }
+
+        // Update production environment name  
+        if (config.match(/^\[env\.production\]\s*\nname = "[^"]*"/m)) {
+          config = config.replace(/^\[env\.production\]\s*\nname = "[^"]*"/m, `[env.production]\nname = "${value}"`);
+          changesMade.push(`Updated production worker name to: ${value}`);
+        }
+        break;
+      case 'databaseName':
+        {
+          const dbNameRegex = /database_name = "[^"]*"/g;
+          if (config.match(dbNameRegex)) {
+            config = config.replace(dbNameRegex, `database_name = "${value}"`);
+            changesMade.push(`Updated database name to: ${value}`);
+          }
+          break;
+        }
+      case 'databaseId':
+        {
+          const dbIdRegex = /database_id = "[^"]*"/g;
+          if (config.match(dbIdRegex)) {
+            config = config.replace(dbIdRegex, `database_id = "${value}"`);
+            changesMade.push(`Updated database ID to: ${value}`);
+          }
+          break;
+        }
+      case 'serviceDomain':
+        {
+          const domainRegex = /SERVICE_DOMAIN = "[^"]*"/g;
+          if (config.match(domainRegex)) {
+            config = config.replace(domainRegex, `SERVICE_DOMAIN = "${value}"`);
+            changesMade.push(`Updated service domain to: ${value}`);
+          }
+          break;
+        }
+      case 'compatibilityDate':
+        {
+          const dateRegex = /^compatibility_date = "[^"]*"/m;
+          if (config.match(dateRegex)) {
+            config = config.replace(dateRegex, `compatibility_date = "${value}"`);
+            changesMade.push(`Updated compatibility date to: ${value}`);
+          }
+          break;
+        }
+      default:
+        console.warn(`Unknown config update key: ${key}`);
+    }
+  }
+  writeFileSync(configPath, config);
+  return {
+    configPath,
+    changesMade,
+    success: changesMade.length > 0
+  };
+}
+export function backupConfig(configPath = 'wrangler.toml', suffix = null) {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const timestamp = suffix || new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${configPath}.backup.${timestamp}`;
+  copyFileSync(configPath, backupPath);
+  return {
+    originalPath: configPath,
+    backupPath,
+    timestamp: new Date().toISOString()
+  };
+}
+export function validateConfig(configPath = 'wrangler.toml') {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const config = readFileSync(configPath, 'utf8');
+  const issues = [];
+  const warnings = [];
+
+  // Required fields validation
+  const requiredFields = [{
+    pattern: /^name = "/m,
+    description: 'Worker name'
+  }, {
+    pattern: /^compatibility_date = "/m,
+    description: 'Compatibility date'
+  }, {
+    pattern: /^main = "/m,
+    description: 'Main entry point'
+  }];
+  requiredFields.forEach(field => {
+    if (!config.match(field.pattern)) {
+      issues.push(`Missing required field: ${field.description}`);
+    }
+  });
+
+  // Database configuration validation
+  const hasDatabaseBinding = config.includes('[[d1_databases]]');
+  if (hasDatabaseBinding) {
+    if (!config.includes('database_name =')) {
+      issues.push('Database binding found but missing database_name');
+    }
+    if (!config.includes('database_id =')) {
+      issues.push('Database binding found but missing database_id');
+    }
+  }
+
+  // Environment validation
+  const hasProductionEnv = config.includes('[env.production]');
+  if (hasProductionEnv) {
+    const prodSection = config.split('[env.production]')[1];
+    if (prodSection && !prodSection.includes('name =')) {
+      warnings.push('Production environment missing explicit name');
+    }
+  }
+
+  // Compatibility date validation
+  const compatMatch = config.match(/compatibility_date = "([^"]+)"/);
+  if (compatMatch) {
+    const date = new Date(compatMatch[1]);
+    const now = new Date();
+    const daysDiff = (now - date) / (1000 * 60 * 60 * 24);
+    if (daysDiff > 365) {
+      warnings.push(`Compatibility date is ${Math.floor(daysDiff)} days old`);
+    }
+  }
+  return {
+    isValid: issues.length === 0,
+    issues,
+    warnings,
+    summary: {
+      errors: issues.length,
+      warnings: warnings.length,
+      status: issues.length === 0 ? 'valid' : 'invalid'
+    }
+  };
+}
+export function parseWranglerConfig(configPath = 'wrangler.toml') {
+  if (!existsSync(configPath)) {
+    throw new Error(`Configuration file not found: ${configPath}`);
+  }
+  const config = readFileSync(configPath, 'utf8');
+  const parsed = {};
+
+  // Extract main fields
+  const extractField = (pattern, key) => {
+    const match = config.match(pattern);
+    if (match) parsed[key] = match[1];
+  };
+  extractField(/^name = "([^"]+)"/m, 'name');
+  extractField(/^compatibility_date = "([^"]+)"/m, 'compatibilityDate');
+  extractField(/^main = "([^"]+)"/m, 'main');
+
+  // Extract database configuration
+  if (config.includes('[[d1_databases]]')) {
+    parsed.database = {};
+    extractField(/database_name = "([^"]+)"/m, 'name');
+    extractField(/database_id = "([^"]+)"/m, 'id');
+    if (parsed.name) parsed.database.name = parsed.name;
+    if (parsed.id) parsed.database.id = parsed.id;
+    delete parsed.name;
+    delete parsed.id;
+  }
+
+  // Extract environment configurations
+  parsed.environments = {};
+  const envMatches = config.matchAll(/\[env\.([^\]]+)\]/g);
+  for (const match of envMatches) {
+    const envName = match[1];
+    parsed.environments[envName] = {};
+
+    // Extract env-specific settings (simplified parsing)
+    const envSection = config.split(`[env.${envName}]`)[1];
+    if (envSection) {
+      const nextEnv = envSection.indexOf('[env.');
+      const sectionContent = nextEnv > 0 ? envSection.substring(0, nextEnv) : envSection;
+      const nameMatch = sectionContent.match(/name = "([^"]+)"/);
+      if (nameMatch) parsed.environments[envName].name = nameMatch[1];
+    }
+  }
+  return parsed;
+}
+export function generateWranglerConfig(options) {
+  const {
+    name,
+    main = 'src/worker/index.js',
+    compatibilityDate = new Date().toISOString().split('T')[0],
+    database = null,
+    environments = {},
+    vars = {},
+    secrets = []
+  } = options;
+  let config = `# Generated Wrangler Configuration
+# Timestamp: ${new Date().toISOString()}
+
+name = "${name}"
+main = "${main}"
+compatibility_date = "${compatibilityDate}"
+`;
+
+  // Add variables
+  if (Object.keys(vars).length > 0) {
+    config += '\n[vars]\n';
+    Object.entries(vars).forEach(([key, value]) => {
+      config += `${key} = "${value}"\n`;
+    });
+  }
+
+  // Add database configuration
+  if (database) {
+    config += `
+[[d1_databases]]
+binding = "DB"
+database_name = "${database.name}"
+database_id = "${database.id}"
+`;
+  }
+
+  // Add environments
+  Object.entries(environments).forEach(([envName, envConfig]) => {
+    config += `\n[env.${envName}]\n`;
+    if (envConfig.name) config += `name = "${envConfig.name}"\n`;
+    if (envConfig.vars) {
+      Object.entries(envConfig.vars).forEach(([key, value]) => {
+        config += `${key} = "${value}"\n`;
+      });
+    }
+    if (envConfig.database) {
+      config += `
+[[env.${envName}.d1_databases]]
+binding = "DB"
+database_name = "${envConfig.database.name}"
+database_id = "${envConfig.database.id}"
+`;
+    }
+  });
+  return config;
+}
+export function listConfigFiles(directory = '.') {
+  const configFiles = [];
+  const patterns = ['wrangler.toml', 'package.json', '.env*'];
+  try {
+    const items = readdirSync(directory);
+    items.forEach(item => {
+      const path = join(directory, item);
+      const stat = statSync(path);
+      if (stat.isFile()) {
+        const matches = patterns.some(pattern => {
+          if (pattern.includes('*')) {
+            return item.startsWith(pattern.replace('*', ''));
+          }
+          return item === pattern;
+        });
+        if (matches) {
+          configFiles.push({
+            name: item,
+            path,
+            size: stat.size,
+            modified: stat.mtime
+          });
+        }
+      }
+    });
+    return configFiles.sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    return [];
+  }
+}

package/dist/shared/database/connection-manager.js

@@ -0,0 +1,338 @@
+/**
+ * Database Connection Manager
+ * Implements connection pooling, timeout handling, and retry logic for D1 operations
+ */
+
+import { executeSql } from '../cloudflare/ops.js';
+import { ErrorRecoveryManager } from '../utils/error-recovery.js';
+export class DatabaseConnectionManager {
+  constructor(options = {}) {
+    this.options = options;
+    this.config = null;
+    this.connectionPool = new Map();
+    this.activeConnections = 0;
+    this.errorRecovery = null; // Will be initialized after framework config is loaded
+  }
+
+  /**
+   * Initialize with framework configuration
+   */
+  async initialize() {
+    // Import framework config for consistent database connection settings
+    const {
+      frameworkConfig
+    } = await import('../../../src/utils/framework-config.js');
+    const timing = frameworkConfig.getTiming();
+    const database = frameworkConfig.getDatabaseConfig();
+    this.config = {
+      maxRetries: this.options.maxRetries || timing.retryAttempts,
+      retryDelay: this.options.retryDelay || timing.retryDelay,
+      connectionTimeout: this.options.connectionTimeout || database.connectionTimeout,
+      queryTimeout: this.options.queryTimeout || database.queryTimeout,
+      enableConnectionPooling: this.options.enableConnectionPooling !== false,
+      maxPoolSize: this.options.maxPoolSize || database.maxPoolSize,
+      connectionIdleTimeout: this.options.connectionIdleTimeout || database.connectionIdleTimeout,
+      ...this.options
+    };
+
+    // Initialize error recovery with loaded config
+    const {
+      ErrorRecoveryManager
+    } = await import('../utils/error-recovery.js');
+    this.errorRecovery = new ErrorRecoveryManager({
+      maxRetries: this.config.maxRetries,
+      retryDelay: this.config.retryDelay,
+      gracefulDegradation: true
+    });
+    await this.errorRecovery.initialize();
+  }
+
+  /**
+   * Execute a database query with connection management
+   */
+  async executeQuery(databaseName, sql, options = {}) {
+    if (!this.config) {
+      throw new Error('ConnectionManager must be initialized before use. Call initialize() first.');
+    }
+    const config = {
+      env: 'production',
+      timeout: this.config.queryTimeout,
+      usePool: this.config.enableConnectionPooling,
+      ...options
+    };
+    return await this.errorRecovery.executeWithRecovery(async () => {
+      return await this.executeQueryInternal(databaseName, sql, config);
+    }, {
+      operationId: `db_query_${databaseName}`
+    });
+  }
+
+  /**
+   * Execute query with timeout and connection handling
+   */
+  async executeQueryInternal(databaseName, sql, config) {
+    const startTime = Date.now();
+    try {
+      // Get or create connection
+      const connection = await this.getConnection(databaseName, config);
+
+      // Execute query with timeout
+      const result = await this.executeWithTimeout(() => executeSql(databaseName, sql, config.env), config.timeout);
+      const duration = Date.now() - startTime;
+
+      // Release connection back to pool
+      if (config.usePool) {
+        this.releaseConnection(databaseName, connection);
+      }
+      return {
+        success: true,
+        result,
+        duration,
+        connectionId: connection.id
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+
+      // Handle connection errors
+      if (this.isConnectionError(error)) {
+        await this.handleConnectionError(databaseName, error);
+      }
+      throw new Error(`Database query failed: ${error.message} (duration: ${duration}ms)`);
+    }
+  }
+
+  /**
+   * Execute multiple queries in a transaction
+   */
+  async executeTransaction(databaseName, queries, options = {}) {
+    const config = {
+      env: 'production',
+      timeout: this.config.queryTimeout * queries.length,
+      // Longer timeout for transactions
+      ...options
+    };
+    return await this.errorRecovery.executeWithRecovery(async () => {
+      return await this.executeTransactionInternal(databaseName, queries, config);
+    }, {
+      operationId: `db_transaction_${databaseName}`
+    });
+  }
+
+  /**
+   * Execute transaction with proper error handling
+   */
+  async executeTransactionInternal(databaseName, queries, config) {
+    const startTime = Date.now();
+    const results = [];
+    try {
+      const connection = await this.getConnection(databaseName, config);
+      for (let i = 0; i < queries.length; i++) {
+        const query = queries[i];
+        try {
+          const result = await this.executeWithTimeout(() => executeSql(databaseName, query, config.env), config.timeout / queries.length // Divide timeout among queries
+          );
+          results.push({
+            index: i,
+            success: true,
+            result,
+            query
+          });
+        } catch (queryError) {
+          // Transaction failed, all previous queries should be rolled back
+          // Note: D1 doesn't support explicit transactions, so we need to handle this at application level
+          results.push({
+            index: i,
+            success: false,
+            error: queryError.message,
+            query
+          });
+          throw new Error(`Transaction failed at query ${i}: ${queryError.message}`);
+        }
+      }
+      const duration = Date.now() - startTime;
+      if (config.usePool) {
+        this.releaseConnection(databaseName, connection);
+      }
+      return {
+        success: true,
+        results,
+        duration,
+        transactionId: `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      throw new Error(`Database transaction failed: ${error.message} (duration: ${duration}ms)`);
+    }
+  }
+
+  /**
+   * Get a connection from the pool or create a new one
+   */
+  async getConnection(databaseName, config) {
+    if (!config.usePool) {
+      return this.createConnection(databaseName);
+    }
+    const poolKey = databaseName;
+    let pool = this.connectionPool.get(poolKey);
+    if (!pool) {
+      pool = [];
+      this.connectionPool.set(poolKey, pool);
+    }
+
+    // Find an available connection
+    let connection = pool.find(conn => !conn.inUse && !this.isConnectionExpired(conn));
+    if (!connection && pool.length < this.config.maxPoolSize) {
+      connection = this.createConnection(databaseName);
+      pool.push(connection);
+    }
+    if (!connection) {
+      // Wait for an available connection
+      connection = await this.waitForAvailableConnection(pool, config.timeout);
+    }
+    if (!connection) {
+      throw new Error('No available database connections');
+    }
+    connection.inUse = true;
+    connection.lastUsed = Date.now();
+    this.activeConnections++;
+    return connection;
+  }
+
+  /**
+   * Release a connection back to the pool
+   */
+  releaseConnection(databaseName, connection) {
+    connection.inUse = false;
+    connection.lastUsed = Date.now();
+    this.activeConnections--;
+  }
+
+  /**
+   * Create a new database connection
+   */
+  createConnection(databaseName) {
+    return {
+      id: `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      databaseName,
+      created: Date.now(),
+      lastUsed: Date.now(),
+      inUse: false
+    };
+  }
+
+  /**
+   * Wait for an available connection
+   */
+  async waitForAvailableConnection(pool, timeout) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const connection = pool.find(conn => !conn.inUse && !this.isConnectionExpired(conn));
+      if (connection) {
+        return connection;
+      }
+
+      // Wait a bit before checking again
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    return null;
+  }
+
+  /**
+   * Check if a connection is expired
+   */
+  isConnectionExpired(connection) {
+    const now = Date.now();
+    return now - connection.lastUsed > this.config.connectionIdleTimeout;
+  }
+
+  /**
+   * Handle connection errors
+   */
+  async handleConnectionError(databaseName, error) {
+    // Clean up any bad connections from the pool
+    const poolKey = databaseName;
+    const pool = this.connectionPool.get(poolKey);
+    if (pool) {
+      const validConnections = pool.filter(conn => !this.isConnectionExpired(conn));
+      this.connectionPool.set(poolKey, validConnections);
+    }
+
+    // Could implement connection health checks here
+    console.warn(`Database connection error for ${databaseName}:`, error.message);
+  }
+
+  /**
+   * Check if error is connection-related
+   */
+  isConnectionError(error) {
+    const connectionErrorPatterns = ['connection', 'timeout', 'network', 'ECONNREFUSED', 'ENOTFOUND', 'ETIMEDOUT'];
+    const errorMessage = error.message.toLowerCase();
+    return connectionErrorPatterns.some(pattern => errorMessage.includes(pattern));
+  }
+
+  /**
+   * Execute a function with timeout
+   */
+  async executeWithTimeout(fn, timeout) {
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        reject(new Error(`Operation timed out after ${timeout}ms`));
+      }, timeout);
+      fn().then(result => {
+        clearTimeout(timeoutId);
+        resolve(result);
+      }).catch(error => {
+        clearTimeout(timeoutId);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * Get connection pool statistics
+   */
+  getPoolStats(databaseName) {
+    const pool = this.connectionPool.get(databaseName) || [];
+    return {
+      databaseName,
+      totalConnections: pool.length,
+      activeConnections: pool.filter(conn => conn.inUse).length,
+      idleConnections: pool.filter(conn => !conn.inUse).length,
+      expiredConnections: pool.filter(conn => this.isConnectionExpired(conn)).length,
+      globalActiveConnections: this.activeConnections
+    };
+  }
+
+  /**
+   * Get all pool statistics
+   */
+  getAllPoolStats() {
+    const stats = {};
+    for (const [databaseName, pool] of this.connectionPool) {
+      stats[databaseName] = this.getPoolStats(databaseName);
+    }
+    return stats;
+  }
+
+  /**
+   * Clean up expired connections
+   */
+  cleanupExpiredConnections() {
+    for (const [databaseName, pool] of this.connectionPool) {
+      const validConnections = pool.filter(conn => !this.isConnectionExpired(conn));
+      this.connectionPool.set(databaseName, validConnections);
+    }
+  }
+
+  /**
+   * Close all connections
+   */
+  async closeAllConnections() {
+    for (const [databaseName, pool] of this.connectionPool) {
+      // In a real implementation, you'd close actual connections
+      pool.length = 0;
+    }
+    this.connectionPool.clear();
+    this.activeConnections = 0;
+  }
+}

package/dist/shared/database/index.js

@@ -0,0 +1,7 @@
+/**
+ * Database Module
+ * Exports all database management utilities
+ */
+
+export { DatabaseOrchestrator } from './orchestrator.js';
+export { DatabaseConnectionManager } from './connection-manager.js';