Function lintFile

packages/cli/src/commands/lint.ts:169–244

(path: string | undefined, options: LintOptions)

}

async function lintFile(path: string | undefined, options: LintOptions): Promise<LintFileResult> {
  // Loading `.env` and injecting integration env vars mutates `process.env`; restore it afterwards
  // so a lint run is idempotent and doesn't clobber caller-provided env values (see withRestoredEnv).
  return withRestoredEnv(async () => {
    const { absolutePath } = await resolvePathToDeepnoteFile(path)
    const fileDir = dirname(absolutePath)

    const { file: deepnoteFile, warnings } = await loadAndResolveDeepnoteFile(absolutePath)
    emitInitResolverWarnings(warnings, options.output === 'json')

    // Load .env file so env: references in integrations can be resolved
    dotenv.config({ path: join(fileDir, DEFAULT_ENV_FILE), quiet: true })

    // Load and parse integrations file
    const integrationsFilePath = options.integrationsFile ?? getDefaultIntegrationsFilePath(fileDir)

    // If the user explicitly specified an integrations file, fail loudly when it's missing
    // (an absent implicit default file is fine — integrations are optional in that case).
    if (options.integrationsFile) {
      try {
        await fs.stat(integrationsFilePath)
      } catch (error) {
        if (isErrnoENOENT(error)) {
          throw new FileResolutionError(`File not found: ${integrationsFilePath}`)
        }
        throw error
      }
    }

    debug(`Loading integrations from: ${integrationsFilePath}`)
    const parsedIntegrations = await parseIntegrationsFile(integrationsFilePath)

    debug(`Parsed ${parsedIntegrations.integrations.length} integrations, ${parsedIntegrations.issues.length} issues`)

    // Generate integration env vars and inject them into process.env so checkMissingIntegrations
    // works correctly. Generation failures (e.g. invalid BigQuery/Spanner service_account JSON) are
    // surfaced as configuration issues so a schema-valid-but-impossible to generate integration doesn't lint green.
    const integrationsIssues = [...parsedIntegrations.issues]
    if (parsedIntegrations.integrations.length > 0) {
      const { envVars, issues } = generateIntegrationEnvVars(parsedIntegrations.integrations, fileDir)
      integrationsIssues.push(...issues)
      for (const { name, value } of envVars) {
        process.env[name] = value
      }
      debug(
        `Injected ${envVars.length} environment variables for ${parsedIntegrations.integrations.length} integrations`
      )
    }

    debug(`Analyzing blocks...`)
    const pythonInterpreter = options.python ? await resolvePythonExecutable(options.python) : undefined
    const { lint } = await checkForIssues(deepnoteFile, {
      notebook: options.notebook,
      pythonInterpreter,
    })

    // Integration/config issues are hard errors (no severity field), so fold their count into
    // both `errors` and `total` to keep `issueCount` consistent with `success` and the reported