@teleporthq/teleport-plugin-next-workflows 0.45.14 → 0.45.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teleporthq/teleport-plugin-next-workflows",
-  "version": "0.45.14",
+  "version": "0.45.15",
   "description": "A plugin for workflow code generation in Next.js projects.",
   "author": "teleportHQ",
   "license": "MIT",
@@ -69,5 +69,5 @@
     "@teleporthq/teleport-shared": "^0.45.0",
     "@teleporthq/teleport-types": "^0.45.0"
   },
-  "gitHead": "c6b7eefde3d386aba19edc7ffa850879d7e1ce23"
+  "gitHead": "c93e2bd998c78f667928f7a87b6bb5175de8fea1"
 }

package/src/api-route-generator.ts

@@ -479,8 +479,8 @@ module.exports = async function handler(req, res) {
         continue;
       }
 
-      // Loop nodes must be handled specially: iterate over the collection,
-      // execute loop body nodes for each item, then continue after the loop.
+      // Loop nodes must be handled specially: run the loop body nodes once per
+      // pass of the loop type (see createLoopSteps), then continue after the loop.
       if (node.type === 'general-loop') {
         const loopEdges = SEGMENT_CONFIG.edges.filter(function(e) { return e.source === node.id; });
         const loopBodyEdge = loopEdges.find(function(e) { return e.sourceHandle === 'loop'; });
@@ -531,8 +531,9 @@ module.exports = async function handler(req, res) {
         if (!context.__loopNodeIds) context.__loopNodeIds = {};
         context.__loopNodeIds[node.id] = true;
 
-        for (var li = 0; li < collection.length; li++) {
-          context[node.id] = utils.loopIterationContext(collection, li);
+        var loopSteps = utils.createLoopSteps(node, resolved, context, collection);
+        for (var loopPass = loopSteps.next(context); loopPass; loopPass = loopSteps.next(context)) {
+          context[loopPass.key] = loopPass.value;
           for (var bi = 0; bi < bodyNodes.length; bi++) {
             var bNode = bodyNodes[bi];
             var bResolved = resolveNodeConfig(bNode, context);
@@ -561,7 +562,7 @@ module.exports = async function handler(req, res) {
 
         context.__loopScopeStack.pop();
 
-        context[node.id] = { completed: true, iterations: collection.length, results: loopResults };
+        context[node.id] = { completed: true, iterations: loopSteps.iterations(), results: loopResults };
         // Store body node IDs so the outer loop can skip them
         if (!context.__loopBodyNodeIds) context.__loopBodyNodeIds = {};
         Object.assign(context.__loopBodyNodeIds, bodyNodeIds);
@@ -916,8 +917,9 @@ module.exports = async function handler(req, res) {
         context.__loopScopeStack.push({ loopNodeId: node.id, bodyNodeIds: ssBodyNodeIds });
         if (!context.__loopNodeIds) context.__loopNodeIds = {};
         context.__loopNodeIds[node.id] = true;
-        for (var ssli = 0; ssli < ssLoopCollection.length; ssli++) {
-          context[node.id] = utils.loopIterationContext(ssLoopCollection, ssli);
+        var ssLoopSteps = utils.createLoopSteps(node, resolved, context, ssLoopCollection);
+        for (var ssLoopPass = ssLoopSteps.next(context); ssLoopPass; ssLoopPass = ssLoopSteps.next(context)) {
+          context[ssLoopPass.key] = ssLoopPass.value;
           for (var ssbi = 0; ssbi < ssBodyNodes.length; ssbi++) {
             var ssbNode = ssBodyNodes[ssbi];
             var ssbRes = resolveNodeConfig(ssbNode, context);
@@ -941,7 +943,7 @@ module.exports = async function handler(req, res) {
           }
         }
         context.__loopScopeStack.pop();
-        context[node.id] = { completed: true, iterations: ssLoopCollection.length, results: ssLoopResults };
+        context[node.id] = { completed: true, iterations: ssLoopSteps.iterations(), results: ssLoopResults };
         Object.keys(ssBodyNodeIds).forEach(function(k) { executed[k] = true; });
         executed[node.id] = true;
         if (streamStarted) {
@@ -1750,8 +1752,9 @@ ${resumeBlock}
         if (!context.__loopNodeIds) context.__loopNodeIds = {};
         context.__loopNodeIds[node.id] = true;
 
-        for (var li = 0; li < collection.length; li++) {
-          context[node.id] = utils.loopIterationContext(collection, li);
+        var loopSteps = utils.createLoopSteps(node, resolved, context, collection);
+        for (var loopPass = loopSteps.next(context); loopPass; loopPass = loopSteps.next(context)) {
+          context[loopPass.key] = loopPass.value;
           for (var bi = 0; bi < bodyNodes.length; bi++) {
             var bNode = bodyNodes[bi];
             var bResolved = resolveNodeConfig(bNode, context);
@@ -1780,7 +1783,7 @@ ${resumeBlock}
 
         context.__loopScopeStack.pop();
 
-        context[node.id] = { completed: true, iterations: collection.length, results: loopResults };
+        context[node.id] = { completed: true, iterations: loopSteps.iterations(), results: loopResults };
         if (!context.__loopBodyNodeIds) context.__loopBodyNodeIds = {};
         Object.assign(context.__loopBodyNodeIds, bodyNodeIds);
         continue;

package/src/executor-generator.ts

@@ -161,6 +161,60 @@ function loopIterationContext(collection, index) {
   };
 }
 
+// How every loop type steps, for the client executor and for each server
+// route alike. next(context) hands back what one pass publishes before its
+// body runs ({ key, value }, stored as context[key]), or null once the loop is
+// over. A collection is walked under the loop's own id; a counted or a
+// conditional loop publishes its counter under "<loopId>_iter". A while / until
+// condition is tested before every pass, against the context of that pass.
+var DEFAULT_LOOP_MAX_ITERATIONS = 1000;
+
+function createLoopSteps(loopNode, config, context, collection) {
+  var loopType = config.loopType || 'forEach';
+  var iterKey = loopNode.id + '_iter';
+  var passes = 0;
+  var next;
+  if (loopType === 'forEach' || loopType === 'map') {
+    next = function() {
+      return passes < collection.length
+        ? { key: loopNode.id, value: loopIterationContext(collection, passes) }
+        : null;
+    };
+  } else if (loopType === 'for') {
+    var cursor = Number(resolveValue(config.startIndex, context)) || 0;
+    var end = Number(resolveValue(config.endIndex, context)) || 0;
+    var step = Number(resolveValue(config.step, context)) || 1;
+    next = function() {
+      if (!(step > 0 ? cursor < end : cursor > end)) return null;
+      var index = cursor;
+      cursor += step;
+      return { key: iterKey, value: { index: index } };
+    };
+  } else {
+    var maxIterations = Number(resolveValue(config.maxIterations, context)) || DEFAULT_LOOP_MAX_ITERATIONS;
+    var authoredCondition = loopNode.config && loopNode.config.condition;
+    next = function(passContext) {
+      if (passes >= maxIterations) return null;
+      var scaffold = { iteration: passes };
+      var testContext = Object.assign({}, passContext);
+      testContext[iterKey] = scaffold;
+      var condition = resolveValue(config.condition, testContext);
+      // Only the authored condition is compiled (see runExpression).
+      var holds = runExpression(authoredCondition, condition, ['context'], [testContext], testContext);
+      if (loopType === 'until' ? holds : !holds) return null;
+      return { key: iterKey, value: scaffold };
+    };
+  }
+  return {
+    next: function(passContext) {
+      var pass = next(passContext || context);
+      if (pass) passes++;
+      return pass;
+    },
+    iterations: function() { return passes; }
+  };
+}
+
 function resolveCtxRef(ref, context) {
   var elem = context.triggerElement;
   if (!elem || typeof elem.getAttribute !== 'function') return undefined;
@@ -1496,35 +1550,15 @@ async function executeLoop(loopNode, config, allNodes, edges, context, nodeHandl
     context[loopNode.id] = loopType === 'map'
       ? { results: results, iterations: collection.length }
       : { completed: true, iterations: collection.length };
-  } else if (loopType === 'for') {
-    const start = resolveValue(config.startIndex, context) || 0;
-    const end = resolveValue(config.endIndex, context) || 0;
-    const step = resolveValue(config.step, context) || 1;
-    let count = 0;
-    for (let fi = start; step > 0 ? fi < end : fi > end; fi += step) {
-      const forCtx = Object.assign({}, context);
-      forCtx[loopNode.id + '_iter'] = { index: fi };
-      await executeNodes(bodyNodes, edges, forCtx, nodeHandlers, workflowConfig, callServerSegment, executionId);
-      Object.assign(context, forCtx);
-      count++;
-    }
-    context[loopNode.id] = { completed: true, iterations: count };
   } else {
-    const maxIter = resolveValue(config.maxIterations, context) || 1000;
-    let iter = 0;
-    while (iter < maxIter) {
-      const whileCtx = Object.assign({}, context);
-      whileCtx[loopNode.id + '_iter'] = { iteration: iter };
-      const condStr = resolveValue(config.condition, whileCtx);
-      // Only the authored condition is compiled (see runExpression).
-      const condResult = runExpression(loopNode.config && loopNode.config.condition, condStr, ['context'], [whileCtx], whileCtx);
-      if (loopType === 'while' && !condResult) break;
-      if (loopType === 'until' && condResult) break;
-      await executeNodes(bodyNodes, edges, whileCtx, nodeHandlers, workflowConfig, callServerSegment, executionId);
-      Object.assign(context, whileCtx);
-      iter++;
+    const steps = createLoopSteps(loopNode, config, context);
+    for (let pass = steps.next(context); pass; pass = steps.next(context)) {
+      const passCtx = Object.assign({}, context);
+      passCtx[pass.key] = pass.value;
+      await executeNodes(bodyNodes, edges, passCtx, nodeHandlers, workflowConfig, callServerSegment, executionId);
+      Object.assign(context, passCtx);
     }
-    context[loopNode.id] = { completed: true, iterations: iter };
+    context[loopNode.id] = { completed: true, iterations: steps.iterations() };
   }
   } finally {
     context.__loopScopeStack.pop();
@@ -1820,6 +1854,7 @@ module.exports = {
   resolveRichTextContext,
   unwrapWorkflowCollection,
   loopIterationContext,
+  createLoopSteps,
   snapshotIncomingContext,
   segmentReply,
   withoutCredentialColumns,