improvement(subflows): support multiple blocks in parallel subflow, enhance logs to group by iteration for parallels/loop (#1429)

* feat(changelog): added changelog

* move avatar icons in changelog

* improvement(parallels): support multiple blocks in parallel subflow, enhance logs to group by iteration for parallels/loops

* restore env

* added tests

* lint

* update drizzle

---------

Co-authored-by: waleed <waleed>

Author: waleedlatif1

apps/sim/app/changelog/components/timeline-list.tsx

@@ -98,9 +98,40 @@ export default function ChangelogList({ initialEntries }: Props) {
     <div className='space-y-10'>
       {entries.map((entry) => (
         <div key={entry.tag}>
-          <div className='flex items-baseline justify-between gap-4'>
-            <div className={`${soehne.className} font-semibold text-[18px] tracking-tight`}>
-              {entry.tag}
+          <div className='flex items-center justify-between gap-4'>
+            <div className='flex items-center gap-2'>
+              <div className={`${soehne.className} font-semibold text-[18px] tracking-tight`}>
+                {entry.tag}
+              </div>
+              {entry.contributors && entry.contributors.length > 0 && (
+                <div className='-space-x-2 flex'>
+                  {entry.contributors.slice(0, 5).map((contributor) => (
+                    <a
+                      key={contributor}
+                      href={`https://github.com/${contributor}`}
+                      target='_blank'
+                      rel='noreferrer noopener'
+                      aria-label={`View @${contributor} on GitHub`}
+                      title={`@${contributor}`}
+                      className='block'
+                    >
+                      <Avatar className='size-6 ring-2 ring-background'>
+                        <AvatarImage
+                          src={`https://avatars.githubusercontent.com/${contributor}`}
+                          alt={`@${contributor}`}
+                          className='hover:z-10'
+                        />
+                        <AvatarFallback>{contributor.slice(0, 2).toUpperCase()}</AvatarFallback>
+                      </Avatar>
+                    </a>
+                  ))}
+                  {entry.contributors.length > 5 && (
+                    <div className='relative flex size-6 items-center justify-center rounded-full bg-muted text-[10px] text-foreground ring-2 ring-background hover:z-10'>
+                      +{entry.contributors.length - 5}
+                    </div>
+                  )}
+                </div>
+              )}
             </div>
             <div className={`${inter.className} text-muted-foreground text-xs`}>
               {new Date(entry.date).toLocaleDateString('en-US', {
@@ -184,26 +215,6 @@ export default function ChangelogList({ initialEntries }: Props) {
               {cleanMarkdown(entry.content)}
             </ReactMarkdown>
           </div>
-
-          {entry.contributors && entry.contributors.length > 0 && (
-            <div className='-space-x-2 mt-3 flex'>
-              {entry.contributors.slice(0, 5).map((contributor) => (
-                <Avatar key={contributor} className='size-6 ring-2 ring-background'>
-                  <AvatarImage
-                    src={`https://avatars.githubusercontent.com/${contributor}`}
-                    alt={`@${contributor}`}
-                    className='hover:z-10'
-                  />
-                  <AvatarFallback>{contributor.slice(0, 2).toUpperCase()}</AvatarFallback>
-                </Avatar>
-              ))}
-              {entry.contributors.length > 5 && (
-                <div className='relative flex size-6 items-center justify-center rounded-full bg-muted text-[10px] text-foreground ring-2 ring-background hover:z-10'>
-                  +{entry.contributors.length - 5}
-                </div>
-              )}
-            </div>
-          )}
         </div>
       ))}
 

apps/sim/executor/handlers/loop/loop-handler.test.ts

@@ -82,35 +82,29 @@ describe('LoopBlockHandler', () => {
     it('should initialize loop on first execution', async () => {
       const result = await handler.execute(mockBlock, {}, mockContext)
 
-      // After execution, the counter is incremented for the next iteration
       expect(mockContext.loopIterations.get('loop-1')).toBe(1)
       expect(mockContext.activeExecutionPath.has('inner-block')).toBe(true)
 
-      // Type guard to check if result has the expected structure
       if (typeof result === 'object' && result !== null) {
         const response = result as any
-        expect(response.currentIteration).toBe(0) // Still shows current iteration as 0
+        expect(response.currentIteration).toBe(1)
         expect(response.maxIterations).toBe(3)
         expect(response.completed).toBe(false)
       }
     })
 
     it('should activate loop-end-source when iterations complete', async () => {
-      // Set to last iteration
-      mockContext.loopIterations.set('loop-1', 3)
+      mockContext.loopIterations.set('loop-1', 4)
 
       const result = await handler.execute(mockBlock, {}, mockContext)
 
-      // The loop handler no longer marks loops as completed - that's handled by the loop manager
       expect(mockContext.completedLoops.has('loop-1')).toBe(false)
-      // The loop handler also doesn't activate end connections anymore
       expect(mockContext.activeExecutionPath.has('after-loop')).toBe(false)
-      // But it should not activate the inner block either since we're at max iterations
       expect(mockContext.activeExecutionPath.has('inner-block')).toBe(false)
 
       if (typeof result === 'object' && result !== null) {
         const response = result as any
-        expect(response.completed).toBe(false) // Not completed until all blocks execute
+        expect(response.completed).toBe(false)
         expect(response.message).toContain('Final iteration')
       }
     })
@@ -131,7 +125,7 @@ describe('LoopBlockHandler', () => {
       if (typeof result === 'object' && result !== null) {
         const response = result as any
         expect(response.loopType).toBe('forEach')
-        expect(response.maxIterations).toBe(3) // Limited by items length
+        expect(response.maxIterations).toBe(3)
       }
     })
 
@@ -153,28 +147,26 @@ describe('LoopBlockHandler', () => {
     })
 
     it('should limit forEach loops by collection size, not iterations parameter', async () => {
-      // This tests the fix for the bug where forEach loops were using the iterations count
-      // instead of the actual collection size
       mockContext.workflow!.loops['loop-1'] = {
         id: 'loop-1',
         nodes: ['inner-block'],
-        iterations: 10, // High iteration count
+        iterations: 10,
         loopType: 'forEach',
-        forEachItems: ['a', 'b'], // Only 2 items
+        forEachItems: ['a', 'b'],
       }
 
-      // First execution
       let result = await handler.execute(mockBlock, {}, mockContext)
       expect(mockContext.loopIterations.get('loop-1')).toBe(1)
       expect(mockContext.loopItems.get('loop-1')).toBe('a')
 
       if (typeof result === 'object' && result !== null) {
         const response = result as any
-        expect(response.maxIterations).toBe(2) // Should be limited to 2, not 10
+        expect(response.maxIterations).toBe(2)
         expect(response.completed).toBe(false)
       }
 
-      // Second execution
+      mockContext.loopIterations.set('loop-1', 2)
+
       result = await handler.execute(mockBlock, {}, mockContext)
       expect(mockContext.loopIterations.get('loop-1')).toBe(2)
       expect(mockContext.loopItems.get('loop-1')).toBe('b')
@@ -184,7 +176,10 @@ describe('LoopBlockHandler', () => {
         expect(response.completed).toBe(false)
       }
 
-      // Third execution should complete the loop
+      // Manually increment iteration for third execution (exceeds max)
+      mockContext.loopIterations.set('loop-1', 3)
+
+      // Third execution should exceed the loop limit
       result = await handler.execute(mockBlock, {}, mockContext)
       // The loop handler no longer marks loops as completed - that's handled by the loop manager
       expect(mockContext.completedLoops.has('loop-1')).toBe(false)
@@ -196,7 +191,7 @@ describe('LoopBlockHandler', () => {
         nodes: ['inner-block'],
         iterations: 5,
         loopType: 'forEach',
-        forEachItems: '', // Empty collection
+        forEachItems: '',
       }
 
       await expect(handler.execute(mockBlock, {}, mockContext)).rejects.toThrow(
@@ -210,7 +205,7 @@ describe('LoopBlockHandler', () => {
         nodes: ['inner-block'],
         iterations: 5,
         loopType: 'forEach',
-        forEachItems: [], // Empty array
+        forEachItems: [],
       }
 
       await expect(handler.execute(mockBlock, {}, mockContext)).rejects.toThrow(
@@ -223,40 +218,34 @@ describe('LoopBlockHandler', () => {
     it('should activate children when in active path', async () => {
       const handlerWithPathTracker = new LoopBlockHandler(undefined, mockPathTracker as any)
 
-      // Mock PathTracker to return true (block is in active path)
       mockPathTracker.isInActivePath.mockReturnValue(true)
 
       await handlerWithPathTracker.execute(mockBlock, {}, mockContext)
 
-      // Should activate children when in active path
       expect(mockContext.activeExecutionPath.has('inner-block')).toBe(true)
       expect(mockPathTracker.isInActivePath).toHaveBeenCalledWith('loop-1', mockContext)
     })
 
     it('should not activate children when not in active path', async () => {
       const handlerWithPathTracker = new LoopBlockHandler(undefined, mockPathTracker as any)
 
-      // Mock PathTracker to return false (block is not in active path)
       mockPathTracker.isInActivePath.mockReturnValue(false)
 
       await handlerWithPathTracker.execute(mockBlock, {}, mockContext)
 
-      // Should not activate children when not in active path
       expect(mockContext.activeExecutionPath.has('inner-block')).toBe(false)
       expect(mockPathTracker.isInActivePath).toHaveBeenCalledWith('loop-1', mockContext)
     })
 
     it('should handle PathTracker errors gracefully', async () => {
       const handlerWithPathTracker = new LoopBlockHandler(undefined, mockPathTracker as any)
 
-      // Mock PathTracker to throw error
       mockPathTracker.isInActivePath.mockImplementation(() => {
         throw new Error('PathTracker error')
       })
 
       await handlerWithPathTracker.execute(mockBlock, {}, mockContext)
 
-      // Should default to activating children when PathTracker fails
       expect(mockContext.activeExecutionPath.has('inner-block')).toBe(true)
     })
   })

apps/sim/executor/handlers/loop/loop-handler.ts

@@ -32,7 +32,6 @@ export class LoopBlockHandler implements BlockHandler {
   ): Promise<BlockOutput> {
     logger.info(`Executing loop block: ${block.id}`)
 
-    // Get the loop configuration from the workflow
     const loop = context.workflow?.loops?.[block.id]
     if (!loop) {
       logger.error(`Loop configuration not found for block ${block.id}`, {
@@ -43,13 +42,12 @@ export class LoopBlockHandler implements BlockHandler {
       throw new Error(`Loop configuration not found for block ${block.id}`)
     }
 
-    // Initialize loop iteration if not already done
     if (!context.loopIterations.has(block.id)) {
-      context.loopIterations.set(block.id, 0)
-      logger.info(`Initialized loop ${block.id} with 0 iterations`)
+      context.loopIterations.set(block.id, 1)
+      logger.info(`Initialized loop ${block.id} starting at iteration 1`)
     }
 
-    const currentIteration = context.loopIterations.get(block.id) || 0
+    const currentIteration = context.loopIterations.get(block.id) || 1
     let maxIterations: number
     let forEachItems: any[] | Record<string, any> | null = null
     if (loop.loopType === 'forEach') {
@@ -75,7 +73,6 @@ export class LoopBlockHandler implements BlockHandler {
         )
       }
 
-      // For forEach, max iterations = items length
       const itemsLength = Array.isArray(forEachItems)
         ? forEachItems.length
         : Object.keys(forEachItems).length
@@ -94,12 +91,9 @@ export class LoopBlockHandler implements BlockHandler {
       `Loop ${block.id} - Current iteration: ${currentIteration}, Max iterations: ${maxIterations}`
     )
 
-    // Check if we've reached the maximum iterations
-    if (currentIteration >= maxIterations) {
+    if (currentIteration > maxIterations) {
       logger.info(`Loop ${block.id} has reached maximum iterations (${maxIterations})`)
 
-      // Don't mark as completed here - let the loop manager handle it after all blocks execute
-      // Just return that this is the final iteration
       return {
         loopId: block.id,
         currentIteration: currentIteration - 1, // Report the actual last iteration number
@@ -110,28 +104,20 @@ export class LoopBlockHandler implements BlockHandler {
       } as Record<string, any>
     }
 
-    // For forEach loops, set the current item BEFORE incrementing
     if (loop.loopType === 'forEach' && forEachItems) {
-      // Store the full items array for access via <loop.items>
       context.loopItems.set(`${block.id}_items`, forEachItems)
 
+      const arrayIndex = currentIteration - 1
       const currentItem = Array.isArray(forEachItems)
-        ? forEachItems[currentIteration]
-        : Object.entries(forEachItems)[currentIteration]
+        ? forEachItems[arrayIndex]
+        : Object.entries(forEachItems)[arrayIndex]
       context.loopItems.set(block.id, currentItem)
       logger.info(
-        `Loop ${block.id} - Set current item for iteration ${currentIteration}:`,
+        `Loop ${block.id} - Set current item for iteration ${currentIteration} (index ${arrayIndex}):`,
         currentItem
       )
     }
 
-    // Increment the iteration counter for the NEXT iteration
-    // This happens AFTER we've set up the current iteration's data
-    context.loopIterations.set(block.id, currentIteration + 1)
-    logger.info(
-      `Loop ${block.id} - Incremented counter for next iteration: ${currentIteration + 1}`
-    )
-
     // Use routing strategy to determine if this block requires active path checking
     const blockType = block.metadata?.id
     if (Routing.requiresActivePathCheck(blockType || '')) {
@@ -141,12 +127,10 @@ export class LoopBlockHandler implements BlockHandler {
           isInActivePath = this.pathTracker.isInActivePath(block.id, context)
         } catch (error) {
           logger.warn(`PathTracker check failed for ${blockType} block ${block.id}:`, error)
-          // Default to true to maintain existing behavior if PathTracker fails
           isInActivePath = true
         }
       }
 
-      // Only activate child nodes if this block is in the active execution path
       if (isInActivePath) {
         this.activateChildNodes(block, context, currentIteration)
       } else {
@@ -155,17 +139,18 @@ export class LoopBlockHandler implements BlockHandler {
         )
       }
     } else {
-      // Regular blocks always activate their children
       this.activateChildNodes(block, context, currentIteration)
     }
 
+    context.loopIterations.set(block.id, currentIteration)
+
     return {
       loopId: block.id,
       currentIteration,
       maxIterations,
       loopType: loop.loopType || 'for',
       completed: false,
-      message: `Starting iteration ${currentIteration + 1} of ${maxIterations}`,
+      message: `Starting iteration ${currentIteration} of ${maxIterations}`,
     } as Record<string, any>
   }
 
@@ -177,7 +162,6 @@ export class LoopBlockHandler implements BlockHandler {
     context: ExecutionContext,
     currentIteration: number
   ): void {
-    // Loop is still active, activate the loop-start-source connection
     const loopStartConnections =
       context.workflow?.connections.filter(
         (conn) => conn.source === block.id && conn.sourceHandle === 'loop-start-source'