@tamyla/clodo-framework 3.1.22 → 3.1.24

package/dist/config/domain-examples/multi-domain.json

@@ -0,0 +1,144 @@
+{
+  "domains": {
+    "api.example.com": {
+      "environment": "production",
+      "serviceName": "api-service",
+      "serviceType": "data-service",
+      "cloudflareToken": "CLOUDFLARE_API_TOKEN_PLACEHOLDER",
+      "cloudflareAccountId": "1234567890abcdef1234567890abcdef",
+      "cloudflareZoneId": "0987654321fedcba0987654321fedcba",
+      "displayName": "Production API Service",
+      "description": "Production API service with high availability",
+      "deploymentStrategy": "blue-green",
+      "healthCheck": {
+        "enabled": true,
+        "path": "/health",
+        "interval": 30,
+        "timeout": 10
+      },
+      "routing": {
+        "rules": [
+          {
+            "pattern": "/api/v1/*",
+            "target": "api-v1-worker",
+            "methods": ["GET", "POST", "PUT", "DELETE"]
+          },
+          {
+            "pattern": "/api/v2/*",
+            "target": "api-v2-worker",
+            "methods": ["GET", "POST", "PUT", "DELETE"]
+          }
+        ]
+      },
+      "security": {
+        "cors": {
+          "enabled": true,
+          "origins": ["https://app.example.com", "https://admin.example.com"],
+          "methods": ["GET", "POST", "PUT", "DELETE"],
+          "headers": ["Content-Type", "Authorization", "X-API-Key"]
+        },
+        "rateLimit": {
+          "enabled": true,
+          "requests": 5000,
+          "window": 60
+        }
+      }
+    },
+    "admin.example.com": {
+      "environment": "production",
+      "serviceName": "admin-service",
+      "serviceType": "web-service",
+      "cloudflareToken": "CLOUDFLARE_API_TOKEN_PLACEHOLDER",
+      "cloudflareAccountId": "1234567890abcdef1234567890abcdef",
+      "cloudflareZoneId": "0987654321fedcba0987654321fedcba",
+      "displayName": "Admin Dashboard Service",
+      "description": "Administrative dashboard with restricted access",
+      "deploymentStrategy": "rolling",
+      "healthCheck": {
+        "enabled": true,
+        "path": "/admin/health",
+        "interval": 60,
+        "timeout": 15
+      },
+      "routing": {
+        "rules": [
+          {
+            "pattern": "/admin/*",
+            "target": "admin-worker",
+            "methods": ["GET", "POST", "PUT", "DELETE"],
+            "auth": {
+              "required": true,
+              "type": "jwt"
+            }
+          }
+        ]
+      },
+      "security": {
+        "cors": {
+          "enabled": false
+        },
+        "rateLimit": {
+          "enabled": true,
+          "requests": 100,
+          "window": 60
+        },
+        "waf": {
+          "enabled": true,
+          "rules": ["sql-injection", "xss", "csrf"]
+        }
+      }
+    },
+    "cdn.example.com": {
+      "environment": "production",
+      "serviceName": "cdn-service",
+      "serviceType": "static-site",
+      "cloudflareToken": "CLOUDFLARE_API_TOKEN_PLACEHOLDER",
+      "cloudflareAccountId": "1234567890abcdef1234567890abcdef",
+      "cloudflareZoneId": "0987654321fedcba0987654321fedcba",
+      "displayName": "CDN Static Assets",
+      "description": "Content delivery network for static assets",
+      "deploymentStrategy": "instant",
+      "healthCheck": {
+        "enabled": false
+      },
+      "routing": {
+        "rules": [
+          {
+            "pattern": "/*",
+            "target": "cdn-worker",
+            "methods": ["GET", "HEAD"],
+            "cache": {
+              "enabled": true,
+              "ttl": 3600,
+              "purgeOnDeploy": true
+            }
+          }
+        ]
+      },
+      "security": {
+        "cors": {
+          "enabled": true,
+          "origins": ["*"],
+          "methods": ["GET", "HEAD"],
+          "headers": ["Cache-Control", "ETag"]
+        },
+        "rateLimit": {
+          "enabled": false
+        }
+      }
+    }
+  },
+  "global": {
+    "customer": "example-company",
+    "organization": "Example Corp",
+    "contact": "devops@example.com",
+    "version": "1.0.0",
+    "lastUpdated": "2025-10-28",
+    "multiDomain": {
+      "enabled": true,
+      "parallelDeployments": 2,
+      "rollbackOnFailure": true,
+      "healthCheckTimeout": 300
+    }
+  }
+}

