chore(repo): Enhance E2E cleanup script (#6870)

Author: jacekradko

integration/cleanup/cleanup.setup.ts

@@ -15,20 +15,37 @@ setup('cleanup instances ', async () => {
       }
       const parsedPk = parsePublishableKey(pk);
       const apiUrl = isStaging(parsedPk.frontendApi) ? 'https://api.clerkstage.dev' : 'https://api.clerk.com';
-      return { secretKey, apiUrl };
+      return {
+        secretKey,
+        apiUrl,
+        instanceName: parsedPk.instanceId || parsedPk.frontendApi.split('.')[0] || 'unknown',
+      };
     })
     .filter(Boolean);
 
-  const errors: Array<{ instance: string; error: Error; operation: string }> = [];
+  const cleanupSummary: Array<{
+    instanceName: string;
+    usersDeleted: number;
+    orgsDeleted: number;
+    errors: string[];
+    status: 'success' | 'error' | 'unauthorized';
+  }> = [];
+
+  console.log('🧹 Starting E2E Test Cleanup Process...\n');
 
   for (const entry of entries) {
-    const instanceKey = entry.secretKey.replace(/(sk_(test|live)_)(.+)(...)/, '$1***$4');
-    console.log(`Cleanup for ${instanceKey}`);
+    const instanceSummary = {
+      instanceName: entry.instanceName,
+      usersDeleted: 0,
+      orgsDeleted: 0,
+      errors: [] as string[],
+      status: 'success' as 'success' | 'error' | 'unauthorized',
+    };
 
     try {
       const clerkClient = createClerkClient({ secretKey: entry.secretKey, apiUrl: entry.apiUrl });
 
-      // Get users
+      // Get users with error handling
       let users: any[] = [];
       try {
         const { data: usersWithEmail } = await clerkClient.users.getUserList({
@@ -43,14 +60,19 @@ setup('cleanup instances ', async () => {
           limit: 150,
         });
 
-        users = [...usersWithEmail, ...usersWithPhoneNumber];
+        // Deduplicate users by ID
+        const allUsersMap = new Map();
+        [...usersWithEmail, ...usersWithPhoneNumber].forEach(user => {
+          allUsersMap.set(user.id, user);
+        });
+        users = Array.from(allUsersMap.values());
       } catch (error) {
-        errors.push({ instance: instanceKey, error: error as Error, operation: 'getUserList' });
-        console.error(`Error getting users for ${instanceKey}:`, error);
+        instanceSummary.errors.push(`Failed to get users: ${error.message}`);
+        console.error(`Error getting users for ${entry.instanceName}:`, error);
         users = []; // Continue with empty users list
       }
 
-      // Get organizations
+      // Get organizations with error handling
       let orgs: any[] = [];
       try {
         const { data: orgsData } = await clerkClient.organizations.getOrganizationList({
@@ -63,16 +85,16 @@ setup('cleanup instances ', async () => {
         if (isClerkAPIResponseError(error) && (error.status === 404 || error.status === 403)) {
           orgs = [];
         } else {
-          errors.push({ instance: instanceKey, error: error as Error, operation: 'getOrganizationList' });
-          console.error(`Error getting organizations for ${instanceKey}:`, error);
+          instanceSummary.errors.push(`Failed to get organizations: ${error.message}`);
+          console.error(`Error getting organizations for ${entry.instanceName}:`, error);
           orgs = []; // Continue with empty orgs list
         }
       }
 
       const usersToDelete = batchElements(skipObjectsThatWereCreatedWithinTheLast10Minutes(users), 5);
       const orgsToDelete = batchElements(skipObjectsThatWereCreatedWithinTheLast10Minutes(orgs), 5);
 
-      // Delete users
+      // Delete users with tracking
       for (const batch of usersToDelete) {
         console.log(`Starting user deletion batch...`);
         await Promise.all(
@@ -82,47 +104,94 @@ setup('cleanup instances ', async () => {
                 user.createdAt,
               ).toISOString()})`,
             );
-            return clerkClient.users.deleteUser(user.id).catch(error => {
-              console.error(`Error deleting user ${user.id}:`, error);
-            });
+            return clerkClient.users
+              .deleteUser(user.id)
+              .then(() => {
+                instanceSummary.usersDeleted++;
+              })
+              .catch(error => {
+                if (error.status !== 404) {
+                  instanceSummary.errors.push(`User ${user.id}: ${error.message}`);
+                  console.error(`Error deleting user ${user.id}:`, error);
+                }
+              });
           }),
         );
         await new Promise(r => setTimeout(r, 1000));
       }
 
-      // Delete organizations
+      // Delete organizations with tracking
       for (const batch of orgsToDelete) {
         console.log(`Starting organization deletion batch...`);
         await Promise.all(
           batch.map(org => {
             console.log(`Cleaning up org ${org.id} (${org.name}) (${new Date(org.createdAt).toISOString()})`);
-            return clerkClient.organizations.deleteOrganization(org.id).catch(error => {
-              console.error(`Error deleting org ${org.id}:`, error);
-            });
+            return clerkClient.organizations
+              .deleteOrganization(org.id)
+              .then(() => {
+                instanceSummary.orgsDeleted++;
+              })
+              .catch(error => {
+                if (error.status !== 404) {
+                  instanceSummary.errors.push(`Org ${org.id}: ${error.message}`);
+                  console.error(`Error deleting org ${org.id}:`, error);
+                }
+              });
           }),
         );
         await new Promise(r => setTimeout(r, 1000));
       }
+
+      // Report instance results
+      const maskedKey = entry.secretKey.replace(/(sk_(test|live)_)(.+)(...)/, '$1***$4');
+      if (instanceSummary.usersDeleted > 0 || instanceSummary.orgsDeleted > 0) {
+        console.log(
+          `✅ ${entry.instanceName} (${maskedKey}): ${instanceSummary.usersDeleted} users, ${instanceSummary.orgsDeleted} orgs deleted`,
+        );
+      } else {
+        console.log(`✅ ${entry.instanceName} (${maskedKey}): clean`);
+      }
+
+      if (instanceSummary.errors.length > 0) {
+        instanceSummary.status = 'error';
+      }
     } catch (error) {
-      errors.push({ instance: instanceKey, error: error as Error, operation: 'general' });
-      console.error(`General error during cleanup for ${instanceKey}:`, error);
+      const maskedKey = entry.secretKey.replace(/(sk_(test|live)_)(.+)(...)/, '$1***$4');
+      if (isClerkAPIResponseError(error) && (error.status === 401 || error.status === 403)) {
+        console.log(`🔒 ${entry.instanceName} (${maskedKey}): Unauthorized access`);
+        instanceSummary.status = 'unauthorized';
+      } else {
+        console.log(`❌ ${entry.instanceName} (${maskedKey}): ${error.message}`);
+        instanceSummary.errors.push(error.message);
+        instanceSummary.status = 'error';
+      }
     }
+
+    cleanupSummary.push(instanceSummary);
   }
 
-  // Report all errors at the end
-  if (errors.length > 0) {
-    console.log('\n=== CLEANUP ERRORS SUMMARY ===');
-    errors.forEach(({ instance, error, operation }) => {
-      console.log(`Instance: ${instance}`);
-      console.log(`Operation: ${operation}`);
-      console.log(`Error: ${error.message}`);
-      if (isClerkAPIResponseError(error)) {
-        console.log(`Status: ${error.status}`);
-      }
-      console.log('---');
+  // Final summary
+  const totalUsersDeleted = cleanupSummary.reduce((sum, instance) => sum + instance.usersDeleted, 0);
+  const totalOrgsDeleted = cleanupSummary.reduce((sum, instance) => sum + instance.orgsDeleted, 0);
+  const errorInstances = cleanupSummary.filter(instance => instance.status === 'error').length;
+  const unauthorizedInstances = cleanupSummary.filter(instance => instance.status === 'unauthorized').length;
+
+  console.log(`\n📊 Summary: ${totalUsersDeleted} users, ${totalOrgsDeleted} orgs deleted`);
+  if (errorInstances > 0 || unauthorizedInstances > 0) {
+    console.log(`   ${errorInstances} errors, ${unauthorizedInstances} unauthorized`);
+  }
+
+  // Detailed error report
+  const instancesWithErrors = cleanupSummary.filter(instance => instance.errors.length > 0);
+  if (instancesWithErrors.length > 0) {
+    console.log('\n=== DETAILED ERROR REPORT ===');
+    instancesWithErrors.forEach(instance => {
+      console.log(`\n${instance.instanceName}:`);
+      instance.errors.forEach(error => console.log(`  - ${error}`));
     });
-    console.log(`Total errors: ${errors.length}`);
-  } else {
+  }
+
+  if (errorInstances === 0 && unauthorizedInstances === 0) {
     console.log('\n✅ Cleanup completed successfully with no errors');
   }
 });