@tamyla/clodo-framework 3.1.22 → 3.1.24

package/dist/worker/index.js

@@ -0,0 +1,4 @@
+// Worker Integration Framework
+// Helpers for Cloudflare Worker integration
+
+export * from './integration.js';

package/dist/worker/integration.js

@@ -0,0 +1,351 @@
+import { COMMON_FEATURES, ConfigurationManager } from '../lib/shared/config/ConfigurationManager.js';
+import { getDomainFromEnv, createEnvironmentConfig } from '../config/domains.js';
+
+// Create a singleton instance of ConfigurationManager for use in integration
+export const configManager = new ConfigurationManager({});
+
+// Legacy featureManager compatibility interface using ConfigurationManager
+const featureManager = {
+  setDomain: domainConfig => configManager.setDomain(domainConfig),
+  getEnabledFeatures: () => configManager.getEnabledFeatures(),
+  isEnabled: featureName => configManager.isFeatureEnabled(featureName)
+};
+
+// Simple inline logger to avoid circular dependency with index.js
+const logger = {
+  info: (message, ...args) => console.log(`[WorkerIntegration] ${message}`, ...args),
+  error: (message, ...args) => console.error(`[WorkerIntegration] ${message}`, ...args),
+  warn: (message, ...args) => console.warn(`[WorkerIntegration] ${message}`, ...args),
+  debug: (message, ...args) => console.debug(`[WorkerIntegration] ${message}`, ...args)
+};
+
+/**
+ * Initializes a service with domain and feature context
+ * @param {Object} env - Cloudflare Worker environment
+ * @param {Object} domainConfigs - Available domain configurations
+ * @returns {Object} Service initialization context
+ */
+export const initializeService = (env, domainConfigs = {}) => {
+  try {
+    // Get domain configuration from environment
+    const domainConfig = getDomainFromEnv(env, domainConfigs);
+    if (!domainConfig) {
+      throw new Error('No domain configuration found for service initialization');
+    }
+
+    // Set domain in feature manager
+    featureManager.setDomain(domainConfig);
+
+    // Create environment-specific config
+    const environment = env.ENVIRONMENT || env.NODE_ENV || 'development';
+    const envConfig = createEnvironmentConfig(domainConfig, environment);
+
+    // Initialize service context
+    const serviceContext = {
+      domain: domainConfig.name,
+      environment,
+      features: featureManager.getEnabledFeatures(),
+      config: envConfig,
+      env,
+      isProduction: environment === 'production',
+      isStaging: environment === 'staging',
+      isDevelopment: environment === 'development'
+    };
+    logger.info(`Service initialized: ${domainConfig.name} (${environment})`);
+    logger.debug(`Enabled features: ${serviceContext.features.join(', ')}`);
+    return serviceContext;
+  } catch (error) {
+    logger.error(`Service initialization failed: ${error.message}`);
+    throw error;
+  }
+};
+
+/**
+ * Creates a feature guard middleware for Cloudflare Workers
+ * @param {string} featureName - Name of the feature to guard
+ * @param {Object} options - Guard options
+ * @returns {Function} Feature guard middleware
+ */
+export const createFeatureGuard = (featureName, options = {}) => {
+  const {
+    fallbackResponse = null,
+    required = true,
+    logAccess = true
+  } = options;
+  return handler => {
+    return async (request, env, ctx) => {
+      const isEnabled = featureManager.isEnabled(featureName);
+      if (logAccess) {
+        logger.debug(`Feature access: ${featureName} = ${isEnabled}`);
+      }
+      if (required && !isEnabled) {
+        const response = fallbackResponse || new Response(JSON.stringify({
+          error: 'Feature not available',
+          feature: featureName,
+          message: `The ${featureName} feature is not enabled for this domain`
+        }), {
+          status: 404,
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+        logger.warn(`Feature guard blocked access to ${featureName}`);
+        return response;
+      }
+      if (!isEnabled) {
+        logger.info(`Feature ${featureName} disabled, skipping handler`);
+        return fallbackResponse || new Response('Not Found', {
+          status: 404
+        });
+      }
+
+      // Feature is enabled, proceed with handler
+      return handler(request, env, ctx);
+    };
+  };
+};
+
+/**
+ * Creates a route-based feature guard
+ * @param {Object} routeConfig - Route configuration with feature requirements
+ * @returns {Function} Route guard middleware
+ */
+export const createRouteGuard = routeConfig => {
+  return handler => {
+    return async (request, env, ctx) => {
+      // Check route-specific feature requirements
+      for (const [feature, required] of Object.entries(routeConfig)) {
+        if (required && !featureManager.isEnabled(feature)) {
+          logger.warn(`Route blocked: missing required feature ${feature}`);
+          return new Response(JSON.stringify({
+            error: 'Feature required',
+            feature,
+            message: `This endpoint requires the ${feature} feature`
+          }), {
+            status: 403,
+            headers: {
+              'Content-Type': 'application/json'
+            }
+          });
+        }
+      }
+      return handler(request, env, ctx);
+    };
+  };
+};
+
+/**
+ * Creates an environment-based guard
+ * @param {string[]} allowedEnvironments - Array of allowed environments
+ * @returns {Function} Environment guard middleware
+ */
+export const createEnvironmentGuard = (allowedEnvironments = ['production', 'staging']) => {
+  return handler => {
+    return async (request, env, ctx) => {
+      const currentEnv = env.ENVIRONMENT || env.NODE_ENV || 'development';
+      if (!allowedEnvironments.includes(currentEnv)) {
+        logger.warn(`Environment guard blocked: ${currentEnv} not in ${allowedEnvironments.join(', ')}`);
+        return new Response('Not Found', {
+          status: 404
+        });
+      }
+      return handler(request, env, ctx);
+    };
+  };
+};
+
+/**
+ * Creates a rate limiting guard (basic implementation)
+ * @param {Object} options - Rate limiting options
+ * @returns {Function} Rate limiting middleware
+ */
+export const createRateLimitGuard = (options = {}) => {
+  const {
+    windowMs = 60000,
+    // 1 minute
+    maxRequests = 100,
+    skipSuccessfulRequests = false,
+    skipFailedRequests = false
+  } = options;
+  const requests = new Map();
+  const cleanup = () => {
+    const now = Date.now();
+    for (const [key, data] of requests.entries()) {
+      if (now - data.resetTime > windowMs) {
+        requests.delete(key);
+      }
+    }
+  };
+  return handler => {
+    return async (request, env, ctx) => {
+      // Skip rate limiting if feature is disabled
+      if (!featureManager.isEnabled(COMMON_FEATURES.RATE_LIMITING)) {
+        return handler(request, env, ctx);
+      }
+      const clientId = request.headers.get('CF-Connecting-IP') || 'anonymous';
+      const now = Date.now();
+      cleanup();
+      const clientData = requests.get(clientId) || {
+        count: 0,
+        resetTime: now + windowMs
+      };
+
+      // Reset counter if window has passed
+      if (now > clientData.resetTime) {
+        clientData.count = 0;
+        clientData.resetTime = now + windowMs;
+      }
+      clientData.count++;
+      requests.set(clientId, clientData);
+
+      // Check if limit exceeded
+      if (clientData.count > maxRequests) {
+        logger.warn(`Rate limit exceeded for ${clientId}`);
+        return new Response(JSON.stringify({
+          error: 'Too many requests',
+          retryAfter: Math.ceil((clientData.resetTime - now) / 1000)
+        }), {
+          status: 429,
+          headers: {
+            'Content-Type': 'application/json',
+            'Retry-After': Math.ceil((clientData.resetTime - now) / 1000).toString()
+          }
+        });
+      }
+      const response = await handler(request, env, ctx);
+
+      // Optionally skip successful/failed requests from count
+      if (skipSuccessfulRequests && response.ok || skipFailedRequests && !response.ok) {
+        clientData.count--;
+        requests.set(clientId, clientData);
+      }
+      return response;
+    };
+  };
+};
+
+/**
+ * Creates CORS middleware
+ * @param {Object} options - CORS options
+ * @returns {Function} CORS middleware
+ */
+export const createCorsMiddleware = (options = {}) => {
+  const {
+    origins = ['*'],
+    methods = ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    headers = ['Content-Type', 'Authorization'],
+    credentials = false,
+    maxAge = 86400
+  } = options;
+  return handler => {
+    return async (request, env, ctx) => {
+      // Handle preflight requests
+      if (request.method === 'OPTIONS') {
+        const origin = request.headers.get('Origin');
+
+        // Check if origin is allowed
+        const isWildcard = origins.includes('*');
+        const isOriginAllowed = isWildcard || origin && origins.includes(origin);
+        if (!isOriginAllowed) {
+          return new Response('CORS policy violation: Origin not allowed', {
+            status: 403,
+            headers: {
+              'Content-Type': 'text/plain'
+            }
+          });
+        }
+        const allowedOrigin = isWildcard ? '*' : origin;
+        return new Response(null, {
+          status: 200,
+          headers: {
+            'Access-Control-Allow-Origin': allowedOrigin,
+            'Access-Control-Allow-Methods': methods.join(', '),
+            'Access-Control-Allow-Headers': headers.join(', '),
+            'Access-Control-Max-Age': maxAge.toString(),
+            ...(credentials && {
+              'Access-Control-Allow-Credentials': 'true'
+            })
+          }
+        });
+      }
+
+      // Handle actual requests
+      const response = await handler(request, env, ctx);
+      const origin = request.headers.get('Origin');
+
+      // Add CORS headers to response only if origin is allowed
+      const isWildcard = origins.includes('*');
+      const isOriginAllowed = isWildcard || origin && origins.includes(origin);
+      if (isOriginAllowed) {
+        const allowedOrigin = isWildcard ? '*' : origin;
+        response.headers.set('Access-Control-Allow-Origin', allowedOrigin);
+        response.headers.set('Access-Control-Allow-Methods', methods.join(', '));
+        response.headers.set('Access-Control-Allow-Headers', headers.join(', '));
+        if (credentials) {
+          response.headers.set('Access-Control-Allow-Credentials', 'true');
+        }
+      }
+      return response;
+    };
+  };
+};
+
+/**
+ * Creates error handling middleware
+ * @param {Object} options - Error handling options
+ * @returns {Function} Error handling middleware
+ */
+export const createErrorHandler = (options = {}) => {
+  const {
+    includeStack = false,
+    logErrors = true,
+    transformError = null
+  } = options;
+  return handler => {
+    return async (request, env, ctx) => {
+      try {
+        return await handler(request, env, ctx);
+      } catch (error) {
+        if (logErrors) {
+          logger.error(`Request error: ${error.message}`, {
+            url: request.url,
+            method: request.method,
+            stack: includeStack ? error.stack : undefined
+          });
+        }
+
+        // Transform error if transformer provided
+        let errorResponse = {
+          error: 'Internal Server Error',
+          message: error.message,
+          ...(includeStack && {
+            stack: error.stack
+          })
+        };
+        if (transformError) {
+          errorResponse = transformError(error, errorResponse);
+        }
+        return new Response(JSON.stringify(errorResponse), {
+          status: 500,
+          headers: {
+            'Content-Type': 'application/json'
+          }
+        });
+      }
+    };
+  };
+};
+
+/**
+ * Composes multiple middleware functions
+ * @param {...Function} middlewares - Middleware functions to compose
+ * @returns {Function} Composed middleware
+ */
+export const composeMiddleware = (...middlewares) => {
+  if (middlewares.length === 0) {
+    return handler => handler;
+  }
+  return middlewares.reduceRight((composed, middleware) => {
+    return handler => middleware(composed(handler));
+  });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tamyla/clodo-framework",
-  "version": "3.1.22",
+  "version": "3.1.24",
   "description": "Reusable framework for Clodo-style software architecture on Cloudflare Workers + D1",
   "type": "module",
   "sideEffects": [
@@ -42,23 +42,15 @@
     "./modules/security": "./dist/modules/security.js"
   },
   "bin": {
-    "clodo-service": "./dist/bin/clodo-service.js",
-    "clodo-security": "./dist/bin/security/security-cli.js"
+    "clodo-service": "./dist/cli/clodo-service.js",
+    "clodo-security": "./dist/cli/security-cli.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
-    "dist/!(bin)",
-    "dist/bin/clodo-service.js",
-    "dist/bin/commands/deploy.js",
-    "dist/bin/commands/validate.js",
-    "dist/bin/commands/helpers/",
-    "dist/bin/shared/",
-    "dist/bin/security/",
-    "dist/bin/service-management/",
-    "dist/security/",
-    "dist/utils/",
+    "dist/",
+    "!dist/internal/",
     "types",
     "templates",
     "ui-structures",
@@ -71,8 +63,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "npm run prebuild && babel src/ --out-dir dist/ && babel bin/ --out-dir dist/bin/ --ignore 'bin/**/*.test.js' && node -e \"const fs=require('fs'); fs.cpSync('ui-structures', 'dist/ui-structures', {recursive: true}); fs.cpSync('config', 'dist/config', {recursive: true});\" && npm run postbuild",
-    "build:ci": "npm run prebuild:ci && babel src/ --out-dir dist/ && babel bin/ --out-dir dist/bin/ --ignore 'bin/**/*.test.js' && node -e \"const fs=require('fs'); fs.cpSync('ui-structures', 'dist/ui-structures', {recursive: true}); fs.cpSync('config', 'dist/config', {recursive: true});\" && npm run postbuild",
+    "build": "npm run prebuild && babel src/ --out-dir dist/ && babel cli/ --out-dir dist/cli/ --ignore 'cli/**/*.test.js' && babel lib/ --out-dir dist/lib/ --ignore 'lib/**/*.test.js' && node -e \"const fs=require('fs'); fs.cpSync('ui-structures', 'dist/ui-structures', {recursive: true}); fs.cpSync('config', 'dist/config', {recursive: true});\" && npm run postbuild",
+    "build:ci": "npm run prebuild:ci && babel src/ --out-dir dist/ && babel cli/ --out-dir dist/cli/ --ignore 'cli/**/*.test.js' && babel lib/ --out-dir dist/lib/ --ignore 'lib/**/*.test.js' && node -e \"const fs=require('fs'); fs.cpSync('ui-structures', 'dist/ui-structures', {recursive: true}); fs.cpSync('config', 'dist/config', {recursive: true});\" && npm run postbuild",
     "prebuild": "npm run clean && npm run type-check",
     "prebuild:ci": "npm run clean && npm run type-check",
     "postbuild": "npm run check:bundle && npm run check:imports && node scripts/utilities/fix-dist-imports.js",

package/dist/bin/commands/validate.js

@@ -1,51 +0,0 @@
-/**
- * Validate Command - Validate an existing service configuration
- */
-
-import chalk from 'chalk';
-import { ServiceOrchestrator } from '../../service-management/ServiceOrchestrator.js';
-import { StandardOptions } from '../shared/utils/cli-options.js';
-import { ConfigLoader } from '../shared/utils/config-loader.js';
-export function registerValidateCommand(program) {
-  const command = program.command('validate <service-path>').description('Validate an existing service configuration').option('--deep-scan', 'Run comprehensive validation checks').option('--export-report <file>', 'Export validation report to JSON file');
-
-  // Add standard options (--verbose, --quiet, --json, --no-color, --config-file)
-  StandardOptions.define(command).action(async (servicePath, options) => {
-    try {
-      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options);
-      const configLoader = new ConfigLoader({
-        verbose: options.verbose,
-        quiet: options.quiet,
-        json: options.json
-      });
-
-      // Load config from file if specified
-      let configFileData = {};
-      if (options.configFile) {
-        configFileData = configLoader.loadSafe(options.configFile, {});
-        if (options.verbose && !options.quiet) {
-          output.info(`Loaded configuration from: ${options.configFile}`);
-        }
-      }
-
-      // Merge config file defaults with CLI options (CLI takes precedence)
-      const mergedOptions = configLoader.merge(configFileData, options);
-      const orchestrator = new ServiceOrchestrator();
-      const result = await orchestrator.validateService(servicePath, {
-        deepScan: mergedOptions.deepScan,
-        exportReport: mergedOptions.exportReport
-      });
-      if (result.valid) {
-        output.success('Service configuration is valid');
-      } else {
-        output.error('Service configuration has issues:');
-        output.list(result.issues || []);
-        process.exit(1);
-      }
-    } catch (error) {
-      const output = new (await import('../shared/utils/output-formatter.js')).OutputFormatter(options || {});
-      output.error(`Validation failed: ${error.message}`);
-      process.exit(1);
-    }
-  });
-}

package/dist/bin/security/security-cli.js

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-import { SecurityCLI } from '../../security/SecurityCLI.js';
-const command = process.argv[2];
-const args = process.argv.slice(3);
-async function main() {
-  const cli = new SecurityCLI();
-  switch (command) {
-    case 'validate':
-      const [customer, environment] = args;
-      const result = await cli.validateConfiguration(customer, environment);
-      if (result.valid) {
-        console.log('✅ Security validation passed');
-      } else {
-        console.log('❌ Security issues found');
-        result.securityIssues.forEach(issue => {
-          console.log(`   ${issue.severity.toUpperCase()}: ${issue.message}`);
-        });
-      }
-      process.exit(result.valid ? 0 : 1);
-      break;
-    case 'generate-key':
-      const [type, lengthStr] = args;
-      const length = lengthStr ? parseInt(lengthStr) : undefined;
-      const keyResult = cli.generateKey(type, length);
-      if (keyResult.success) {
-        console.log(`Generated ${keyResult.type}: ${keyResult.key}`);
-      } else {
-        console.error(`Key generation failed: ${keyResult.error}`);
-        process.exit(1);
-      }
-      break;
-    case 'deploy':
-      // Check for help flag first
-      if (args.includes('--help') || args.includes('-h')) {
-        console.log('Deploy with security validation');
-        console.log('');
-        console.log('Usage:');
-        console.log('  clodo-security deploy <customer> <environment> [options]');
-        console.log('');
-        console.log('Arguments:');
-        console.log('  customer      Customer name (e.g., wetechfounders)');
-        console.log('  environment   Target environment (development, staging, production)');
-        console.log('');
-        console.log('Options:');
-        console.log('  --dry-run     Simulate deployment without making changes');
-        console.log('  --help, -h    Display this help message');
-        console.log('');
-        console.log('Examples:');
-        console.log('  clodo-security deploy wetechfounders development');
-        console.log('  clodo-security deploy greatidude production --dry-run');
-        break;
-      }
-      const [deployCustomer, deployEnvironment] = args.filter(arg => !arg.startsWith('--'));
-      const dryRun = args.includes('--dry-run');
-      const deployResult = await cli.deployWithSecurity(deployCustomer, deployEnvironment, {
-        dryRun
-      });
-      if (deployResult.success) {
-        console.log(`✅ Deployment ${dryRun ? 'validation' : 'completed'} successfully`);
-      } else {
-        console.error(`Deployment failed: ${deployResult.error}`);
-        process.exit(1);
-      }
-      break;
-    case 'generate-config':
-      const [configCustomer, configEnvironment] = args;
-      const configResult = cli.generateSecureConfig(configCustomer, configEnvironment);
-      if (configResult.success) {
-        console.log('Generated secure configuration:');
-        console.log(JSON.stringify(configResult.config, null, 2));
-      } else {
-        console.error(`Config generation failed: ${configResult.error}`);
-        process.exit(1);
-      }
-      break;
-    case 'check-readiness':
-      const [readyCustomer, readyEnvironment] = args;
-      const readinessResult = cli.checkDeploymentReadiness(readyCustomer, readyEnvironment);
-      if (readinessResult.ready) {
-        console.log('✅ Deployment ready');
-      } else {
-        console.log('❌ Deployment not ready:');
-        readinessResult.issues.forEach(issue => console.log(`   - ${issue}`));
-        process.exit(1);
-      }
-      break;
-    default:
-      console.log('Clodo Framework Security CLI');
-      console.log('');
-      console.log('Commands:');
-      console.log('  validate <customer> <environment>    - Validate configuration security');
-      console.log('  generate-key [type] [length]         - Generate secure key (api/jwt)');
-      console.log('  deploy <customer> <environment>      - Deploy with security validation');
-      console.log('  generate-config <customer> <env>     - Generate secure configuration');
-      console.log('  check-readiness <customer> <env>     - Check deployment readiness');
-      console.log('');
-      console.log('Examples:');
-      console.log('  clodo-security validate tamyla production');
-      console.log('  clodo-security generate-key jwt 64');
-      console.log('  clodo-security generate-key content-skimmer');
-      console.log('  clodo-security deploy tamyla staging --dry-run');
-      break;
-  }
-}
-main().catch(error => {
-  console.error(`Unexpected error: ${error.message}`);
-  process.exit(1);
-});

package/dist/bin/shared/deployment/index.js

@@ -1,10 +0,0 @@
-/**
- * Deployment Module
- * Exports all deployment-related orchestrators, validators, and managers
- */
-
-export { DeploymentValidator } from './validator.js';
-export { MultiDomainOrchestrator } from '../../orchestration/multi-domain-orchestrator.js';
-export { CrossDomainCoordinator } from '../../orchestration/cross-domain-coordinator.js';
-export { DeploymentAuditor } from './auditor.js';
-export { RollbackManager } from './rollback-manager.js';