chore: import upstream snapshot with attribution

apps/sim/executor/variables/resolvers/reference-async.server.ts

@@ -0,0 +1,229 @@
+import { isUserFileWithMetadata } from '@/lib/core/utils/user-file'
+import { recordMaterializedAccessKeys } from '@/lib/execution/payloads/access-keys'
+import {
+  isLargeArrayManifest,
+  type LargeArrayManifest,
+  readLargeArrayManifestSlice,
+} from '@/lib/execution/payloads/large-array-manifest'
+import {
+  assertNoLargeValueRefs,
+  getLargeValueMaterializationError,
+  isLargeValueRef,
+} from '@/lib/execution/payloads/large-value-ref'
+import { materializeLargeValueRef } from '@/lib/execution/payloads/store'
+import { hydrateUserFileWithBase64 } from '@/lib/uploads/utils/user-file-base64.server'
+import type { PathNavigationContext } from '@/executor/variables/resolvers/reference'
+
+interface MaterializedNavigationValue {
+  value: unknown
+  context: PathNavigationContext
+}
+
+function withLocalLargeValueExecutionIds(
+  context: PathNavigationContext,
+  materializedValue: unknown
+): PathNavigationContext {
+  if (!context.executionContext) {
+    return context
+  }
+  recordMaterializedAccessKeys(context.executionContext, materializedValue)
+  return {
+    ...context,
+    executionContext: {
+      ...context.executionContext,
+      largeValueKeys: context.executionContext.largeValueKeys,
+      fileKeys: context.executionContext.fileKeys,
+    },
+  }
+}
+
+async function materializeLargeValueRefOrThrow(
+  value: unknown,
+  context: PathNavigationContext
+): Promise<MaterializedNavigationValue> {
+  if (!isLargeValueRef(value)) {
+    return { value, context }
+  }
+  const materialized = await materializeLargeValueRef(value, {
+    workspaceId: context.executionContext.workspaceId,
+    workflowId: context.executionContext.workflowId,
+    executionId: context.executionContext.executionId,
+    largeValueExecutionIds: context.executionContext.largeValueExecutionIds,
+    largeValueKeys: context.executionContext.largeValueKeys,
+    fileKeys: context.executionContext.fileKeys,
+    allowLargeValueWorkflowScope: context.executionContext.allowLargeValueWorkflowScope,
+    userId: context.executionContext.userId,
+  })
+  if (materialized === undefined) {
+    throw getLargeValueMaterializationError(value)
+  }
+  return {
+    value: materialized,
+    context: withLocalLargeValueExecutionIds(context, materialized),
+  }
+}
+
+async function hydrateExplicitBase64(
+  file: unknown,
+  context: PathNavigationContext
+): Promise<string | undefined> {
+  if (!isUserFileWithMetadata(file)) {
+    return undefined
+  }
+  const hydrated = await hydrateUserFileWithBase64(file, {
+    requestId: context.executionContext.metadata?.requestId,
+    workspaceId: context.executionContext.workspaceId,
+    workflowId: context.executionContext.workflowId,
+    executionId: context.executionContext.executionId,
+    largeValueExecutionIds: context.executionContext.largeValueExecutionIds,
+    largeValueKeys: context.executionContext.largeValueKeys,
+    fileKeys: context.executionContext.fileKeys,
+    allowLargeValueWorkflowScope: context.executionContext.allowLargeValueWorkflowScope,
+    userId: context.executionContext.userId,
+    maxBytes: context.executionContext.base64MaxBytes,
+  })
+  if (!hydrated.base64) {
+    throw new Error(
+      `Base64 content for ${file.name} is unavailable or exceeds the configured inline limit.`
+    )
+  }
+  return hydrated.base64
+}
+
+async function readManifestIndexAsync(
+  value: LargeArrayManifest,
+  part: string,
+  context: PathNavigationContext
+): Promise<unknown> {
+  const [item] = await readLargeArrayManifestSlice(value, Number.parseInt(part, 10), 1, {
+    workspaceId: context.executionContext.workspaceId,
+    workflowId: context.executionContext.workflowId,
+    executionId: context.executionContext.executionId,
+    largeValueExecutionIds: context.executionContext.largeValueExecutionIds,
+    largeValueKeys: context.executionContext.largeValueKeys,
+    allowLargeValueWorkflowScope: context.executionContext.allowLargeValueWorkflowScope,
+    userId: context.executionContext.userId,
+  })
+  return item
+}
+
+async function navigateManifestMetadataOrIndexAsync(
+  value: unknown,
+  part: string,
+  context: PathNavigationContext
+): Promise<MaterializedNavigationValue> {
+  if (!isLargeArrayManifest(value)) {
+    return { value: undefined, context }
+  }
+  if (part === 'length' || part === 'totalCount') {
+    return { value: value.totalCount, context }
+  }
+  if (part === 'chunkCount' || part === 'byteSize' || part === 'preview') {
+    return { value: value[part], context: withLocalLargeValueExecutionIds(context, value[part]) }
+  }
+  if (/^\d+$/.test(part)) {
+    const item = await readManifestIndexAsync(value, part, context)
+    return {
+      value: item,
+      context: withLocalLargeValueExecutionIds(context, item),
+    }
+  }
+  return { value: undefined, context }
+}
+
+/**
+ * Server-side path navigation used during execution. It can hydrate persisted
+ * large values and UserFile.base64 only when the requested path explicitly asks
+ * for base64.
+ */
+export async function navigatePathAsync(
+  obj: any,
+  path: string[],
+  context: PathNavigationContext
+): Promise<any> {
+  let current = obj
+  let currentContext = context
+  for (const part of path) {
+    ;({ value: current, context: currentContext } = await materializeLargeValueRefOrThrow(
+      current,
+      currentContext
+    ))
+
+    if (current === null || current === undefined) {
+      return undefined
+    }
+
+    if (part === 'base64') {
+      const base64 = await hydrateExplicitBase64(current, currentContext)
+      if (base64 !== undefined) {
+        current = base64
+        continue
+      }
+    }
+
+    if (isLargeArrayManifest(current)) {
+      ;({ value: current, context: currentContext } = await navigateManifestMetadataOrIndexAsync(
+        current,
+        part,
+        currentContext
+      ))
+      continue
+    }
+
+    const arrayMatch = part.match(/^([^[]+)(\[.+)$/)
+    if (arrayMatch) {
+      const [, prop, bracketsPart] = arrayMatch
+      current =
+        typeof current === 'object' && current !== null
+          ? (current as Record<string, unknown>)[prop]
+          : undefined
+      ;({ value: current, context: currentContext } = await materializeLargeValueRefOrThrow(
+        current,
+        currentContext
+      ))
+      if (current === undefined || current === null) {
+        return undefined
+      }
+
+      const indices = bracketsPart.match(/\[(\d+)\]/g)
+      if (indices) {
+        for (const indexMatch of indices) {
+          ;({ value: current, context: currentContext } = await materializeLargeValueRefOrThrow(
+            current,
+            currentContext
+          ))
+          if (current === null || current === undefined) {
+            return undefined
+          }
+          const idx = Number.parseInt(indexMatch.slice(1, -1), 10)
+          if (isLargeArrayManifest(current)) {
+            ;({ value: current, context: currentContext } =
+              await navigateManifestMetadataOrIndexAsync(current, String(idx), currentContext))
+          } else {
+            current = Array.isArray(current) ? current[idx] : undefined
+          }
+        }
+      }
+    } else if (/^\d+$/.test(part)) {
+      const index = Number.parseInt(part, 10)
+      if (isLargeArrayManifest(current)) {
+        ;({ value: current, context: currentContext } = await navigateManifestMetadataOrIndexAsync(
+          current,
+          part,
+          currentContext
+        ))
+      } else {
+        current = Array.isArray(current) ? current[index] : undefined
+      }
+    } else {
+      current =
+        typeof current === 'object' && current !== null
+          ? (current as Record<string, unknown>)[part]
+          : undefined
+    }
+  }
+  if (!context.allowLargeValueRefs) {
+    assertNoLargeValueRefs(current)
+  }
+  return current
+}