@tamyla/clodo-framework 3.0.15 → 3.1.0

package/dist/service-management/generators/config/StagingEnvGenerator.js

@@ -0,0 +1,97 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+
+/**
+ * StagingEnvGenerator
+ * 
+ * Generates config/staging.env file for staging environment.
+ */
+export class StagingEnvGenerator extends BaseGenerator {
+  constructor(options = {}) {
+    super({
+      name: 'StagingEnvGenerator',
+      description: 'Generates staging environment configuration',
+      outputPath: 'config/staging.env',
+      ...options
+    });
+  }
+  shouldGenerate(context) {
+    return true;
+  }
+  async generate(context) {
+    const coreInputs = context.coreInputs || context;
+    const confirmedValues = context.confirmedValues || context;
+    const servicePath = context.servicePath || context.outputDir;
+    this.setContext({
+      coreInputs,
+      confirmedValues,
+      servicePath
+    });
+    const content = `# Staging Environment Configuration
+# Generated by Clodo Framework GenerationEngine
+
+# Service Configuration
+SERVICE_NAME=${coreInputs.serviceName}
+SERVICE_TYPE=${coreInputs.serviceType}
+ENVIRONMENT=staging
+
+# URLs
+PRODUCTION_URL=${confirmedValues.productionUrl}
+STAGING_URL=${confirmedValues.stagingUrl}
+DEVELOPMENT_URL=${confirmedValues.developmentUrl}
+
+# Cloudflare Configuration
+CLOUDFLARE_ACCOUNT_ID=${coreInputs.cloudflareAccountId}
+CLOUDFLARE_ZONE_ID=${coreInputs.cloudflareZoneId}
+
+# Database
+DATABASE_NAME=${confirmedValues.databaseName}
+
+# Logging and Monitoring
+LOG_LEVEL=info
+METRICS_ENABLED=true
+ERROR_REPORTING_ENABLED=true
+`;
+    await this.writeFile(join('config', 'staging.env'), content);
+    return join(servicePath, 'config', 'staging.env');
+  }
+  validateContext(context) {
+    const coreInputs = context.coreInputs || context;
+    const confirmedValues = context.confirmedValues || context;
+    const required = [{
+      field: 'serviceName',
+      source: coreInputs
+    }, {
+      field: 'serviceType',
+      source: coreInputs
+    }, {
+      field: 'cloudflareAccountId',
+      source: coreInputs
+    }, {
+      field: 'cloudflareZoneId',
+      source: coreInputs
+    }, {
+      field: 'productionUrl',
+      source: confirmedValues
+    }, {
+      field: 'stagingUrl',
+      source: confirmedValues
+    }, {
+      field: 'developmentUrl',
+      source: confirmedValues
+    }, {
+      field: 'databaseName',
+      source: confirmedValues
+    }];
+    const missing = required.filter(({
+      field,
+      source
+    }) => !source || !source[field]).map(({
+      field
+    }) => field);
+    if (missing.length > 0) {
+      throw new Error(`StagingEnvGenerator: Missing required fields: ${missing.join(', ')}`);
+    }
+    return true;
+  }
+}

package/dist/service-management/generators/config/WranglerTomlGenerator.js

