[FEATURE] set up tests to validate imports work for all app

Author: jcortes

.github/workflows/publish-packages.yaml

@@ -46,6 +46,12 @@ jobs:
         run: pnpm install -r --no-frozen-lockfile
       - name: Compile TypeScript
         run: pnpm run build
+      # Pre-publish validation
+      - name: Validate Package Imports and Dependencies
+        run: |
+          node scripts/validate-packages.js
+        env:
+          NODE_ENV: production
       # See https://pnpm.io/using-changesets
       - name: Setup npmrc for pnpm publish
         run: echo "//registry.npmjs.org/:_authToken=${{ secrets.NPM_TOKEN }}" > .npmrc

components/netlify/actions/get-site/get-site.mjs

@@ -4,7 +4,7 @@ export default {
   key: "netlify-get-site",
   name: "Get Site",
   description: "Get a specified site. [See docs](https://docs.netlify.com/api/get-started/#get-sites)",
-  version: "0.1.0",
+  version: "0.1.1",
   type: "action",
   props: {
     netlify,

components/netlify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/netlify",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Pipedream Netlify Components",
   "main": "netlify.app.mjs",
   "keywords": [

pnpm-lock.yaml

@@ -0,0 +1,210 @@
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function validatePackages() {
+  const componentsDir = 'components';
+  const apps = fs.readdirSync(componentsDir).filter(dir => {
+    const packagePath = path.join(componentsDir, dir, 'package.json');
+    return fs.existsSync(packagePath);
+  });
+
+  const results = {
+    validated: [],
+    failed: [],
+    skipped: []
+  };
+
+  console.log(`🔍 Validating ${apps.length} component packages...\n`);
+
+  for (const app of apps) {
+    const packagePath = path.join(componentsDir, app, 'package.json');
+    let packageJson = null;
+    let packageName = app; // Use app name as fallback
+    
+    try {
+      // Parse package.json
+      const packageJsonContent = fs.readFileSync(packagePath, 'utf8');
+      packageJson = JSON.parse(packageJsonContent);
+      packageName = packageJson.name || `${app} (no name)`;
+      
+      // Only validate @pipedream/* packages with publishConfig
+      if (!packageName || !packageName.startsWith('@pipedream/')) {
+        results.skipped.push({ app, packageName, reason: 'Not a @pipedream package' });
+        continue;
+      }
+      
+      if (!packageJson.publishConfig?.access) {
+        results.skipped.push({ app, packageName, reason: 'No publishConfig.access' });
+        continue;
+      }
+
+      console.log(`📦 Validating ${packageName}...`);
+      
+      // Run all validations
+      validatePackageJson(packageJson, app);
+      validateMainFile(packageJson, app);
+      validateDependencies(packageJson, app);
+      validateImport(packageName, app, packageJson);
+      
+      results.validated.push({ app, packageName });
+      console.log(`✅ ${packageName} - VALID\n`);
+      
+    } catch (error) {
+      results.failed.push({ 
+        app, 
+        packageName,
+        error: error.message 
+      });
+      console.error(`❌ ${app} (${packageName}) - FAILED: ${error.message}\n`);
+    }
+  }
+  
+  // Print summary
+  printSummary(results);
+  
+  // Exit with error if any validations failed
+  if (results.failed.length > 0) {
+    console.error(`\n💥 Validation failed for ${results.failed.length} packages. See errors above.`);
+    process.exit(1);
+  }
+  
+  console.log(`\n🎉 All ${results.validated.length} packages validated successfully!`);
+}
+
+function validatePackageJson(packageJson, app) {
+  const required = ['name', 'version', 'main'];
+  
+  for (const field of required) {
+    if (!packageJson[field]) {
+      throw new Error(`Missing required field: ${field}`);
+    }
+  }
+  
+  // Validate version format
+  if (!/^\d+\.\d+\.\d+/.test(packageJson.version)) {
+    throw new Error(`Invalid version format: ${packageJson.version}`);
+  }
+  
+  // Validate publishConfig
+  if (!packageJson.publishConfig?.access) {
+    throw new Error('Missing publishConfig.access for public package');
+  }
+}
+
+function validateMainFile(packageJson, app) {
+  const mainFile = path.join('components', app, packageJson.main);
+  
+  if (!fs.existsSync(mainFile)) {
+    throw new Error(`Main file not found: ${packageJson.main}`);
+  }
+  
+  // Check if main file has basic export structure
+  const content = fs.readFileSync(mainFile, 'utf8');
+  if (!content.includes('export') && !content.includes('module.exports')) {
+    throw new Error(`Main file ${packageJson.main} has no exports`);
+  }
+}
+
+function validateDependencies(packageJson, app) {
+  if (!packageJson.dependencies) return;
+  
+  // Check for common problematic dependencies
+  const problematic = Object.keys(packageJson.dependencies).filter(dep => {
+    // Add checks for dependencies that commonly cause issues
+    return dep.includes('node-gyp') || dep.includes('native');
+  });
+  
+  if (problematic.length > 0) {
+    console.warn(`⚠️  Potentially problematic dependencies: ${problematic.join(', ')}`);
+  }
+  
+  // Validate @pipedream/platform version if present
+  const platformDep = packageJson.dependencies['@pipedream/platform'];
+  if (platformDep && !platformDep.match(/^[\^~]?\d+\.\d+\.\d+/)) {
+    throw new Error(`Invalid @pipedream/platform version: ${platformDep}`);
+  }
+}
+
+function validateImport(packageName, app, packageJson) {
+  const mainFile = path.resolve('components', app, packageJson.main);
+  
+  // First, check if file exists
+  if (!fs.existsSync(mainFile)) {
+    throw new Error(`Main file not found: ${packageJson.main}`);
+  }
+  
+  // Syntax check
+  try {
+    execSync(`node --check ${mainFile}`, { 
+      stdio: 'pipe',
+      timeout: 5000 
+    });
+  } catch (error) {
+    throw new Error(`Syntax error in main file: ${error.message}`);
+  }
+  
+  // Import test using file path instead of package name
+  const testFile = path.join('components', app, '__import_test__.mjs');
+  const testContent = `
+try {
+  // Import from local file path using file:// protocol
+  const pkg = await import("file://${mainFile}");
+  
+  if (!pkg.default) {
+    throw new Error("No default export found");
+  }
+  
+  const component = pkg.default;
+  if (typeof component !== 'object') {
+    throw new Error("Default export is not an object");
+  }
+  
+  console.log("✓ Import successful for ${packageName}");
+  process.exit(0);
+  
+} catch (error) {
+  console.error("Import failed for ${packageName}:", error.message);
+  process.exit(1);
+}`;
+  
+  try {
+    fs.writeFileSync(testFile, testContent);
+    execSync(`node ${testFile}`, { 
+      stdio: 'pipe',
+      cwd: process.cwd(),
+      timeout: 10000
+    });
+  } catch (error) {
+    throw new Error(`Import test failed: ${error.message}`);
+  } finally {
+    if (fs.existsSync(testFile)) {
+      fs.unlinkSync(testFile);
+    }
+  }
+}
+
+function printSummary(results) {
+  console.log('\n📊 VALIDATION SUMMARY');
+  console.log('='.repeat(50));
+  console.log(`✅ Validated: ${results.validated.length}`);
+  console.log(`❌ Failed: ${results.failed.length}`);
+  console.log(`⏭️  Skipped: ${results.skipped.length}`);
+  
+  if (results.failed.length > 0) {
+    console.log('\n❌ FAILED PACKAGES:');
+    results.failed.forEach(({ app, packageName, error }) => {
+      console.log(`  • ${packageName} (${app}): ${error}`);
+    });
+  }
+  
+  if (results.validated.length > 0) {
+    console.log('\n✅ VALIDATED PACKAGES:');
+    results.validated.forEach(({ packageName }) => {
+      console.log(`  • ${packageName}`);
+    });
+  }
+}
+
+// Run validation
+validatePackages();