package/dist/config/domain-examples/single-domain.json

@@ -0,0 +1,50 @@
+{
+  "domains": {
+    "api.example.com": {
+      "environment": "production",
+      "serviceName": "api-service",
+      "serviceType": "data-service",
+      "cloudflareToken": "CLOUDFLARE_API_TOKEN_PLACEHOLDER",
+      "cloudflareAccountId": "1234567890abcdef1234567890abcdef",
+      "cloudflareZoneId": "0987654321fedcba0987654321fedcba",
+      "displayName": "Example API Service",
+      "description": "Single domain configuration for production API service",
+      "deploymentStrategy": "rolling",
+      "healthCheck": {
+        "enabled": true,
+        "path": "/health",
+        "interval": 30,
+        "timeout": 10
+      },
+      "routing": {
+        "rules": [
+          {
+            "pattern": "/api/*",
+            "target": "api-worker",
+            "methods": ["GET", "POST", "PUT", "DELETE"]
+          }
+        ]
+      },
+      "security": {
+        "cors": {
+          "enabled": true,
+          "origins": ["https://app.example.com"],
+          "methods": ["GET", "POST", "PUT", "DELETE"],
+          "headers": ["Content-Type", "Authorization"]
+        },
+        "rateLimit": {
+          "enabled": true,
+          "requests": 1000,
+          "window": 60
+        }
+      }
+    }
+  },
+  "global": {
+    "customer": "example-company",
+    "organization": "Example Corp",
+    "contact": "devops@example.com",
+    "version": "1.0.0",
+    "lastUpdated": "2025-10-28"
+  }
+}

package/dist/config/domains.js

