@tamyla/clodo-framework 3.0.15 → 3.1.0

package/dist/service-management/ServiceCreator.js

@@ -6,6 +6,7 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync, readdirSync, statSync } from 'fs';
 import { join, dirname, resolve } from 'path';
 import { fileURLToPath } from 'url';
+import { FrameworkConfig } from '../utils/framework-config.js';
 const SERVICE_TYPES = ['data-service', 'auth-service', 'content-service', 'api-gateway', 'generic'];
 export class ServiceCreator {
   constructor(options = {}) {
@@ -19,6 +20,9 @@ export class ServiceCreator {
     })();
     this.templatesDir = options.templatesDir || templatesDir;
     this.serviceTypes = options.serviceTypes || SERVICE_TYPES;
+
+    // Load framework configuration
+    this.frameworkConfig = options.frameworkConfig || new FrameworkConfig();
   }
 
   /**
@@ -74,9 +78,16 @@ export class ServiceCreator {
       const templateDir = join(this.templatesDir, config.type);
       const serviceDir = join(config.output, serviceName);
 
-      // Check if template exists
+      // Check if template exists, fall back to generic if not
+      let actualTemplateDir = templateDir;
       if (!existsSync(templateDir)) {
-        throw new Error(`Template not found: ${templateDir}. Available templates: ${this.serviceTypes.join(', ')}`);
+        const genericTemplate = join(this.templatesDir, 'generic');
+        if (existsSync(genericTemplate)) {
+          console.log(`⚠️  Template for '${config.type}' not found, using 'generic' template as fallback`);
+          actualTemplateDir = genericTemplate;
+        } else {
+          throw new Error(`Template not found: ${templateDir}. Available templates: ${this.serviceTypes.join(', ')}`);
+        }
       }
 
       // Check if service directory already exists
@@ -85,15 +96,20 @@ export class ServiceCreator {
       }
 
       // Copy template to service directory
-      cpSync(templateDir, serviceDir, {
+      cpSync(actualTemplateDir, serviceDir, {
         recursive: true
       });
 
+      // Load template defaults from config
+      const templateDefaults = this.frameworkConfig.config?.templates?.defaults || {};
+
       // Prepare template variables
       const defaultVariables = {
         '{{SERVICE_NAME}}': serviceName,
         '{{SERVICE_TYPE}}': config.type,
         '{{SERVICE_DISPLAY_NAME}}': this.toTitleCase(serviceName.replace(/-/g, ' ')),
+        '{{DOMAIN_NAME}}': config.domain || templateDefaults.DOMAIN_NAME || 'example.com',
+        '{{WORKERS_DEV_DOMAIN}}': templateDefaults.WORKERS_DEV_DOMAIN || 'workers.dev',
         '{{CURRENT_DATE}}': new Date().toISOString().split('T')[0],
         '{{CURRENT_YEAR}}': new Date().getFullYear().toString(),
         '{{FRAMEWORK_VERSION}}': this.getFrameworkVersion()

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

@@ -0,0 +1,233 @@
+/**
+ * BaseGenerator - Abstract base class for all file generators
+ *
+ * Provides common functionality for loading templates, rendering content,
+ * and writing files. All concrete generators should extend this class.
+ *
+ * NOTE: This class uses Node.js filesystem APIs and is designed for
+ * build-time usage during service generation, not runtime in Cloudflare Workers.
+ *
+ * @abstract
+ */
+import { promises as fs } from 'fs';
+import * as path from 'path';
+export class BaseGenerator {
+  /**
+   * Create a new generator instance
+   * @param {Object} options - Generator configuration options
+   * @param {string} options.name - Generator name (for logging/debugging)
+   * @param {string} options.templatesPath - Path to templates directory
+   * @param {string} options.servicePath - Path to service being generated
+   */
+  constructor(options = {}) {
+    if (new.target === BaseGenerator) {
+      throw new Error('BaseGenerator is abstract and cannot be instantiated directly');
+    }
+    this.name = options.name || this.constructor.name;
+    this.templatesPath = options.templatesPath || options.templatesDir || null;
+    this.servicePath = options.servicePath || null;
+
+    // Warn if running in Cloudflare Workers environment
+    if (typeof globalThis !== 'undefined' && globalThis.caches) {
+      console.warn(`⚠️  ${this.name}: Generators are designed for build-time usage, not runtime in Cloudflare Workers`);
+    }
+    this.context = {};
+    this.logger = options.logger || console;
+  }
+
+  /**
+   * Main generation method - must be implemented by concrete generators
+   * @abstract
+   * @param {Object} context - Generation context with service configuration
+   * @returns {Promise<void>}
+   */
+  async generate(context) {
+    throw new Error(`generate() must be implemented by ${this.constructor.name}`);
+  }
+
+  /**
+   * Determine if this generator should run for the given context
+   * Override this to conditionally skip generation
+   * @param {Object} context - Generation context
+   * @returns {boolean} - True if generator should run
+   */
+  shouldGenerate(context) {
+    return true;
+  }
+
+  /**
+   * Set the generation context
+   * @param {Object} context - Generation context with service configuration
+   */
+  setContext(context) {
+    this.context = {
+      ...context
+    };
+
+    // Update paths if provided in context
+    if (context.servicePath) {
+      this.servicePath = context.servicePath;
+    }
+    if (context.templatesPath) {
+      this.templatesPath = context.templatesPath;
+    }
+  }
+
+  /**
+   * Extract and normalize context into consistent format
+   * @param {Object} context - Generation context
+   * @returns {Object} - Normalized context with coreInputs, confirmedValues, servicePath
+   */
+  extractContext(context) {
+    return {
+      coreInputs: context.coreInputs || {},
+      confirmedValues: context.confirmedValues || {},
+      servicePath: context.servicePath || this.servicePath || this.outputDir
+    };
+  }
+
+  /**
+   * Get a value from the context
+   * @param {string} key - Context key (supports dot notation: 'config.name')
+   * @param {*} defaultValue - Default value if key not found
+   * @returns {*} - Context value or default
+   */
+  getContext(key, defaultValue = undefined) {
+    if (!key) return this.context;
+    const keys = key.split('.');
+    let value = this.context;
+    for (const k of keys) {
+      if (value && typeof value === 'object' && k in value) {
+        value = value[k];
+      } else {
+        return defaultValue;
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Load a template file from the templates directory
+   * Subclasses can override this to implement custom template loading
+   * @param {string} templateName - Template filename or path relative to templatesPath
+   * @returns {Promise<string>} - Template content
+   */
+  async loadTemplate(templateName) {
+    if (!this.templatesPath) {
+      throw new Error(`templatesPath not set for ${this.name}`);
+    }
+    const templatePath = path.join(this.templatesPath, templateName);
+    try {
+      const content = await fs.readFile(templatePath, 'utf8');
+      return content;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to load template '${templateName}' from '${templatePath}': ${errorMessage}`);
+    }
+  }
+
+  /**
+   * Render a template with variables
+   * Replaces {{variable}} placeholders with values from the variables object
+   * @param {string} template - Template string with {{placeholders}}
+   * @param {Object} variables - Variable values to replace
+   * @returns {string} - Rendered template
+   */
+  renderTemplate(template, variables = {}) {
+    if (typeof template !== 'string') {
+      throw new Error('Template must be a string');
+    }
+
+    // Merge context with provided variables (variables take precedence)
+    const mergedVars = {
+      ...this.context,
+      ...variables
+    };
+
+    // Replace {{variable}} placeholders
+    return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+      const trimmedKey = key.trim();
+
+      // Check provided variables first (priority), then context
+      let value;
+      if (trimmedKey in variables) {
+        value = variables[trimmedKey];
+      } else {
+        // Support dot notation for context: {{config.name}}
+        value = this.getContext(trimmedKey);
+      }
+      if (value === undefined || value === null) {
+        this.logger.warn(`Template variable '${trimmedKey}' is undefined in ${this.name}`);
+        return match; // Keep placeholder if variable not found
+      }
+      return String(value);
+    });
+  }
+
+  /**
+   * Write content to a file within the service directory
+   * Creates parent directories if they don't exist
+   * @param {string} relativePath - Path relative to servicePath
+   * @param {string} content - File content to write
+   * @param {Object} options - Write options
+   * @param {boolean} options.overwrite - Whether to overwrite existing files (default: true)
+   * @returns {Promise<void>}
+   */
+  async writeFile(relativePath, content, options = {}) {
+    if (!this.servicePath) {
+      throw new Error(`servicePath not set for ${this.name}`);
+    }
+    const fullPath = path.join(this.servicePath, relativePath);
+    const overwrite = options.overwrite !== false; // Default to true
+
+    // Check if file exists and overwrite is disabled
+    try {
+      await fs.access(fullPath);
+      if (!overwrite) {
+        this.logger.info(`Skipping existing file: ${relativePath}`);
+        return;
+      }
+    } catch {
+      // File doesn't exist, continue
+    }
+
+    // Ensure parent directory exists
+    const dir = path.dirname(fullPath);
+    await fs.mkdir(dir, {
+      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}`);
+    }
+  }
+
+  /**
+   * Log a message at info level
+   * @param {string} message - Message to log
+   */
+  log(message) {
+    this.logger.info(`[${this.name}] ${message}`);
+  }
+
+  /**
+   * Log a warning message
+   * @param {string} message - Warning message
+   */
+  warn(message) {
+    this.logger.warn(`[${this.name}] ${message}`);
+  }
+
+  /**
+   * Log an error message
+   * @param {string} message - Error message
+   */
+  error(message) {
+    this.logger.error(`[${this.name}] ${message}`);
+  }
+}
+export default BaseGenerator;

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

@@ -0,0 +1,254 @@
+/**
+ * GeneratorRegistry - Registry for managing and executing generators
+ * 
+ * Provides a centralized registry for all generators, organized by category.
+ * Controls execution order and manages generator lifecycle.
+ */
+export class GeneratorRegistry {
+  /**
+   * Create a new generator registry
+   */
+  constructor() {
+    this.categories = new Map();
+    this.executionOrder = ['core',
+    // Core configuration files (package.json, wrangler.toml, etc.)
+    'config',
+    // Environment and config files
+    'code',
+    // Source code (schemas, handlers, middleware, utils)
+    'scripts',
+    // Utility scripts (deploy, setup, health-check)
+    'tests',
+    // Test files and test configuration
+    'docs',
+    // Documentation files
+    'ci',
+    // CI/CD workflows
+    'service-types' // Service-type specific generation
+    ];
+  }
+
+  /**
+   * Register one or more generators in a category
+   * @param {string} category - Category name (e.g., 'core', 'config', 'code')
+   * @param {BaseGenerator|BaseGenerator[]} generators - Generator instance(s) to register
+   * @throws {Error} If category or generators are invalid
+   */
+  register(category, generators) {
+    if (!category || typeof category !== 'string') {
+      throw new Error('Category must be a non-empty string');
+    }
+    if (!generators) {
+      throw new Error('Generators must be provided');
+    }
+
+    // Ensure generators is an array
+    const generatorArray = Array.isArray(generators) ? generators : [generators];
+    if (generatorArray.length === 0) {
+      throw new Error('At least one generator must be provided');
+    }
+
+    // Validate all generators have a generate() method
+    for (const generator of generatorArray) {
+      if (!generator || typeof generator.generate !== 'function') {
+        throw new Error(`Invalid generator: must have a generate() method. Got: ${generator?.constructor?.name || typeof generator}`);
+      }
+    }
+
+    // Get existing generators for this category or create new array
+    const existing = this.categories.get(category) || [];
+
+    // Add new generators
+    this.categories.set(category, [...existing, ...generatorArray]);
+  }
+
+  /**
+   * Unregister a specific generator from a category
+   * @param {string} category - Category name
+   * @param {string} generatorName - Name of the generator to remove
+   * @returns {boolean} - True if generator was found and removed
+   */
+  unregister(category, generatorName) {
+    if (!this.categories.has(category)) {
+      return false;
+    }
+    const generators = this.categories.get(category);
+    const initialLength = generators.length;
+    const filtered = generators.filter(gen => gen.name !== generatorName);
+    if (filtered.length === 0) {
+      this.categories.delete(category);
+    } else {
+      this.categories.set(category, filtered);
+    }
+    return filtered.length < initialLength;
+  }
+
+  /**
+   * Get all generators for a specific category
+   * @param {string} category - Category name
+   * @returns {BaseGenerator[]} - Array of generators (empty if category not found)
+   */
+  getGenerators(category) {
+    return this.categories.get(category) || [];
+  }
+
+  /**
+   * Get all registered categories in execution order
+   * @returns {string[]} - Array of category names
+   */
+  getCategories() {
+    const registeredCategories = Array.from(this.categories.keys());
+
+    // Return categories in execution order, followed by any unordered categories
+    const ordered = this.executionOrder.filter(cat => registeredCategories.includes(cat));
+    const unordered = registeredCategories.filter(cat => !this.executionOrder.includes(cat));
+    return [...ordered, ...unordered];
+  }
+
+  /**
+   * Get total count of registered generators across all categories
+   * @returns {number} - Total generator count
+   */
+  getCount() {
+    let count = 0;
+    for (const generators of this.categories.values()) {
+      count += generators.length;
+    }
+    return count;
+  }
+
+  /**
+   * Get count of generators in a specific category
+   * @param {string} category - Category name
+   * @returns {number} - Generator count for category
+   */
+  getCategoryCount(category) {
+    return this.getGenerators(category).length;
+  }
+
+  /**
+   * Check if a category has any generators
+   * @param {string} category - Category name
+   * @returns {boolean} - True if category has generators
+   */
+  hasCategory(category) {
+    return this.categories.has(category) && this.categories.get(category).length > 0;
+  }
+
+  /**
+   * Clear all generators from a category
+   * @param {string} category - Category name
+   * @returns {boolean} - True if category existed and was cleared
+   */
+  clearCategory(category) {
+    return this.categories.delete(category);
+  }
+
+  /**
+   * Clear all generators from all categories
+   */
+  clearAll() {
+    this.categories.clear();
+  }
+
+  /**
+   * Execute all generators in order
+   * @param {Object} context - Generation context to pass to all generators
+   * @param {Object} options - Execution options
+   * @param {Function} options.logger - Logger for progress tracking
+   * @param {boolean} options.stopOnError - Whether to stop execution on first error (default: false)
+   * @returns {Promise<Object>} - Execution results { success, failed, skipped }
+   */
+  async execute(context, options = {}) {
+    const logger = options.logger || console;
+    const stopOnError = options.stopOnError !== false; // Default to true for safety
+
+    const results = {
+      success: [],
+      failed: [],
+      skipped: []
+    };
+    const categories = this.getCategories();
+    logger.info(`Starting generator execution: ${this.getCount()} generators in ${categories.length} categories`);
+    for (const category of categories) {
+      const generators = this.getGenerators(category);
+      logger.info(`Executing category: ${category} (${generators.length} generators)`);
+      for (const generator of generators) {
+        const name = generator.name || generator.constructor.name;
+        try {
+          // Check if generator should run
+          if (generator.shouldGenerate && !generator.shouldGenerate(context)) {
+            logger.info(`Skipping ${name}: shouldGenerate() returned false`);
+            results.skipped.push({
+              name,
+              category,
+              reason: 'shouldGenerate() returned false'
+            });
+            continue;
+          }
+
+          // Execute generator
+          logger.info(`Running ${name}...`);
+          await generator.generate(context);
+          results.success.push({
+            name,
+            category
+          });
+          logger.info(`✓ ${name} completed successfully`);
+        } catch (error) {
+          const errorInfo = {
+            name,
+            category,
+            error: error.message,
+            stack: error.stack
+          };
+          results.failed.push(errorInfo);
+          logger.error(`✗ ${name} failed: ${error.message}`);
+          if (stopOnError) {
+            logger.error('Stopping execution due to error (stopOnError=true)');
+            throw new Error(`Generator execution stopped: ${name} failed - ${error.message}`);
+          }
+        }
+      }
+    }
+
+    // Log summary
+    logger.info('\n=== Generator Execution Summary ===');
+    logger.info(`Total: ${this.getCount()} generators`);
+    logger.info(`✓ Success: ${results.success.length}`);
+    logger.info(`✗ Failed: ${results.failed.length}`);
+    logger.info(`⊘ Skipped: ${results.skipped.length}`);
+    if (results.failed.length > 0) {
+      logger.error('\nFailed generators:');
+      results.failed.forEach(({
+        name,
+        error
+      }) => {
+        logger.error(`  - ${name}: ${error}`);
+      });
+    }
+    return results;
+  }
+
+  /**
+   * Get a summary of all registered generators
+   * @returns {Object} - Summary with categories and generator counts
+   */
+  getSummary() {
+    const categories = this.getCategories();
+    const summary = {
+      totalCategories: categories.length,
+      totalGenerators: this.getCount(),
+      categories: {}
+    };
+    for (const category of categories) {
+      const generators = this.getGenerators(category);
+      summary.categories[category] = {
+        count: generators.length,
+        generators: generators.map(g => g.name || g.constructor.name)
+      };
+    }
+    return summary;
+  }
+}
+export default GeneratorRegistry;

package/dist/service-management/generators/cicd/CiWorkflowGenerator.js

@@ -0,0 +1,87 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync, mkdirSync } from 'fs';
+
+/**
+ * CI Workflow Generator
+ * Generates GitHub Actions CI workflow for automated testing
+ */
+export class CiWorkflowGenerator extends BaseGenerator {
+  /**
+   * Generate CI workflow
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated CI workflow file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+
+    // Ensure .github/workflows directory exists
+    const workflowsDir = join(servicePath, '.github', 'workflows');
+    mkdirSync(workflowsDir, {
+      recursive: true
+    });
+    const ciWorkflow = this._generateCiWorkflow(coreInputs, confirmedValues);
+    const filePath = join(workflowsDir, 'ci.yml');
+    writeFileSync(filePath, ciWorkflow, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate CI workflow content
+   * @private
+   */
+  _generateCiWorkflow(coreInputs, confirmedValues) {
+    return `name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '18'
+        cache: 'npm'
+
+    - name: Install dependencies
+      run: npm ci
+
+    - name: Lint code
+      run: npm run lint
+
+    - name: Run tests
+      run: npm test
+
+    - name: Build
+      run: npm run build
+
+    - name: Upload coverage reports
+      uses: codecov/codecov-action@v3
+      with:
+        file: ./coverage/lcov.info
+`;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate CI workflow
+  }
+}