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

package/__tests__/cron-route-loop-templateparams.test.ts

@@ -6,6 +6,7 @@
 // fields and its loop body would never run.
 import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
 import { generateCronAPIRoute } from '../src/api-route-generator'
+import { generateServerRuntimeCode } from '../src/server-runtime-code'
 
 const TRIGGER_ID = 'cron-1'
 const SCAN_ID = 'scan-1'
@@ -124,10 +125,10 @@ describe('generateCronAPIRoute — loop + templateParams support', () => {
   })
 
   it('uses the loop-capable executor (handles general-loop body discovery)', () => {
-    // The shared execution loop keys the loop body off the 'loop' sourceHandle
-    // and walks 'loop-body-out' edges — markers absent from the old naive loop.
-    expect(route).toContain("e.sourceHandle === 'loop'")
-    expect(route).toContain('loop-body-out')
+    // The route runs a loop through the server runtime, which finds its body
+    // by walking from the 'loop' edge up to the loop-back edge.
+    expect(route).toContain('utils.runServerLoop(node, resolved, sortedNodes, ')
+    expect(generateServerRuntimeCode()).toContain('utils.getLoopBodyNodeIds(loopNode.id, edges)')
   })
 
   it('merges templateParams into email body + subject', () => {

package/__tests__/custom-js-loop-scope.test.ts

@@ -1,6 +1,7 @@
 import { generateServerSegmentAPIRoute, generateSharedRuntimeUtilsCode } from '../src'
 import type { WorkflowSegment } from '../src/types'
 import { loadHandler, HandlerFn } from './_helpers/load-handler'
+import { generateServerRuntimeCode } from '../src/server-runtime-code'
 
 // Regression guard for the "loop body custom-js sees the wrong innerParams"
 // bug.
@@ -500,16 +501,20 @@ describe('runtime emission — loop scope stack is pushed and popped', () => {
   })
 
   it('pushes a loop scope before iterating and pops after', () => {
+    // The route hands its loops to runServerLoop, which manages the stack.
     const route = generateServerSegmentAPIRoute(buildSegment())
-    expect(route).toMatch(
-      /context\.__loopScopeStack\.push\(\{\s*loopNodeId:\s*node\.id,\s*bodyNodeIds:\s*bodyNodeIds\s*\}\)/
+    expect(route).toContain('utils.runServerLoop(node, resolved, sortedNodes, ')
+    const runtime = generateServerRuntimeCode()
+    expect(runtime).toMatch(
+      /context\.__loopScopeStack\.push\(\{\s*loopNodeId:\s*loopNode\.id,\s*bodyNodeIds:\s*bodyNodeIds\s*\}\)/
     )
-    expect(route).toContain('context.__loopScopeStack.pop();')
+    expect(runtime).toContain('context.__loopScopeStack.pop();')
   })
 
   it('initialises __loopScopeStack lazily (does not assume caller seeded it)', () => {
-    const route = generateServerSegmentAPIRoute(buildSegment())
-    expect(route).toMatch(/if \(!context\.__loopScopeStack\) context\.__loopScopeStack = \[\];/)
+    expect(generateServerRuntimeCode()).toMatch(
+      /if \(!context\.__loopScopeStack\) context\.__loopScopeStack = \[\];/
+    )
   })
 })
 

package/__tests__/loop-collection-unwrap.test.ts

@@ -1,5 +1,6 @@
 import { generateSharedRuntimeUtilsCode, generateServerSegmentAPIRoute } from '../src'
 import type { WorkflowSegment } from '../src/types'
+import { generateServerRuntimeCode } from '../src/server-runtime-code'
 
 // Regression guard for the "loop iterates 0 times even though the
 // upstream node returned data" bug.
@@ -317,8 +318,12 @@ describe('every loop emit site routes through unwrapWorkflowCollection', () => {
   })
 
   it('regular server segment uses utils.unwrapWorkflowCollection for the loop collection', () => {
+    // Every server route runs its loops through runServerLoop, which unwraps.
     const src = generateServerSegmentAPIRoute(buildLoopSegment(), 'T')
-    expect(src).toContain('utils.unwrapWorkflowCollection(resolved.collection)')
+    expect(src).toContain('utils.runServerLoop(node, resolved, sortedNodes, ')
+    expect(generateServerRuntimeCode()).toContain(
+      'utils.unwrapWorkflowCollection(config.collection)'
+    )
   })
 
   it('client-side runtime uses unwrapWorkflowCollection in executeLoop', () => {

package/__tests__/server-loop-body-branches.test.ts

@@ -0,0 +1,188 @@
+import {
+  generateCronAPIRoute,
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+} from '../src/api-route-generator'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+import { withEnv } from './_helpers/fake-fetch'
+
+/**
+ * An if-statement inside a loop body takes one branch per pass. The server
+ * routes ran the body as a flat list, so both branches ran on every pass.
+ * Each route kind runs a four-pass loop whose body branches on the pass index.
+ */
+
+const LOOP_ID = 'loop-1'
+const IF_ID = 'if-1'
+const HIGH_ID = 'high-1'
+const LOW_ID = 'low-1'
+const AFTER_ID = 'after-1'
+const ITER_ID = LOOP_ID + '_iter'
+const RUNS_KEY = '__serverLoopBranchRuns'
+
+const runs = (): string[] => (globalThis as Record<string, any>)[RUNS_KEY] || []
+
+const recordingNode = (id: string, stepNumber: number) => ({
+  id,
+  type: 'general-custom-js',
+  config: {
+    code: [
+      'function customHandler() {',
+      `  globalThis.${RUNS_KEY} = (globalThis.${RUNS_KEY} || []).concat('${id}');`,
+      '  return { ok: true };',
+      '}',
+    ].join('\n'),
+    context: 'server',
+  },
+  stepNumber,
+  label: id,
+})
+
+const nodes = [
+  {
+    id: LOOP_ID,
+    type: 'general-loop',
+    config: { loopType: 'for', endIndex: 4 },
+    stepNumber: 1,
+    label: 'Loop',
+  },
+  {
+    id: IF_ID,
+    type: 'general-if-statement',
+    config: {
+      conditionType: 'simple-comparison',
+      leftValue: { type: 'workflowContext', nodeId: ITER_ID, path: [ITER_ID, 'index'] },
+      operator: '>=',
+      rightValue: 2,
+    },
+    stepNumber: 2,
+    label: 'Index Is High',
+  },
+  recordingNode(HIGH_ID, 3),
+  recordingNode(LOW_ID, 4),
+  recordingNode(AFTER_ID, 5),
+]
+
+const edges = [
+  { id: 'e1', source: LOOP_ID, target: IF_ID, sourceHandle: 'loop', targetHandle: 'loop-body-in' },
+  { id: 'e2', source: IF_ID, target: HIGH_ID, sourceHandle: 'true' },
+  { id: 'e3', source: IF_ID, target: LOW_ID, sourceHandle: 'false' },
+  {
+    id: 'e4',
+    source: HIGH_ID,
+    target: LOOP_ID,
+    sourceHandle: 'loop-body-out',
+    targetHandle: 'loop-back',
+  },
+  {
+    id: 'e5',
+    source: LOW_ID,
+    target: LOOP_ID,
+    sourceHandle: 'loop-body-out',
+    targetHandle: 'loop-back',
+  },
+  { id: 'e6', source: LOOP_ID, target: AFTER_ID, sourceHandle: 'exit' },
+]
+
+const ONE_BRANCH_PER_PASS = [LOW_ID, LOW_ID, HIGH_ID, HIGH_ID, AFTER_ID]
+
+const requireRuntime = () => {
+  const runtime = loadServerRuntime()
+  return (id: string): unknown => {
+    if (id.endsWith('/utils/workflows/server-runtime')) {
+      return runtime
+    }
+    throw new Error('Unexpected require: ' + id)
+  }
+}
+
+const bootRoute = (source: string) => {
+  const routeModule: { exports: any } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', source)(
+    routeModule,
+    routeModule.exports,
+    requireRuntime()
+  )
+  return routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+}
+
+const jsonReply = () => {
+  const reply = { status: 0, body: undefined as any }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  return { reply, res }
+}
+
+const segment = {
+  id: 'seg-loop-branches',
+  env: 'server',
+  nodeIds: nodes.map((node) => node.id),
+  nodes,
+  edges,
+} as unknown as WorkflowSegment
+
+beforeEach(() => {
+  delete (globalThis as Record<string, any>)[RUNS_KEY]
+})
+
+afterAll(() => {
+  delete (globalThis as Record<string, any>)[RUNS_KEY]
+})
+
+describe.each<[string, () => string]>([
+  ['a server segment route', () => generateServerSegmentAPIRoute(segment)],
+  ['a streaming server segment route', () => generateStreamingServerSegmentAPIRoute(segment)],
+])('%s runs one branch of a loop body per pass', (_route, generate) => {
+  it('skips the branch the if-statement did not take, on that pass only', async () => {
+    const handler = bootRoute(generate())
+    const { reply, res } = jsonReply()
+
+    await handler({ method: 'POST', body: { context: {} }, headers: { host: 'site.example' } }, res)
+
+    expect(reply.status).toBe(200)
+    expect(runs()).toEqual(ONE_BRANCH_PER_PASS)
+  })
+})
+
+describe('a scheduled route runs one branch of a loop body per pass', () => {
+  it('skips the branch the if-statement did not take, on that pass only', async () => {
+    const workflow: any = {
+      id: 'wf-scheduled-loop-branches',
+      name: 'Scheduled Loop Branches',
+      trigger: {
+        type: 'event-cron-triggered',
+        nodeId: 't',
+        scope: 'global',
+        config: { schedule: '5 * * * *', urlPath: 'cron_loop_branches' },
+      },
+      nodes,
+      edges: [{ id: 'e0', source: 't', target: LOOP_ID }, ...edges],
+    }
+    const handler = bootRoute(generateCronAPIRoute(workflow, undefined as never))
+    const { reply, res } = jsonReply()
+    const req = {
+      method: 'POST',
+      url: '/api/workflows/cron_loop_branches',
+      headers: { host: 'site.example', 'x-forwarded-proto': 'https' },
+      body: {},
+    }
+
+    await withEnv({ TELEPORT_CRON_ALLOW_UNSIGNED: 'true', TELEPORT_CRON_SECRET: undefined }, () =>
+      handler(req, res)
+    )
+
+    expect(reply.status).toBe(200)
+    expect(runs()).toEqual(ONE_BRANCH_PER_PASS)
+  })
+})

package/__tests__/server-loop-types.test.ts

@@ -0,0 +1,371 @@
+import {
+  generateCronAPIRoute,
+  generateServerSegmentAPIRoute,
+  generateStreamingServerSegmentAPIRoute,
+} from '../src/api-route-generator'
+import { generateSharedRuntimeUtilsCode } from '../src/executor-generator'
+import type { WorkflowSegment } from '../src/types'
+import { loadServerRuntime } from './_helpers/load-server-runtime'
+import { withEnv } from './_helpers/fake-fetch'
+
+/**
+ * A loop steps by its loopType wherever it runs. The server routes walked
+ * `collection` for every type, so a for, while or until loop whose body ran on
+ * the server made no pass at all. Each route kind is booted here and run with
+ * every loop type, next to the client executor running the same loops.
+ */
+
+const LOOP_ID = 'loop-1'
+const BODY_ID = 'body-1'
+const ITER_ID = LOOP_ID + '_iter'
+const PASSES_KEY = '__serverLoopTypePasses'
+
+const passes = (): number => (globalThis as Record<string, any>)[PASSES_KEY] || 0
+
+const COUNT_PASSES_CODE = [
+  'function customHandler() {',
+  `  globalThis.${PASSES_KEY} = (globalThis.${PASSES_KEY} || 0) + 1;`,
+  `  return { n: globalThis.${PASSES_KEY} };`,
+  '}',
+].join('\n')
+
+const loopEdges = [
+  {
+    id: 'e1',
+    source: LOOP_ID,
+    target: BODY_ID,
+    sourceHandle: 'loop',
+    targetHandle: 'loop-body-in',
+  },
+  {
+    id: 'e2',
+    source: BODY_ID,
+    target: LOOP_ID,
+    sourceHandle: 'loop-body-out',
+    targetHandle: 'loop-back',
+  },
+]
+
+const loopNode = (config: Record<string, unknown>) => ({
+  id: LOOP_ID,
+  type: 'general-loop',
+  config,
+  stepNumber: 1,
+  label: 'Loop',
+})
+
+const countingBody = () => ({
+  id: BODY_ID,
+  type: 'general-custom-js',
+  config: { code: COUNT_PASSES_CODE, context: 'server' },
+  stepNumber: 2,
+  label: 'Count The Pass',
+})
+
+const BODY_RAN_FEWER_THAN_THREE_TIMES = `!context['${BODY_ID}'] || context['${BODY_ID}'].n < 3`
+const BODY_RAN_THREE_TIMES = `!!context['${BODY_ID}'] && context['${BODY_ID}'].n >= 3`
+
+interface LoopCase {
+  name: string
+  config: Record<string, unknown>
+  expectedPasses: number
+}
+
+const NON_COLLECTION_LOOPS: LoopCase[] = [
+  {
+    name: 'a for loop up to endIndex',
+    config: { loopType: 'for', endIndex: 4 },
+    expectedPasses: 4,
+  },
+  {
+    name: 'a for loop from startIndex by step',
+    config: { loopType: 'for', startIndex: 2, endIndex: 9, step: 3 },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a for loop counting down',
+    config: { loopType: 'for', startIndex: 3, endIndex: 0, step: -1 },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a for loop whose bounds arrive as text',
+    config: { loopType: 'for', startIndex: '0', endIndex: '3' },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a while loop, its condition read again before every pass',
+    config: { loopType: 'while', condition: BODY_RAN_FEWER_THAN_THREE_TIMES },
+    expectedPasses: 3,
+  },
+  {
+    name: 'an until loop, its condition read again before every pass',
+    config: { loopType: 'until', condition: BODY_RAN_THREE_TIMES },
+    expectedPasses: 3,
+  },
+  {
+    name: 'a while loop that never ends, stopped at maxIterations',
+    config: { loopType: 'while', condition: 'true', maxIterations: 7 },
+    expectedPasses: 7,
+  },
+  {
+    name: 'an until loop that never ends, stopped at the default cap',
+    config: { loopType: 'until', condition: 'false' },
+    expectedPasses: 1000,
+  },
+]
+
+const NON_COLLECTION_LOOP_ROWS = NON_COLLECTION_LOOPS.map(
+  (loop): [string, Record<string, unknown>, number] => [loop.name, loop.config, loop.expectedPasses]
+)
+
+const requireRuntime = (extra: Record<string, unknown> = {}) => {
+  const runtime = loadServerRuntime()
+  return (id: string): unknown => {
+    if (id.endsWith('/utils/workflows/server-runtime')) {
+      return runtime
+    }
+    const known = Object.keys(extra).find((suffix) => id.endsWith(suffix))
+    if (known) {
+      return extra[known]
+    }
+    throw new Error('Unexpected require: ' + id)
+  }
+}
+
+const bootRoute = (source: string, requireFn: (id: string) => unknown) => {
+  const routeModule: { exports: any } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', 'require', source)(routeModule, routeModule.exports, requireFn)
+  return routeModule.exports as (req: unknown, res: unknown) => Promise<void>
+}
+
+const jsonReply = () => {
+  const reply = { status: 0, body: undefined as any }
+  const res = {
+    status(code: number) {
+      reply.status = code
+      return this
+    },
+    json(payload: unknown) {
+      reply.body = payload
+      return this
+    },
+    setHeader: (): void => undefined,
+  }
+  return { reply, res }
+}
+
+const segmentOf = (config: Record<string, unknown>): WorkflowSegment =>
+  ({
+    id: 'seg-loop',
+    env: 'server',
+    nodeIds: [LOOP_ID, BODY_ID],
+    nodes: [loopNode(config), countingBody()],
+    edges: loopEdges,
+  } as unknown as WorkflowSegment)
+
+type SegmentRouteGenerator = (segment: WorkflowSegment) => string
+
+const runSegmentRoute = async (
+  generate: SegmentRouteGenerator,
+  config: Record<string, unknown>
+) => {
+  const handler = bootRoute(generate(segmentOf(config)), requireRuntime())
+  const { reply, res } = jsonReply()
+  await handler({ method: 'POST', body: { context: {} }, headers: { host: 'site.example' } }, res)
+  return reply
+}
+
+const scheduledWorkflow = (
+  config: Record<string, unknown>,
+  body: Record<string, unknown>
+): any => ({
+  id: 'wf-scheduled-loop',
+  name: 'Scheduled Loop',
+  trigger: {
+    type: 'event-cron-triggered',
+    nodeId: 't',
+    scope: 'global',
+    config: { schedule: '5 * * * *', urlPath: 'cron_loop' },
+  },
+  nodes: [loopNode(config), body],
+  edges: [{ id: 'e0', source: 't', target: LOOP_ID }, ...loopEdges],
+})
+
+const runScheduledRoute = async (
+  workflow: any,
+  customNodes?: Record<string, unknown>,
+  customNodeModule: Record<string, unknown> = {}
+) => {
+  const handler = bootRoute(
+    generateCronAPIRoute(workflow, customNodes as never),
+    requireRuntime({ '/utils/workflows/custom-nodes': customNodeModule })
+  )
+  const { reply, res } = jsonReply()
+  const req = {
+    method: 'POST',
+    url: '/api/workflows/cron_loop',
+    headers: { host: 'site.example', 'x-forwarded-proto': 'https' },
+    body: {},
+  }
+  await withEnv({ TELEPORT_CRON_ALLOW_UNSIGNED: 'true', TELEPORT_CRON_SECRET: undefined }, () =>
+    handler(req, res)
+  )
+  return reply
+}
+
+const runOnClient = async (config: Record<string, unknown>) => {
+  const shared: { exports: Record<string, any> } = { exports: {} }
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval
+  new Function('module', 'exports', generateSharedRuntimeUtilsCode())(shared, shared.exports)
+  const context: Record<string, any> = {}
+  let ran = 0
+  const handlers = {
+    'general-custom-js': async () => {
+      ran++
+      return { n: ran }
+    },
+  }
+  await shared.exports.executeNodes(
+    [loopNode(config), countingBody()],
+    loopEdges,
+    context,
+    handlers,
+    {},
+    null,
+    'exec-1'
+  )
+  return { ran, context }
+}
+
+beforeEach(() => {
+  delete (globalThis as Record<string, any>)[PASSES_KEY]
+})
+
+afterAll(() => {
+  delete (globalThis as Record<string, any>)[PASSES_KEY]
+})
+
+describe.each<[string, SegmentRouteGenerator]>([
+  ['a server segment route', (segment) => generateServerSegmentAPIRoute(segment)],
+  [
+    'a streaming server segment route',
+    (segment) => generateStreamingServerSegmentAPIRoute(segment),
+  ],
+])('%s steps a loop by its type', (_route, generate) => {
+  it.each(NON_COLLECTION_LOOP_ROWS)('runs %s', async (_name, config, expectedPasses) => {
+    const reply = await runSegmentRoute(generate, config)
+
+    expect(reply.status).toBe(200)
+    expect(passes()).toBe(expectedPasses)
+    expect(reply.body.results[LOOP_ID]).toEqual({
+      completed: true,
+      iterations: expectedPasses,
+      results: [],
+    })
+  })
+
+  it('still walks the collection of a forEach and a map loop', async () => {
+    const forEach = await runSegmentRoute(generate, { loopType: 'forEach', collection: ['a', 'b'] })
+    expect(passes()).toBe(2)
+    expect(forEach.body.results[LOOP_ID]).toEqual({ completed: true, iterations: 2, results: [] })
+
+    const map = await runSegmentRoute(generate, { loopType: 'map', collection: ['a', 'b', 'c'] })
+    expect(passes()).toBe(5)
+    expect(map.body.results[LOOP_ID]).toEqual({
+      completed: true,
+      iterations: 3,
+      results: [{ n: 3 }, { n: 4 }, { n: 5 }],
+    })
+  })
+})
+
+describe('a scheduled route steps a loop by its type', () => {
+  it.each(NON_COLLECTION_LOOP_ROWS)('runs %s', async (_name, config, expectedPasses) => {
+    const reply = await runScheduledRoute(scheduledWorkflow(config, countingBody()))
+
+    expect(reply.status).toBe(200)
+    expect(passes()).toBe(expectedPasses)
+  })
+
+  const customNodeBody = (parameters: Record<string, unknown>) => ({
+    id: BODY_ID,
+    type: 'general-custom-node',
+    config: { customNodeId: 'cn-record', parameters },
+    stepNumber: 2,
+    label: 'Record The Pass',
+  })
+  const customNodes: Record<string, unknown> = {
+    'cn-record': { id: 'cn-record', name: 'Record', nodes: [], edges: [] },
+  }
+  const iterationRef = (field: string) => ({
+    type: 'workflowContext',
+    nodeId: ITER_ID,
+    path: [ITER_ID, field],
+  })
+  const recordingModule = () => {
+    const seen: unknown[] = []
+    const module = {
+      'cn-record': async (_context: unknown, parameters: unknown) => {
+        seen.push(parameters)
+        return { n: seen.length }
+      },
+    }
+    return { seen, module }
+  }
+
+  it('hands a for loop body the index of its pass', async () => {
+    const { seen, module } = recordingModule()
+    const workflow = scheduledWorkflow(
+      { loopType: 'for', startIndex: 1, endIndex: 7, step: 2 },
+      customNodeBody({ index: iterationRef('index') })
+    )
+
+    const reply = await runScheduledRoute(workflow, customNodes, module)
+
+    expect(reply.status).toBe(200)
+    expect(seen).toEqual([{ index: 1 }, { index: 3 }, { index: 5 }])
+  })
+
+  it('hands a while loop body the number of its pass, and its condition too', async () => {
+    const { seen, module } = recordingModule()
+    const workflow = scheduledWorkflow(
+      { loopType: 'while', condition: `context['${ITER_ID}'].iteration < 2` },
+      customNodeBody({ iteration: iterationRef('iteration') })
+    )
+
+    const reply = await runScheduledRoute(workflow, customNodes, module)
+
+    expect(reply.status).toBe(200)
+    expect(seen).toEqual([{ iteration: 0 }, { iteration: 1 }])
+  })
+
+  it('still hands a forEach loop body the item of its pass', async () => {
+    const { seen, module } = recordingModule()
+    const workflow = scheduledWorkflow(
+      { loopType: 'forEach', collection: [{ id: 'a' }, { id: 'b' }] },
+      customNodeBody({
+        id: { type: 'workflowContext', nodeId: LOOP_ID, path: [LOOP_ID, 'currentItem', 'id'] },
+        index: { type: 'workflowContext', nodeId: LOOP_ID, path: [LOOP_ID, 'index'] },
+        isLast: { type: 'workflowContext', nodeId: LOOP_ID, path: [LOOP_ID, 'isLast'] },
+      })
+    )
+
+    const reply = await runScheduledRoute(workflow, customNodes, module)
+
+    expect(reply.status).toBe(200)
+    expect(seen).toEqual([
+      { id: 'a', index: 0, isLast: false },
+      { id: 'b', index: 1, isLast: true },
+    ])
+  })
+})
+
+describe('the client executor and the server routes make the same passes', () => {
+  it.each(NON_COLLECTION_LOOP_ROWS)('for %s', async (_name, config, expectedPasses) => {
+    const client = await runOnClient(config)
+
+    expect(client.ran).toBe(expectedPasses)
+    expect(client.context[LOOP_ID]).toEqual({ completed: true, iterations: expectedPasses })
+  })
+})