@@ -0,0 +1,186 @@
+// Simple inline logger to avoid circular dependency with index.js
+import { validateRequired, deepMerge } from '../utils/index.js';
+const logger = {
+  info: (message, ...args) => console.log(`[DomainConfig] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[DomainConfig] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[DomainConfig] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[DomainConfig] ${message}`, ...args)
+};
+
+/**
+ * Creates a base domain configuration schema
+ * @returns {Object} Base domain configuration template
+ */
+export const createDomainConfigSchema = () => ({
+  name: '',
+  displayName: '',
+  accountId: '',
+  zoneId: '',
+  domains: {
+    production: '',
+    staging: '',
+    development: ''
+  },
+  services: {},
+  databases: {},
+  features: {},
+  settings: {
+    environment: 'development',
+    logLevel: 'info',
+    corsOrigins: ['*']
+  }
+});
+
+/**
+ * Validates a domain configuration object
+ * @param {Object} config - Domain configuration to validate
+ * @throws {Error} If validation fails
+ */
+export const validateDomainConfig = config => {
+  try {
+    // Required top-level fields
+    validateRequired(config, ['name', 'accountId', 'zoneId']);
+
+    // Validate Cloudflare IDs format (basic check)
+    if (!/^[a-f0-9]{32}$/.test(config.accountId)) {
+      throw new Error('accountId must be a valid Cloudflare account ID (32 hex characters)');
+    }
+    if (!/^[a-f0-9]{32}$/.test(config.zoneId)) {
+      throw new Error('zoneId must be a valid Cloudflare zone ID (32 hex characters)');
+    }
+
+    // Validate domains structure
+    if (!config.domains || typeof config.domains !== 'object') {
+      throw new Error('domains must be an object with production/staging/development keys');
+    }
+
+    // At least one domain should be configured
+    const hasDomain = Object.values(config.domains).some(domain => domain && domain.trim());
+    if (!hasDomain) {
+      throw new Error('At least one domain (production, staging, or development) must be configured');
+    }
+
+    // Validate domain formats (basic URL validation)
+    Object.entries(config.domains).forEach(([env, domain]) => {
+      if (domain && domain.trim()) {
+        try {
+          new URL(`https://${domain}`);
+        } catch {
+          throw new Error(`Invalid domain format for ${env}: ${domain}`);
+        }
+      }
+    });
+    logger.info(`Domain configuration validated: ${config.name}`);
+  } catch (error) {
+    logger.error(`Domain configuration validation failed: ${error.message}`);
+    throw error;
+  }
+};
+
+/**
+ * Merges base domain config with service-specific extensions
+ * @param {Object} baseConfig - Base domain configuration
+ * @param {Object} serviceConfig - Service-specific configuration extensions
+ * @returns {Object} Merged configuration
+ */
+export const mergeDomainConfigs = (baseConfig, serviceConfig) => {
+  if (!baseConfig || !serviceConfig) {
+    throw new Error('Both baseConfig and serviceConfig are required for merging');
+  }
+  const merged = deepMerge(baseConfig, serviceConfig);
+
+  // Validate the merged configuration
+  validateDomainConfig(merged);
+  logger.info(`Domain configurations merged: ${baseConfig.name}`);
+  return merged;
+};
+
+/**
+ * Creates a domain configuration registry
+ * @param {Object} domainConfigs - Object containing domain configurations
+ * @returns {Object} Domain registry with lookup methods
+ */
+export const createDomainRegistry = domainConfigs => {
+  const registry = {
+    ...domainConfigs
+  };
+  return {
+    get: domainName => {
+      const config = registry[domainName];
+      if (!config) {
+        throw new Error(`Domain not found: ${domainName}`);
+      }
+      return config;
+    },
+    list: () => Object.keys(registry),
+    validateAll: () => {
+      Object.values(registry).forEach(validateDomainConfig);
+      logger.info(`All ${Object.keys(registry).length} domain configurations validated`);
+    },
+    add: (domainName, config) => {
+      validateDomainConfig(config);
+      registry[domainName] = config;
+      logger.info(`Domain added to registry: ${domainName}`);
+    },
+    remove: domainName => {
+      if (!registry[domainName]) {
+        throw new Error(`Domain not found: ${domainName}`);
+      }
+      delete registry[domainName];
+      logger.info(`Domain removed from registry: ${domainName}`);
+    }
+  };
+};
+
+/**
+ * Gets domain configuration from environment variables
+ * @param {Object} env - Environment variables
+ * @param {Object} domainConfigs - Available domain configurations
+ * @returns {Object} Domain configuration for current environment
+ */
+export const getDomainFromEnv = (env, domainConfigs) => {
+  const domainName = env.DOMAIN_NAME || env.CF_DOMAIN_NAME || 'default';
+  if (!domainConfigs[domainName]) {
+    logger.warn(`Domain not found: ${domainName}, using default`);
+    return domainConfigs.default || Object.values(domainConfigs)[0];
+  }
+  return domainConfigs[domainName];
+};
+
+/**
+ * Creates environment-specific configuration overrides
+ * @param {Object} baseConfig - Base domain configuration
+ * @param {string} environment - Target environment (production, staging, development)
+ * @returns {Object} Environment-specific configuration
+ */
+export const createEnvironmentConfig = (baseConfig, environment = 'development') => {
+  const envConfig = {
+    ...baseConfig
+  };
+
+  // Set environment-specific settings
+  envConfig.settings = {
+    ...envConfig.settings,
+    environment,
+    isProduction: environment === 'production',
+    isStaging: environment === 'staging',
+    isDevelopment: environment === 'development'
+  };
+
+  // Environment-specific domain selection
+  if (envConfig.domains[environment]) {
+    envConfig.currentDomain = envConfig.domains[environment];
+  }
+
+  // Environment-specific feature overrides
+  if (environment === 'production') {
+    // Ensure critical features are enabled in production
+    envConfig.features = {
+      ...envConfig.features,
+      errorReporting: true,
+      monitoring: true
+    };
+  }
+  logger.info(`Environment config created for ${baseConfig.name} (${environment})`);
+  return envConfig;
+};

package/dist/config/examples

@@ -0,0 +1,12 @@
+{
+  "customer": "mycompany",
+  "environment": "production",
+  "serviceName": "my-api-service",
+  "serviceType": "data-service",
+  "domainName": "api.mycompany.com",
+  "cloudflareToken": "CLOUDFLARE_API_TOKEN_PLACEHOLDER",
+  "cloudflareAccountId": "1234567890abcdef1234567890abcdef",
+  "cloudflareZoneId": "0987654321fedcba0987654321fedcba",
+  "displayName": "My Company API Service",
+  "description": "Production API service for customer data management"
+}

package/dist/config/features.js

