@tamyla/clodo-framework 3.1.21 → 3.1.22

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

@@ -1,233 +0,0 @@
-/**
- * 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

@@ -1,254 +0,0 @@
-/**
- * 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

@@ -1,87 +0,0 @@
-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
-  }
-}

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

@@ -1,106 +0,0 @@
-import { BaseGenerator } from '../BaseGenerator.js';
-import { join } from 'path';
-import { writeFileSync, mkdirSync } from 'fs';
-
-/**
- * Deploy Workflow Generator
- * Generates GitHub Actions deployment workflow for staging and production
- */
-export class DeployWorkflowGenerator extends BaseGenerator {
-  /**
-   * Generate deployment workflow
-   * @param {Object} context - Generation context
-   * @returns {Promise<string>} Path to generated deploy 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 deployWorkflow = this._generateDeployWorkflow(coreInputs, confirmedValues);
-    const filePath = join(workflowsDir, 'deploy.yml');
-    writeFileSync(filePath, deployWorkflow, 'utf8');
-    return filePath;
-  }
-
-  /**
-   * Generate deployment workflow content
-   * @private
-   */
-  _generateDeployWorkflow(coreInputs, confirmedValues) {
-    return `name: Deploy
-
-on:
-  push:
-    branches: [ main, master ]
-  workflow_run:
-    workflows: ["CI"]
-    types:
-      - completed
-
-jobs:
-  deploy-staging:
-    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
-    environment: staging
-
-    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: Deploy to staging
-      run: npx wrangler deploy --env staging
-      env:
-        CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
-        CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
-
-  deploy-production:
-    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
-    runs-on: ubuntu-latest
-    environment: production
-
-    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: Deploy to production
-      run: npx wrangler deploy --env production
-      env:
-        CLOUDFLARE_API_TOKEN: \${{ secrets.CLOUDFLARE_API_TOKEN }}
-        CLOUDFLARE_ACCOUNT_ID: \${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
-`;
-  }
-
-  /**
-   * Determine if generator should run
-   */
-  shouldGenerate(context) {
-    return true; // Always generate deployment workflow
-  }
-}