@@ -0,0 +1,238 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+
+/**
+ * WranglerTomlGenerator
+ * 
+ * Generates wrangler.toml configuration files for Cloudflare Workers.
+ * 
+ * Responsibilities:
+ * - Generate main worker configuration (name, main, compatibility)
+ * - Include routes configuration from RouteGenerator
+ * - Include Workers Sites configuration from SiteConfigGenerator
+ * - Configure environment-specific settings (dev/staging/production)
+ * - Configure D1 database bindings
+ * - Configure environment variables and feature flags
+ * 
+ * Dependencies:
+ * - RouteGenerator (for routes configuration)
+ * - SiteConfigGenerator (for Workers Sites configuration)
+ */
+export class WranglerTomlGenerator extends BaseGenerator {
+  constructor(options = {}) {
+    super({
+      name: 'WranglerTomlGenerator',
+      description: 'Generates wrangler.toml configuration for Cloudflare Workers',
+      outputPath: 'wrangler.toml',
+      ...options
+    });
+    this.routeGenerator = options.routeGenerator;
+    this.siteConfigGenerator = options.siteConfigGenerator;
+  }
+
+  /**
+   * Always generate wrangler.toml
+   */
+  shouldGenerate(context) {
+    return true;
+  }
+
+  /**
+   * Generate wrangler.toml content
+   */
+  async generate(context) {
+    // Support both new structured format and legacy flat format
+    const coreInputs = context.coreInputs || context;
+    const confirmedValues = context.confirmedValues || context;
+    const servicePath = context.servicePath || context.outputDir;
+    this.setContext({
+      coreInputs,
+      confirmedValues,
+      servicePath
+    });
+
+    // Generate routes configuration
+    const routesConfig = await this._generateRoutesConfig(coreInputs, confirmedValues);
+
+    // Generate Workers Sites configuration (static-site only)
+    const siteConfig = await this._generateSiteConfig(coreInputs);
+
+    // Build wrangler.toml content
+    const content = this._buildWranglerToml(coreInputs, confirmedValues, routesConfig, siteConfig);
+
+    // Write file
+    await this.writeFile('wrangler.toml', content);
+
+    // Return full path for backward compatibility
+    return join(servicePath, 'wrangler.toml');
+  }
+
+  /**
+   * Generate routes configuration using RouteGenerator
+   */
+  async _generateRoutesConfig(coreInputs, confirmedValues) {
+    if (!this.routeGenerator) {
+      console.warn('⚠️  RouteGenerator not available. Routes will need to be configured manually.');
+      return '# Routes will be configured during deployment\n';
+    }
+    try {
+      const routesConfig = this.routeGenerator.generateRoutes(coreInputs, confirmedValues, {
+        includeComments: true,
+        includeZoneId: true
+      });
+      return routesConfig;
+    } catch (error) {
+      console.warn(`⚠️  Could not generate routes: ${error.message}`);
+      console.warn('   Continuing without automatic routes. You can add them manually later.');
+      return '# Routes will be configured during deployment\n';
+    }
+  }
+
+  /**
+   * Generate Workers Sites configuration using SiteConfigGenerator
+   */
+  async _generateSiteConfig(coreInputs) {
+    if (!this.siteConfigGenerator) {
+      return '';
+    }
+
+    // Only generate site config for static-site service type
+    if (coreInputs.serviceType !== 'static-site') {
+      return '';
+    }
+    try {
+      const siteConfig = await this.siteConfigGenerator.generate({
+        coreInputs,
+        siteConfig: coreInputs.siteConfig || {}
+      });
+      return siteConfig;
+    } catch (error) {
+      console.warn(`⚠️  Could not generate Workers Sites config: ${error.message}`);
+      return '';
+    }
+  }
+
+  /**
+   * Build the complete wrangler.toml content
+   */
+  _buildWranglerToml(coreInputs, confirmedValues, routesConfig, siteConfig) {
+    const compatDate = new Date().toISOString().split('T')[0];
+    return `# Cloudflare Workers Configuration for ${confirmedValues.displayName}
+name = "${confirmedValues.workerName}"
+main = "src/worker/index.js"
+compatibility_date = "${compatDate}"
+compatibility_flags = ["nodejs_compat"]
+
+# Account configuration
+account_id = "${coreInputs.cloudflareAccountId}"
+
+${routesConfig}
+${siteConfig ? '\n' + siteConfig : ''}
+
+# Environment configurations
+[env.development]
+name = "${confirmedValues.workerName}-dev"
+
+[env.staging]
+name = "${confirmedValues.workerName}-staging"
+
+[env.production]
+name = "${confirmedValues.workerName}"
+
+# Database bindings
+[[d1_databases]]
+binding = "DB"
+database_name = "${confirmedValues.databaseName}"
+database_id = ""  # To be configured during setup
+
+# Environment variables
+[vars]
+SERVICE_NAME = "${coreInputs.serviceName}"
+SERVICE_TYPE = "${coreInputs.serviceType}"
+DOMAIN_NAME = "${coreInputs.domainName}"
+ENVIRONMENT = "${coreInputs.environment}"
+API_BASE_PATH = "${confirmedValues.apiBasePath}"
+HEALTH_CHECK_PATH = "${confirmedValues.healthCheckPath}"
+
+# Domain-specific variables
+PRODUCTION_URL = "${confirmedValues.productionUrl}"
+STAGING_URL = "${confirmedValues.stagingUrl}"
+DEVELOPMENT_URL = "${confirmedValues.developmentUrl}"
+
+# Feature flags
+${this._generateFeatureFlags(confirmedValues.features)}
+
+# Custom environment variables (configure as needed)
+# CUSTOM_VAR = "value"
+`;
+  }
+
+  /**
+   * Generate feature flags section
+   */
+  _generateFeatureFlags(features) {
+    if (!features || typeof features !== 'object') {
+      return '# No feature flags configured';
+    }
+    const flagEntries = Object.entries(features).filter(([, enabled]) => enabled).map(([feature, enabled]) => `FEATURE_${feature.toUpperCase()} = ${enabled}`);
+    return flagEntries.length > 0 ? flagEntries.join('\n') : '# No feature flags configured';
+  }
+
+  /**
+   * Validate context has required fields
+   */
+  validateContext(context) {
+    const coreInputs = context.coreInputs || context;
+    const confirmedValues = context.confirmedValues || context;
+    const required = [{
+      field: 'cloudflareAccountId',
+      source: coreInputs
+    }, {
+      field: 'serviceName',
+      source: coreInputs
+    }, {
+      field: 'serviceType',
+      source: coreInputs
+    }, {
+      field: 'domainName',
+      source: coreInputs
+    }, {
+      field: 'environment',
+      source: coreInputs
+    }, {
+      field: 'workerName',
+      source: confirmedValues
+    }, {
+      field: 'displayName',
+      source: confirmedValues
+    }, {
+      field: 'databaseName',
+      source: confirmedValues
+    }, {
+      field: 'apiBasePath',
+      source: confirmedValues
+    }, {
+      field: 'healthCheckPath',
+      source: confirmedValues
+    }, {
+      field: 'productionUrl',
+      source: confirmedValues
+    }, {
+      field: 'stagingUrl',
+      source: confirmedValues
+    }, {
+      field: 'developmentUrl',
+      source: confirmedValues
+    }];
+    const missing = required.filter(({
+      field,
+      source
+    }) => !source || !source[field]).map(({
+      field
+    }) => field);
+    if (missing.length > 0) {
+      throw new Error(`WranglerTomlGenerator: Missing required fields: ${missing.join(', ')}`);
+    }
+    return true;
+  }
+}

