@tamyla/clodo-framework 3.1.22 → 3.1.23

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

@@ -0,0 +1,85 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync } from 'fs';
+
+/**
+ * ESLint Configuration Generator
+ * Generates ESLint linting configuration for code quality
+ */
+export class EslintConfigGenerator extends BaseGenerator {
+  /**
+   * Generate ESLint configuration
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated config file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+    const eslintConfig = this._generateEslintConfig(coreInputs, confirmedValues);
+    const filePath = join(servicePath, '.eslintrc.js');
+    writeFileSync(filePath, eslintConfig, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate ESLint configuration content
+   * @private
+   */
+  _generateEslintConfig(coreInputs, confirmedValues) {
+    return `export default [
+  {
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'module',
+      globals: {
+        console: 'readonly',
+        process: 'readonly',
+        Buffer: 'readonly',
+        crypto: 'readonly',
+        fetch: 'readonly',
+        Request: 'readonly',
+        Response: 'readonly',
+        URL: 'readonly',
+        Headers: 'readonly',
+        describe: 'readonly',
+        test: 'readonly',
+        expect: 'readonly',
+        beforeAll: 'readonly',
+        afterAll: 'readonly',
+        beforeEach: 'readonly',
+        afterEach: 'readonly'
+      }
+    },
+    rules: {
+      'no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+      'no-console': 'off', // Cloudflare Workers use console
+      'prefer-const': 'error',
+      'no-var': 'error',
+      'object-shorthand': 'error',
+      'prefer-arrow-callback': 'error',
+      'no-multiple-empty-lines': ['error', { max: 2, maxEOF: 0 }],
+      'semi': ['error', 'always'],
+      'quotes': ['error', 'single', { avoidEscape: true }],
+      'comma-dangle': ['error', 'never'],
+      'indent': ['error', 2, { SwitchCase: 1 }],
+      'linebreak-style': ['error', 'unix'],
+      'eol-last': ['error', 'always']
+    }
+  }
+];
+`;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate ESLint config
+  }
+}

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

