Het globaal opzetten van een website

Configuration System Implementation

// Advanced Configuration Manager
interface ConfigLayer {
  name: string;
  priority: number;
  source: 'file' | 'env' | 'cli' | 'default';
  values: Record<string, any>;
}

interface ConfigSchema {
  [key: string]: {
    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
    required?: boolean;
    default?: any;
    validate?: (value: any) => boolean | string;
    description?: string;
  };
}

class ConfigurationManager {
  private layers: ConfigLayer[] = [];
  private schema: ConfigSchema = {};
  private resolved: Record<string, any> = {};
  private watchers: Map<string, Function[]> = new Map();
  
  constructor(schema: ConfigSchema) {
    this.schema = schema;
    this.addDefaultLayer();
  }
  
  // Add configuration layer with priority
  addLayer(layer: Omit<ConfigLayer, 'priority'> & { priority?: number }) {
    const configLayer: ConfigLayer = {
      priority: layer.priority ?? this.getDefaultPriority(layer.source),
      ...layer
    };
    
    this.layers.push(configLayer);
    this.layers.sort((a, b) => a.priority - b.priority);
    this.resolveConfiguration();
  }
  
  // Load configuration from file
  async loadFromFile(filePath: string, format: 'json' | 'yaml' | 'env' = 'json') {
    try {
      let values: Record<string, any> = {};
      
      switch (format) {
        case 'json':
          const fileContent = await fs.readFile(filePath, 'utf-8');
          values = JSON.parse(fileContent);
          break;
        case 'yaml':
          const yamlContent = await fs.readFile(filePath, 'utf-8');
          values = yaml.parse(yamlContent);
          break;
        case 'env':
          values = this.parseEnvFile(filePath);
          break;
      }
      
      this.addLayer({
        name: `file:${filePath}`,
        source: 'file',
        values
      });
      
    } catch (error) {
      console.warn(`Failed to load config from ${filePath}:`, error.message);
    }
  }
  
  // Load from environment variables
  loadFromEnv(prefix = '') {
    const envVars: Record<string, any> = {};
    
    Object.keys(process.env).forEach(key => {
      if (!prefix || key.startsWith(prefix)) {
        const configKey = prefix ? key.slice(prefix.length) : key;
        let value: any = process.env[key];
        
        // Type conversion
        if (value === 'true') value = true;
        else if (value === 'false') value = false;
        else if (/^\\d+$/.test(value)) value = parseInt(value);
        else if (/^\\d+\\.\\d+$/.test(value)) value = parseFloat(value);
        
        this.setNestedValue(envVars, configKey, value);
      }
    });
    
    this.addLayer({
      name: 'environment',
      source: 'env',
      values: envVars
    });
  }
  
  // Get configuration value with type safety
  get<T = any>(key: string, defaultValue?: T): T {
    const value = this.getNestedValue(this.resolved, key);
    return value !== undefined ? value : defaultValue;
  }
}

// Template Generation System
class ProjectTemplateGenerator {
  constructor(templateDir, outputDir) {
    this.templateDir = templateDir;
    this.outputDir = outputDir;
    this.handlebars = require('handlebars');
    this.fs = require('fs-extra');
    this.path = require('path');
  }
  
  async generateProject(templateName, context = {}) {
    const templatePath = this.path.join(this.templateDir, templateName);
    const templateConfig = await this.loadTemplateConfig(templatePath);
    
    // Validate required context variables
    this.validateContext(context, templateConfig.required || []);
    
    // Process template files
    await this.processTemplate(templatePath, this.outputDir, {
      ...templateConfig.defaults,
      ...context
    });
    
    // Run post-generation hooks
    if (templateConfig.postGeneration) {
      await this.runPostGenerationHooks(templateConfig.postGeneration, context);
    }
    
    console.log(`Project generated successfully from template: ${templateName}`);
  }
  
  async processTemplate(templatePath, outputPath, context) {
    const files = await this.fs.readdir(templatePath);
    
    for (const file of files) {
      const filePath = this.path.join(templatePath, file);
      const stats = await this.fs.stat(filePath);
      
      if (stats.isDirectory()) {
        const dirName = this.processFileName(file, context);
        const newDirPath = this.path.join(outputPath, dirName);
        await this.fs.ensureDir(newDirPath);
        await this.processTemplate(filePath, newDirPath, context);
      } else {
        await this.processFile(filePath, outputPath, context);
      }
    }
  }
  
  async processFile(filePath, outputPath, context) {
    const fileName = this.path.basename(filePath);
    
    // Skip template config files
    if (fileName === 'template.json') return;
    
    const content = await this.fs.readFile(filePath, 'utf-8');
    const processedFileName = this.processFileName(fileName, context);
    const outputFilePath = this.path.join(outputPath, processedFileName);
    
    // Process file content if it's a template
    if (fileName.endsWith('.hbs')) {
      const template = this.handlebars.compile(content);
      const processedContent = template(context);
      const finalFileName = processedFileName.replace(/\\.hbs$/, '');
      const finalFilePath = this.path.join(outputPath, finalFileName);
      await this.fs.writeFile(finalFilePath, processedContent);
    } else {
      // Copy binary files as-is
      await this.fs.copy(filePath, outputFilePath);
    }
  }
}