package/dist/service-management/generators/core/PackageJsonGenerator.js

@@ -0,0 +1,243 @@
+/**
+ * PackageJsonGenerator - Generates package.json for services
+ * 
+ * Creates a complete package.json with service-type specific dependencies,
+ * scripts for development/testing/deployment, and proper metadata.
+ */
+import { BaseGenerator } from '../BaseGenerator.js';
+export class PackageJsonGenerator extends BaseGenerator {
+  /**
+   * Create a new PackageJsonGenerator instance
+   * @param {Object} options - Generator options
+   */
+  constructor(options = {}) {
+    super({
+      name: 'PackageJsonGenerator',
+      ...options
+    });
+  }
+
+  /**
+   * Generate package.json file
+   * 
+   * Supports two calling conventions for backward compatibility:
+   * 1. New: context = { coreInputs: {...}, confirmedValues: {...} }
+   * 2. Merged: context = { ...coreInputs, ...confirmedValues }
+   * 
+   * @param {Object} context - Generation context
+   * @param {Object} context.coreInputs - Core service inputs (serviceType, etc.) [new convention]
+   * @param {Object} context.confirmedValues - Confirmed user values (packageName, version, etc.) [new convention]
+   * @returns {Promise<void>}
+   */
+  async generate(context) {
+    this.setContext(context);
+
+    // Support both calling conventions
+    // New: { coreInputs: {...}, confirmedValues: {...} }
+    // Merged: { serviceName, serviceType, packageName, version, ... }
+    let coreInputs, confirmedValues;
+    if (context.coreInputs || context.confirmedValues) {
+      // New convention - use separate objects (with defaults for missing ones)
+      coreInputs = context.coreInputs || {};
+      confirmedValues = context.confirmedValues || {};
+    } else {
+      // Merged convention - extract from flat context
+      coreInputs = {
+        serviceName: context.serviceName,
+        serviceType: context.serviceType,
+        domainName: context.domainName,
+        cloudflareAccountId: context.cloudflareAccountId,
+        cloudflareZoneId: context.cloudflareZoneId,
+        environment: context.environment
+      };
+      confirmedValues = {
+        packageName: context.packageName,
+        version: context.version,
+        description: context.description,
+        author: context.author,
+        displayName: context.displayName,
+        gitRepositoryUrl: context.gitRepositoryUrl,
+        workerName: context.workerName,
+        databaseName: context.databaseName,
+        apiBasePath: context.apiBasePath,
+        healthCheckPath: context.healthCheckPath,
+        productionUrl: context.productionUrl,
+        stagingUrl: context.stagingUrl,
+        developmentUrl: context.developmentUrl,
+        features: context.features,
+        keywords: context.keywords
+      };
+    }
+    if (!coreInputs || !confirmedValues) {
+      throw new Error('PackageJsonGenerator requires service configuration in context');
+    }
+    const packageJson = this.buildPackageJson(coreInputs, confirmedValues);
+    const content = JSON.stringify(packageJson, null, 2);
+    await this.writeFile('package.json', content);
+  }
+
+  /**
+   * Build the package.json object
+   * @param {Object} coreInputs - Core service inputs
+   * @param {Object} confirmedValues - Confirmed user values
+   * @returns {Object} - Package.json object
+   */
+  buildPackageJson(coreInputs, confirmedValues) {
+    return {
+      name: confirmedValues.packageName,
+      version: confirmedValues.version || '1.0.0',
+      description: confirmedValues.description || `Clodo Framework ${coreInputs.serviceType} service`,
+      main: 'src/worker/index.js',
+      type: 'module',
+      scripts: this.buildScripts(coreInputs),
+      dependencies: this.buildDependencies(coreInputs),
+      devDependencies: this.buildDevDependencies(coreInputs),
+      author: confirmedValues.author,
+      // Match original - can be undefined
+      license: confirmedValues.license || 'MIT',
+      repository: this.buildRepository(confirmedValues),
+      keywords: this.buildKeywords(coreInputs, confirmedValues),
+      engines: {
+        node: '>=18.0.0'
+      }
+    };
+  }
+
+  /**
+   * Build npm scripts section
+   * @param {Object} coreInputs - Core service inputs
+   * @returns {Object} - Scripts object
+   */
+  buildScripts(coreInputs) {
+    const scripts = {
+      // Development
+      dev: 'wrangler dev',
+      // Testing
+      test: 'jest',
+      'test:watch': 'jest --watch',
+      'test:coverage': 'jest --coverage',
+      // Deployment (cross-platform via framework)
+      deploy: 'clodo-service deploy',
+      'deploy:dev': 'node scripts/deploy.js development',
+      'deploy:staging': 'node scripts/deploy.js staging',
+      'deploy:prod': 'node scripts/deploy.js production',
+      // Code Quality
+      lint: 'eslint src/ test/',
+      'lint:fix': 'eslint src/ test/ --fix',
+      format: 'prettier --write src/ test/',
+      // Utilities
+      validate: 'clodo-service validate .',
+      diagnose: 'clodo-service diagnose .',
+      build: 'wrangler deploy --dry-run',
+      clean: 'rimraf dist/ coverage/'
+    };
+
+    // Add service-type specific scripts
+    if (coreInputs.serviceType === 'static-site') {
+      scripts['build:assets'] = 'echo "Add your static asset build command here"';
+      scripts['preview'] = 'wrangler dev --local';
+    }
+    return scripts;
+  }
+
+  /**
+   * Build production dependencies
+   * 
+   * NOTE: UUID is included for all service types to match original GenerationEngine behavior.
+   * While not all services may need it, it's a small dependency and many services use it for
+   * request tracking, correlation IDs, or other purposes.
+   * 
+   * @param {Object} coreInputs - Core service inputs
+   * @returns {Object} - Dependencies object
+   */
+  buildDependencies(coreInputs) {
+    const dependencies = {
+      '@tamyla/clodo-framework': '^3.0.15',
+      uuid: '^13.0.0',
+      // Always included (matches original GenerationEngine behavior)
+      wrangler: '^3.0.0'
+    };
+
+    // Service-type specific additional dependencies
+    switch (coreInputs.serviceType) {
+      case 'auth':
+        dependencies.bcrypt = '^5.1.0'; // For password hashing
+        break;
+      case 'static-site':
+        dependencies['mime-types'] = '^2.1.35'; // For MIME type detection
+        break;
+
+      // data, content, api-gateway, generic: uuid is already included above
+      default:
+        break;
+    }
+    return dependencies;
+  }
+
+  /**
+   * Build development dependencies
+   * @param {Object} coreInputs - Core service inputs
+   * @returns {Object} - DevDependencies object
+   */
+  buildDevDependencies(coreInputs) {
+    const devDependencies = {
+      '@types/jest': '^29.5.0',
+      '@types/node': '^20.0.0',
+      eslint: '^8.54.0',
+      jest: '^29.7.0',
+      prettier: '^3.1.0',
+      rimraf: '^5.0.0'
+    };
+
+    // Add service-type specific dev dependencies
+    if (coreInputs.serviceType === 'static-site') {
+      devDependencies['@types/mime-types'] = '^2.1.1';
+    }
+    return devDependencies;
+  }
+
+  /**
+   * Build repository configuration
+   * @param {Object} confirmedValues - Confirmed user values
+   * @returns {Object|undefined} - Repository object or undefined
+   */
+  buildRepository(confirmedValues) {
+    if (!confirmedValues.gitRepositoryUrl) {
+      return undefined;
+    }
+    return {
+      type: 'git',
+      url: confirmedValues.gitRepositoryUrl
+    };
+  }
+
+  /**
+   * Build keywords array
+   * Matches original GenerationEngine behavior exactly
+   * @param {Object} coreInputs - Core service inputs
+   * @param {Object} confirmedValues - Confirmed user values
+   * @returns {string[]} - Keywords array
+   */
+  buildKeywords(coreInputs, confirmedValues) {
+    const keywords = ['clodo-framework', coreInputs.serviceType, 'cloudflare', 'serverless'
+    // Note: 'workers' removed to match original GenerationEngine
+    ];
+
+    // Add custom keywords if provided
+    if (confirmedValues.keywords && Array.isArray(confirmedValues.keywords)) {
+      keywords.push(...confirmedValues.keywords);
+    }
+    return keywords;
+  }
+
+  /**
+   * Determine if this generator should run
+   * @param {Object} context - Generation context
+   * @returns {boolean} - True if should generate
+   */
+  shouldGenerate(context) {
+    // Always generate package.json for all service types
+    return true;
+  }
+}
+export default PackageJsonGenerator;