@@ -0,0 +1,237 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync, mkdirSync } from 'fs';
+
+/**
+ * Integration Tests Generator
+ * Generates integration tests for end-to-end service testing
+ */
+export class IntegrationTestsGenerator extends BaseGenerator {
+  /**
+   * Generate integration tests
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated test file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+
+    // Ensure test/integration directory exists
+    const testDir = join(servicePath, 'test', 'integration');
+    mkdirSync(testDir, {
+      recursive: true
+    });
+    const integrationTestContent = this._generateIntegrationTestContent(coreInputs, confirmedValues);
+    const filePath = join(testDir, 'service.integration.test.js');
+    writeFileSync(filePath, integrationTestContent, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate integration test content
+   * @private
+   */
+  _generateIntegrationTestContent(coreInputs, confirmedValues) {
+    return `import { describe, test, expect, beforeAll, afterAll } from '@jest/globals';
+
+describe('${confirmedValues.displayName} - Integration Tests', () => {
+  let baseUrl;
+
+  beforeAll(() => {
+    baseUrl = process.env.TEST_URL || '${confirmedValues.developmentUrl}';
+  });
+
+  afterAll(() => {
+    // Cleanup after tests
+  });
+
+  describe('Health Check Endpoint', () => {
+    test('responds with 200 status', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+      expect(response.status).toBe(200);
+    });
+
+    test('returns valid health check response', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+      const json = await response.json();
+
+      expect(json.status).toBe('healthy');
+      expect(json.service).toBe('${coreInputs.serviceName}');
+      expect(json.version).toBe('${confirmedValues.version}');
+      expect(json.timestamp).toBeDefined();
+    });
+
+    test('includes health checks', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+      const json = await response.json();
+
+      expect(Array.isArray(json.checks)).toBe(true);
+      expect(json.checks.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('API Endpoints', () => {
+    test('base API path is accessible', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}\`);
+      expect(response.status).toBeLessThan(500); // Should not be a server error
+    });
+
+    ${this._generateServiceTypeTests(coreInputs.serviceType, confirmedValues)}
+  });
+
+  ${confirmedValues.features.caching ? `
+  describe('Caching', () => {
+    test('cache headers are present', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+      
+      // Check for cache-related headers
+      const cacheControl = response.headers.get('cache-control');
+      expect(cacheControl).toBeDefined();
+    });
+
+    test('repeated requests use cache', async () => {
+      const response1 = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+      const response2 = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+
+      expect(response1.status).toBe(200);
+      expect(response2.status).toBe(200);
+    });
+  });` : ''}
+
+  ${confirmedValues.features.database ? `
+  describe('Database Integration', () => {
+    test('database connectivity', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+      const json = await response.json();
+
+      const dbCheck = json.checks.find(check => check.name === 'database');
+      expect(dbCheck).toBeDefined();
+      expect(dbCheck.status).toBe('healthy');
+    });
+
+    test('CRUD operations', async () => {
+      // Test Create, Read, Update, Delete operations
+      expect(true).toBe(true); // Placeholder
+    });
+  });` : `
+  describe('Database Integration', () => {
+    test.skip('database tests skipped - not enabled for this service type', () => {
+      expect(true).toBe(true);
+    });
+  });`}
+
+  describe('Middleware Integration', () => {
+    test('request headers added', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.healthCheckPath}\`);
+
+      expect(response.headers.get('x-service')).toBe('${coreInputs.serviceName}');
+      expect(response.headers.get('x-version')).toBe('${confirmedValues.version}');
+    });
+
+    ${confirmedValues.features.authentication ? `
+    test('authentication middleware', async () => {
+      // Test authentication requirements
+      expect(true).toBe(true); // Placeholder
+    });` : ''}
+
+    ${confirmedValues.features.authorization ? `
+    test('authorization middleware', async () => {
+      // Test authorization checks
+      expect(true).toBe(true); // Placeholder
+    });` : ''}
+  });
+
+  describe('Error Handling', () => {
+    test('graceful error responses', async () => {
+      // Test error scenarios
+      expect(true).toBe(true); // Placeholder
+    });
+
+    test('error logging', async () => {
+      // Test error logging functionality
+      expect(true).toBe(true); // Placeholder
+    });
+  });
+});
+`;
+  }
+
+  /**
+   * Generate service-type specific integration tests
+   * @private
+   */
+  _generateServiceTypeTests(serviceType, confirmedValues) {
+    switch (serviceType) {
+      case 'data-service':
+        return `test('data retrieval endpoint', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/data\`);
+      expect(response.status).toBeLessThan(500);
+    });
+
+    test('data storage endpoint', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/data\`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ test: 'data' })
+      });
+      expect(response.status).toBeLessThan(500);
+    });`;
+      case 'auth-service':
+        return `test('login endpoint', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/login\`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ username: 'test', password: 'test' })
+      });
+      expect(response.status).toBeLessThan(500);
+    });
+
+    test('token validation endpoint', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/validate\`);
+      expect(response.status).toBeLessThan(500);
+    });`;
+      case 'content-service':
+        return `test('content retrieval endpoint', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/content\`);
+      expect(response.status).toBeLessThan(500);
+    });
+
+    test('content creation endpoint', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/content\`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ title: 'Test', body: 'Content' })
+      });
+      expect(response.status).toBeLessThan(500);
+    });`;
+      case 'api-gateway':
+        return `test('gateway routing', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/route\`);
+      expect(response.status).toBeLessThan(500);
+    });
+
+    test('service proxying', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}/proxy\`);
+      expect(response.status).toBeLessThan(500);
+    });`;
+      default:
+        return `test('service endpoints are accessible', async () => {
+      const response = await fetch(\`\${baseUrl}${confirmedValues.apiBasePath}\`);
+      expect(response.status).toBeLessThan(500);
+    });`;
+    }
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate integration tests
+  }
+}

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

@@ -0,0 +1,72 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync } from 'fs';
+
+/**
+ * Jest Configuration Generator
+ * Generates Jest test runner configuration
+ */
+export class JestConfigGenerator extends BaseGenerator {
+  /**
+   * Generate Jest configuration
+   * @param {Object} context - Generation context
+   * @returns {Promise<string>} Path to generated config file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+    const jestConfig = this._generateJestConfig(coreInputs, confirmedValues);
+    const filePath = join(servicePath, 'jest.config.js');
+    writeFileSync(filePath, jestConfig, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate Jest configuration content
+   * @private
+   */
+  _generateJestConfig(coreInputs, confirmedValues) {
+    return `/** @type {import('jest').Config} */
+export default {
+  testEnvironment: 'node',
+  testMatch: [
+    '<rootDir>/test/**/*.test.js'
+  ],
+  collectCoverageFrom: [
+    'src/**/*.js',
+    '!src/worker/index.js' // Worker code runs in different environment
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+  coverageThreshold: {
+    global: {
+      branches: 70,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  },
+  setupFilesAfterEnv: ['<rootDir>/test/setup.js'],
+  testTimeout: 10000,
+  verbose: true,
+  transform: {},
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1'
+  }
+};
+`;
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate Jest config
+  }
+}

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

