@tamyla/clodo-framework 4.0.13 → 4.0.15

package/dist/security/ConfigurationValidator.js

@@ -460,6 +460,222 @@ export class ConfigurationValidator {
     return config;
   }
 
+  /**
+   * Validate service configuration consistency between manifest and wrangler config
+   * @param {string} manifestPath - Path to manifest.json
+   * @param {string} wranglerPath - Path to wrangler.toml
+   * @returns {Object} Validation result with issues array
+   */
+  static validateServiceConfig(manifestPath, wranglerPath) {
+    const issues = [];
+    try {
+      // Read manifest.json
+      const manifestContent = readFileSync(manifestPath, 'utf8');
+      const manifest = JSON.parse(manifestContent);
+
+      // Read wrangler.toml (basic parsing - could be enhanced with a TOML parser)
+      const wranglerContent = readFileSync(wranglerPath, 'utf8');
+      const wranglerConfig = this.parseWranglerToml(wranglerContent);
+
+      // Validate D1 database consistency
+      this.validateD1Consistency(manifest, wranglerConfig, issues);
+
+      // Validate KV namespace consistency
+      this.validateKVConsistency(manifest, wranglerConfig, issues);
+
+      // Validate R2 bucket consistency
+      this.validateR2Consistency(manifest, wranglerConfig, issues);
+
+      // Validate environment variables
+      this.validateEnvironmentConsistency(manifest, wranglerConfig, issues);
+    } catch (error) {
+      issues.push({
+        type: 'error',
+        message: `Configuration validation failed: ${error.message}`,
+        severity: 'critical'
+      });
+    }
+    return {
+      valid: issues.length === 0,
+      issues: issues
+    };
+  }
+
+  /**
+   * Parse wrangler.toml content (basic implementation)
+   * @param {string} content - TOML content
+   * @returns {Object} Parsed configuration
+   */
+  static parseWranglerToml(content) {
+    const config = {
+      d1_databases: [],
+      kv_namespaces: [],
+      r2_buckets: [],
+      vars: {}
+    };
+    if (!content || !content.trim()) {
+      return config;
+    }
+    const lines = content.split('\n');
+    let currentSection = null;
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Section headers
+      if (trimmed.startsWith('[[')) {
+        if (trimmed.includes('d1_databases')) {
+          currentSection = 'd1_databases';
+          config.d1_databases.push({});
+        } else if (trimmed.includes('kv_namespaces')) {
+          currentSection = 'kv_namespaces';
+          config.kv_namespaces.push({});
+        } else if (trimmed.includes('r2_buckets')) {
+          currentSection = 'r2_buckets';
+          config.r2_buckets.push({});
+        }
+      } else if (trimmed.startsWith('[') && !trimmed.startsWith('[[')) {
+        currentSection = trimmed.replace(/\[|\]/g, '');
+        // Support both table and array-of-tables syntaxes by creating a container
+        if (Array.isArray(config[currentSection]) && config[currentSection].length === 0) {
+          config[currentSection].push({});
+        }
+      }
+      // Key-value pairs
+      else if (trimmed.includes('=') && currentSection) {
+        const [key, ...valueParts] = trimmed.split('=');
+        const value = valueParts.join('=').trim().replace(/"/g, '');
+        if (currentSection === 'vars') {
+          config.vars[key.trim()] = value;
+        } else if (Array.isArray(config[currentSection])) {
+          const currentItem = config[currentSection][config[currentSection].length - 1];
+          if (currentItem) {
+            currentItem[key.trim()] = value;
+          }
+        }
+      }
+    }
+    return config;
+  }
+
+  /**
+   * Validate D1 database consistency
+   */
+  static validateD1Consistency(manifest, wranglerConfig, issues) {
+    const manifestD1 = manifest.d1 || false;
+    const wranglerD1 = wranglerConfig.d1_databases || [];
+    if (manifestD1 === true && wranglerD1.length === 0) {
+      issues.push({
+        type: 'mismatch',
+        message: 'Manifest declares D1=true but wrangler.toml has no [[d1_databases]] configured',
+        severity: 'critical',
+        manifest: {
+          d1: manifestD1
+        },
+        wrangler: {
+          d1_databases: wranglerD1
+        }
+      });
+    } else if (manifestD1 === false && wranglerD1.length > 0) {
+      issues.push({
+        type: 'mismatch',
+        message: 'Manifest declares D1=false but wrangler.toml has [[d1_databases]] configured',
+        severity: 'critical',
+        manifest: {
+          d1: manifestD1
+        },
+        wrangler: {
+          d1_databases: wranglerD1
+        }
+      });
+    }
+  }
+
+  /**
+   * Validate KV namespace consistency
+   */
+  static validateKVConsistency(manifest, wranglerConfig, issues) {
+    const manifestKV = manifest.kv || false;
+    const wranglerKV = wranglerConfig.kv_namespaces || [];
+    if (manifestKV === true && wranglerKV.length === 0) {
+      issues.push({
+        type: 'mismatch',
+        message: 'Manifest declares KV=true but wrangler.toml has no [[kv_namespaces]] configured',
+        severity: 'critical',
+        manifest: {
+          kv: manifestKV
+        },
+        wrangler: {
+          kv_namespaces: wranglerKV
+        }
+      });
+    } else if (manifestKV === false && wranglerKV.length > 0) {
+      issues.push({
+        type: 'mismatch',
+        message: 'Manifest declares KV=false but wrangler.toml has [[kv_namespaces]] configured',
+        severity: 'critical',
+        manifest: {
+          kv: manifestKV
+        },
+        wrangler: {
+          kv_namespaces: wranglerKV
+        }
+      });
+    }
+  }
+
+  /**
+   * Validate R2 bucket consistency
+   */
+  static validateR2Consistency(manifest, wranglerConfig, issues) {
+    const manifestR2 = manifest.r2 || false;
+    const wranglerR2 = wranglerConfig.r2_buckets || [];
+    if (manifestR2 === true && wranglerR2.length === 0) {
+      issues.push({
+        type: 'mismatch',
+        message: 'Manifest declares R2=true but wrangler.toml has no [[r2_buckets]] configured',
+        severity: 'critical',
+        manifest: {
+          r2: manifestR2
+        },
+        wrangler: {
+          r2_buckets: wranglerR2
+        }
+      });
+    } else if (manifestR2 === false && wranglerR2.length > 0) {
+      issues.push({
+        type: 'mismatch',
+        message: 'Manifest declares R2=false but wrangler.toml has [[r2_buckets]] configured',
+        severity: 'critical',
+        manifest: {
+          r2: manifestR2
+        },
+        wrangler: {
+          r2_buckets: wranglerR2
+        }
+      });
+    }
+  }
+
+  /**
+   * Validate environment variable consistency
+   */
+  static validateEnvironmentConsistency(manifest, wranglerConfig, issues) {
+    const manifestEnv = manifest.environment || {};
+    const wranglerEnv = wranglerConfig.vars || {};
+
+    // Check for required environment variables declared in manifest but missing in wrangler
+    for (const [key, value] of Object.entries(manifestEnv)) {
+      if (value === 'required' && !(key in wranglerEnv)) {
+        issues.push({
+          type: 'missing_env',
+          message: `Manifest declares ${key} as required but not found in wrangler.toml vars`,
+          severity: 'warning',
+          key: key
+        });
+      }
+    }
+  }
+
   /**
    * Log validation results
    */

