@tamyla/clodo-framework 3.1.21 → 3.1.22

package/dist/service-management/routing/DomainRouteMapper.js

@@ -1,311 +0,0 @@
-/**
- * DomainRouteMapper - Maps domain configurations to route patterns
- * 
- * Handles the business logic of converting domain metadata into
- * Cloudflare Workers route patterns with proper specificity ordering.
- * 
- * @module service-management/routing/DomainRouteMapper
- */
-
-import { frameworkConfig } from '../../utils/framework-config.js';
-export class DomainRouteMapper {
-  constructor(options = {}) {
-    // Load environment-specific routing config
-    this.frameworkConfig = frameworkConfig;
-    this.options = options;
-  }
-
-  /**
-   * Map domain configuration to route patterns
-   * 
-   * @param {Object} domainConfig - Domain configuration object
-   * @param {Object} domainConfig.domains - Domain URLs by environment
-   * @param {string} domainConfig.zoneId - Cloudflare zone ID
-   * @param {string} domainConfig.apiBasePath - API base path (optional)
-   * @param {string} environment - Target environment (production|staging|development)
-   * 
-   * @returns {Object} Route mapping with patterns and zone_id
-   * @returns {Array<string>} returns.patterns - Route patterns (ordered by specificity)
-   * @returns {string} returns.zoneId - Cloudflare zone ID
-   * @returns {string} returns.environment - Environment name
-   * 
-   * @example
-   * const mapper = new DomainRouteMapper();
-   * const routes = mapper.mapDomainToRoutes(
-   *   {
-   *     domains: { production: 'api.example.com' },
-   *     zoneId: 'xyz789...',
-   *     apiBasePath: '/api'
-   *   },
-   *   'production'
-   * );
-   * // Returns:
-   * // {
-   * //   patterns: ['api.example.com/*', 'example.com/api/*'],
-   * //   zoneId: 'xyz789...',
-   * //   environment: 'production'
-   * // }
-   */
-  mapDomainToRoutes(domainConfig, environment) {
-    const domainUrl = domainConfig.domains[environment];
-    if (!domainUrl) {
-      return {
-        patterns: [],
-        zoneId: domainConfig.zoneId,
-        environment
-      };
-    }
-
-    // Skip workers.dev subdomains (no routes needed)
-    const routingConfig = this.frameworkConfig.getRoutingConfig();
-    const workersDomain = routingConfig.domains.workersDomain;
-    if (domainUrl.includes(workersDomain)) {
-      return {
-        patterns: [],
-        zoneId: domainConfig.zoneId,
-        environment
-      };
-    }
-
-    // Generate route patterns based on environment
-    let patterns;
-    switch (environment) {
-      case 'production':
-        patterns = this.generateProductionRoutes(domainUrl, domainConfig);
-        break;
-      case 'staging':
-        patterns = this.generateStagingRoutes(domainUrl, domainConfig);
-        break;
-      case 'development':
-        patterns = this.generateDevelopmentRoutes(domainUrl, domainConfig);
-        break;
-      default:
-        patterns = this._generateGenericRoutes(domainUrl, domainConfig);
-    }
-    return {
-      patterns,
-      zoneId: domainConfig.zoneId,
-      environment
-    };
-  }
-
-  /**
-   * Generate production environment routes
-   * 
-   * Creates subdomain pattern and root domain fallback
-   * 
-   * @param {string} domain - Domain URL (e.g., api.example.com)
-   * @param {Object} config - Domain configuration
-   * @returns {Array<string>} Route patterns (ordered by specificity)
-   * 
-   * @example
-   * mapper.generateProductionRoutes('api.example.com', { apiBasePath: '/api' })
-   * // Returns: ['api.example.com/*', 'example.com/api/*']
-   */
-  generateProductionRoutes(domain, config = {}) {
-    const patterns = [];
-
-    // Check if it's a subdomain
-    const isSubdomain = this._isSubdomain(domain);
-    if (isSubdomain) {
-      // 1. Subdomain wildcard (most specific)
-      patterns.push(`${domain}/*`);
-
-      // 2. Root domain with path fallback
-      const rootDomain = this._getRootDomain(domain);
-      const pathPrefix = config.apiBasePath || this._getSubdomainPrefix(domain);
-      patterns.push(`${rootDomain}${pathPrefix}/*`);
-    } else {
-      // Root domain only
-      const envRouting = this.frameworkConfig.getEnvironmentRoutingConfig('production');
-      const pathPrefix = config.apiBasePath || envRouting.defaultPathPrefix;
-      patterns.push(`${domain}${pathPrefix}/*`);
-    }
-    return patterns;
-  }
-
-  /**
-   * Generate staging environment routes
-   * 
-   * Similar to production but with staging-specific patterns
-   * 
-   * @param {string} domain - Domain URL (e.g., staging-api.example.com)
-   * @param {Object} config - Domain configuration
-   * @returns {Array<string>} Route patterns (ordered by specificity)
-   */
-  generateStagingRoutes(domain, config = {}) {
-    const patterns = [];
-
-    // Check if it's a subdomain
-    const isSubdomain = this._isSubdomain(domain);
-    if (isSubdomain) {
-      // 1. Staging subdomain wildcard
-      patterns.push(`${domain}/*`);
-
-      // 2. Root domain with staging path fallback
-      const rootDomain = this._getRootDomain(domain);
-      const pathPrefix = config.apiBasePath || this._getSubdomainPrefix(domain);
-      patterns.push(`${rootDomain}${pathPrefix}/*`);
-    } else {
-      // Root domain only
-      const envRouting = this.frameworkConfig.getEnvironmentRoutingConfig('staging');
-      const pathPrefix = config.apiBasePath || envRouting.defaultPathPrefix;
-      patterns.push(`${domain}${pathPrefix}/*`);
-    }
-    return patterns;
-  }
-
-  /**
-   * Generate development environment routes
-   * 
-   * Development typically uses workers.dev subdomain (no routes needed)
-   * Only generate routes if custom domain explicitly specified
-   * 
-   * @param {string} domain - Domain URL
-   * @param {Object} config - Domain configuration
-   * @returns {Array<string>} Route patterns (usually empty)
-   */
-  generateDevelopmentRoutes(domain, config = {}) {
-    // Development typically uses *.workers.dev (no routes needed)
-    const routingConfig = this.frameworkConfig.getRoutingConfig();
-    const workersDomain = routingConfig.domains.workersDomain;
-    if (!domain || domain.includes(workersDomain)) {
-      return [];
-    }
-
-    // If custom domain specified for development, generate routes
-    const patterns = [];
-    const isSubdomain = this._isSubdomain(domain);
-    if (isSubdomain) {
-      patterns.push(`${domain}/*`);
-      const rootDomain = this._getRootDomain(domain);
-      const pathPrefix = config.apiBasePath || this._getSubdomainPrefix(domain);
-      patterns.push(`${rootDomain}${pathPrefix}/*`);
-    } else {
-      const envRouting = this.frameworkConfig.getEnvironmentRoutingConfig('development');
-      const pathPrefix = config.apiBasePath || envRouting.defaultPathPrefix;
-      patterns.push(`${domain}${pathPrefix}/*`);
-    }
-    return patterns;
-  }
-
-  /**
-   * Generate generic routes (for any environment)
-   * @private
-   */
-  _generateGenericRoutes(domain, config = {}) {
-    const patterns = [];
-    const isSubdomain = this._isSubdomain(domain);
-    if (isSubdomain) {
-      patterns.push(`${domain}/*`);
-      const rootDomain = this._getRootDomain(domain);
-      const pathPrefix = config.apiBasePath || this._getSubdomainPrefix(domain);
-      patterns.push(`${rootDomain}${pathPrefix}/*`);
-    } else {
-      const envRouting = this.frameworkConfig.getEnvironmentRoutingConfig('production');
-      const pathPrefix = config.apiBasePath || envRouting.defaultPathPrefix;
-      patterns.push(`${domain}${pathPrefix}/*`);
-    }
-    return patterns;
-  }
-
-  /**
-   * Check if domain is a subdomain
-   * @private
-   * 
-   * @param {string} domain - Domain name
-   * @returns {boolean} True if subdomain, false if root domain
-   * 
-   * @example
-   * _isSubdomain('api.example.com')  // true
-   * _isSubdomain('example.com')      // false
-   * _isSubdomain('www.example.com')  // true
-   */
-  _isSubdomain(domain) {
-    if (!domain) return false;
-    const parts = domain.split('.');
-
-    // At least 3 parts = subdomain (e.g., api.example.com)
-    // 2 parts = root domain (e.g., example.com)
-    // Account for TLDs like .co.uk (4+ parts)
-    return parts.length >= 3;
-  }
-
-  /**
-   * Extract root domain from subdomain
-   * @private
-   * 
-   * @param {string} domain - Full domain (e.g., api.example.com)
-   * @returns {string} Root domain (e.g., example.com)
-   * 
-   * @example
-   * _getRootDomain('api.example.com')          // 'example.com'
-   * _getRootDomain('staging-api.example.com')  // 'example.com'
-   * _getRootDomain('example.com')              // 'example.com'
-   */
-  _getRootDomain(domain) {
-    if (!domain) return '';
-    const parts = domain.split('.');
-
-    // Handle different TLD formats
-    if (parts.length <= 2) {
-      // Already root domain
-      return domain;
-    }
-
-    // Extract last 2 parts (handles .com, .org, etc.)
-    // TODO: Handle complex TLDs like .co.uk (requires TLD database)
-    return parts.slice(-2).join('.');
-  }
-
-  /**
-   * Extract subdomain prefix and convert to path
-   * @private
-   * 
-   * @param {string} domain - Full domain (e.g., api.example.com)
-   * @returns {string} Path prefix (e.g., /api)
-   * 
-   * @example
-   * _getSubdomainPrefix('api.example.com')          // '/api'
-   * _getSubdomainPrefix('staging-api.example.com')  // '/staging-api'
-   * _getSubdomainPrefix('www.example.com')          // '/www'
-   */
-  _getSubdomainPrefix(domain) {
-    if (!domain) return '';
-    const parts = domain.split('.');
-    if (parts.length < 3) {
-      // Not a subdomain
-      return '';
-    }
-
-    // Get first part (subdomain)
-    const subdomain = parts[0];
-
-    // Convert to path (add leading slash)
-    return `/${subdomain}`;
-  }
-
-  /**
-   * Get zone ID for domain
-   * 
-   * Extracts zone_id from coreInputs with validation
-   * 
-   * @param {string} domain - Domain name
-   * @param {Object} coreInputs - Core service inputs
-   * @returns {string} Cloudflare zone ID
-   * @throws {Error} If zone_id missing or invalid format
-   */
-  getZoneIdForDomain(domain, coreInputs) {
-    if (!coreInputs || !coreInputs.cloudflareZoneId) {
-      throw new Error(`cloudflareZoneId is required for domain "${domain}" route generation`);
-    }
-    const zoneId = coreInputs.cloudflareZoneId;
-
-    // Validate zone_id format (32 hex characters)
-    const zoneIdPattern = /^[a-f0-9]{32}$/;
-    if (!zoneIdPattern.test(zoneId)) {
-      throw new Error(`Invalid zone_id format for domain "${domain}". ` + `Expected 32 hex characters, received: "${zoneId}"`);
-    }
-    return zoneId;
-  }
-}

