Method resolveAsync

apps/sim/executor/variables/resolvers/block.ts:151–218

(reference: string, context: ResolutionContext)

  }

  async resolveAsync(reference: string, context: ResolutionContext): Promise<any> {
    if (!this.navigatePathAsync) {
      return this.resolve(reference, context)
    }
    const parts = parseReferencePath(reference)
    if (parts.length === 0) {
      return undefined
    }
    const [blockName, ...pathParts] = parts

    const blockId = this.findBlockIdByName(blockName)
    if (!blockId) {
      return undefined
    }

    const block = this.blockById.get(blockId)!
    const output = this.getBlockOutput(blockId, context)

    const blockData: Record<string, unknown> = {}
    const blockOutputSchemas: Record<string, OutputSchema> = {}

    if (output !== undefined) {
      blockData[blockId] = output
    }

    const outputSchema = getBlockSchema(block)

    if (outputSchema && Object.keys(outputSchema).length > 0) {
      blockOutputSchemas[blockId] = outputSchema
    }

    try {
      const blockReferenceContext = {
        blockNameMapping: Object.fromEntries(this.nameToBlockId),
        blockData,
        blockOutputSchemas,
      }
      const result = (await resolveBlockReferenceAsync(
        blockName,
        pathParts,
        blockReferenceContext,
        context,
        this.navigatePathAsync
      ))!

      if (result.value !== undefined) {
        if (!context.allowLargeValueRefs) {
          assertNoLargeValueRefs(result.value)
        }
        return result.value
      }

      const backwardsCompat = await this.handleBackwardsCompat(block, output, pathParts, context)
      if (backwardsCompat !== undefined) {
        return backwardsCompat
      }

      return RESOLVED_EMPTY