@@ -0,0 +1,61 @@
+/**
+ * Feature Flag Manager
+ * Simple stub for missing features.js
+ */
+
+export class FeatureFlagManager {
+  constructor() {
+    this.features = new Map();
+  }
+  isEnabled(feature) {
+    return this.features.get(feature) || false;
+  }
+  enable(feature) {
+    this.features.set(feature, true);
+  }
+  disable(feature) {
+    this.features.set(feature, false);
+  }
+  withFeature(feature, enhancedFn, legacyFn = null) {
+    if (this.isEnabled(feature)) {
+      return enhancedFn();
+    } else if (legacyFn) {
+      return legacyFn();
+    } else {
+      // If no legacy function provided, just call enhanced anyway
+      return enhancedFn();
+    }
+  }
+  getAllFeatures() {
+    const result = {};
+    for (const [key, value] of this.features) {
+      result[key] = {
+        enabled: value
+      };
+    }
+    return result;
+  }
+}
+
+// Default instance
+export const featureManager = new FeatureFlagManager();
+
+// Feature constants
+export const FEATURES = {
+  ENHANCED_SCHEMA: 'enhanced_schema',
+  ENHANCED_VALIDATION: 'enhanced_validation',
+  ENABLE_COMPREHENSIVE_VALIDATION: 'enhanced_validation',
+  ENABLE_SQL_CACHING: 'sql_caching',
+  ENABLE_SCHEMA_CACHING: 'schema_caching',
+  ENABLE_ADVANCED_QUERIES: 'advanced_queries',
+  ENABLE_SECURITY_CONTROLS: 'security_controls',
+  ENABLE_QUERY_CACHING: 'query_caching',
+  ENABLE_ADVANCED_PAGINATION: 'advanced_pagination',
+  ENABLE_CACHE_METRICS: 'cache_metrics',
+  ENABLE_DEBUG_LOGGING: 'debug_logging',
+  ENABLE_ENHANCED_SCHEMA: 'enhanced_schema',
+  ENABLE_HOOK_METRICS: 'hook_metrics',
+  ENABLE_HOOK_TIMEOUT: 'hook_timeout',
+  ENABLE_ENHANCED_HOOKS: 'enhanced_hooks',
+  ENABLE_PARALLEL_EXECUTION: 'parallel_execution'
+};

package/dist/config/index.js

@@ -0,0 +1,6 @@
+// Configuration Framework
+// Domain configuration and feature flag management
+
+export * from './domains.js';
+export * from './features.js';
+export * from './customers.js';

package/dist/config/staging-deployment.json

@@ -0,0 +1,60 @@
+{
+  "// Comment": "Staging deployment configuration for clodo-framework",
+  "// Instructions": "This config deploys to staging environment using environment-mapped domain configuration",
+  "// Domain": "Uses staging.example.com domain from environment-mapped.json",
+  "// Environment": "Staging environment with moderate security and monitoring",
+
+  "domain": "staging.example.com",
+  "environment": "staging",
+  "cloudflareToken": "${CLOUDFLARE_API_TOKEN}",
+  "cloudflareAccountId": "${CLOUDFLARE_ACCOUNT_ID}",
+  "cloudflareZoneId": "${CLOUDFLARE_ZONE_ID}",
+
+  "deployment": {
+    "strategy": "rolling",
+    "replicas": 2,
+    "maxConcurrency": 50,
+    "timeout": 60000,
+    "healthCheckInterval": 10000,
+    "rollbackOnFailure": true
+  },
+
+  "routing": {
+    "enableLoadBalancing": true,
+    "loadBalancingPolicy": "round-robin",
+    "corsEnabled": true,
+    "corsOrigins": ["https://staging.example.com", "https://app-staging.example.com"]
+  },
+
+  "monitoring": {
+    "enableMetrics": true,
+    "metricsEndpoint": "https://metrics-staging.example.com",
+    "alertOnFailure": true,
+    "alertEmail": "staging-alerts@example.com"
+  },
+
+  "security": {
+    "enableSSL": true,
+    "minTLSVersion": "1.2",
+    "enableWAF": true,
+    "rateLimit": 500,
+    "rateLimitWindow": 60,
+    "wafRules": ["sql-injection", "xss"]
+  },
+
+  "healthCheck": {
+    "enabled": true,
+    "endpoint": "/health",
+    "interval": 30000,
+    "timeout": 10000,
+    "healthyThreshold": 2,
+    "unhealthyThreshold": 3
+  },
+
+  "logging": {
+    "level": "info",
+    "includeRequestId": true,
+    "includeTimestamp": true,
+    "maskSensitiveData": true
+  }
+}