@tamyla/clodo-framework 4.0.12 → 4.0.14

package/scripts/test-package.js

@@ -0,0 +1,339 @@
+#!/usr/bin/env node
+/**
+ * Comprehensive Package Testing Script
+ * Tests the built package as a downstream developer would use it
+ * 
+ * This script:
+ * 1. Creates a temporary test project
+ * 2. Packs the current package (creates a .tgz file)
+ * 3. Installs it in the test project like a real user would
+ * 4. Tests all exported modules and APIs
+ * 5. Checks for import errors, circular dependencies, and runtime issues
+ */
+
+import { execSync } from 'child_process';
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, '..');
+const testDir = join(projectRoot, 'tmp', 'package-test');
+
+console.log('\n🧪 Starting Comprehensive Package Test\n');
+console.log('━'.repeat(60));
+
+// Clean up previous test
+if (existsSync(testDir)) {
+  console.log('🧹 Cleaning up previous test directory...');
+  rmSync(testDir, { recursive: true, force: true });
+}
+
+// Step 1: Build the package
+console.log('\n📦 Step 1: Building package...');
+try {
+  execSync('npm run build', { cwd: projectRoot, stdio: 'inherit' });
+  console.log('✅ Build successful');
+} catch (error) {
+  console.error('❌ Build failed');
+  process.exit(1);
+}
+
+// Step 2: Pack the package (creates .tgz)
+console.log('\n📦 Step 2: Packing package...');
+let tarballPath;
+try {
+  const output = execSync('npm pack', { cwd: projectRoot, encoding: 'utf8' });
+  tarballPath = output.trim().split('\n').pop();
+  console.log(`✅ Package created: ${tarballPath}`);
+} catch (error) {
+  console.error('❌ Pack failed');
+  process.exit(1);
+}
+
+// Step 3: Create test project
+console.log('\n📁 Step 3: Creating test project...');
+mkdirSync(testDir, { recursive: true });
+
+// Create package.json for test project
+const testPackageJson = {
+  name: 'test-downstream-project',
+  version: '1.0.0',
+  type: 'module',
+  private: true
+};
+writeFileSync(
+  join(testDir, 'package.json'),
+  JSON.stringify(testPackageJson, null, 2)
+);
+console.log('✅ Test project created');
+
+// Step 4: Install the packed package
+console.log('\n📥 Step 4: Installing package in test project...');
+try {
+  const tarballFullPath = join(projectRoot, tarballPath);
+  execSync(`npm install "${tarballFullPath}"`, {
+    cwd: testDir,
+    stdio: 'inherit'
+  });
+  console.log('✅ Package installed');
+} catch (error) {
+  console.error('❌ Installation failed');
+  process.exit(1);
+}
+
+// Step 5: Test all exports
+console.log('\n🧪 Step 5: Testing package exports...');
+
+const tests = [
+  {
+    name: 'Main Entry Point',
+    code: `import * as framework from '@tamyla/clodo-framework';
+console.log('✓ Main export loaded');
+if (!framework.initializeService) throw new Error('Missing initializeService');
+console.log('✓ initializeService exists');`
+  },
+  {
+    name: 'Worker Integration',
+    code: `import { initializeService, configManager } from '@tamyla/clodo-framework/worker';
+console.log('✓ Worker exports loaded');
+if (typeof initializeService !== 'function') throw new Error('initializeService is not a function');
+console.log('✓ initializeService is a function');`
+  },
+  {
+    name: 'Config Module',
+    code: `import * as config from '@tamyla/clodo-framework/config';
+console.log('✓ Config exports loaded');
+if (!config.getDomainFromEnv) throw new Error('Missing getDomainFromEnv');
+console.log('✓ getDomainFromEnv exists');`
+  },
+  {
+    name: 'Services Module',
+    code: `import { GenericDataService, createDataService } from '@tamyla/clodo-framework/services';
+console.log('✓ Services exports loaded');
+if (typeof createDataService !== 'function') throw new Error('createDataService is not a function');
+console.log('✓ createDataService is a function');`
+  },
+  {
+    name: 'Schema Module',
+    code: `import { SchemaManager, schemaManager } from '@tamyla/clodo-framework/schema';
+console.log('✓ Schema exports loaded');
+if (!SchemaManager) throw new Error('Missing SchemaManager');
+console.log('✓ SchemaManager exists');`
+  },
+  {
+    name: 'Routing Module',
+    code: `import { EnhancedRouter, createEnhancedRouter } from '@tamyla/clodo-framework/routing';
+console.log('✓ Routing exports loaded');
+if (typeof createEnhancedRouter !== 'function') throw new Error('createEnhancedRouter is not a function');
+console.log('✓ createEnhancedRouter is a function');`
+  },
+  {
+    name: 'Security Module',
+    code: `import { SecurityCLI, SecretGenerator } from '@tamyla/clodo-framework/security';
+console.log('✓ Security exports loaded');
+if (!SecurityCLI) throw new Error('Missing SecurityCLI');
+console.log('✓ SecurityCLI exists');`
+  },
+  {
+    name: 'Service Management',
+    code: `import { ServiceCreator, ServiceOrchestrator } from '@tamyla/clodo-framework/service-management';
+console.log('✓ Service management exports loaded');
+if (!ServiceCreator) throw new Error('Missing ServiceCreator');
+console.log('✓ ServiceCreator exists');`
+  },
+  {
+    name: 'Database Module',
+    code: `import * as db from '@tamyla/clodo-framework/database';
+console.log('✓ Database exports loaded');
+if (!db.DatabaseOrchestrator) throw new Error('Missing DatabaseOrchestrator');
+console.log('✓ DatabaseOrchestrator exists');`
+  },
+  {
+    name: 'Deployment Module',
+    code: `import { DeploymentValidator, DeploymentAuditor } from '@tamyla/clodo-framework/deployment';
+console.log('✓ Deployment exports loaded');
+if (!DeploymentValidator) throw new Error('Missing DeploymentValidator');
+console.log('✓ DeploymentValidator exists');`
+  },
+  {
+    name: 'Cloudflare Utils',
+    code: `import * as cf from '@tamyla/clodo-framework/utils/cloudflare';
+console.log('✓ Cloudflare utils exports loaded');
+if (!cf.CloudflareAPI) throw new Error('Missing CloudflareAPI');
+console.log('✓ CloudflareAPI exists');`
+  },
+  {
+    name: 'Dynamic Import Test (frameworkConfig)',
+    code: `import { initializeService } from '@tamyla/clodo-framework/worker';
+// Test that dynamic imports work at runtime
+const env = { DOMAIN: 'test' };
+const domains = { test: { name: 'test', accountId: '123' } };
+try {
+  const result = initializeService(env, domains);
+  console.log('✓ initializeService executed without import errors');
+} catch (error) {
+  if (error.message.includes('Cannot find module')) {
+    throw new Error('Dynamic import path broken: ' + error.message);
+  }
+  // Other errors are OK (we're not testing full functionality, just imports)
+  console.log('✓ No import path errors (functional errors are OK for this test)');
+}`
+  },
+  {
+    name: 'Circular Dependency Check',
+    code: `import * as framework from '@tamyla/clodo-framework';
+import * as worker from '@tamyla/clodo-framework/worker';
+import * as config from '@tamyla/clodo-framework/config';
+console.log('✓ No circular dependency errors on import');
+// Check that we can access nested properties without infinite loops
+if (config.getDomainFromEnv) {
+  console.log('✓ Config module accessible');
+}
+if (worker.initializeService) {
+  console.log('✓ Worker module accessible');
+}
+console.log('✓ No circular reference runtime errors');`
+  }
+];
+
+let passed = 0;
+let failed = 0;
+const failures = [];
+
+for (const test of tests) {
+  const testFile = join(testDir, `test-${passed + failed}.mjs`);
+  writeFileSync(testFile, test.code);
+  
+  try {
+    console.log(`\n  Testing: ${test.name}`);
+    execSync(`node "${testFile}"`, { cwd: testDir, encoding: 'utf8', stdio: 'pipe' });
+    console.log(`  ✅ ${test.name} passed`);
+    passed++;
+  } catch (error) {
+    console.error(`  ❌ ${test.name} failed`);
+    console.error(`     ${error.message}`);
+    failed++;
+    failures.push({ name: test.name, error: error.message });
+  }
+}
+
+// Step 6: Check for common issues in dist/
+console.log('\n🔍 Step 6: Checking for common packaging issues...');
+
+const distPath = join(projectRoot, 'dist');
+const issuesFound = [];
+
+// Check for references to src/ or ../lib/ that escaped outside dist/
+function checkFileForBadImports(filePath, relativePath) {
+  const content = readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+  
+  //Skip re-export wrappers in dist/utils/ that are intended to re-export from dist/lib/
+  // Normalize path separators to forward slashes for consistent matching
+  const normalizedPath = relativePath.replace(/\\/g, '/');
+  const isReExportWrapper = normalizedPath.match(/^utils\/(file-manager|formatters|logger|index|cloudflare\/ops)\.js$/);
+  const isServiceManagementGenerator = normalizedPath.match(/^service-management\/generators\/testing\//);
+  
+  lines.forEach((line, index) => {
+    // Check for imports that go outside dist/
+    // Skip if this is within lib/ going to another lib location or to config/ (which is also in dist/)
+    const isLibToLib = normalizedPath.startsWith('lib/') && line.match(/from\s+['"]\.\.\/\.\.\//);
+    const isLibToConfig = normalizedPath.startsWith('lib/shared/config/') && line.includes('../../../config/');
+    
+    if (line.match(/from\s+['"]\.\.\/\.\.\/\.\.\//)) {
+      if (!isLibToLib && !isLibToConfig) {
+        issuesFound.push({
+          file: relativePath,
+          line: index + 1,
+          issue: 'Import path goes too far up (../../../)',
+          code: line.trim()
+        });
+      }
+    }
+    
+    // Check for absolute imports to src/ or lib/
+    if (line.match(/from\s+['"].*\/src\//) && !isServiceManagementGenerator) {
+      issuesFound.push({
+        file: relativePath,
+        line: index + 1,
+        issue: 'Absolute import to src/ (should be relative within dist/)',
+        code: line.trim()
+      });
+    }
+    
+    // Check for imports that try to access lib/ from project root
+    if (line.match(/from\s+['"]\.\.\/lib\//) && !relativePath.includes('lib\\') && !relativePath.includes('lib/') && !isReExportWrapper) {
+      issuesFound.push({
+        file: relativePath,
+        line: index + 1,
+        issue: 'Import tries to access lib/ outside dist/',
+        code: line.trim()
+      });
+    }
+  });
+}
+
+function walkDir(dir, baseDir = dir) {
+  const files = readdirSync(dir, { withFileTypes: true });
+  files.forEach(file => {
+    const fullPath = join(dir, file.name);
+    if (file.isDirectory()) {
+      walkDir(fullPath, baseDir);
+    } else if (file.name.endsWith('.js')) {
+      const relativePath = fullPath.substring(baseDir.length + 1);
+      checkFileForBadImports(fullPath, relativePath);
+    }
+  });
+}
+
+walkDir(distPath);
+
+if (issuesFound.length > 0) {
+  console.log('\n⚠️  Found potential packaging issues:');
+  issuesFound.forEach(issue => {
+    console.log(`\n  File: ${issue.file}:${issue.line}`);
+    console.log(`  Issue: ${issue.issue}`);
+    console.log(`  Code: ${issue.code}`);
+  });
+} else {
+  console.log('✅ No obvious packaging issues found');
+}
+
+// Final Report
+console.log('\n' + '━'.repeat(60));
+console.log('\n📊 TEST SUMMARY');
+console.log('━'.repeat(60));
+console.log(`\n  ✅ Passed: ${passed}`);
+console.log(`  ❌ Failed: ${failed}`);
+
+if (issuesFound.length > 0) {
+  console.log(`  ⚠️  Packaging issues: ${issuesFound.length}`);
+}
+
+if (failed > 0) {
+  console.log('\n❌ FAILURES:');
+  failures.forEach(f => {
+    console.log(`\n  ${f.name}:`);
+    console.log(`    ${f.error}`);
+  });
+}
+
+console.log('\n' + '━'.repeat(60));
+
+// Cleanup
+console.log('\n🧹 Cleaning up...');
+const tarballFullPath = join(projectRoot, tarballPath);
+if (existsSync(tarballFullPath)) {
+  rmSync(tarballFullPath);
+}
+
+if (failed > 0 || issuesFound.length > 0) {
+  console.log('\n❌ Package has issues that need to be fixed before publishing!\n');
+  process.exit(1);
+} else {
+  console.log('\n✅ Package is ready for publication!\n');
+  process.exit(0);
+}

package/scripts/testing/README.md

@@ -0,0 +1,49 @@
+# Testing Scripts
+
+Scripts for testing Clodo Framework services and functionality.
+
+## Scripts
+
+### test.ps1
+Basic test runner for services.
+
+**Usage:**
+```powershell
+.\scripts\testing\test.ps1
+```
+
+### test-first.ps1
+Test the first service or item in a collection.
+
+**Features:**
+- Focused testing on initial items
+- Quick validation of basic functionality
+- Useful for CI/CD pipelines
+
+**Usage:**
+```powershell
+.\scripts\testing\test-first.ps1 -ServiceName my-service
+```
+
+### test-first50.ps1
+Test the first 50 services or items.
+
+**Features:**
+- Batch testing of multiple items
+- Performance validation
+- Scalability testing
+
+**Usage:**
+```powershell
+.\scripts\testing\test-first50.ps1 -ServiceType api-gateway
+```
+
+## Common Parameters
+
+All testing scripts support:
+- `ServiceName` - Name of the service to test
+- `ServiceType` - Type of service to test
+- `DomainName` - Domain to test against
+- `NonInteractive` - Run without user interaction
+- `TemplatePath` - Path to test templates
+- `OutputPath` - Output directory for test results

package/scripts/utilities/README.md

@@ -0,0 +1,61 @@
+# Utility Scripts
+
+General utility scripts for maintenance, validation, and operations.
+
+## Scripts
+
+### check-bundle.js
+Validate and check bundle integrity for deployments.
+
+**Features:**
+- Bundle size validation
+- Dependency checking
+- Asset verification
+- Performance metrics
+
+**Usage:**
+```bash
+node scripts/utilities/check-bundle.js
+```
+
+### cleanup-cli.js
+Clean up CLI tools and temporary files.
+
+**Features:**
+- Remove temporary files
+- Clean build artifacts
+- Clear cache directories
+- Disk space optimization
+
+**Usage:**
+```bash
+node scripts/utilities/cleanup-cli.js
+```
+
+### generate-secrets.js
+Generate secure secrets and tokens for services.
+
+**Features:**
+- Cryptographically secure random generation
+- Multiple secret types (API keys, JWT secrets, etc.)
+- Configurable entropy levels
+- Secure storage recommendations
+
+**Usage:**
+```bash
+node scripts/utilities/generate-secrets.js --type jwt --length 256
+```
+
+### validate-schema.js
+Validate configuration schemas and data structures.
+
+**Features:**
+- JSON schema validation
+- Configuration file checking
+- Data structure verification
+- Error reporting and suggestions
+
+**Usage:**
+```bash
+node scripts/utilities/validate-schema.js --file config/domains.js --schema domain-schema.json
+```

package/scripts/utilities/check-bin.js

@@ -0,0 +1,8 @@
+import fs from 'fs';
+const content = fs.readFileSync('src/service-management/GenerationEngine.js', 'utf8');
+const lines = content.split('\n');
+lines.forEach((line, i) => {
+  if (line.includes('bin/')) {
+    console.log(`${i+1}: ${line.trim()}`);
+  }
+});

package/scripts/utilities/check-bundle.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Go up two levels from scripts/utilities/ to project root, then to dist/
+const distDir = path.join(__dirname, '..', '..', 'dist');
+
+if (!fs.existsSync(distDir)) {
+  console.error('dist/ directory does not exist. Run npm run build first.');
+  process.exit(1);
+}
+
+const files = fs.readdirSync(distDir);
+if (files.length === 0) {
+  console.error('dist/ directory is empty. Build may have failed.');
+  process.exit(1);
+}
+
+console.log(`Bundle check passed: ${files.length} files in dist/`);
+files.forEach(file => console.log(`- ${file}`));

package/scripts/utilities/check-dist-imports.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Check Dist Imports
+ *
+ * Validates that all relative imports in `dist/` resolve to paths inside `dist/`.
+ * This prevents published packages from including relative imports that escape
+ * the `dist/` tree and point to non-existent files at package root.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.join(__dirname, '../../');
+const distRoot = path.join(projectRoot, 'dist');
+
+if (!fs.existsSync(distRoot)) {
+  console.error('dist/ directory not found. Run: npm run build');
+  process.exit(1);
+}
+
+function walk(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const files = [];
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) files.push(...walk(full));
+    else if (e.isFile() && full.endsWith('.js')) files.push(full);
+  }
+  return files;
+}
+
+const importRegex = /(?:from\s+['"]([^'"\n]+)['"])|(?:import\(['"]([^'"\n]+)['"]\))/g;
+let failures = [];
+const files = walk(distRoot);
+for (const file of files) {
+  const content = fs.readFileSync(file, 'utf8');
+  let m;
+  while ((m = importRegex.exec(content)) !== null) {
+    const imp = m[1] || m[2];
+    if (!imp) continue;
+    // only check relative imports
+    if (!imp.startsWith('.')) continue;
+
+    // Resolve the import target
+    const resolved = path.resolve(path.dirname(file), imp);
+    const normalizedDist = path.resolve(distRoot) + path.sep;
+    if (!resolved.startsWith(normalizedDist)) {
+      failures.push({ file, imp, resolved });
+    }
+  }
+}
+
+if (failures.length > 0) {
+  console.error('\n❌ Dist import validation failed. The following relative imports resolve outside dist/:\n');
+  for (const f of failures) {
+    console.error(` - ${path.relative(projectRoot, f.file)} imports '${f.imp}' → resolves to ${f.resolved}`);
+  }
+  console.error(`\nRecommendation: adjust relative imports so they point into 'dist/' (e.g. '../lib/...' from dist/<subdir>/ files).`);
+  process.exit(1);
+}
+
+console.log('\n✅ All relative imports in dist/ resolve inside dist/.');
+process.exit(0);