package/dist/service-management/routing/RouteGenerator.js

@@ -1,266 +0,0 @@
-/**
- * RouteGenerator - Main orchestrator for route generation
- * 
- * Generates Cloudflare Workers [[routes]] configuration from domain metadata.
- * This is a CORE IDENTITY feature that completes multi-domain orchestration.
- * 
- * @module service-management/routing/RouteGenerator
- */
-
-import { DomainRouteMapper } from './DomainRouteMapper.js';
-import { WranglerRoutesBuilder } from './WranglerRoutesBuilder.js';
-import { frameworkConfig } from '../../utils/framework-config.js';
-export class RouteGenerator {
-  constructor(options = {}) {
-    this.mapper = new DomainRouteMapper(options);
-    this.builder = new WranglerRoutesBuilder(options);
-
-    // Load routing configuration from validation-config.json
-    const routingConfig = frameworkConfig.getRoutingConfig();
-    const templateDefaults = frameworkConfig.config.templates?.defaults || {};
-    this.options = {
-      // Routing defaults from config
-      includeComments: routingConfig.defaults.includeComments,
-      includeZoneId: routingConfig.defaults.includeZoneId,
-      environment: routingConfig.defaults.targetEnvironment,
-      // Map targetEnvironment -> environment
-      orderStrategy: routingConfig.defaults.orderStrategy,
-      // Domain configuration
-      workersDomain: templateDefaults.WORKERS_DEV_DOMAIN || 'workers.dev',
-      skipPatterns: routingConfig.domains.skipPatterns,
-      // Allow runtime overrides
-      ...options
-    };
-  }
-
-  /**
-   * Generate routes configuration for wrangler.toml
-   * 
-   * @param {Object} coreInputs - Core service inputs (6 values)
-   * @param {string} coreInputs.serviceName - Service name
-   * @param {string} coreInputs.serviceType - Service type
-   * @param {string} coreInputs.domainName - Domain name
-   * @param {string} coreInputs.cloudflareAccountId - Cloudflare account ID
-   * @param {string} coreInputs.cloudflareZoneId - Cloudflare zone ID (32 hex chars)
-   * @param {string} coreInputs.environment - Environment (production|staging|development)
-   * 
-   * @param {Object} confirmedValues - Confirmed configuration values (15 values)
-   * @param {string} confirmedValues.productionUrl - Production URL (e.g., api.example.com)
-   * @param {string} confirmedValues.stagingUrl - Staging URL (e.g., staging-api.example.com)
-   * @param {string} confirmedValues.developmentUrl - Development URL (optional, defaults to workers.dev)
-   * @param {string} confirmedValues.apiBasePath - API base path (e.g., /api)
-   * @param {string} confirmedValues.workerName - Worker name
-   * 
-   * @param {Object} options - Generation options
-   * @param {boolean} options.includeComments - Include explanatory comments (default: true)
-   * @param {boolean} options.includeZoneId - Include zone_id in routes (default: true)
-   * @param {string} options.environment - Target environment filter (default: 'all')
-   * 
-   * @returns {string} TOML-formatted routes configuration
-   * 
-   * @throws {Error} If domain configuration is invalid or incomplete
-   * 
-   * @example
-   * const routeGenerator = new RouteGenerator();
-   * const routesConfig = routeGenerator.generateRoutes(
-   *   {
-   *     serviceName: 'my-api',
-   *     domainName: 'example.com',
-   *     cloudflareZoneId: 'abc123...',
-   *     // ... other core inputs
-   *   },
-   *   {
-   *     productionUrl: 'api.example.com',
-   *     stagingUrl: 'staging-api.example.com',
-   *     apiBasePath: '/api',
-   *     // ... other confirmed values
-   *   }
-   * );
-   */
-  generateRoutes(coreInputs, confirmedValues, options = {}) {
-    // Merge options
-    const opts = {
-      ...this.options,
-      ...options
-    };
-
-    // Validate inputs
-    this.validateDomainConfig(coreInputs, confirmedValues);
-
-    // Build domain configuration
-    const domainConfig = {
-      domains: {
-        production: confirmedValues.productionUrl,
-        staging: confirmedValues.stagingUrl,
-        development: confirmedValues.developmentUrl
-      },
-      zoneId: coreInputs.cloudflareZoneId,
-      apiBasePath: confirmedValues.apiBasePath,
-      serviceName: coreInputs.serviceName,
-      workerName: confirmedValues.workerName
-    };
-
-    // Generate routes for each environment
-    const productionRoutes = this._generateEnvironmentRoutes(domainConfig, 'production', opts);
-    const stagingRoutes = this._generateEnvironmentRoutes(domainConfig, 'staging', opts);
-    const developmentRoutes = this._generateEnvironmentRoutes(domainConfig, 'development', opts);
-
-    // Build complete routes section
-    let routesSection = '';
-
-    // Add header comment
-    if (opts.includeComments) {
-      routesSection += `# Routes configuration for ${domainConfig.serviceName}\n`;
-      routesSection += `# Generated by Clodo Framework RouteGenerator\n`;
-      routesSection += `# Generated: ${new Date().toISOString()}\n\n`;
-    }
-
-    // Add production routes (top-level)
-    if (productionRoutes && (opts.environment === 'all' || opts.environment === 'production')) {
-      routesSection += productionRoutes;
-    }
-
-    // Add staging routes
-    if (stagingRoutes && (opts.environment === 'all' || opts.environment === 'staging')) {
-      if (routesSection && !routesSection.endsWith('\n\n')) {
-        routesSection += '\n';
-      }
-      routesSection += stagingRoutes;
-    }
-
-    // Add development routes (usually none - workers.dev)
-    if (developmentRoutes && (opts.environment === 'all' || opts.environment === 'development')) {
-      if (routesSection && !routesSection.endsWith('\n\n')) {
-        routesSection += '\n';
-      }
-      routesSection += developmentRoutes;
-    }
-    return routesSection.trim() + '\n';
-  }
-
-  /**
-   * Generate routes for a specific environment
-   * @private
-   */
-  _generateEnvironmentRoutes(domainConfig, environment, options) {
-    const domainUrl = domainConfig.domains[environment];
-
-    // Skip if no domain configured or matches skip patterns
-    if (!domainUrl || this._shouldSkipDomain(domainUrl)) {
-      // workers.dev subdomain - no routes needed
-      if (environment === 'development' && options.includeComments) {
-        return this.builder.generateDevComment(domainConfig.workerName);
-      }
-      return '';
-    }
-
-    // Map domain to route patterns
-    const routeMapping = this.mapper.mapDomainToRoutes(domainConfig, environment);
-
-    // Build TOML routes section
-    return this.builder.buildRoutesSection(routeMapping.patterns, environment, {
-      zoneId: options.includeZoneId ? routeMapping.zoneId : null,
-      includeComments: options.includeComments,
-      domain: domainUrl,
-      serviceName: domainConfig.serviceName
-    });
-  }
-
-  /**
-   * Validate domain configuration completeness
-   * 
-   * @param {Object} coreInputs - Core service inputs
-   * @param {Object} confirmedValues - Confirmed configuration values
-   * @throws {Error} If validation fails
-   */
-  validateDomainConfig(coreInputs, confirmedValues) {
-    // Check required coreInputs
-    if (!coreInputs) {
-      throw new Error('coreInputs is required for route generation');
-    }
-    if (!coreInputs.serviceName) {
-      throw new Error('coreInputs.serviceName is required for route generation');
-    }
-    if (!coreInputs.cloudflareZoneId) {
-      throw new Error('coreInputs.cloudflareZoneId is required for route generation');
-    }
-
-    // Validate zone_id format (32 hex characters)
-    const zoneIdPattern = /^[a-f0-9]{32}$/;
-    if (!zoneIdPattern.test(coreInputs.cloudflareZoneId)) {
-      throw new Error('coreInputs.cloudflareZoneId must be a valid Cloudflare zone ID (32 hex characters). ' + `Received: "${coreInputs.cloudflareZoneId}"`);
-    }
-
-    // Check required confirmedValues
-    if (!confirmedValues) {
-      throw new Error('confirmedValues is required for route generation');
-    }
-    if (!confirmedValues.productionUrl) {
-      throw new Error('confirmedValues.productionUrl is required for route generation');
-    }
-
-    // Validate production URL format
-    if (!this._isValidDomain(confirmedValues.productionUrl)) {
-      throw new Error('confirmedValues.productionUrl must be a valid domain name. ' + `Received: "${confirmedValues.productionUrl}"`);
-    }
-  }
-
-  /**
-   * Check if a string is a valid domain name
-   * @private
-   */
-  _isValidDomain(domain) {
-    if (!domain || typeof domain !== 'string') {
-      return false;
-    }
-
-    // Basic domain validation
-    const domainPattern = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?(\.[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?)*$/i;
-    return domainPattern.test(domain);
-  }
-
-  /**
-   * Get route patterns for a specific domain and environment
-   * 
-   * @param {string} domain - Domain name (e.g., api.example.com)
-   * @param {string} environment - Environment (production|staging|development)
-   * @param {Object} options - Additional options
-   * @returns {Array<string>} Array of route patterns
-   * 
-   * @example
-   * const patterns = routeGenerator.getRoutePatterns('api.example.com', 'production');
-   * // Returns: ['api.example.com/*', 'example.com/api/*']
-   */
-  getRoutePatterns(domain, environment, options = {}) {
-    const domainConfig = {
-      domains: {
-        [environment]: domain
-      },
-      zoneId: options.zoneId || 'placeholder',
-      apiBasePath: options.apiBasePath,
-      serviceName: options.serviceName || 'service'
-    };
-    const routeMapping = this.mapper.mapDomainToRoutes(domainConfig, environment);
-    return routeMapping.patterns;
-  }
-
-  /**
-   * Check if a domain should be skipped for route generation
-   * @private
-   * 
-   * @param {string} domain - Domain to check
-   * @returns {boolean} True if domain should be skipped
-   */
-  _shouldSkipDomain(domain) {
-    if (!domain) return true;
-
-    // Check workers.dev domain
-    if (domain.includes(this.options.workersDomain)) {
-      return true;
-    }
-
-    // Check configured skip patterns
-    const skipPatterns = this.options.skipPatterns || [];
-    return skipPatterns.some(pattern => domain.includes(pattern));
-  }
-}