@tamyla/clodo-framework 4.0.13 → 4.0.14

package/scripts/post-publish-test.js

@@ -0,0 +1,663 @@
+#!/usr/bin/env node
+/**
+ * Post-Publish Release Testing
+ * 
+ * Comprehensive test that:
+ * 1. Creates a fresh test project in temp directory
+ * 2. Installs the published npm package
+ * 3. Tests all major exports and functionality
+ * 4. Validates CLI commands work
+ * 5. Tests worker integration
+ * 6. Verifies no import path errors
+ */
+
+import { mkdtemp, rm, writeFile, mkdir } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { execSync } from 'child_process';
+
+const PACKAGE_NAME = '@tamyla/clodo-framework';
+const TEST_TIMEOUT = 120000; // 2 minutes
+
+class PostPublishTester {
+  constructor() {
+    this.testDir = null;
+    this.results = {
+      passed: [],
+      failed: [],
+      skipped: []
+    };
+  }
+
+  log(message, type = 'info') {
+    const icons = { info: 'ℹ️', success: '✅', error: '❌', warning: '⚠️', test: '🧪' };
+    console.log(`${icons[type] || icons.info} ${message}`);
+  }
+
+  async setupTestEnvironment() {
+    this.log('Setting up test environment...', 'test');
+    
+    // Create temporary directory
+    this.testDir = await mkdtemp(join(tmpdir(), 'clodo-release-test-'));
+    this.log(`Test directory: ${this.testDir}`);
+
+    // Create package.json
+    const packageJson = {
+      name: 'clodo-release-test',
+      version: '1.0.0',
+      type: 'module',
+      private: true
+    };
+    
+    await writeFile(
+      join(this.testDir, 'package.json'),
+      JSON.stringify(packageJson, null, 2)
+    );
+
+    this.log('Test environment ready', 'success');
+  }
+
+  async installPublishedPackage() {
+    this.log(`Installing ${PACKAGE_NAME} from npm...`, 'test');
+    
+    try {
+      execSync(`npm install ${PACKAGE_NAME}`, {
+        cwd: this.testDir,
+        stdio: 'pipe',
+        timeout: TEST_TIMEOUT
+      });
+      
+      // Verify installation
+      const version = execSync(`npm list ${PACKAGE_NAME} --depth=0`, {
+        cwd: this.testDir,
+        encoding: 'utf8'
+      });
+      
+      this.log(`Installed: ${version.trim()}`, 'success');
+      this.results.passed.push('Package installation');
+      return true;
+    } catch (error) {
+      this.log(`Installation failed: ${error.message}`, 'error');
+      this.results.failed.push(`Package installation: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testMainExports() {
+    this.log('Testing main exports...', 'test');
+    
+    const testFile = join(this.testDir, 'test-exports.mjs');
+    const testCode = `
+import { 
+  Clodo,
+  createService, 
+  validate,
+  initialize,
+  GenericDataService,
+  SchemaManager,
+  ModuleManager,
+  EnhancedRouter,
+  createDomainConfigSchema,
+  validateDomainConfig,
+  SecurityCLI,
+  DeploymentValidator,
+  DeploymentAuditor,
+  StandardOptions,
+  OutputFormatter
+} from '${PACKAGE_NAME}';
+
+// Test that exports are defined
+const exports = {
+  Clodo,
+  createService,
+  validate,
+  initialize,
+  GenericDataService,
+  SchemaManager,
+  ModuleManager,
+  EnhancedRouter,
+  createDomainConfigSchema,
+  validateDomainConfig,
+  SecurityCLI,
+  DeploymentValidator,
+  DeploymentAuditor,
+  StandardOptions,
+  OutputFormatter
+};
+
+let passed = 0;
+let failed = 0;
+
+for (const [name, value] of Object.entries(exports)) {
+  if (value !== undefined && value !== null) {
+    console.log(\`✅ \${name}\`);
+    passed++;
+  } else {
+    console.log(\`❌ \${name} is undefined\`);
+    failed++;
+  }
+}
+
+console.log(\`\\nResults: \${passed} passed, \${failed} failed\`);
+process.exit(failed > 0 ? 1 : 0);
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      this.log('Main exports test results:', 'info');
+      console.log(output);
+      this.results.passed.push('Main exports');
+      return true;
+    } catch (error) {
+      this.log(`Main exports test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Main exports: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testWorkerIntegration() {
+    this.log('Testing worker integration...', 'test');
+    
+    const testFile = join(this.testDir, 'test-worker.mjs');
+    const testCode = `
+import { initializeService, createFeatureGuard, createRateLimitGuard } from '${PACKAGE_NAME}/worker';
+
+try {
+  // Test that worker functions are available
+  console.log('✅ initializeService:', typeof initializeService);
+  console.log('✅ createFeatureGuard:', typeof createFeatureGuard);
+  console.log('✅ createRateLimitGuard:', typeof createRateLimitGuard);
+  
+  // Test basic feature guard creation
+  const guard = createFeatureGuard('TEST_FEATURE');
+  console.log('✅ Created feature guard successfully');
+  
+  // Test rate limit guard creation
+  const rateLimit = createRateLimitGuard({ maxRequests: 100, windowMs: 60000 });
+  console.log('✅ Created rate limit guard successfully');
+  
+  console.log('\\n✅ Worker integration test passed');
+  process.exit(0);
+} catch (error) {
+  console.error('❌ Worker integration test failed:', error.message);
+  process.exit(1);
+}
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      console.log(output);
+      this.results.passed.push('Worker integration');
+      return true;
+    } catch (error) {
+      this.log(`Worker integration test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Worker integration: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testCLICommands() {
+    this.log('Testing CLI commands...', 'test');
+    
+    const commands = [
+      { name: 'version', cmd: 'clodo-service --version', expect: /\d+\.\d+\.\d+/ },
+      { name: 'help', cmd: 'clodo-service --help', expect: /(Usage|Commands)/ },
+      { name: 'create help', cmd: 'clodo-service create --help', expect: /Create.*service/ },
+      { name: 'validate help', cmd: 'clodo-service validate --help', expect: /Validate.*service/ },
+      { name: 'deploy help', cmd: 'clodo-service deploy --help', expect: /Deploy.*service/ },
+      { name: 'init-config help', cmd: 'clodo-service init-config --help', expect: /Initialize.*config/ },
+    ];
+
+    let passed = 0;
+    let failed = 0;
+
+    for (const { name, cmd, expect } of commands) {
+      try {
+        const output = execSync(`npx ${cmd}`, {
+          cwd: this.testDir,
+          encoding: 'utf8',
+          timeout: 10000
+        });
+        
+        if (expect.test(output)) {
+          this.log(`  ✓ ${name}`, 'success');
+          passed++;
+        } else {
+          this.log(`  ✗ ${name} - unexpected output`, 'error');
+          failed++;
+        }
+      } catch (error) {
+        this.log(`  ✗ ${name} - ${error.message}`, 'error');
+        failed++;
+      }
+    }
+
+    if (failed === 0) {
+      this.log(`All ${passed} CLI commands working`, 'success');
+      this.results.passed.push(`CLI commands (${passed}/${commands.length})`);
+      return true;
+    } else {
+      this.log(`${failed} CLI commands failed`, 'error');
+      this.results.failed.push(`CLI commands: ${failed}/${commands.length} failed`);
+      return false;
+    }
+  }
+
+  async testServiceCreation() {
+    this.log('Testing service creation API...', 'test');
+    
+    const testFile = join(this.testDir, 'test-service-api.mjs');
+    const testCode = `
+import { Clodo } from '${PACKAGE_NAME}';
+
+try {
+  // Test that Clodo API exists
+  console.log('✅ Clodo.createService:', typeof Clodo.createService);
+  console.log('✅ Clodo.validate:', typeof Clodo.validate);
+  console.log('✅ Clodo.deploy:', typeof Clodo.deploy);
+  console.log('✅ Clodo.initialize:', typeof Clodo.initialize);
+  console.log('✅ Clodo.getInfo:', typeof Clodo.getInfo);
+  
+  // Test getInfo
+  const info = Clodo.getInfo();
+  console.log('✅ Framework info:', info.name);
+  
+  if (info.name !== 'Clodo Framework') {
+    throw new Error('Framework info incorrect');
+  }
+  
+  console.log('\\n✅ Service creation API test passed');
+  process.exit(0);
+} catch (error) {
+  console.error('❌ Service API test failed:', error.message);
+  process.exit(1);
+}
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      console.log(output);
+      this.results.passed.push('Service creation API');
+      return true;
+    } catch (error) {
+      this.log(`Service API test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Service creation API: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testConfigurationManagement() {
+    this.log('Testing configuration management...', 'test');
+    
+    const testFile = join(this.testDir, 'test-config.mjs');
+    const testCode = `
+import { StandardOptions, OutputFormatter } from '${PACKAGE_NAME}';
+
+try {
+  console.log('✅ StandardOptions:', typeof StandardOptions);
+  console.log('✅ OutputFormatter:', typeof OutputFormatter);
+  
+  // Test StandardOptions has required methods
+  if (typeof StandardOptions.define !== 'function') {
+    throw new Error('StandardOptions.define is not a function');
+  }
+  console.log('✅ StandardOptions.define exists');
+  
+  // Test OutputFormatter can be instantiated
+  const formatter = new OutputFormatter({});
+  console.log('✅ OutputFormatter instance created');
+  
+  console.log('\\n✅ Configuration management test passed');
+  process.exit(0);
+} catch (error) {
+  console.error('❌ Configuration test failed:', error.message);
+  process.exit(1);
+}
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      console.log(output);
+      this.results.passed.push('Configuration management');
+      return true;
+    } catch (error) {
+      this.log(`Configuration test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Configuration management: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testSecurityFeatures() {
+    this.log('Testing security features...', 'test');
+    
+    const testFile = join(this.testDir, 'test-security.mjs');
+    const testCode = `
+import { SecurityCLI } from '${PACKAGE_NAME}';
+
+try {
+  console.log('✅ SecurityCLI:', typeof SecurityCLI);
+  
+  // Verify SecurityCLI has expected methods
+  const securityCli = new SecurityCLI();
+  console.log('✅ SecurityCLI instance created');
+  
+  console.log('\\n✅ Security features test passed');
+  process.exit(0);
+} catch (error) {
+  console.error('❌ Security test failed:', error.message);
+  process.exit(1);
+}
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      console.log(output);
+      this.results.passed.push('Security features');
+      return true;
+    } catch (error) {
+      this.log(`Security test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Security features: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testInheritableCapabilities() {
+    this.log('Testing inheritable classes and capabilities...', 'test');
+    
+    const testFile = join(this.testDir, 'test-inheritance.mjs');
+    const testCode = `
+import { 
+  SchemaManager,
+  ModuleManager,
+  EnhancedRouter
+} from '${PACKAGE_NAME}';
+
+try {
+  let passed = 0;
+  let failed = 0;
+
+  // Note: GenericDataService requires D1 database client and is designed
+  // for runtime use with Cloudflare Workers, not standalone inheritance testing
+
+  // Test SchemaManager extensibility
+  try {
+    class CustomSchemaManager extends SchemaManager {
+      constructor() {
+        super();
+      }
+      
+      customMethod() {
+        return 'custom';
+      }
+    }
+    const customSchema = new CustomSchemaManager();
+    if (customSchema.customMethod() === 'custom') {
+      console.log('✅ SchemaManager - extendable with custom methods');
+      passed++;
+    } else {
+      throw new Error('Custom method not working');
+    }
+  } catch (e) {
+    console.log('❌ SchemaManager - not extendable:', e.message);
+    failed++;
+  }
+
+  // Test ModuleManager extensibility
+  try {
+    class CustomModuleManager extends ModuleManager {
+      constructor() {
+        super();
+      }
+      
+      customRegister(name) {
+        return \`custom-\${name}\`;
+      }
+    }
+    const customModule = new CustomModuleManager();
+    if (customModule.customRegister('test') === 'custom-test') {
+      console.log('✅ ModuleManager - extendable with custom methods');
+      passed++;
+    } else {
+      throw new Error('Custom method not working');
+    }
+  } catch (e) {
+    console.log('❌ ModuleManager - not extendable:', e.message);
+    failed++;
+  }
+
+  // Test EnhancedRouter extensibility
+  try {
+    class CustomRouter extends EnhancedRouter {
+      constructor() {
+        super();
+      }
+      
+      customRoute(path) {
+        return \`/custom\${path}\`;
+      }
+    }
+    const customRouter = new CustomRouter();
+    if (customRouter.customRoute('/test') === '/custom/test') {
+      console.log('✅ EnhancedRouter - extendable with custom methods');
+      passed++;
+    } else {
+      throw new Error('Custom method not working');
+    }
+  } catch (e) {
+    console.log('❌ EnhancedRouter - not extendable:', e.message);
+    failed++;
+  }
+
+  console.log(\`\\nResults: \${passed} passed, \${failed} failed\`);
+  console.log('Note: GenericDataService requires D1 client and is tested in worker integration');
+  process.exit(failed > 0 ? 1 : 0);
+} catch (error) {
+  console.error('❌ Inheritance test failed:', error.message);
+  process.exit(1);
+}
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      console.log(output);
+      this.results.passed.push('Inheritable capabilities');
+      return true;
+    } catch (error) {
+      this.log(`Inheritance test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Inheritable capabilities: ${error.message}`);
+      return false;
+    }
+  }
+
+  async testDeploymentCapabilities() {
+    this.log('Testing deployment and orchestration...', 'test');
+    
+    const testFile = join(this.testDir, 'test-deployment.mjs');
+    const testCode = `
+import { 
+  DeploymentValidator,
+  DeploymentAuditor
+} from '${PACKAGE_NAME}';
+
+try {
+  console.log('✅ DeploymentValidator:', typeof DeploymentValidator);
+  console.log('✅ DeploymentAuditor:', typeof DeploymentAuditor);
+  
+  // Test that validators can be instantiated
+  const validator = new DeploymentValidator();
+  console.log('✅ DeploymentValidator instance created');
+  
+  const auditor = new DeploymentAuditor();
+  console.log('✅ DeploymentAuditor instance created');
+  
+  console.log('\\n✅ Deployment capabilities test passed');
+  process.exit(0);
+} catch (error) {
+  console.error('❌ Deployment test failed:', error.message);
+  process.exit(1);
+}
+`;
+
+    await writeFile(testFile, testCode);
+
+    try {
+      const output = execSync(`node ${testFile}`, {
+        cwd: this.testDir,
+        encoding: 'utf8',
+        timeout: 30000
+      });
+      
+      console.log(output);
+      this.results.passed.push('Deployment capabilities');
+      return true;
+    } catch (error) {
+      this.log(`Deployment test failed: ${error.message}`, 'error');
+      if (error.stdout) console.log(error.stdout.toString());
+      this.results.failed.push(`Deployment capabilities: ${error.message}`);
+      return false;
+    }
+  }
+
+  async cleanup() {
+    if (this.testDir) {
+      this.log('Cleaning up test environment...', 'info');
+      try {
+        await rm(this.testDir, { recursive: true, force: true });
+        this.log('Cleanup complete', 'success');
+      } catch (error) {
+        this.log(`Cleanup warning: ${error.message}`, 'warning');
+      }
+    }
+  }
+
+  printSummary() {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 POST-PUBLISH TEST SUMMARY');
+    console.log('='.repeat(60));
+    
+    if (this.results.passed.length > 0) {
+      console.log(`\n✅ PASSED (${this.results.passed.length}):`);
+      this.results.passed.forEach(test => console.log(`   ✓ ${test}`));
+    }
+    
+    if (this.results.failed.length > 0) {
+      console.log(`\n❌ FAILED (${this.results.failed.length}):`);
+      this.results.failed.forEach(test => console.log(`   ✗ ${test}`));
+    }
+    
+    if (this.results.skipped.length > 0) {
+      console.log(`\n⏭️  SKIPPED (${this.results.skipped.length}):`);
+      this.results.skipped.forEach(test => console.log(`   - ${test}`));
+    }
+    
+    const total = this.results.passed.length + this.results.failed.length;
+    const successRate = total > 0 ? ((this.results.passed.length / total) * 100).toFixed(1) : 0;
+    
+    console.log('\n' + '='.repeat(60));
+    console.log(`Total: ${total} tests | Success Rate: ${successRate}%`);
+    console.log('='.repeat(60));
+    
+    if (this.results.failed.length === 0) {
+      console.log('\n🎉 All post-publish tests passed!');
+      console.log('✅ Package is ready for production use');
+      return true;
+    } else {
+      console.log('\n⚠️  Some tests failed. Review the failures above.');
+      return false;
+    }
+  }
+
+  async run() {
+    console.log('╔═══════════════════════════════════════════════════════════╗');
+    console.log('║  POST-PUBLISH RELEASE TESTING                              ║');
+    console.log('║  Testing published package from npm registry               ║');
+    console.log('╚═══════════════════════════════════════════════════════════╝\n');
+
+    try {
+      await this.setupTestEnvironment();
+      
+      const installed = await this.installPublishedPackage();
+      if (!installed) {
+        this.log('Cannot proceed without successful installation', 'error');
+        return false;
+      }
+
+      // Run all tests
+      await this.testMainExports();
+      await this.testWorkerIntegration();
+      await this.testCLICommands();
+      await this.testServiceCreation();
+      await this.testConfigurationManagement();
+      await this.testSecurityFeatures();
+      await this.testInheritableCapabilities();
+      await this.testDeploymentCapabilities();
+
+      const success = this.printSummary();
+      return success;
+
+    } catch (error) {
+      this.log(`Unexpected error: ${error.message}`, 'error');
+      console.error(error);
+      return false;
+    } finally {
+      await this.cleanup();
+    }
+  }
+}
+
+// Run the tests
+const tester = new PostPublishTester();
+tester.run().then(success => {
+  process.exit(success ? 0 : 1);
+}).catch(error => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/scripts/scan-worker-issues.js

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const incompatiblePatterns = [
+  /import.*from.*['"]fs['"]/,
+  /import.*from.*['"]path['"]/,
+  /import.*from.*['"]child_process['"]/,
+  /import.*from.*['"]os['"]/,
+  /import.*from.*['"]https['"]/,
+  /import.*from.*['"]http['"]/,
+  /process\.cwd/,
+  /__dirname/,
+  /__filename/,
+  /readFileSync|writeFileSync|existsSync|mkdirSync|readdirSync|statSync/
+];
+
+function scanDirectory(dir, results = []) {
+  try {
+    const items = fs.readdirSync(dir);
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      const stat = fs.statSync(fullPath);
+      if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
+        scanDirectory(fullPath, results);
+      } else if (item.endsWith('.js')) {
+        const content = fs.readFileSync(fullPath, 'utf8');
+        const issues = [];
+        for (const pattern of incompatiblePatterns) {
+          const matches = content.match(pattern);
+          if (matches) {
+            issues.push(matches[0]);
+          }
+        }
+        if (issues.length > 0) {
+          results.push({ file: fullPath, issues });
+        }
+      }
+    }
+  } catch (e) {}
+  return results;
+}
+
+const results = scanDirectory('src');
+console.log('Files with Worker-incompatible code:');
+results.forEach(r => {
+  console.log(`\n${r.file}:`);
+  r.issues.forEach(issue => console.log(`  - ${issue}`));
+});