package/dist/service-management/generators/core/SiteConfigGenerator.js

@@ -0,0 +1,115 @@
+/**
+ * SiteConfigGenerator - Generates Workers Sites [site] configuration
+ * 
+ * Creates the [site] section for wrangler.toml for static-site services.
+ * Only generates for static-site template, not for other service types.
+ */
+import { BaseGenerator } from '../BaseGenerator.js';
+export class SiteConfigGenerator extends BaseGenerator {
+  /**
+   * Create a new SiteConfigGenerator instance
+   * @param {Object} options - Generator options
+   */
+  constructor(options = {}) {
+    super({
+      name: 'SiteConfigGenerator',
+      ...options
+    });
+  }
+
+  /**
+   * Generate Workers Sites configuration
+   * Returns TOML [site] section as a string
+   * 
+   * Supports two calling conventions:
+   * 1. New: context = { coreInputs: { serviceType }, siteConfig: {...} }
+   * 2. Old: context = { serviceType, siteConfig: {...} }
+   * 
+   * @param {Object} context - Generation context
+   * @param {Object} context.coreInputs - Core service inputs (serviceType, etc.) [new convention]
+   * @param {string} context.serviceType - Service type [old convention - deprecated]
+   * @param {Object} context.siteConfig - Optional site configuration overrides
+   * @returns {Promise<string>} - TOML [site] section or empty string
+   */
+  async generate(context) {
+    this.setContext(context);
+
+    // Support both old and new calling conventions
+    // Old: { serviceType: 'static-site', siteConfig: {...} }
+    // New: { coreInputs: { serviceType: 'static-site' }, siteConfig: {...} }
+    const serviceType = context.coreInputs?.serviceType || context.serviceType;
+    const siteConfig = context.siteConfig || {};
+
+    // Handle undefined/null serviceType gracefully (like original)
+    if (!serviceType) {
+      this.log('No service type provided - skipping [site] config');
+      return '';
+    }
+
+    // Only generate for static-site template
+    if (serviceType !== 'static-site') {
+      this.log('Skipping [site] config - not a static-site service');
+      return '';
+    }
+    return this.buildSiteConfig(siteConfig);
+  }
+
+  /**
+   * Build the [site] configuration section
+   * @param {Object} siteConfig - Site configuration overrides
+   * @returns {string} - TOML [site] section
+   */
+  buildSiteConfig(siteConfig = {}) {
+    const bucket = siteConfig.bucket || './public';
+    const include = siteConfig.include || ['**/*'];
+    const exclude = siteConfig.exclude || this.getDefaultExcludes();
+
+    // Build TOML [site] section
+    const lines = ['', '# Workers Sites configuration', '# Serves static assets from the bucket directory', '[site]', `bucket = "${bucket}"`, `include = ${JSON.stringify(include)}`, `exclude = ${JSON.stringify(exclude)}`, ''];
+    return lines.join('\n');
+  }
+
+  /**
+   * Get default file exclusions for Workers Sites
+   * @returns {string[]} - Array of glob patterns to exclude
+   */
+  getDefaultExcludes() {
+    return ['node_modules/**', '.git/**', '.*', '*.md', '.env*', 'secrets/**', 'wrangler.toml', 'package.json', 'package-lock.json', 'yarn.lock', 'pnpm-lock.yaml'];
+  }
+
+  /**
+   * Determine if this generator should run
+   * 
+   * Supports both calling conventions for backward compatibility.
+   * 
+   * @param {Object} context - Generation context
+   * @returns {boolean} - True if service type is static-site
+   */
+  shouldGenerate(context) {
+    const serviceType = context?.coreInputs?.serviceType || context?.serviceType;
+    return serviceType === 'static-site';
+  }
+
+  /**
+   * Validate site configuration
+   * @param {Object} siteConfig - Site config to validate
+   * @returns {Object} - Validation result { valid: boolean, errors: string[] }
+   */
+  validateSiteConfig(siteConfig) {
+    const errors = [];
+    if (siteConfig.bucket && typeof siteConfig.bucket !== 'string') {
+      errors.push('bucket must be a string path');
+    }
+    if (siteConfig.include && !Array.isArray(siteConfig.include)) {
+      errors.push('include must be an array of glob patterns');
+    }
+    if (siteConfig.exclude && !Array.isArray(siteConfig.exclude)) {
+      errors.push('exclude must be an array of glob patterns');
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+}
+export default SiteConfigGenerator;