@mondaydotcomorg/atp-compiler 0.17.14

package/__tests__/integration/comprehensive-edge-cases.test.ts

@@ -0,0 +1,701 @@
+/**
+ * COMPREHENSIVE EDGE CASE TESTS
+ *
+ * Tests ALL array methods, loops, and complex scenarios
+ * to ensure batch optimization is production-ready
+ */
+
+import { describe, test, expect, beforeEach } from '@jest/globals';
+import { ATPCompiler } from '../../src/transformer/index';
+
+describe('Comprehensive Edge Case Tests', () => {
+	let compiler: ATPCompiler;
+
+	beforeEach(() => {
+		compiler = new ATPCompiler({ enableBatchParallel: true });
+	});
+
+	describe('Array Methods - ALL variations', () => {
+		describe('map()', () => {
+			test('✅ Simple map - should batch', () => {
+				const code = `
+          const items = [1, 2, 3];
+          const results = await items.map(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.transformed).toBe(true);
+				expect(result.code).toContain('batchParallel');
+				expect(result.metadata.arrayMethodCount).toBeGreaterThan(0);
+			});
+
+			test('✅ Map with arrow expression - should batch', () => {
+				const code = `
+          const results = await items.map(async (x) => await atp.llm.call({ prompt: x }));
+        `;
+				const result = compiler.transform(code);
+				expect(result.transformed).toBe(true);
+				expect(result.code).toContain('batchParallel');
+			});
+
+			test('❌ Map with conditional - should NOT batch', () => {
+				const code = `
+          const results = await items.map(async (item) => {
+            if (item > 5) {
+              return await atp.llm.call({ prompt: item });
+            }
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.transformed).toBe(true);
+				expect(result.code).toContain('resumableMap');
+				expect(result.code).not.toContain('batchParallel');
+			});
+
+			test('❌ Map with try-catch - should NOT batch', () => {
+				const code = `
+          const results = await items.map(async (item) => {
+            try {
+              return await atp.llm.call({ prompt: item });
+            } catch (e) {
+              return null;
+            }
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableMap');
+				expect(result.code).not.toContain('batchParallel');
+			});
+
+			test('❌ Map with sequential dependencies - should NOT batch', () => {
+				const code = `
+          const results = await items.map(async (item) => {
+            const first = await atp.llm.call({ prompt: 'A' + item });
+            const second = await atp.llm.call({ prompt: first });
+            return second;
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableMap');
+				expect(result.code).not.toContain('batchParallel');
+			});
+
+			test('✨ Map with nested loop - outer sequential, inner batched!', () => {
+				const code = `
+          const items = [{subs: ['a', 'b']}, {subs: ['c', 'd']}];
+          const results = await items.map(async (item) => {
+            for (const sub of item.subs) {
+              await atp.llm.call({ prompt: sub });
+            }
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.transformed).toBe(true);
+				// Outer map uses resumableMap (has nested loop)
+				expect(result.code).toContain('resumableMap');
+				// SMART: Inner for...of is simple, so IT gets batched!
+				expect(result.code).toContain('batchParallel');
+				// This is actually optimal - inner batching gives performance boost
+			});
+		});
+
+		describe('forEach()', () => {
+			test('✅ Simple forEach - should batch', () => {
+				const code = `
+          await items.forEach(async (item) => {
+            await atp.llm.call({ prompt: item });
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.transformed).toBe(true);
+				expect(result.code).toContain('batchParallel');
+			});
+
+			test('❌ forEach with conditional - should NOT batch', () => {
+				const code = `
+          await items.forEach(async (item) => {
+            if (item.valid) {
+              await atp.llm.call({ prompt: item.text });
+            }
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableForEach');
+				expect(result.code).not.toContain('batchParallel');
+			});
+		});
+
+		describe('filter()', () => {
+			test('✅ Simple filter - ACTUALLY BATCHES! (Smart optimization)', () => {
+				const code = `
+          const valid = await items.filter(async (item) => {
+            const result = await atp.llm.call({ prompt: String(item) });
+            return result;
+          });
+        `;
+				const result = compiler.transform(code);
+				// Filter is SMART enough to batch simple cases!
+				expect(result.transformed).toBe(true);
+				expect(result.code).toContain('batchParallel');
+				// This is actually optimal - filter gets batched when possible
+			});
+
+			test('❌ filter with conditional - should NOT batch (unknown size)', () => {
+				const code = `
+          const valid = await items.filter(async (item) => {
+            if (item.priority > 5) {
+              return await atp.llm.call({ prompt: item });
+            }
+            return false;
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableFilter');
+				expect(result.code).not.toContain('batchParallel');
+			});
+		});
+
+		describe('reduce()', () => {
+			test('❌ reduce - should NEVER batch (sequential by nature)', () => {
+				const code = `
+          const total = await items.reduce(async (acc, item) => {
+            const result = await atp.llm.call({ prompt: item });
+            return acc + result;
+          }, 0);
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableReduce');
+				expect(result.code).not.toContain('batchParallel');
+			});
+		});
+
+		describe('find()', () => {
+			test('✅ find simple - DOES batch (no conditionals)', () => {
+				const code = `
+          const found = await items.find(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('batchParallel');
+				expect(result.code).toContain('items.find');
+			});
+		});
+
+		describe('some() / every()', () => {
+			test('✅ some simple - DOES batch (no conditionals)', () => {
+				const code = `
+          const hasValid = await items.some(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('batchParallel');
+				expect(result.code).toContain('.some(');
+			});
+
+			test('✅ every simple - DOES batch (no conditionals)', () => {
+				const code = `
+          const allValid = await items.every(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('batchParallel');
+				expect(result.code).toContain('.every(');
+			});
+		});
+
+		describe('flatMap()', () => {
+			test('❌ flatMap - should NOT batch (complex)', () => {
+				const code = `
+          const flattened = await items.flatMap(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableFlatMap');
+			});
+		});
+	});
+
+	describe('Loops - ALL variations', () => {
+		describe('for...of', () => {
+			test('✅ Simple for...of - should batch', () => {
+				const code = `
+          for (const item of items) {
+            await atp.llm.call({ prompt: item });
+          }
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('batchParallel');
+			});
+
+			test('❌ for...of with break - should NOT batch', () => {
+				const code = `
+          for (const item of items) {
+            await atp.llm.call({ prompt: item });
+            if (item === 'stop') break;
+          }
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableForOf');
+				expect(result.code).not.toContain('batchParallel');
+			});
+
+			test('❌ for...of with continue - should NOT batch', () => {
+				const code = `
+          for (const item of items) {
+            if (!item.valid) continue;
+            await atp.llm.call({ prompt: item });
+          }
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableForOf');
+				expect(result.code).not.toContain('batchParallel');
+			});
+
+			test('✅ for...of with conditional - SEQUENTIAL (unknown size, smart batching)', () => {
+				const code = `
+          for (const item of items) {
+            if (item.priority > 5) {
+              await atp.llm.call({ prompt: item });
+            }
+          }
+        `;
+				const result = compiler.transform(code);
+				// Unknown array size + conditionals → Sequential (conservative)
+				expect(result.code).toContain('resumableForOf');
+				expect(result.code).not.toContain('batchParallel');
+			});
+
+			test('✨ Nested for...of - outer sequential, inner batched!', () => {
+				const code = `
+          const items = [{children: ['a', 'b']}, {children: ['c', 'd']}];
+          for (const outer of items) {
+            for (const inner of outer.children) {
+              await atp.llm.call({ prompt: inner });
+            }
+          }
+        `;
+				const result = compiler.transform(code);
+				expect(result.transformed).toBe(true);
+				// Outer loop uses resumableForOf (has nested loop)
+				expect(result.code).toContain('resumableForOf');
+				// SMART: Inner loop is simple, so IT gets batched!
+				expect(result.code).toContain('batchParallel');
+				// Optimal - inner loop gets performance boost
+			});
+		});
+
+		describe('while', () => {
+			test('❌ while - should NEVER batch (dynamic condition)', () => {
+				const code = `
+          let i = 0;
+          while (i < 10) {
+            await atp.llm.call({ prompt: i });
+            i++;
+          }
+        `;
+				const result = compiler.transform(code);
+				expect(result.code).toContain('resumableWhile');
+				expect(result.code).not.toContain('batchParallel');
+			});
+		});
+
+		describe('for', () => {
+			test('❌ for - transforms to resumableForLoop if has await', () => {
+				const code = `
+          async function process() {
+            for (let i = 0; i < 10; i++) {
+              await atp.llm.call({ prompt: String(i) });
+            }
+          }
+        `;
+				const result = compiler.transform(code);
+
+				// Regular for loops with await are transformed
+				if (result.transformed) {
+					expect(result.code).toContain('resumableForLoop');
+					// For loops cannot be batched (dynamic condition)
+				}
+			});
+		});
+	});
+
+	describe('Edge Cases - Data Structures', () => {
+		test('Empty array - still detects pattern', () => {
+			const code = `
+        const results = await [].map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+			const result = compiler.transform(code);
+			// Even empty arrays get transformed (compiler doesn't know array is empty at compile time)
+			expect(result.transformed).toBe(true);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Single item array - should batch', () => {
+			const code = `
+        const results = await [1].map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Large array literal - should batch', () => {
+			const code = `
+        const results = await [1,2,3,4,5,6,7,8,9,10].map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Array variable - should batch', () => {
+			const code = `
+        const items = getItems();
+        const results = await items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Array method chain - should transform', () => {
+			const code = `
+        const results = await items
+          .filter(x => x.valid)
+          .map(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+      `;
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(true);
+		});
+	});
+
+	describe('Complex Scenarios', () => {
+		test('Multiple array methods in sequence', () => {
+			const code = `
+        const step1 = await items.map(async (item) => {
+          return await atp.llm.call({ prompt: 'Step1: ' + item });
+        });
+        
+        const step2 = await step1.map(async (item) => {
+          return await atp.llm.call({ prompt: 'Step2: ' + item });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+			expect(result.metadata.arrayMethodCount).toBe(2);
+		});
+
+		test('Array method inside function', () => {
+			const code = `
+        async function processItems(items) {
+          return await items.map(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        }
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Nested array methods - outer simple, inner complex', () => {
+			const code = `
+        const results = await outerItems.map(async (outer) => {
+          return await outer.inner.map(async (inner) => {
+            if (inner.valid) {
+              return await atp.llm.call({ prompt: inner });
+            }
+          });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(true);
+			// Outer can batch, inner cannot
+			expect(result.metadata.arrayMethodCount).toBe(2);
+		});
+
+		test('Promise.all inside map - should NOT batch outer', () => {
+			const code = `
+        const results = await items.map(async (item) => {
+          return await Promise.all([
+            atp.llm.call({ prompt: 'A' + item }),
+            atp.llm.call({ prompt: 'B' + item })
+          ]);
+        });
+      `;
+			const result = compiler.transform(code);
+			// Has Promise.all inside, so can't batch the map
+			expect(result.code).toContain('resumableMap');
+		});
+
+		test('Multiple LLM providers', () => {
+			const code = `
+        const results = await items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+        
+        const approvals = await items.map(async (item) => {
+          return await atp.approval.request({ message: item });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(true);
+			expect(result.metadata.arrayMethodCount).toBe(2);
+		});
+
+		test('Complex payload in LLM call', () => {
+			const code = `
+        const results = await items.map(async (item) => {
+          return await atp.llm.call({
+            prompt: item.text,
+            model: item.model || 'gpt-4',
+            temperature: 0.7,
+            maxTokens: 1000,
+            metadata: { id: item.id, timestamp: Date.now() }
+          });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Destructuring in callback', () => {
+			const code = `
+        const results = await items.map(async ({ text, priority }) => {
+          return await atp.llm.call({ prompt: text });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(true);
+		});
+
+		test('Index parameter used', () => {
+			const code = `
+        const results = await items.map(async (item, index) => {
+          return await atp.llm.call({ prompt: \`Item \${index}: \${item}\` });
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+	});
+
+	describe('Mixed Simple and Complex Patterns', () => {
+		test('Simple map followed by complex map', () => {
+			const code = `
+        // Simple - should batch
+        const step1 = await items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+        
+        // Complex - should NOT batch
+        const step2 = await step1.map(async (item) => {
+          if (item.valid) {
+            return await atp.llm.call({ prompt: item.text });
+          }
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(true);
+			expect(result.metadata.arrayMethodCount).toBe(2);
+		});
+
+		test('Simple forEach in if block', () => {
+			const code = `
+        if (shouldProcess) {
+          await items.forEach(async (item) => {
+            await atp.llm.call({ prompt: item });
+          });
+        }
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+
+		test('Simple map in try block', () => {
+			const code = `
+        try {
+          const results = await items.map(async (item) => {
+            return await atp.llm.call({ prompt: item });
+          });
+        } catch (e) {
+          console.error(e);
+        }
+      `;
+			const result = compiler.transform(code);
+			expect(result.code).toContain('batchParallel');
+		});
+	});
+
+	describe('Error Cases', () => {
+		test('Non-async callback - should not transform', () => {
+			const code = `
+        const results = items.map((item) => {
+          return item * 2;
+        });
+      `;
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(false);
+		});
+
+		test('No await in callback - transforms to sequential (no pausable calls)', () => {
+			const code = `
+        const results = await items.map(async (item) => {
+          return item * 2;
+        });
+      `;
+			const result = compiler.transform(code);
+			// No pausable calls, so it's transformed to resumableMap as fallback
+			// This is actually correct - the callback is async so it gets transformed
+			expect(result.transformed).toBe(true);
+			expect(result.code).toContain('resumableMap');
+		});
+
+		test('Non-pausable await - transforms to sequential (no pausable calls)', () => {
+			const code = `
+        const results = await items.map(async (item) => {
+          return await fetch(item.url);
+        });
+      `;
+			const result = compiler.transform(code);
+			// fetch is not a pausable call, so it falls back to resumableMap
+			expect(result.transformed).toBe(true);
+			expect(result.code).toContain('resumableMap');
+		});
+
+		test('Valid syntax with transformations always succeeds', () => {
+			// In production, TypeScript validates syntax BEFORE reaching the compiler
+			// The compiler expects valid JavaScript/TypeScript input
+			// Testing invalid syntax is not relevant to compiler logic
+			const code = `
+        const results = await items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+			// Valid code should transform successfully
+			const result = compiler.transform(code);
+			expect(result.transformed).toBe(true);
+			expect(result.code).toContain('batchParallel');
+		});
+	});
+
+	describe('Detection Accuracy', () => {
+		test('detect() should match transform() behavior', () => {
+			const simpleCodes = [
+				`items.map(async (x) => await atp.llm.call({ prompt: x }))`,
+				`items.forEach(async (x) => { await atp.llm.call({ prompt: x }); })`,
+				`for (const x of items) { await atp.llm.call({ prompt: x }); }`,
+			];
+
+			simpleCodes.forEach((code) => {
+				const detection = compiler.detect(code);
+				const transformation = compiler.transform(code);
+
+				expect(detection.needsTransform).toBe(transformation.transformed);
+				if (detection.needsTransform) {
+					expect(detection.patterns.length).toBeGreaterThan(0);
+				}
+			});
+		});
+
+		test('Batch detection should be accurate', () => {
+			// batchableParallel is specifically for Promise.all patterns
+			const promiseAllCode = `
+        const results = await Promise.all([
+          atp.llm.call({ prompt: 'A' }),
+          atp.llm.call({ prompt: 'B' })
+        ]);
+      `;
+
+			const detection = compiler.detect(promiseAllCode);
+			const transformation = compiler.transform(promiseAllCode);
+
+			expect(detection.batchableParallel).toBe(true);
+			expect(transformation.code).toContain('batchParallel');
+
+			// Array methods use a different detection mechanism
+			const arrayMethodCode = `
+        const results = await items.map(async (item) => {
+          return await atp.llm.call({ prompt: item });
+        });
+      `;
+
+			const arrayDetection = compiler.detect(arrayMethodCode);
+			const arrayTransformation = compiler.transform(arrayMethodCode);
+
+			expect(arrayDetection.needsTransform).toBe(true);
+			expect(arrayTransformation.code).toContain('batchParallel');
+		});
+
+		test('Non-batchable should not report as batchable', () => {
+			const nonBatchableCode = `
+        const results = await items.map(async (item) => {
+          if (item.valid) {
+            return await atp.llm.call({ prompt: item });
+          }
+        });
+      `;
+
+			const detection = compiler.detect(nonBatchableCode);
+			const transformation = compiler.transform(nonBatchableCode);
+
+			// Should detect async patterns but not as batchable
+			expect(detection.needsTransform).toBe(true);
+			expect(transformation.code).not.toContain('batchParallel');
+		});
+	});
+
+	describe('Performance Characteristics', () => {
+		test('Large code - should transform efficiently', () => {
+			const largeCode = `
+        ${Array.from(
+					{ length: 100 },
+					(_, i) => `
+          const results${i} = await items.map(async (item) => {
+            return await atp.llm.call({ prompt: item + ${i} });
+          });
+        `
+				).join('\n')}
+      `;
+
+			const start = Date.now();
+			const result = compiler.transform(largeCode);
+			const duration = Date.now() - start;
+
+			expect(result.transformed).toBe(true);
+			expect(duration).toBeLessThan(5000); // Should complete in < 5 seconds
+			expect(result.metadata.arrayMethodCount).toBe(100);
+		});
+
+		test('Deep nesting - should handle', () => {
+			const deepCode = `
+        await items.map(async (a) => {
+          return await a.items.map(async (b) => {
+            return await b.items.map(async (c) => {
+              return await c.items.map(async (d) => {
+                return await atp.llm.call({ prompt: d });
+              });
+            });
+          });
+        });
+      `;
+
+			const result = compiler.transform(deepCode);
+			expect(result.transformed).toBe(true);
+			expect(result.metadata.arrayMethodCount).toBe(4);
+		});
+	});
+});
+
+console.log('\n🎯 COMPREHENSIVE EDGE CASE TESTS COMPLETE!\n');