Function getBlockDependencies

packages/reactivity/src/ast-analyzer.ts:74–136

(
  blocks: DeepnoteBlock[],
  options: { pythonInterpreter?: string } = {}
)

 * Intentionally mixing Python and SQL blocks here because we want to use just one local process invocation.
 */
export async function getBlockDependencies(
  blocks: DeepnoteBlock[],
  options: { pythonInterpreter?: string } = {}
): Promise<BlockContentDepsWithOrder[]> {
  const { pythonInterpreter = 'python3' } = options

  const blocksNeedingComputation = blocks
    // Process only supported cell types
    .filter(block => SUPPORTED_CELL_TYPES.has(block.type))
    // Format blocks for parser
    .map(block => ({
      ...block,
      content: block.content ?? '',
    }))

  // Early return if no blocks need computation
  if (blocksNeedingComputation.length === 0) {
    return []
  }

  try {
    const inputData = JSON.stringify({ blocks: blocksNeedingComputation })

    const scriptPath = path.join(_dirname, 'scripts', 'ast-analyzer.py')
    const outputData = await safelyCallChildProcessWithInputOutput(pythonInterpreter, [scriptPath], inputData)

    const json = JSON.parse(outputData)
    const parsed = await AstAnalyzerResponseSchema.safeParseAsync(json)
    if (!parsed.success) {
      throw new AstAnalyzerInternalError(
        `Internal parser error: unexpected output format from AST analyzer, ${parsed.error.message}`
      )
    }

    const parsedData = parsed.data

    if (Array.isArray(parsedData)) {
      const resultWithOrder = parsedData.map(block => ({
        ...block,
        order: blocks.findIndex(b => b.id === block.id),
      }))

      return resultWithOrder
    }

    if (typeof parsedData === 'object' && parsedData !== null && 'errorMessage' in parsedData) {
      const errorMessage = (parsedData as { errorMessage: string }).errorMessage
      throw new AstAnalyzerInternalError(
        `Could not build a dependency graph for this notebook due to errors in the code: ${errorMessage}`
      )
    }

    throw new AstAnalyzerInternalError('Internal parser error: malformed analyzer output.')
  } catch (error) {
    if (error instanceof AstAnalyzerInternalError) {
      throw error
    }