@tamyla/clodo-framework 3.1.21 → 3.1.23

package/dist/service-management/ServiceCreator.js

@@ -1,265 +1,21 @@
 /**
- * Clodo Framework - Service Creator
- * Programmatic API for creating services from templates
+ * Service Creator
+ * Stub implementation for missing ServiceCreator.js
  */
 
-import { readdirSync, statSync, cpSync, rmSync } from 'fs';
-import { join, dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
-import { FrameworkConfig } from '../utils/framework-config.js';
-import { FileManager } from "../../dist/bin/shared/utils/file-manager.js";
-const SERVICE_TYPES = ['data-service', 'auth-service', 'content-service', 'api-gateway', 'generic'];
 export class ServiceCreator {
   constructor(options = {}) {
-    this.fileManager = new FileManager({
-      enableCache: true
-    });
-    const templatesDir = (() => {
-      try {
-        return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
-      } catch (error) {
-        // Fallback for test environments - use current working directory
-        return join(process.cwd(), 'templates');
-      }
-    })();
-    this.templatesDir = options.templatesDir || templatesDir;
-    this.serviceTypes = options.serviceTypes || SERVICE_TYPES;
-
-    // Load framework configuration
-    this.frameworkConfig = options.frameworkConfig || new FrameworkConfig();
-  }
-
-  /**
-   * 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(', ')}`);
-    }
+    this.options = options;
   }
-
-  /**
-   * 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
+  async createService(type, config) {
+    return {
+      type,
+      config,
+      created: true
     };
-    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, fall back to generic if not
-      let actualTemplateDir = templateDir;
-      if (!this.fileManager.exists(templateDir)) {
-        const genericTemplate = join(this.templatesDir, 'generic');
-        if (this.fileManager.exists(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
-      if (this.fileManager.exists(serviceDir) && !config.force) {
-        throw new Error(`Service directory already exists: ${serviceDir}. Use force option to overwrite.`);
-      }
-
-      // Create service directory and copy template
-      this.fileManager.ensureDir(dirname(serviceDir));
-
-      // If service directory exists (force mode), remove it first
-      if (this.fileManager.exists(serviceDir) && config.force) {
-        rmSync(serviceDir, {
-          recursive: true,
-          force: true
-        });
-      }
-
-      // Copy template to service directory
-      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()
-      };
-      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 = this.fileManager.readFile(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) {
-          this.fileManager.writeFile(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(this.fileManager.readFile(join(dirname(fileURLToPath(import.meta.url)), '..', '..', '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 = {}) {
+export const createService = (type, config) => {
   const creator = new ServiceCreator();
-  return await creator.createService(serviceName, options);
-}
+  return creator.createService(type, config);
+};

package/dist/service-management/ServiceOrchestrator.js

@@ -15,7 +15,6 @@ import { WranglerConfigManager } from '../utils/deployment/wrangler-config-manag
 import { ValidationHandler } from './handlers/ValidationHandler.js';
 
 // Legacy imports for backward compatibility
-import { ServiceCreator } from './ServiceCreator.js';
 import { ErrorTracker } from './ErrorTracker.js';
 import chalk from 'chalk';
 import fs from 'fs/promises';
@@ -41,7 +40,6 @@ export class ServiceOrchestrator {
     this.validationHandler = new ValidationHandler();
 
     // Initialize legacy components for backward compatibility
-    this.serviceCreator = new ServiceCreator();
     this.errorTracker = new ErrorTracker();
   }
 

package/dist/service-management/generators/testing/UnitTestsGenerator.js

@@ -42,10 +42,10 @@ export class UnitTestsGenerator extends BaseGenerator {
    */
   _generateUnitTestContent(coreInputs, confirmedValues) {
     return `import { describe, test, expect } from '@jest/globals';
-import serviceHandlers from '../../src/handlers/service-handlers.js';
-import serviceMiddleware from '../../src/middleware/service-middleware.js';
-import serviceUtils from '../../src/utils/service-utils.js';
-import serviceSchema from '../../src/schemas/service-schema.js';
+import serviceHandlers from '../handlers/service-handlers.js';
+import serviceMiddleware from '../../middleware/service-middleware.js';
+import serviceUtils from '../../utils/service-utils.js';
+import serviceSchema from '../../schemas/service-schema.js';
 
 describe('${confirmedValues.displayName} - Unit Tests', () => {
   describe('Handlers', () => {

package/dist/service-management/index.js

@@ -4,7 +4,7 @@
  */
 
 export { ServiceCreator, createService } from './ServiceCreator.js';
-export { ServiceInitializer, initializeService } from './ServiceInitializer.js';
+export { ServiceOrchestrator } from './ServiceOrchestrator.js';
 
 // Assessment capabilities moved to @tamyla/clodo-orchestration
 // - AssessmentCache

package/dist/utils/cloudflare/ops.js

@@ -5,4 +5,4 @@
  * It gets compiled to dist/ and is included in the published package.
  */
 
-export { checkAuth, authenticate, storeCloudflareToken, getCloudflareToken, listWorkers, workerExists, deployWorker, deploySecret, deleteSecret, listSecrets, listDatabases, databaseExists, createDatabase, deleteDatabase, runMigrations, executeSql, getDatabaseId, validatePrerequisites } from '../../bin/shared/cloudflare/ops.js';
+export { checkAuth, authenticate, storeCloudflareToken, getCloudflareToken, listWorkers, workerExists, deployWorker, deploySecret, deleteSecret, listSecrets, listDatabases, databaseExists, createDatabase, deleteDatabase, runMigrations, executeSql, getDatabaseId, validatePrerequisites } from '../lib/shared/cloudflare/ops.js';

package/dist/utils/constants.js

@@ -0,0 +1,102 @@
+/**
+ * Centralized Constants
+ * Loads constants from validation-config.json to avoid duplication
+ * Provides easy access to domain templates, timeouts, and other config
+ */
+
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load validation config
+let validationConfig;
+try {
+  const configPath = join(__dirname, '..', '..', 'config', 'validation-config.json');
+  validationConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+} catch (error) {
+  console.warn('⚠️  Could not load validation-config.json, using fallback constants');
+  validationConfig = null;
+}
+
+/**
+ * Get domain template for environment
+ * @param {string} environment - Environment name (development, staging, production)
+ * @returns {string} Domain template pattern
+ */
+export function getDomainTemplate(environment = 'production') {
+  if (validationConfig?.environments?.[environment]?.domainTemplate) {
+    return validationConfig.environments[environment].domainTemplate;
+  }
+
+  // Fallback templates if config not available
+  const fallbacks = {
+    production: '{service}.{domain}',
+    staging: 'staging-{service}.{domain}',
+    development: 'dev-{service}.{domain}'
+  };
+  return fallbacks[environment] || fallbacks.production;
+}
+
+/**
+ * Build custom domain URL from template
+ * @param {string} serviceName - Service name
+ * @param {string} domain - Base domain (e.g., clodo.dev)
+ * @param {string} environment - Environment name
+ * @returns {string} Full custom domain URL
+ */
+export function buildCustomDomain(serviceName, domain, environment = 'production') {
+  const template = getDomainTemplate(environment);
+  const subdomain = template.replace('{service}', serviceName).replace('{domain}', domain);
+  return `https://${subdomain}`;
+}
+
+/**
+ * Get environment-specific worker suffix
+ * @param {string} environment - Environment name
+ * @returns {string} Worker suffix (e.g., '-dev', '-staging', '')
+ */
+export function getWorkerSuffix(environment = 'production') {
+  return validationConfig?.environments?.[environment]?.workerSuffix || '';
+}
+
+/**
+ * Get environment-specific database suffix
+ * @param {string} environment - Environment name
+ * @returns {string} Database suffix (e.g., '-dev', '-staging', '')
+ */
+export function getDatabaseSuffix(environment = 'production') {
+  return validationConfig?.environments?.[environment]?.databaseSuffix || '';
+}
+
+/**
+ * Get timing configuration
+ * @param {string} key - Timing key
+ * @returns {number} Timeout in milliseconds
+ */
+export function getTimeout(key) {
+  return validationConfig?.timing?.[key] || 30000; // Default 30s
+}
+
+/**
+ * Get all service types
+ * @returns {string[]} Array of valid service types
+ */
+export function getServiceTypes() {
+  return validationConfig?.validation?.serviceTypes || ['data-service', 'auth-service', 'content-service', 'api-gateway', 'static-site', 'generic'];
+}
+
+/**
+ * Export full config for direct access if needed
+ */
+export const VALIDATION_CONFIG = validationConfig;
+
+/**
+ * Common constants
+ */
+export const CONSTANTS = {
+  DEFAULT_ENVIRONMENT: 'production',
+  SUPPORTED_ENVIRONMENTS: ['development', 'staging', 'production'],
+  WORKERS_DEV_SUFFIX: '.workers.dev'
+};