sailfork / t3code-github / .repos/ effect/ packages/ tools/ api-diff/ src/ Worktrees.ts

import * as Console from "effect/Console"
import * as Context from "effect/Context"
import * as Effect from "effect/Effect"
import * as FileSystem from "effect/FileSystem"
import * as Layer from "effect/Layer"
import * as Path from "effect/Path"
import * as ChildProcess from "effect/process/ChildProcess"
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"
import * as Stream from "effect/Stream"
import { ApiDiffError, isApiDiffError } from "./Error.ts"
import { decodeJson } from "./Json.ts"
import type { ApiSnapshot } from "./Model.ts"
import { snapshotCacheKey, Snapshotter } from "./Snapshot.ts"

export interface PrepareSnapshotOptions {
  readonly repoRoot: string
  readonly cacheRoot: string
  readonly worktreesRoot: string
  readonly name: "base" | "head"
  readonly ref: string
  readonly sha: string
  readonly modules?: ReadonlyArray<string>
}

export class Worktrees extends Context.Service<Worktrees, {
  readonly resolveRef: (repoRoot: string, ref: string) => Effect.Effect<string, ApiDiffError>
  readonly prepareSnapshot: (options: PrepareSnapshotOptions) => Effect.Effect<ApiSnapshot, ApiDiffError>
}>()("@effect/api-diff/Worktrees") {
  static readonly layerNoDependencies = Layer.effect(
    Worktrees,
    Effect.gen(function*() {
      const fs = yield* FileSystem.FileSystem
      const path = yield* Path.Path
      const snapshotter = yield* Snapshotter
      const spawner = yield* ChildProcessSpawner.ChildProcessSpawner

      const runCommandScoped = Effect.fnUntraced(function*(
        command: string,
        args: ReadonlyArray<string>,
        cwd: string
      ) {
        const display = `${command} ${args.join(" ")}`
        const handle = yield* spawner.spawn(
          ChildProcess.make(command, args, { cwd })
        ).pipe(
          Effect.mapError((cause) =>
            new ApiDiffError({
              message: `Could not start command (${display})`,
              cause
            })
          )
        )
        const [output, exitCode] = yield* Effect.all([
          Stream.mkString(Stream.decodeText(handle.all)),
          handle.exitCode
        ], { concurrency: "unbounded" }).pipe(
          Effect.mapError((cause) =>
            new ApiDiffError({
              message: `Could not run command (${display})`,
              cause
            })
          )
        )
        return { display, exitCode, output }
      })

      const runCommand = (
        command: string,
        args: ReadonlyArray<string>,
        cwd: string
      ): Effect.Effect<{
        readonly display: string
        readonly exitCode: ChildProcessSpawner.ExitCode
        readonly output: string
      }, ApiDiffError> => Effect.scoped(runCommandScoped(command, args, cwd))

      const runChecked = Effect.fnUntraced(function*(
        command: string,
        args: ReadonlyArray<string>,
        cwd: string
      ) {
        const result = yield* runCommand(command, args, cwd)
        if (result.exitCode !== ChildProcessSpawner.ExitCode(0)) {
          return yield* new ApiDiffError({
            message: `Command failed (${result.display}):\n${result.output}`.trim()
          })
        }
        return result.output.trim()
      })

      const enableStripInternal = Effect.fnUntraced(function*(worktree: string) {
        const baseConfig = path.join(worktree, "tsconfig.base.json")
        if (!(yield* fs.exists(baseConfig))) {
          return
        }
        const source = yield* fs.readFileString(baseConfig)
        if (/"stripInternal"\s*:\s*true/.test(source)) {
          return
        }
        const updated = source.replace(/("stripInternal"\s*:\s*)false/, "$1true")
        if (updated !== source) {
          yield* fs.writeFileString(baseConfig, updated)
        }
      })

      const hasProductionStripInternal = Effect.fnUntraced(function*(worktree: string) {
        const candidates = [
          path.join(worktree, "tsconfig.base.json"),
          path.join(worktree, "tsconfig.build.json"),
          path.join(worktree, "packages", "effect", "tsconfig.build.json")
        ]
        for (const candidate of candidates) {
          if ((yield* fs.exists(candidate)) && /"stripInternal"\s*:\s*true/.test(yield* fs.readFileString(candidate))) {
            return true
          }
        }
        return false
      })

      const buildWorktree = Effect.fnUntraced(function*(worktree: string) {
        yield* enableStripInternal(worktree)
        if (!(yield* hasProductionStripInternal(worktree))) {
          return yield* new ApiDiffError({
            message: `No production TypeScript configuration enables stripInternal in ${worktree}`
          })
        }
        // Native test-only dependencies in old branches may not build on the
        // current Node runtime. Declaration emission does not require dependency lifecycle scripts.
        yield* runChecked("pnpm", ["install", "--frozen-lockfile", "--ignore-scripts"], worktree)
        yield* runChecked("pnpm", ["build"], worktree)
      })

      const removeWorktree = (repoRoot: string, worktree: string): Effect.Effect<void> =>
        runCommand("git", ["worktree", "remove", "--force", worktree], repoRoot).pipe(
          Effect.flatMap((result) =>
            result.exitCode === ChildProcessSpawner.ExitCode(0)
              ? Effect.void
              : Console.error(result.output)
          ),
          Effect.catch((error) => Console.error(error.message))
        )

      const resolveRef = Effect.fnUntraced(function*(repoRoot: string, ref: string) {
        return yield* runChecked("git", ["rev-parse", "--verify", `${ref}^{commit}`], repoRoot)
      })

      const prepareSnapshotInternal = Effect.fnUntraced(function*(options: PrepareSnapshotOptions) {
        const key = snapshotCacheKey(options.sha, options.modules)
        const cacheLocation = path.join(options.cacheRoot, key, "snapshot.json")
        if (yield* fs.exists(cacheLocation)) {
          const source = yield* fs.readFileString(cacheLocation).pipe(
            Effect.mapError((cause) =>
              new ApiDiffError({
                message: `Could not read cached snapshot ${cacheLocation}`,
                cause
              })
            )
          )
          const cached = (yield* decodeJson(source).pipe(
            Effect.mapError((cause) =>
              new ApiDiffError({
                message: `Could not parse cached snapshot ${cacheLocation}`,
                cause
              })
            )
          )) as ApiSnapshot
          return { ...cached, ref: options.ref, sha: options.sha }
        }

        yield* fs.makeDirectory(options.worktreesRoot, { recursive: true })
        return yield* Effect.scoped(Effect.gen(function*() {
          const runRoot = yield* fs.makeTempDirectoryScoped({
            directory: options.worktreesRoot,
            prefix: `${options.name}-`
          })
          const worktree = path.join(runRoot, "repo")
          return yield* Effect.acquireUseRelease(
            runChecked("git", ["worktree", "add", "--detach", worktree, options.sha], options.repoRoot),
            () =>
              Effect.gen(function*() {
                yield* buildWorktree(worktree)
                const snapshot = yield* snapshotter.extract({
                  repoRoot: worktree,
                  ref: options.ref,
                  sha: options.sha,
                  ...(options.modules === undefined ? {} : { modules: options.modules })
                }).pipe(
                  Effect.mapError((cause) =>
                    isApiDiffError(cause)
                      ? cause
                      : new ApiDiffError({
                        message: `Could not extract the ${options.name} API snapshot`,
                        cause
                      })
                  )
                )
                let encoded: string | undefined
                try {
                  encoded = JSON.stringify(snapshot)
                } catch {
                  encoded = undefined
                }
                if (encoded !== undefined) {
                  yield* fs.makeDirectory(path.dirname(cacheLocation), { recursive: true })
                  yield* fs.writeFileString(cacheLocation, encoded).pipe(
                    Effect.mapError((cause) =>
                      new ApiDiffError({
                        message: `Could not cache the ${options.name} API snapshot`,
                        cause
                      })
                    )
                  )
                }
                return snapshot
              }),
            () => removeWorktree(options.repoRoot, worktree)
          )
        }))
      })

      const prepareSnapshot = (options: PrepareSnapshotOptions): Effect.Effect<ApiSnapshot, ApiDiffError> =>
        prepareSnapshotInternal(options).pipe(
          Effect.mapError((cause) =>
            isApiDiffError(cause)
              ? cause
              : new ApiDiffError({
                message: `Could not prepare the ${options.name} API snapshot`,
                cause
              })
          )
        )

      return Worktrees.of({
        prepareSnapshot,
        resolveRef
      })
    })
  )

  static readonly layer = this.layerNoDependencies.pipe(
    Layer.provide(Snapshotter.layer)
  )
}