package/dist/service-management/GenerationEngine.js

@@ -52,6 +52,8 @@ export class GenerationEngine {
     this.templatesDir = options.templatesDir || join(__dirname, '..', '..', 'templates');
     this.outputDir = options.outputDir || process.cwd();
     this.force = options.force || false;
+    // Default middleware strategy: 'contract' (can be overridden per-generation)
+    this.middlewareStrategy = options.middlewareStrategy || 'contract';
 
     // Initialize generator registry for centralized management
     this.generatorRegistry = new GeneratorRegistry({
@@ -192,7 +194,7 @@ export class GenerationEngine {
       },
       generateServiceMiddleware: {
         generator: 'serviceMiddlewareGenerator',
-        returnPath: 'src/middleware.js'
+        returnPath: 'src/middleware/service-middleware.js'
       },
       generateServiceUtils: {
         generator: 'serviceUtilsGenerator',
@@ -283,6 +285,8 @@ export class GenerationEngine {
       // Only create proxy method if it doesn't already exist
       if (!this[methodName]) {
         this[methodName] = async function (...args) {
+          // Allow per-call overrides (apply BEFORE building context so context picks it up)
+          if (args[0] && args[0].middlewareStrategy) this.middlewareStrategy = args[0].middlewareStrategy;
           const context = this.buildContext(methodName, ...args);
           const generator = this[config.generator];
           const result = await generator.generate(context);
@@ -315,10 +319,12 @@ export class GenerationEngine {
     }
 
     // For most methods: (coreInputs, confirmedValues, servicePath)
+    // Include middlewareStrategy so generators can adapt their output
     return {
       coreInputs: args[0],
       confirmedValues: args[1],
-      servicePath: args[2]
+      servicePath: args[2],
+      middlewareStrategy: this.middlewareStrategy
     };
   }
 
@@ -334,6 +340,11 @@ export class GenerationEngine {
       outputPath: this.outputDir,
       ...options
     };
+
+    // Allow per-generation override of middleware strategy
+    if (config.middlewareStrategy) {
+      this.middlewareStrategy = config.middlewareStrategy;
+    }
     console.log('⚙️  Tier 3: Automated Generation');
     console.log('Generating 67+ configuration files and service components...\n');
     try {

package/dist/service-management/ServiceOrchestrator.js

@@ -25,6 +25,8 @@ export class ServiceOrchestrator {
     this.interactive = options.interactive !== false;
     this.outputPath = options.outputPath || '.';
     this.templatePath = options.templatePath || './templates';
+    // Middleware strategy for generation: 'contract' (default) or 'legacy'
+    this.middlewareStrategy = options.middlewareStrategy || 'contract';
 
     // Initialize modular handler components
     this.inputHandler = new InputHandler({
@@ -63,7 +65,8 @@ export class ServiceOrchestrator {
       console.log(chalk.yellow('⚙️  Tier 3: Automated Generation'));
       console.log(chalk.white('Generating 67 configuration files and service components...\n'));
       const generationResult = await this.generationHandler.generateService(coreInputs, confirmedValues, {
-        outputPath: this.outputPath
+        outputPath: this.outputPath,
+        middlewareStrategy: this.middlewareStrategy
       });
 
       // Display results
@@ -87,7 +90,8 @@ export class ServiceOrchestrator {
 
       // Generate service using GenerationHandler
       const generationResult = await this.generationHandler.generateService(coreInputs, confirmedValues, {
-        outputPath: this.outputPath
+        outputPath: this.outputPath,
+        middlewareStrategy: this.middlewareStrategy
       });
       console.log(chalk.green(`✓ Service "${coreInputs.serviceName}" created successfully`));
     } catch (error) {

package/dist/service-management/generators/BaseGenerator.js

@@ -180,6 +180,9 @@ export class BaseGenerator {
     const fullPath = path.join(this.servicePath, relativePath);
     const overwrite = options.overwrite !== false; // Default to true
 
+    // Debug: log the target file path for diagnosis
+    this.logger.info(`BaseGenerator: writing file -> ${fullPath}`);
+
     // Check if file exists and overwrite is disabled
     try {
       await fs.access(fullPath);
@@ -197,13 +200,35 @@ export class BaseGenerator {
       recursive: true
     });
 
-    // Write file
-    try {
-      await fs.writeFile(fullPath, content, 'utf8');
-      this.logger.info(`Generated: ${relativePath}`);
-    } catch (error) {
-      throw new Error(`Failed to write file '${relativePath}': ${error.message}`);
+    // Write file with retry logic for filesystem stability
+    const maxRetries = 3;
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        this.logger.info(`BaseGenerator: attempt ${attempt} - writing to ${fullPath}`);
+        await fs.writeFile(fullPath, content, 'utf8');
+
+        // Add a small delay to let file system settle, especially on Windows
+        if (attempt === 1) {
+          await new Promise(resolve => setTimeout(resolve, 10));
+        }
+
+        // Verify the file was written successfully by checking it exists
+        await fs.access(fullPath, fs.constants.F_OK);
+        this.logger.info(`Generated: ${relativePath}`);
+        return; // Success
+      } catch (error) {
+        lastError = error;
+        this.logger.warn(`Write attempt ${attempt}/${maxRetries} failed for ${relativePath}: ${error.message}`);
+        if (attempt < maxRetries) {
+          // Wait before retry (exponential backoff)
+          await new Promise(resolve => setTimeout(resolve, 50 * attempt));
+        }
+      }
     }
+
+    // If all retries failed, throw the last error
+    throw new Error(`Failed to write and verify file '${relativePath}' after ${maxRetries} attempts: ${lastError.message}`);
   }
 
   /**

package/dist/service-management/generators/code/ServiceMiddlewareGenerator.js

@@ -21,8 +21,13 @@ export class ServiceMiddlewareGenerator extends BaseGenerator {
     if (!this.shouldGenerate(context)) {
       return null;
     }
-    const middlewareContent = `/**
- * ${confirmedValues.displayName} - Service Middleware
+
+    // Allow legacy strategy if requested by context
+    const strategy = context && context.middlewareStrategy ? context.middlewareStrategy : 'contract';
+    let middlewareContent;
+    if (strategy === 'legacy') {
+      middlewareContent = `/**
+ * ${confirmedValues.displayName} - Service Middleware (LEGACY)
  *
  * Generated by Clodo Framework GenerationEngine
  * Service Type: ${coreInputs.serviceType}
@@ -47,19 +52,19 @@ export function createServiceMiddleware(serviceConfig, env) {
         headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
       }
 
-      ${confirmedValues.features.logging ? `
+      ${confirmedValues.features && confirmedValues.features.logging ? `
       // Request logging
-      console.log(\`[\${new Date().toISOString()}] \${request.method} \${request.url}\`);` : ''}
+      console.log('[' + new Date().toISOString() + '] ' + request.method + ' ' + request.url);` : ''}
 
-      ${confirmedValues.features.rateLimiting ? `
+      ${confirmedValues.features && confirmedValues.features.rateLimiting ? `
       // Rate limiting (placeholder - implement based on requirements)
       // This would typically check request frequency and block if over limit` : ''}
 
-      ${confirmedValues.features.authentication ? `
+      ${confirmedValues.features && confirmedValues.features.authentication ? `
       // Authentication middleware (placeholder)
       // This would validate JWT tokens, API keys, etc.` : ''}
 
-      ${confirmedValues.features.authorization ? `
+      ${confirmedValues.features && confirmedValues.features.authorization ? `
       // Authorization middleware (placeholder)
       // This would check user permissions and roles` : ''}
 
@@ -77,11 +82,11 @@ export function createServiceMiddleware(serviceConfig, env) {
       headers.set('X-Version', '${confirmedValues.version}');
       headers.set('X-Response-Time', Date.now().toString());
 
-      ${confirmedValues.features.monitoring ? `
+      ${confirmedValues.features && confirmedValues.features.monitoring ? `
       // Response monitoring
-      console.log(\`Response: \${response.status} (\${Date.now()}ms)\`);` : ''}
+      console.log('Response: ' + response.status + ' (' + Date.now() + 'ms)');` : ''}
 
-      ${confirmedValues.features.caching ? `
+      ${confirmedValues.features && confirmedValues.features.caching ? `
       // Cache headers (placeholder - implement based on content type)
       if (response.status === 200) {
         headers.set('Cache-Control', 'public, max-age=300'); // 5 minutes
@@ -95,6 +100,35 @@ export function createServiceMiddleware(serviceConfig, env) {
   };
 }
 `;
+    } else {
+      middlewareContent = `/**
+ * ${confirmedValues.displayName} - Service Middleware
+ *
+ * Generated by Clodo Framework GenerationEngine
+ * Service Type: ${coreInputs.serviceType}
+ */
+
+// Service middleware contract skeleton - minimal and opt-in
+export default class ${confirmedValues.packageName || confirmedValues.serviceName ? confirmedValues.serviceName : 'Service'}Middleware {
+  // Implement only the hooks you need
+  async preprocess(request) { return null; }
+  async authenticate(request) { return null; }
+  async validate(request) { return null; }
+  async postprocess(response) { return response; }
+}
+
+// Optional registration helper - Worker generator will call this to register
+export function registerMiddleware(registry, serviceName) {
+  if (!registry || typeof registry.register !== 'function') return;
+  try {
+    registry.register(serviceName || '${coreInputs.serviceName}', new (exports.default || ${confirmedValues.packageName || confirmedValues.serviceName ? confirmedValues.serviceName : 'Service'}Middleware)());
+  } catch (e) {
+    // Non-fatal - allow services to manually register if needed
+  }
+}
+
+`;
+    }
     const filePath = join(servicePath, 'src', 'middleware', 'service-middleware.js');
 
     // Ensure directory exists
@@ -104,6 +138,118 @@ export function createServiceMiddleware(serviceConfig, env) {
     });
     writeFileSync(filePath, middlewareContent, 'utf8');
     this.logger.info(`Generated: ${filePath}`);
+
+    // Also generate a lightweight runtime helper for middleware composition and registry
+    const runtimeContent = `// Lightweight middleware runtime for generated services
+export const MiddlewareRegistry = (() => {
+  const map = new Map();
+  return {
+    register(serviceName, instance) { map.set(serviceName, instance); },
+    get(serviceName) { return map.get(serviceName) || null; },
+    clear() { map.clear(); }
+  };
+})();
+
+export const MiddlewareComposer = {
+  compose(...middlewares) {
+    const chain = middlewares.filter(Boolean);
+    return {
+      async execute(request, handler) {
+        let req = request;
+        for (const m of chain) {
+          if (typeof m.preprocess === 'function') {
+            const res = await m.preprocess(req);
+            if (res) return res;
+          }
+          if (typeof m.authenticate === 'function') {
+            const res = await m.authenticate(req);
+            if (res) return res;
+          }
+          if (typeof m.validate === 'function') {
+            const res = await m.validate(req);
+            if (res) return res;
+          }
+        }
+        let response = await handler(req);
+        for (const m of chain.slice().reverse()) {
+          if (typeof m.postprocess === 'function') {
+            const updated = await m.postprocess(response);
+            if (updated instanceof Response) response = updated;
+          }
+        }
+        return response;
+      }
+    };
+  }
+};
+`;
+    const runtimePath = join(servicePath, 'src', 'middleware', 'runtime.js');
+    writeFileSync(runtimePath, runtimeContent, 'utf8');
+    this.logger.info(`Generated: ${runtimePath}`);
+
+    // Minimal shared implementations (copied into generated service for self-containment)
+    const sharedDir = join(servicePath, 'src', 'middleware', 'shared');
+    mkdirSync(sharedDir, {
+      recursive: true
+    });
+    const corsContent = `export function cors(options = {}) {
+  const origin = options.origin || '*';
+  const allowMethods = options.methods || 'GET, POST, PUT, DELETE, OPTIONS';
+  const allowHeaders = options.headers || 'Content-Type, Authorization';
+
+  return {
+    preprocess(request) {
+      if (request.method === 'OPTIONS') {
+        const headers = new Headers();
+        headers.set('Access-Control-Allow-Origin', origin);
+        headers.set('Access-Control-Allow-Methods', allowMethods);
+        headers.set('Access-Control-Allow-Headers', allowHeaders);
+        return new Response(null, { status: 204, headers });
+      }
+      return null;
+    },
+    postprocess(response) {
+      const headers = new Headers(response.headers);
+      headers.set('Access-Control-Allow-Origin', origin);
+      return new Response(response.body, { ...response, headers });
+    }
+  };
+}
+`;
+    const loggingContent = `export function logging(options = {}) {
+  const level = options.level || 'info';
+  return {
+    preprocess(request) {
+      try {
+        const path = new URL(request.url).pathname;
+        console.log('[' + new Date().toISOString() + '] ' + level.toUpperCase() + ' ' + request.method + ' ' + path);
+      } catch (e) {}
+      return null;
+    }
+  };
+}
+`;
+    const basicAuthContent = `export function basicAuth({ realm = 'Restricted' } = {}) {
+  return {
+    authenticate(request) {
+      const auth = request.headers.get('Authorization');
+      if (!auth) {
+        return new Response(JSON.stringify({ error: 'Unauthorized' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json', 'WWW-Authenticate': 'Basic realm="' + realm + '"' }
+        });
+      }
+      return null;
+    }
+  };
+}
+`;
+    writeFileSync(join(sharedDir, 'cors.js'), corsContent, 'utf8');
+    writeFileSync(join(sharedDir, 'logging.js'), loggingContent, 'utf8');
+    writeFileSync(join(sharedDir, 'basicAuth.js'), basicAuthContent, 'utf8');
+    const indexContent = `export { cors } from './cors.js';\nexport { logging } from './logging.js';\nexport { basicAuth } from './basicAuth.js';\n`;
+    writeFileSync(join(sharedDir, 'index.js'), indexContent, 'utf8');
+    this.logger.info(`Generated shared middleware in: ${sharedDir}`);
     return filePath;
   }
 

package/dist/service-management/generators/code/WorkerIndexGenerator.js

@@ -70,7 +70,8 @@ export class WorkerIndexGenerator extends BaseGenerator {
 
 import { domains } from '../config/domains.js';
 import { createServiceHandlers } from '../handlers/service-handlers.js';
-import { createServiceMiddleware } from '../middleware/service-middleware.js';
+import { MiddlewareRegistry, MiddlewareComposer } from '../middleware/runtime.js';
+import * as Shared from '../middleware/shared/index.js';
 
 export default {
   async fetch(request, env, ctx) {
@@ -78,16 +79,81 @@ export default {
       // Get service configuration
       const serviceConfig = domains['${coreInputs.serviceName}'];
 
-      // Apply middleware
-      const middleware = createServiceMiddleware(serviceConfig, env);
-      const processedRequest = await middleware.processRequest(request);
+      // Build shared middleware instances
+      const sharedMiddlewares = [
+        Shared.cors({ origin: serviceConfig.corsPolicy || '*' }),
+        Shared.logging({ level: serviceConfig.logLevel || 'info' })
+      ];
 
-      // Route to appropriate handler
-      const handlers = createServiceHandlers(serviceConfig, env);
-      const response = await handlers.handleRequest(processedRequest, ctx);
+      // Lazy-load service middleware and support legacy factory compatibility
+      let serviceMiddlewareInstance = null;
+      let legacyFactory = null;
 
-      // Apply response middleware
-      return await middleware.processResponse(response);
+      try {
+        const mod = await import('../middleware/service-middleware.js');
+
+        if (mod?.registerMiddleware) {
+          // New-style registration helper
+          mod.registerMiddleware(MiddlewareRegistry, serviceConfig.name);
+          serviceMiddlewareInstance = MiddlewareRegistry.get(serviceConfig.name);
+        } else if (mod?.default) {
+          const def = mod.default;
+          // If the default is a class (constructor), instantiate and register
+          if (typeof def === 'function' && def.prototype) {
+            try {
+              const instance = new def();
+              MiddlewareRegistry.register(serviceConfig.name, instance);
+              serviceMiddlewareInstance = instance;
+            } catch (e) {
+              // ignore instantiation errors
+            }
+          } else if (typeof def === 'function') {
+            // Legacy factory exported as default
+            legacyFactory = def;
+          }
+        } else if (mod?.createServiceMiddleware) {
+          legacyFactory = mod.createServiceMiddleware;
+        }
+      } catch (e) {
+        // No service-specific middleware found - continue with shared only
+      }
+
+      // Compose final middleware chain
+      let chain;
+
+      if (legacyFactory) {
+        const legacyInstance = legacyFactory(serviceConfig, env);
+        const adapter = {
+          preprocess: async (req) => {
+            if (legacyInstance && typeof legacyInstance.processRequest === 'function') {
+              const processed = await legacyInstance.processRequest(req);
+              if (processed instanceof Response) return processed; // short-circuit
+              return null; // continue (legacy returns a Request)
+            }
+            return null;
+          },
+          postprocess: async (res) => {
+            if (legacyInstance && typeof legacyInstance.processResponse === 'function') {
+              const r = await legacyInstance.processResponse(res);
+              return r instanceof Response ? r : res;
+            }
+            return res;
+          }
+        };
+
+        chain = MiddlewareComposer.compose(...sharedMiddlewares, adapter);
+      } else {
+        const svcMw = serviceMiddlewareInstance || MiddlewareRegistry.get(serviceConfig.name);
+        chain = MiddlewareComposer.compose(...sharedMiddlewares, svcMw);
+      }
+
+      // Execute middleware chain with final handler
+      const response = await chain.execute(request, async (req) => {
+        const handlers = createServiceHandlers(serviceConfig, env);
+        return handlers.handleRequest(req, ctx);
+      });
+
+      return response;
 
     } catch (error) {
       console.error('Worker error:', error);