@tamyla/clodo-framework 3.1.22 → 3.1.23

package/dist/service-management/generators/code/ServiceHandlersGenerator.js

@@ -0,0 +1,235 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+
+/**
+ * Service Handlers Generator
+ * Generates request handlers with routing, health checks, and API endpoints
+ */
+export class ServiceHandlersGenerator extends BaseGenerator {
+  /**
+   * Generate service handlers
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated handlers file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+    const handlersContent = `/**
+ * ${confirmedValues.displayName} - Service Handlers
+ *
+ * Generated by Clodo Framework GenerationEngine
+ * Service Type: ${coreInputs.serviceType}
+ */
+
+import { healthCheckResponseSchema, errorResponseSchema } from '../schemas/service-schema.js';
+
+export function createServiceHandlers(serviceConfig, env) {
+  return {
+    async handleRequest(request, ctx) {
+      const url = new URL(request.url);
+      const path = url.pathname;
+
+      // Health check endpoint
+      if (path === '${confirmedValues.healthCheckPath}') {
+        return this.handleHealthCheck(request, serviceConfig);
+      }
+
+      // API routes
+      if (path.startsWith('${confirmedValues.apiBasePath}')) {
+        return this.handleApiRequest(request, ctx, serviceConfig, env);
+      }
+
+      // Default 404 response
+      return new Response(JSON.stringify({
+        error: 'Not Found',
+        message: \`Endpoint not found: \${path}\`,
+        availableEndpoints: [
+          '${confirmedValues.healthCheckPath}',
+          '${confirmedValues.apiBasePath}/*'
+        ]
+      }), {
+        status: 404,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    },
+
+    async handleHealthCheck(request, serviceConfig) {
+      try {
+        // Perform health checks
+        const healthStatus = await this.performHealthChecks(serviceConfig, env);
+
+        const response = {
+          status: healthStatus.overall === 'healthy' ? 'healthy' : 'unhealthy',
+          timestamp: new Date().toISOString(),
+          service: serviceConfig.name,
+          version: '${confirmedValues.version}',
+          environment: '${coreInputs.environment}',
+          checks: healthStatus.checks
+        };
+
+        return new Response(JSON.stringify(response), {
+          status: healthStatus.overall === 'healthy' ? 200 : 503,
+          headers: { 'Content-Type': 'application/json' }
+        });
+      } catch (error) {
+        return new Response(JSON.stringify({
+          status: 'unhealthy',
+          timestamp: new Date().toISOString(),
+          service: serviceConfig.name,
+          error: error.message
+        }), {
+          status: 503,
+          headers: { 'Content-Type': 'application/json' }
+        });
+      }
+    },
+
+    async handleApiRequest(request, ctx, serviceConfig, env) {
+      try {
+        const url = new URL(request.url);
+        const path = url.pathname.replace('${confirmedValues.apiBasePath}', '');
+
+        // Route to service-specific handlers
+        switch (request.method) {
+          case 'GET':
+            return this.handleGet(path, request, ctx, serviceConfig, env);
+          case 'POST':
+            return this.handlePost(path, request, ctx, serviceConfig, env);
+          case 'PUT':
+            return this.handlePut(path, request, ctx, serviceConfig, env);
+          case 'DELETE':
+            return this.handleDelete(path, request, ctx, serviceConfig, env);
+          default:
+            return new Response(JSON.stringify({
+              error: 'Method Not Allowed',
+              message: \`Method \${request.method} not supported\`
+            }), {
+              status: 405,
+              headers: { 'Content-Type': 'application/json' }
+            });
+        }
+      } catch (error) {
+        return new Response(JSON.stringify({
+          error: 'Internal Server Error',
+          message: error.message,
+          timestamp: new Date().toISOString()
+        }), {
+          status: 500,
+          headers: { 'Content-Type': 'application/json' }
+        });
+      }
+    },
+
+    async performHealthChecks(serviceConfig, env) {
+      const checks = [];
+
+      // Database connectivity check
+      try {
+        ${confirmedValues.features.database ? `
+        // Check database connection
+        const dbCheck = await env.DB.prepare('SELECT 1 as health_check').first();
+        checks.push({
+          name: 'database',
+          status: dbCheck ? 'healthy' : 'unhealthy',
+          responseTime: Date.now()
+        });` : `
+        checks.push({
+          name: 'database',
+          status: 'disabled',
+          message: 'Database not configured for this service type'
+        });`}
+      } catch (error) {
+        checks.push({
+          name: 'database',
+          status: 'unhealthy',
+          error: error.message
+        });
+      }
+
+      // Service configuration check
+      checks.push({
+        name: 'configuration',
+        status: serviceConfig ? 'healthy' : 'unhealthy',
+        message: serviceConfig ? 'Service configuration loaded' : 'Service configuration missing'
+      });
+
+      // Overall health status
+      const overall = checks.every(check => check.status === 'healthy' || check.status === 'disabled')
+        ? 'healthy' : 'unhealthy';
+
+      return { overall, checks };
+    },
+
+    // Placeholder handlers - implement based on service type
+    async handleGet(path, request, ctx, serviceConfig, env) {
+      return new Response(JSON.stringify({
+        message: 'GET handler not implemented',
+        path,
+        service: serviceConfig.name,
+        timestamp: new Date().toISOString()
+      }), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    },
+
+    async handlePost(path, request, ctx, serviceConfig, env) {
+      return new Response(JSON.stringify({
+        message: 'POST handler not implemented',
+        path,
+        service: serviceConfig.name,
+        timestamp: new Date().toISOString()
+      }), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    },
+
+    async handlePut(path, request, ctx, serviceConfig, env) {
+      return new Response(JSON.stringify({
+        message: 'PUT handler not implemented',
+        path,
+        service: serviceConfig.name,
+        timestamp: new Date().toISOString()
+      }), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    },
+
+    async handleDelete(path, request, ctx, serviceConfig, env) {
+      return new Response(JSON.stringify({
+        message: 'DELETE handler not implemented',
+        path,
+        service: serviceConfig.name,
+        timestamp: new Date().toISOString()
+      }), {
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+  };
+}
+`;
+    const filePath = join(servicePath, 'src', 'handlers', 'service-handlers.js');
+
+    // Ensure directory exists
+    const dir = join(servicePath, 'src', 'handlers');
+    mkdirSync(dir, {
+      recursive: true
+    });
+    writeFileSync(filePath, handlersContent, 'utf8');
+    this.logger.info(`Generated: ${filePath}`);
+    return filePath;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate handlers
+  }
+}

package/dist/service-management/generators/code/ServiceMiddlewareGenerator.js

@@ -0,0 +1,116 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+
+/**
+ * Service Middleware Generator
+ * Generates middleware functions for request/response processing
+ */
+export class ServiceMiddlewareGenerator extends BaseGenerator {
+  /**
+   * Generate service middleware
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated middleware file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+    const middlewareContent = `/**
+ * ${confirmedValues.displayName} - Service Middleware
+ *
+ * Generated by Clodo Framework GenerationEngine
+ * Service Type: ${coreInputs.serviceType}
+ */
+
+export function createServiceMiddleware(serviceConfig, env) {
+  return {
+    async processRequest(request) {
+      let processedRequest = request;
+
+      // Add service context headers
+      const headers = new Headers(request.headers);
+      headers.set('X-Service', serviceConfig.name);
+      headers.set('X-Version', '${confirmedValues.version}');
+      headers.set('X-Environment', '${coreInputs.environment}');
+      headers.set('X-Request-ID', crypto.randomUUID());
+
+      // CORS headers for API requests
+      if (request.url.includes('${confirmedValues.apiBasePath}')) {
+        headers.set('Access-Control-Allow-Origin', '*');
+        headers.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+        headers.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+      }
+
+      ${confirmedValues.features.logging ? `
+      // Request logging
+      console.log(\`[\${new Date().toISOString()}] \${request.method} \${request.url}\`);` : ''}
+
+      ${confirmedValues.features.rateLimiting ? `
+      // Rate limiting (placeholder - implement based on requirements)
+      // This would typically check request frequency and block if over limit` : ''}
+
+      ${confirmedValues.features.authentication ? `
+      // Authentication middleware (placeholder)
+      // This would validate JWT tokens, API keys, etc.` : ''}
+
+      ${confirmedValues.features.authorization ? `
+      // Authorization middleware (placeholder)
+      // This would check user permissions and roles` : ''}
+
+      return new Request(request.url, {
+        ...request,
+        headers
+      });
+    },
+
+    async processResponse(response) {
+      const headers = new Headers(response.headers);
+
+      // Add standard response headers
+      headers.set('X-Service', serviceConfig.name);
+      headers.set('X-Version', '${confirmedValues.version}');
+      headers.set('X-Response-Time', Date.now().toString());
+
+      ${confirmedValues.features.monitoring ? `
+      // Response monitoring
+      console.log(\`Response: \${response.status} (\${Date.now()}ms)\`);` : ''}
+
+      ${confirmedValues.features.caching ? `
+      // Cache headers (placeholder - implement based on content type)
+      if (response.status === 200) {
+        headers.set('Cache-Control', 'public, max-age=300'); // 5 minutes
+      }` : ''}
+
+      return new Response(response.body, {
+        ...response,
+        headers
+      });
+    }
+  };
+}
+`;
+    const filePath = join(servicePath, 'src', 'middleware', 'service-middleware.js');
+
+    // Ensure directory exists
+    const dir = join(servicePath, 'src', 'middleware');
+    mkdirSync(dir, {
+      recursive: true
+    });
+    writeFileSync(filePath, middlewareContent, 'utf8');
+    this.logger.info(`Generated: ${filePath}`);
+    return filePath;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate middleware
+  }
+}

package/dist/service-management/generators/code/ServiceUtilsGenerator.js

@@ -0,0 +1,246 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { mkdirSync, writeFileSync } from 'fs';
+
+/**
+ * Service Utils Generator
+ * Generates utility classes for database, validation, responses, logging, and features
+ */
+export class ServiceUtilsGenerator extends BaseGenerator {
+  /**
+   * Generate service utilities
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated utils file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+    const utilsContent = `/**
+ * ${confirmedValues.displayName} - Service Utilities
+ *
+ * Generated by Clodo Framework GenerationEngine
+ * Service Type: ${coreInputs.serviceType}
+ */
+
+/**
+ * Utility functions for ${confirmedValues.displayName}
+ */
+
+// Database utilities
+export class DatabaseUtils {
+  static async executeQuery(env, query, params = []) {
+    try {
+      const stmt = env.DB.prepare(query);
+      if (params.length > 0) {
+        return await stmt.bind(...params).all();
+      }
+      return await stmt.all();
+    } catch (error) {
+      console.error('Database query error:', error);
+      throw new Error(\`Database operation failed: \${error.message}\`);
+    }
+  }
+
+  static async getById(env, table, id) {
+    const result = await this.executeQuery(
+      env,
+      \`SELECT * FROM \${table} WHERE id = ?\`,
+      [id]
+    );
+    return result.results[0] || null;
+  }
+
+  static async create(env, table, data) {
+    const columns = Object.keys(data).join(', ');
+    const placeholders = Object.keys(data).map(() => '?').join(', ');
+    const values = Object.values(data);
+
+    const result = await this.executeQuery(
+      env,
+      \`INSERT INTO \${table} (\${columns}) VALUES (\${placeholders})\`,
+      values
+    );
+
+    return result.meta.last_row_id;
+  }
+
+  static async update(env, table, id, data) {
+    const setClause = Object.keys(data).map(key => \`\${key} = ?\`).join(', ');
+    const values = [...Object.values(data), id];
+
+    const result = await this.executeQuery(
+      env,
+      \`UPDATE \${table} SET \${setClause} WHERE id = ?\`,
+      values
+    );
+
+    return result.meta.changes > 0;
+  }
+
+  static async delete(env, table, id) {
+    const result = await this.executeQuery(
+      env,
+      \`DELETE FROM \${table} WHERE id = ?\`,
+      [id]
+    );
+
+    return result.meta.changes > 0;
+  }
+}
+
+// Validation utilities
+export class ValidationUtils {
+  static isValidUUID(uuid) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(uuid);
+  }
+
+  static isValidEmail(email) {
+    const emailRegex = /^[^@]+@[^@]+.[^@]+$/;
+    return emailRegex.test(email);
+  }
+
+  static sanitizeString(str, maxLength = 1000) {
+    if (typeof str !== 'string') return '';
+    return str.trim().substring(0, maxLength);
+  }
+
+  static validatePagination(limit = 20, offset = 0) {
+    const maxLimit = 100;
+    const sanitizedLimit = Math.min(Math.max(1, limit), maxLimit);
+    const sanitizedOffset = Math.max(0, offset);
+
+    return { limit: sanitizedLimit, offset: sanitizedOffset };
+  }
+}
+
+// Response utilities
+export class ResponseUtils {
+  static createSuccessResponse(data, status = 200) {
+    return new Response(JSON.stringify({
+      success: true,
+      data,
+      timestamp: new Date().toISOString()
+    }), {
+      status,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  }
+
+  static createErrorResponse(error, status = 500, details = null) {
+    const errorResponse = {
+      success: false,
+      error: error.message || 'Internal Server Error',
+      timestamp: new Date().toISOString()
+    };
+
+    if (details) {
+      errorResponse.details = details;
+    }
+
+    return new Response(JSON.stringify(errorResponse), {
+      status,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  }
+
+  static createPaginatedResponse(data, pagination, status = 200) {
+    return new Response(JSON.stringify({
+      success: true,
+      data,
+      pagination: {
+        ...pagination,
+        hasMore: data.length === pagination.limit
+      },
+      timestamp: new Date().toISOString()
+    }), {
+      status,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  }
+}
+
+// Logging utilities
+export class LoggingUtils {
+  static logRequest(request, context = {}) {
+    console.log(JSON.stringify({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      type: 'request',
+      method: request.method,
+      url: request.url,
+      userAgent: request.headers.get('User-Agent'),
+      ...context
+    }));
+  }
+
+  static logError(error, context = {}) {
+    console.error(JSON.stringify({
+      timestamp: new Date().toISOString(),
+      level: 'error',
+      type: 'error',
+      message: error.message,
+      stack: error.stack,
+      ...context
+    }));
+  }
+
+  static logPerformance(operation, startTime, context = {}) {
+    const duration = Date.now() - startTime;
+    console.log(JSON.stringify({
+      timestamp: new Date().toISOString(),
+      level: 'info',
+      type: 'performance',
+      operation,
+      duration,
+      ...context
+    }));
+  }
+}
+
+// Feature flag utilities
+export class FeatureUtils {
+  static isFeatureEnabled(featureName, serviceConfig) {
+    return serviceConfig.features && serviceConfig.features[featureName] === true;
+  }
+
+  static getEnabledFeatures(serviceConfig) {
+    if (!serviceConfig.features) return [];
+    return Object.entries(serviceConfig.features)
+      .filter(([, enabled]) => enabled)
+      .map(([feature]) => feature);
+  }
+
+  static getDisabledFeatures(serviceConfig) {
+    if (!serviceConfig.features) return [];
+    return Object.entries(serviceConfig.features)
+      .filter(([, enabled]) => !enabled)
+      .map(([feature]) => feature);
+  }
+}
+`;
+    const filePath = join(servicePath, 'src', 'utils', 'service-utils.js');
+
+    // Ensure directory exists
+    const dir = join(servicePath, 'src', 'utils');
+    mkdirSync(dir, {
+      recursive: true
+    });
+    writeFileSync(filePath, utilsContent, 'utf8');
+    this.logger.info(`Generated: ${filePath}`);
+    return filePath;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate utils
+  }
+}