@@ -0,0 +1,277 @@
+import { BaseGenerator } from '../BaseGenerator.js';
+import { join } from 'path';
+import { writeFileSync, mkdirSync } from 'fs';
+
+/**
+ * Unit Tests Generator
+ * Generates comprehensive unit test suites for service components
+ */
+export class UnitTestsGenerator extends BaseGenerator {
+  /**
+   * Generate unit tests
+   * @param {Object} context - Generation context
+   * @param {Object} context.coreInputs - Core service inputs
+   * @param {Object} context.confirmedValues - Confirmed configuration values
+   * @param {string} context.servicePath - Service directory path
+   * @returns {Promise<string>} Path to generated test file
+   */
+  async generate(context) {
+    const {
+      coreInputs,
+      confirmedValues,
+      servicePath
+    } = this.extractContext(context);
+    if (!this.shouldGenerate(context)) {
+      return null;
+    }
+
+    // Ensure test/unit directory exists
+    const testDir = join(servicePath, 'test', 'unit');
+    mkdirSync(testDir, {
+      recursive: true
+    });
+    const unitTestContent = this._generateUnitTestContent(coreInputs, confirmedValues);
+    const filePath = join(testDir, 'service.test.js');
+    writeFileSync(filePath, unitTestContent, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Generate unit test content
+   * @private
+   */
+  _generateUnitTestContent(coreInputs, confirmedValues) {
+    return `import { describe, test, expect } from '@jest/globals';
+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', () => {
+    test('exports required handler functions', () => {
+      expect(typeof serviceHandlers.handleRequest).toBe('function');
+      expect(typeof serviceHandlers.handleError).toBe('function');
+    });
+
+    test('handleError returns proper error response', async () => {
+      const error = new Error('Test error');
+      const request = new Request('https://example.com/test');
+      
+      const response = await serviceHandlers.handleError(error, request);
+      expect(response.status).toBeGreaterThanOrEqual(400);
+      
+      const json = await response.json();
+      expect(json.success).toBe(false);
+      expect(json.error).toBeDefined();
+    });
+
+    ${confirmedValues.features.caching ? `
+    test('cache handlers work correctly', () => {
+      expect(typeof serviceHandlers.handleCacheHit).toBe('function');
+      expect(typeof serviceHandlers.handleCacheMiss).toBe('function');
+    });` : ''}
+
+    ${confirmedValues.features.database ? `
+    test('database handlers are defined', () => {
+      expect(typeof serviceHandlers.handleDatabaseQuery).toBe('function');
+      expect(typeof serviceHandlers.handleDatabaseError).toBe('function');
+    });` : ''}
+  });
+
+  describe('Middleware', () => {
+    test('exports middleware functions', () => {
+      expect(typeof serviceMiddleware.addHeaders).toBe('function');
+      expect(typeof serviceMiddleware.handleCors).toBe('function');
+    });
+
+    test('addHeaders adds service headers', () => {
+      const headers = new Headers();
+      serviceMiddleware.addHeaders(headers);
+      
+      expect(headers.get('x-service')).toBe('${coreInputs.serviceName}');
+      expect(headers.get('x-version')).toBe('${confirmedValues.version}');
+    });
+
+    test('handleCors adds CORS headers', () => {
+      const headers = new Headers();
+      serviceMiddleware.handleCors(headers);
+      
+      expect(headers.has('Access-Control-Allow-Origin')).toBe(true);
+    });
+
+    ${confirmedValues.features.authentication ? `
+    test('authentication middleware validates tokens', () => {
+      expect(typeof serviceMiddleware.authenticateRequest).toBe('function');
+    });` : ''}
+
+    ${confirmedValues.features.authorization ? `
+    test('authorization middleware checks permissions', () => {
+      expect(typeof serviceMiddleware.authorizeRequest).toBe('function');
+    });` : ''}
+
+    ${confirmedValues.features.rateLimiting ? `
+    test('rate limiting middleware tracks requests', () => {
+      expect(typeof serviceMiddleware.checkRateLimit).toBe('function');
+    });` : ''}
+  });
+
+  describe('Utilities', () => {
+    test('exports utility functions', () => {
+      expect(typeof serviceUtils.formatResponse).toBe('function');
+      expect(typeof serviceUtils.validateInput).toBe('function');
+    });
+
+    test('formatResponse creates proper response format', () => {
+      const data = { test: 'value' };
+      const formatted = serviceUtils.formatResponse(data);
+      
+      expect(formatted.success).toBe(true);
+      expect(formatted.data).toEqual(data);
+      expect(formatted.timestamp).toBeDefined();
+    });
+
+    test('validateInput uses service schema', () => {
+      const result = serviceUtils.validateInput({}, serviceSchema);
+      expect(result).toBeDefined();
+    });
+
+    ${confirmedValues.features.database ? `
+    test('database utilities handle connections', () => {
+      expect(typeof serviceUtils.getDatabaseConnection).toBe('function');
+    });` : ''}
+
+    ${confirmedValues.features.caching ? `
+    test('cache utilities manage cache operations', () => {
+      expect(typeof serviceUtils.getCacheKey).toBe('function');
+      expect(typeof serviceUtils.setCacheValue).toBe('function');
+    });` : ''}
+  });
+
+  describe('Schema Validation', () => {
+    test('service schema is properly defined', () => {
+      expect(serviceSchema).toBeDefined();
+      expect(typeof serviceSchema.parse).toBe('function');
+    });
+
+    ${this._generateSchemaTests(coreInputs.serviceType, confirmedValues)}
+  });
+
+  describe('Configuration', () => {
+    test('service configuration is valid', () => {
+      expect('${coreInputs.serviceName}').toMatch(/^[a-z][a-z0-9-]*$/);
+      expect('${confirmedValues.version}').toMatch(/^\\d+\\.\\d+\\.\\d+$/);
+    });
+
+    test('environment variables are accessible', () => {
+      // Test environment variable access patterns
+      expect(typeof process.env).toBe('object');
+    });
+
+    test('domains configuration is valid', () => {
+      const domainsConfig = {
+        primary: '${coreInputs.domainName}',
+        environments: {
+          production: '${confirmedValues.productionUrl}',
+          staging: '${confirmedValues.stagingUrl}',
+          development: '${confirmedValues.developmentUrl}'
+        }
+      };
+      
+      expect(domainsConfig.primary).toBeDefined();
+      expect(domainsConfig.environments.production).toContain('${coreInputs.domainName}');
+    });
+  });
+
+  describe('Error Handling', () => {
+    test('errors are properly formatted', () => {
+      const error = new Error('Test error');
+      const formatted = serviceUtils.formatError(error);
+      
+      expect(formatted.success).toBe(false);
+      expect(formatted.error).toBeDefined();
+      expect(formatted.timestamp).toBeDefined();
+    });
+
+    test('handles validation errors', () => {
+      try {
+        serviceSchema.parse({ invalid: 'data' });
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+});
+`;
+  }
+
+  /**
+   * Generate service-type specific schema tests
+   * @private
+   */
+  _generateSchemaTests(serviceType, confirmedValues) {
+    switch (serviceType) {
+      case 'data-service':
+        return `test('data schema validates records', () => {
+      const validData = {
+        id: '123',
+        data: { test: 'value' },
+        timestamp: new Date().toISOString()
+      };
+      expect(() => serviceSchema.parse(validData)).not.toThrow();
+    });
+
+    test('data schema rejects invalid data', () => {
+      const invalidData = { invalid: 'structure' };
+      expect(() => serviceSchema.parse(invalidData)).toThrow();
+    });`;
+      case 'auth-service':
+        return `test('auth schema validates credentials', () => {
+      const validAuth = {
+        username: 'testuser',
+        password: 'testpass123'
+      };
+      expect(() => serviceSchema.parse(validAuth)).not.toThrow();
+    });
+
+    test('auth schema validates tokens', () => {
+      const validToken = {
+        token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+        expiresAt: new Date().toISOString()
+      };
+      expect(() => serviceSchema.parse(validToken)).not.toThrow();
+    });`;
+      case 'content-service':
+        return `test('content schema validates content structure', () => {
+      const validContent = {
+        id: '123',
+        title: 'Test Content',
+        body: 'Content body',
+        author: 'test-author'
+      };
+      expect(() => serviceSchema.parse(validContent)).not.toThrow();
+    });`;
+      case 'api-gateway':
+        return `test('api schema validates requests', () => {
+      const validRequest = {
+        method: 'GET',
+        path: '/test',
+        headers: {}
+      };
+      expect(() => serviceSchema.parse(validRequest)).not.toThrow();
+    });`;
+      default:
+        return `test('service schema validates input', () => {
+      // Add service-specific schema tests
+      expect(serviceSchema).toBeDefined();
+    });`;
+    }
+  }
+
+  /**
+   * Determine if generator should run
+   */
+  shouldGenerate(context) {
+    return true; // Always generate unit tests
+  }
+}