@tamyla/clodo-framework 1.0.0

package/dist/service-management/InputCollector.js

@@ -0,0 +1,237 @@
+/**
+ * InputCollector - Tier 1: Core Input Collection
+ *
+ * Collects the 6 absolutely required inputs for service creation:
+ * 1. Service Name
+ * 2. Service Type
+ * 3. Domain Name
+ * 4. Cloudflare API Token
+ * 5. Cloudflare Account ID
+ * 6. Cloudflare Zone ID
+ * 7. Target Environment (derived but required)
+ */
+
+import { createInterface } from 'readline';
+import chalk from 'chalk';
+import { validateServiceName, validateDomainName } from '../utils/validation.js';
+export class InputCollector {
+  constructor(options = {}) {
+    this.interactive = options.interactive !== false;
+    this.rl = this.interactive ? createInterface({
+      input: process.stdin,
+      output: process.stdout
+    }) : null;
+  }
+
+  /**
+   * Collect all 6 core inputs interactively
+   */
+  async collectCoreInputs() {
+    const inputs = {};
+    console.log(chalk.cyan('📝 Collecting Core Service Information'));
+    console.log(chalk.white('These 6 inputs are required to create your Clodo service.\n'));
+
+    // 1. Service Name
+    inputs.serviceName = await this.collectServiceName();
+
+    // 2. Service Type
+    inputs.serviceType = await this.collectServiceType();
+
+    // 3. Domain Name
+    inputs.domainName = await this.collectDomainName();
+
+    // 4. Cloudflare API Token
+    inputs.cloudflareToken = await this.collectCloudflareToken();
+
+    // 5. Cloudflare Account ID
+    inputs.cloudflareAccountId = await this.collectCloudflareAccountId();
+
+    // 6. Cloudflare Zone ID
+    inputs.cloudflareZoneId = await this.collectCloudflareZoneId();
+
+    // 7. Target Environment
+    inputs.environment = await this.collectEnvironment();
+    return inputs;
+  }
+
+  /**
+   * Validate core inputs (for non-interactive mode)
+   */
+  async validateCoreInputs(inputs) {
+    const required = ['serviceName', 'serviceType', 'domainName', 'cloudflareToken', 'cloudflareAccountId', 'cloudflareZoneId', 'environment'];
+    for (const field of required) {
+      if (!inputs[field]) {
+        throw new Error(`Missing required input: ${field}`);
+      }
+    }
+
+    // Validate service name
+    if (!validateServiceName(inputs.serviceName)) {
+      throw new Error('Invalid service name format');
+    }
+
+    // Validate domain name
+    if (!validateDomainName(inputs.domainName)) {
+      throw new Error('Invalid domain name format');
+    }
+
+    // Validate service type
+    const validTypes = ['data-service', 'auth-service', 'content-service', 'api-gateway', 'generic'];
+    if (!validTypes.includes(inputs.serviceType)) {
+      throw new Error(`Invalid service type. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // Validate environment
+    const validEnvs = ['development', 'staging', 'production'];
+    if (!validEnvs.includes(inputs.environment)) {
+      throw new Error(`Invalid environment. Must be one of: ${validEnvs.join(', ')}`);
+    }
+  }
+
+  /**
+   * Collect service name with validation
+   */
+  async collectServiceName() {
+    for (;;) {
+      const name = await this.prompt('Service Name (lowercase, letters/numbers/hyphens only): ');
+      if (validateServiceName(name)) {
+        return name;
+      }
+      console.log(chalk.red('✗ Invalid service name. Use only lowercase letters, numbers, and hyphens.'));
+    }
+  }
+
+  /**
+   * Collect service type with menu
+   */
+  async collectServiceType() {
+    const types = {
+      'data-service': 'Data service with CRUD operations, search, and filtering',
+      'auth-service': 'Authentication and authorization service',
+      'content-service': 'Content management with file storage and search',
+      'api-gateway': 'API gateway with rate limiting and routing',
+      'generic': 'Basic service with core Clodo Framework features'
+    };
+    console.log(chalk.cyan('Available Service Types:'));
+    Object.entries(types).forEach(([type, desc]) => {
+      console.log(chalk.white(`  ${type}: ${desc}`));
+    });
+    console.log('');
+    for (;;) {
+      const type = await this.prompt('Service Type (default: generic): ', 'generic');
+      if (Object.keys(types).includes(type)) {
+        return type;
+      }
+      console.log(chalk.red('✗ Invalid service type. Choose from the list above.'));
+    }
+  }
+
+  /**
+   * Collect domain name with validation
+   */
+  async collectDomainName() {
+    for (;;) {
+      const domain = await this.prompt('Domain Name (e.g., my-service.com): ');
+      if (validateDomainName(domain)) {
+        return domain;
+      }
+      console.log(chalk.red('✗ Invalid domain name format.'));
+    }
+  }
+
+  /**
+   * Collect Cloudflare API token
+   */
+  async collectCloudflareToken() {
+    console.log(chalk.yellow('Cloudflare Configuration:'));
+    console.log(chalk.white('You can find your API token at: https://dash.cloudflare.com/profile/api-tokens'));
+    console.log('');
+    for (;;) {
+      const token = await this.prompt('Cloudflare API Token: ');
+      if (token && token.length > 20) {
+        // Basic length validation
+        return token;
+      }
+      console.log(chalk.red('✗ Invalid API token format.'));
+    }
+  }
+
+  /**
+   * Collect Cloudflare Account ID
+   */
+  async collectCloudflareAccountId() {
+    console.log(chalk.white('Find your Account ID in the right sidebar of your Cloudflare dashboard.'));
+    console.log('');
+    for (;;) {
+      const accountId = await this.prompt('Cloudflare Account ID: ');
+      if (accountId && /^[a-f0-9]{32}$/i.test(accountId)) {
+        // 32 hex chars
+        return accountId;
+      }
+      console.log(chalk.red('✗ Invalid Account ID format (should be 32 hexadecimal characters).'));
+    }
+  }
+
+  /**
+   * Collect Cloudflare Zone ID
+   */
+  async collectCloudflareZoneId() {
+    console.log(chalk.white('Find your Zone ID in the Overview tab of your domain in Cloudflare.'));
+    console.log('');
+    for (;;) {
+      const zoneId = await this.prompt('Cloudflare Zone ID: ');
+      if (zoneId && /^[a-f0-9]{32}$/i.test(zoneId)) {
+        // 32 hex chars
+        return zoneId;
+      }
+      console.log(chalk.red('✗ Invalid Zone ID format (should be 32 hexadecimal characters).'));
+    }
+  }
+
+  /**
+   * Collect target environment
+   */
+  async collectEnvironment() {
+    const environments = {
+      'development': 'Local development environment',
+      'staging': 'Staging environment for testing',
+      'production': 'Production environment for live services'
+    };
+    console.log(chalk.cyan('Target Environment:'));
+    Object.entries(environments).forEach(([env, desc]) => {
+      console.log(chalk.white(`  ${env}: ${desc}`));
+    });
+    console.log('');
+    for (;;) {
+      const env = await this.prompt('Environment (default: development): ', 'development');
+      if (Object.keys(environments).includes(env)) {
+        return env;
+      }
+      console.log(chalk.red('✗ Invalid environment. Choose from development, staging, or production.'));
+    }
+  }
+
+  /**
+   * Prompt user for input (interactive mode)
+   */
+  async prompt(question, defaultValue = '') {
+    if (!this.interactive) {
+      throw new Error('Cannot prompt in non-interactive mode');
+    }
+    return new Promise(resolve => {
+      const promptText = defaultValue ? `${question}(default: ${defaultValue}) ` : question;
+      this.rl.question(promptText, answer => {
+        resolve(answer || defaultValue);
+      });
+    });
+  }
+
+  /**
+   * Close readline interface
+   */
+  close() {
+    if (this.rl) {
+      this.rl.close();
+    }
+  }
+}

package/dist/service-management/ServiceCreator.js

@@ -0,0 +1,229 @@
+/**
+ * Clodo Framework - Service Creator
+ * Programmatic API for creating services from templates
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync, readdirSync, statSync } from 'fs';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATES_DIR = join(__dirname, '..', '..', 'templates');
+const SERVICE_TYPES = ['data-service', 'auth-service', 'content-service', 'api-gateway', 'generic'];
+export class ServiceCreator {
+  constructor(options = {}) {
+    this.templatesDir = options.templatesDir || TEMPLATES_DIR;
+    this.serviceTypes = options.serviceTypes || SERVICE_TYPES;
+  }
+
+  /**
+   * Validate service name according to framework conventions
+   * @param {string} name - Service name to validate
+   * @throws {Error} If validation fails
+   */
+  validateServiceName(name) {
+    if (!/^[a-z0-9-]+$/.test(name)) {
+      throw new Error('Service name must contain only lowercase letters, numbers, and hyphens');
+    }
+    if (name.length < 3) {
+      throw new Error('Service name must be at least 3 characters long');
+    }
+    if (name.length > 50) {
+      throw new Error('Service name must be no more than 50 characters long');
+    }
+  }
+
+  /**
+   * Validate service type
+   * @param {string} type - Service type to validate
+   * @throws {Error} If type is invalid
+   */
+  validateServiceType(type) {
+    if (!this.serviceTypes.includes(type)) {
+      throw new Error(`Invalid service type. Must be one of: ${this.serviceTypes.join(', ')}`);
+    }
+  }
+
+  /**
+   * Create a service from a template
+   * @param {string} serviceName - Name of the service to create
+   * @param {Object} options - Creation options
+   * @param {string} options.type - Service type (default: 'generic')
+   * @param {string} options.output - Output directory (default: current directory)
+   * @param {boolean} options.force - Overwrite existing directory (default: false)
+   * @param {Object} options.variables - Additional template variables
+   * @returns {Object} Creation result with success status and metadata
+   */
+  async createService(serviceName, options = {}) {
+    const config = {
+      type: 'generic',
+      output: process.cwd(),
+      force: false,
+      variables: {},
+      ...options
+    };
+    try {
+      // Validate inputs
+      this.validateServiceName(serviceName);
+      this.validateServiceType(config.type);
+      const templateDir = join(this.templatesDir, config.type);
+      const serviceDir = join(config.output, serviceName);
+
+      // Check if template exists
+      if (!existsSync(templateDir)) {
+        throw new Error(`Template not found: ${templateDir}. Available templates: ${this.serviceTypes.join(', ')}`);
+      }
+
+      // Check if service directory already exists
+      if (existsSync(serviceDir) && !config.force) {
+        throw new Error(`Service directory already exists: ${serviceDir}. Use force option to overwrite.`);
+      }
+
+      // Copy template to service directory
+      cpSync(templateDir, serviceDir, {
+        recursive: true
+      });
+
+      // Prepare template variables
+      const defaultVariables = {
+        '{{SERVICE_NAME}}': serviceName,
+        '{{SERVICE_TYPE}}': config.type,
+        '{{SERVICE_DISPLAY_NAME}}': this.toTitleCase(serviceName.replace(/-/g, ' ')),
+        '{{CURRENT_DATE}}': new Date().toISOString().split('T')[0],
+        '{{CURRENT_YEAR}}': new Date().getFullYear().toString(),
+        '{{FRAMEWORK_VERSION}}': this.getFrameworkVersion()
+      };
+      const allVariables = {
+        ...defaultVariables,
+        ...config.variables
+      };
+
+      // Replace template variables
+      this.replaceTemplateVariables(serviceDir, allVariables);
+      return {
+        success: true,
+        serviceName,
+        serviceType: config.type,
+        serviceDir,
+        templateDir,
+        variables: allVariables
+      };
+    } catch (error) {
+      return {
+        success: false,
+        serviceName,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Replace template variables in all files within a directory
+   * @param {string} dir - Directory to process
+   * @param {Object} variables - Variable mappings
+   */
+  replaceTemplateVariables(dir, variables) {
+    const files = this.getAllFiles(dir);
+    for (const file of files) {
+      try {
+        let content = readFileSync(file, 'utf8');
+        let modified = false;
+        for (const [placeholder, value] of Object.entries(variables)) {
+          if (content.includes(placeholder)) {
+            content = content.replace(new RegExp(this.escapeRegExp(placeholder), 'g'), value);
+            modified = true;
+          }
+        }
+        if (modified) {
+          writeFileSync(file, content, 'utf8');
+        }
+      } catch (error) {
+        // Skip binary files or files that can't be read
+        if (error.code !== 'EISDIR') {
+          // In programmatic usage, we might want to collect warnings
+          // For now, we'll silently skip problematic files
+        }
+      }
+    }
+  }
+
+  /**
+   * Get all files in a directory recursively
+   * @param {string} dir - Directory to traverse
+   * @returns {string[]} Array of file paths
+   */
+  getAllFiles(dir) {
+    const files = [];
+    function traverse(currentDir) {
+      const items = readdirSync(currentDir);
+      for (const item of items) {
+        const fullPath = join(currentDir, item);
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          // Skip node_modules and other unwanted directories
+          if (!['node_modules', '.git', 'dist', 'build'].includes(item)) {
+            traverse(fullPath);
+          }
+        } else {
+          files.push(fullPath);
+        }
+      }
+    }
+    traverse(dir);
+    return files;
+  }
+
+  /**
+   * Escape special regex characters
+   * @param {string} string - String to escape
+   * @returns {string} Escaped string
+   */
+  escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+
+  /**
+   * Convert string to title case
+   * @param {string} str - String to convert
+   * @returns {string} Title case string
+   */
+  toTitleCase(str) {
+    return str.split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(' ');
+  }
+
+  /**
+   * Get framework version from package.json
+   * @returns {string} Framework version
+   */
+  getFrameworkVersion() {
+    try {
+      const packageJson = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8'));
+      return packageJson.version;
+    } catch {
+      return '1.0.0';
+    }
+  }
+
+  /**
+   * Get available service types
+   * @returns {string[]} Array of available service types
+   */
+  getServiceTypes() {
+    return [...this.serviceTypes];
+  }
+
+  /**
+   * Check if a service type is available
+   * @param {string} type - Service type to check
+   * @returns {boolean} True if type is available
+   */
+  isServiceTypeAvailable(type) {
+    return this.serviceTypes.includes(type);
+  }
+}
+
+// Convenience function for quick service creation
+export async function createService(serviceName, options = {}) {
+  const creator = new ServiceCreator();
+  return await creator.createService(serviceName, options);
+}