@tamyla/clodo-framework 3.1.21 → 3.1.22

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

@@ -1,85 +0,0 @@
-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

@@ -1,237 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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

@@ -1,277 +0,0 @@
-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 '../../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';
-
-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
-  }
-}