chore: import upstream snapshot with attribution

apps/sim/executor/utils/subflow-utils.server.ts

@@ -0,0 +1,127 @@
+import { toError } from '@sim/utils/errors'
+import { recordMaterializedAccessKeys } from '@/lib/execution/payloads/access-keys'
+import {
+  isLargeArrayManifest,
+  LARGE_ARRAY_MANIFEST_MARKER,
+  materializeLargeArrayManifest,
+} from '@/lib/execution/payloads/large-array-manifest'
+import { isLargeValueRef, LARGE_VALUE_REF_MARKER } from '@/lib/execution/payloads/large-value-ref'
+import { MAX_DURABLE_LARGE_VALUE_BYTES } from '@/lib/execution/payloads/materialization.server'
+import { materializeLargeValueRef } from '@/lib/execution/payloads/store'
+import { REFERENCE } from '@/executor/constants'
+import type { ExecutionContext } from '@/executor/types'
+import type { VariableResolver } from '@/executor/variables/resolver'
+
+async function normalizeCollectionValue(ctx: ExecutionContext, value: unknown): Promise<any[]> {
+  if (Array.isArray(value)) {
+    return value
+  }
+
+  if (isLargeArrayManifest(value)) {
+    const materialized = await materializeLargeArrayManifest(value, {
+      workspaceId: ctx.workspaceId,
+      workflowId: ctx.workflowId,
+      executionId: ctx.executionId,
+      largeValueExecutionIds: ctx.largeValueExecutionIds,
+      largeValueKeys: ctx.largeValueKeys,
+      fileKeys: ctx.fileKeys,
+      allowLargeValueWorkflowScope: ctx.allowLargeValueWorkflowScope,
+      userId: ctx.userId,
+      maxBytes: MAX_DURABLE_LARGE_VALUE_BYTES,
+    })
+    recordMaterializedAccessKeys(ctx, materialized)
+    return materialized
+  }
+
+  if (isLargeValueRef(value)) {
+    const materialized = await materializeLargeValueRef(value, {
+      workspaceId: ctx.workspaceId,
+      workflowId: ctx.workflowId,
+      executionId: ctx.executionId,
+      largeValueExecutionIds: ctx.largeValueExecutionIds,
+      largeValueKeys: ctx.largeValueKeys,
+      fileKeys: ctx.fileKeys,
+      allowLargeValueWorkflowScope: ctx.allowLargeValueWorkflowScope,
+      userId: ctx.userId,
+      maxBytes: MAX_DURABLE_LARGE_VALUE_BYTES,
+    })
+    if (materialized === undefined) {
+      throw new Error('Large execution value is unavailable.')
+    }
+    recordMaterializedAccessKeys(ctx, materialized)
+    return normalizeCollectionValue(ctx, materialized)
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    if ((value as Record<string, unknown>)[LARGE_ARRAY_MANIFEST_MARKER] === true) {
+      throw new Error('Invalid large array manifest.')
+    }
+    if ((value as Record<string, unknown>)[LARGE_VALUE_REF_MARKER] === true) {
+      throw new Error('Invalid large value ref.')
+    }
+    return Object.entries(value)
+  }
+
+  if (value === null) {
+    return []
+  }
+
+  throw new Error('Value did not resolve to an array or object')
+}
+
+/**
+ * Resolves loop/parallel collection inputs on the server, including durable
+ * execution values that cannot be imported into client-reachable utilities.
+ */
+export async function resolveArrayInputAsync(
+  ctx: ExecutionContext,
+  items: any,
+  resolver: VariableResolver | null,
+  currentNodeId = ''
+): Promise<any[]> {
+  if (typeof items !== 'string') {
+    if (items === null) {
+      return []
+    }
+    if (!Array.isArray(items) && typeof items !== 'object') {
+      if (!resolver) {
+        return []
+      }
+      try {
+        const resolved = (await resolver.resolveInputs(ctx, currentNodeId, { items })).items
+        return normalizeCollectionValue(ctx, resolved)
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith('Resolved items')) {
+          throw error
+        }
+        throw new Error(`Failed to resolve items: ${toError(error).message}`)
+      }
+    }
+    return normalizeCollectionValue(ctx, items)
+  }
+
+  if (items.startsWith(REFERENCE.START) && items.endsWith(REFERENCE.END) && resolver) {
+    try {
+      const resolved = await resolver.resolveSingleReference(ctx, currentNodeId, items, undefined, {
+        allowLargeValueRefs: true,
+      })
+      return normalizeCollectionValue(ctx, resolved)
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith('Reference "')) {
+        throw error
+      }
+      throw new Error(`Failed to resolve reference "${items}": ${toError(error).message}`)
+    }
+  }
+
+  try {
+    const normalized = items.replace(/'/g, '"')
+    const parsed = JSON.parse(normalized)
+    return normalizeCollectionValue(ctx, parsed)
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('Parsed value')) {
+      throw error
+    }
+    throw new Error(`Failed to parse items as JSON: "${items}"`)
+  }
+}