@bevel-software/platform-core-backend 0.29.0 → 0.30.0

package/src/modules/workflow/git/__tests__/git.service.changedPathsMemo.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { testKbContext } from '../../../../__tests__/kb-context.js';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { WorkspaceService } from '../../../workspace/workspace.service.js';
+import { WorkflowHooks } from '../../workflow-hooks.js';
+import { GitService } from '../git.service.js';
+import { WorkspaceMutex } from '../../../kb-fs/mutex.js';
+
+/**
+ * Every git process the service starts, by argv, so a test can say what a
+ * change-request read is allowed to cost. The fixture's own git runs through
+ * `execFile` and is not logged.
+ */
+const { spawnLog } = vi.hoisted(() => ({ spawnLog: [] as string[][] }));
+
+vi.mock('node:child_process', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:child_process')>();
+  const spawn = ((file: string, args: string[], options: unknown) => {
+    if (file === 'git') spawnLog.push(args ?? []);
+    return (actual.spawn as unknown as (...a: unknown[]) => unknown)(file, args, options);
+  }) as unknown as typeof actual.spawn;
+  return { ...actual, spawn };
+});
+
+const execFileAsync = promisify(execFile);
+
+async function runGit(cwd: string, args: string[]): Promise<void> {
+  await execFileAsync('git', args, {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 't@x.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 't@x.com',
+    },
+  });
+}
+
+const spawnsOf = (subcommand: string) => spawnLog.filter((argv) => argv.includes(subcommand)).length;
+
+/**
+ * What a change request's changed paths cost: the tips come from the ref
+ * files and the diff is read from git ONCE per pair of commits. A listing
+ * that nothing has moved under asks git for nothing; a push moves a tip,
+ * and that request alone is diffed again.
+ */
+describe('a change request is diffed once per pair of commits', () => {
+  let root: string;
+  let upstream: string;
+  let repo: string;
+  let other: string;
+  let svc: GitService;
+  const workspaceId = 'ws-main';
+  const secondWorkspaceId = 'ws-two';
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-changed-memo-'));
+    upstream = path.join(root, 'upstream.git');
+    await runGit(root, ['init', '--bare', '-b', 'main', upstream]);
+    const seed = path.join(root, '.seed');
+    await fs.mkdir(seed);
+    await runGit(seed, ['init', '-b', 'main']);
+    await runGit(seed, ['remote', 'add', 'origin', upstream]);
+    await fs.writeFile(path.join(seed, 'base.md'), 'base\n');
+    await runGit(seed, ['add', '-A']);
+    await runGit(seed, ['commit', '-m', 'init']);
+    await runGit(seed, ['checkout', '-b', 'feature']);
+    await fs.writeFile(path.join(seed, 'one.md'), 'one\n');
+    await runGit(seed, ['add', '-A']);
+    await runGit(seed, ['commit', '-m', 'one']);
+    await runGit(seed, ['push', 'origin', 'main', 'feature']);
+    const workspaceDir = path.join(root, workspaceId);
+    repo = path.join(workspaceDir, 'knowledge-base');
+    await fs.mkdir(workspaceDir, { recursive: true });
+    await runGit(root, ['clone', upstream, repo]);
+    other = path.join(root, 'other');
+    await runGit(root, ['clone', upstream, other]);
+    // A second workspace of the same knowledge base, with its own reservation.
+    const secondDir = path.join(root, secondWorkspaceId);
+    await fs.mkdir(secondDir, { recursive: true });
+    await runGit(root, ['clone', upstream, path.join(secondDir, 'knowledge-base')]);
+    const workspace = {
+      getWorkspacePath: async (id: string) => {
+        if (id === workspaceId) return workspaceDir;
+        if (id === secondWorkspaceId) return secondDir;
+        throw new Error(`unexpected workspace ${id}`);
+      },
+    } as unknown as WorkspaceService;
+    svc = new GitService(
+      workspace,
+      new WorkflowHooks(),
+      testKbContext({ branchModel: { defaultBranch: 'main', protectedBranches: ['main'] } }),
+      new WorkspaceMutex(),
+    );
+    spawnLog.length = 0;
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true });
+  });
+
+  it('reads the tips from the ref files, diffs once, and asks git nothing the second time', async () => {
+    const first = await svc.changedPathsAndPairsForPr(workspaceId, 'main', 'feature', { fetch: false });
+    expect(first.paths).toEqual(['one.md']);
+    expect(first.pairs).toEqual([{ path: 'one.md' }]);
+    expect(spawnsOf('diff')).toBe(1);
+    expect(spawnsOf('rev-parse')).toBe(0);
+
+    spawnLog.length = 0;
+    const second = await svc.changedPathsAndPairsForPr(workspaceId, 'main', 'feature', { fetch: false });
+    expect(second).toEqual(first);
+    expect(spawnLog).toEqual([]);
+
+    // The access-check flavour reads the same pair: the memo answers it too.
+    spawnLog.length = 0;
+    expect(await svc.changedPathsForPr(workspaceId, 'main', 'feature', { fetch: false, forAccessCheck: true })).toEqual(['one.md']);
+    expect(spawnLog).toEqual([]);
+  });
+
+  it('diffs again, once, when a push moves a tip', async () => {
+    await svc.changedPathsAndPairsForPr(workspaceId, 'main', 'feature', { fetch: false });
+    // Someone else pushes to feature; the workspace fetches as a listing's
+    // whole-clone refresh does, which rewrites the ref file.
+    await runGit(other, ['checkout', 'feature']);
+    await fs.writeFile(path.join(other, 'two.md'), 'two\n');
+    await runGit(other, ['add', '-A']);
+    await runGit(other, ['commit', '-m', 'two']);
+    await runGit(other, ['push', 'origin', 'feature']);
+    await runGit(repo, ['fetch', 'origin']);
+
+    spawnLog.length = 0;
+    const after = await svc.changedPathsAndPairsForPr(workspaceId, 'main', 'feature', { fetch: false });
+    expect(after.paths.sort()).toEqual(['one.md', 'two.md']);
+    expect(spawnsOf('diff')).toBe(1);
+    expect(spawnsOf('rev-parse')).toBe(0);
+
+    spawnLog.length = 0;
+    expect(await svc.changedPathsAndPairsForPr(workspaceId, 'main', 'feature', { fetch: false })).toEqual(after);
+    expect(spawnLog).toEqual([]);
+  });
+
+  it('shares one diff between concurrent reads of a pair nobody has seen, even from two workspaces', async () => {
+    // Two workspaces take two reservations, so nothing serialises the two
+    // reads but the in-flight diff itself: both answer, one `diff` runs.
+    const [a, b] = await Promise.all([
+      svc.changedPathsAndPairsForPr(workspaceId, 'main', 'feature', { fetch: false }),
+      svc.changedPathsAndPairsForPr(secondWorkspaceId, 'main', 'feature', { fetch: false }),
+    ]);
+    expect(a).toEqual(b);
+    expect(a.paths).toEqual(['one.md']);
+    expect(spawnsOf('diff')).toBe(1);
+  });
+
+  it('still asks git about a branch the ref files do not hold, and answers as before', async () => {
+    // A branch this clone has never fetched: the files say missing for both
+    // of its names, which is rev-parse's answer too — and `fetch: false`
+    // then turns into the per-request fetch the caller was promised.
+    await runGit(other, ['checkout', '-b', 'later']);
+    await fs.writeFile(path.join(other, 'three.md'), 'three\n');
+    await runGit(other, ['add', '-A']);
+    await runGit(other, ['commit', '-m', 'three']);
+    await runGit(other, ['push', 'origin', 'later']);
+
+    spawnLog.length = 0;
+    const got = await svc.changedPathsAndPairsForPr(workspaceId, 'main', 'later', { fetch: false });
+    expect(got.paths).toEqual(['three.md']);
+    expect(spawnsOf('fetch')).toBe(1);
+    expect(spawnsOf('diff')).toBe(1);
+  });
+});

package/src/modules/workflow/git/__tests__/git.service.worktrees.test.ts

@@ -0,0 +1,284 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { testKbContext } from '../../../../__tests__/kb-context.js';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AuthUser } from '@bevel-software/platform-shared';
+import { NodeFs } from '../../../kb-fs/node-fs.js';
+import { WorkspaceMutex } from '../../../kb-fs/mutex.js';
+import { WorkspaceService } from '../../../workspace/workspace.service.js';
+import { KbRepository, repositoryDirFor } from '../../../workspace/kb-repository.js';
+import { WorkflowHooks } from '../../workflow-hooks.js';
+import { GitService } from '../git.service.js';
+import { NodeGitRunner } from '../node-git-runner.js';
+import { workspaceIdForBranch } from '../../../../shared/workspace-id.js';
+import { newWorkspaceService } from '../../../../__tests__/workspace-service.js';
+
+/**
+ * The git layer over a knowledge base of WORKTREES of one repository: the
+ * same answers as over clones of the same remote, two worktrees committing at
+ * once, and a branch deleted while its own worktree is open. Real git.
+ */
+
+const execFileAsync = promisify(execFile);
+const TARGET = 'current-company-state';
+const ALICE: AuthUser = { id: 'u-alice', email: 'alice@example.com', name: 'Alice' };
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync('git', args, {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test', GIT_AUTHOR_EMAIL: 't@x.com',
+      GIT_COMMITTER_NAME: 'Test', GIT_COMMITTER_EMAIL: 't@x.com',
+    },
+  });
+  return stdout.toString();
+}
+
+let root: string;
+let upstream: string;
+let workspacesRoot: string;
+let workspaces: WorkspaceService;
+let gitService: GitService;
+
+beforeEach(async () => {
+  root = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-git-worktrees-'));
+  workspacesRoot = path.join(root, 'workspaces');
+  await fs.mkdir(workspacesRoot, { recursive: true });
+  upstream = path.join(root, 'upstream.git');
+  await git(root, ['init', '--bare', '-b', TARGET, upstream]);
+  const seed = path.join(root, '.seed');
+  await fs.mkdir(seed);
+  await git(seed, ['init', '-b', TARGET]);
+  await fs.writeFile(path.join(seed, 'base.md'), 'base\n');
+  await git(seed, ['add', '-A']);
+  await git(seed, ['commit', '-m', 'init']);
+  for (const draft of ['alice/a', 'bob/b']) {
+    await git(seed, ['checkout', '-q', '-b', draft, TARGET]);
+    await fs.writeFile(path.join(seed, `${draft.split('/')[0]}.md`), `${draft}\n`);
+    await git(seed, ['add', '-A']);
+    await git(seed, ['commit', '-m', `on ${draft}`]);
+  }
+  await git(seed, ['push', '-q', upstream, TARGET, 'alice/a', 'bob/b']);
+
+  const mutex = new WorkspaceMutex();
+  const runner = new NodeGitRunner();
+  const repository = new KbRepository({
+    dir: repositoryDirFor(workspacesRoot, 'knowledge-base'),
+    kbRepoUrl: () => upstream,
+    gitRunner: runner,
+  });
+  workspaces = newWorkspaceService(
+    workspacesRoot, upstream, testKbContext(), new NodeFs(), runner, undefined, undefined, repository,
+  );
+  gitService = new GitService(workspaces, new WorkflowHooks(), testKbContext(), mutex, null, runner);
+});
+
+afterEach(async () => {
+  await fs.rm(root, { recursive: true, force: true });
+});
+
+const id = (branch: string) => workspaceIdForBranch(branch);
+const checkoutOf = (branch: string) => path.join(workspacesRoot, id(branch), 'knowledge-base');
+
+describe('GitService over worktrees', () => {
+  it('lands two commits requested at the same time in two worktrees, and pushes both', async () => {
+    await workspaces.getOrCreateForBranch('alice/a');
+    await workspaces.getOrCreateForBranch('bob/b');
+    await fs.writeFile(path.join(checkoutOf('alice/a'), 'alice.md'), 'alice edits\n');
+    await fs.writeFile(path.join(checkoutOf('bob/b'), 'bob.md'), 'bob edits\n');
+
+    const [a, b] = await Promise.all([
+      gitService.commitFile(id('alice/a'), ALICE, 'knowledge-base/alice.md', 'alice edits'),
+      gitService.commitFile(id('bob/b'), ALICE, 'knowledge-base/bob.md', 'bob edits'),
+    ]);
+    expect(a).not.toBeNull();
+    expect(b).not.toBeNull();
+    await Promise.all([gitService.push(id('alice/a'), ALICE), gitService.push(id('bob/b'), ALICE)]);
+
+    expect(await git(upstream, ['show', 'alice/a:alice.md'])).toBe('alice edits\n');
+    expect(await git(upstream, ['show', 'bob/b:bob.md'])).toBe('bob edits\n');
+    // Each push left its branch tracking its own remote branch.
+    expect((await git(checkoutOf('alice/a'), ['rev-parse', '--abbrev-ref', '@{upstream}'])).trim()).toBe('origin/alice/a');
+    expect((await git(checkoutOf('bob/b'), ['status', '--porcelain'])).trim()).toBe('');
+  });
+
+  it("answers a change request's files and merges it exactly as a clone of the same remote does", async () => {
+    await workspaces.getOrCreateForBranch(TARGET);
+    await workspaces.getOrCreateForBranch('alice/a');
+    const onWorktrees = await gitService.changedFilesForPr(id(TARGET), TARGET, 'alice/a');
+
+    // The same question asked of a full clone of the same remote.
+    const cloneRoot = path.join(root, 'clones');
+    const clone = path.join(cloneRoot, id(TARGET), 'knowledge-base');
+    await fs.mkdir(path.dirname(clone), { recursive: true });
+    await git(root, ['clone', '-q', '-b', TARGET, upstream, clone]);
+    const clones = newWorkspaceService(cloneRoot, upstream, testKbContext(), new NodeFs());
+    const onClones = await new GitService(clones, new WorkflowHooks(), testKbContext()).changedFilesForPr(
+      id(TARGET), TARGET, 'alice/a',
+    );
+    expect(onWorktrees).toEqual(onClones);
+
+    await gitService.mergeChangeRequest(
+      id(TARGET), 'alice/a', TARGET, { subject: 'Merge alice/a (#1)', body: '' }, ALICE,
+    );
+    expect(await git(upstream, ['show', `${TARGET}:alice.md`])).toBe('alice/a\n');
+  });
+
+  it('deletes a branch whose own worktree is open, and removing that workspace takes the worktree and its ref', async () => {
+    await workspaces.getOrCreateForBranch(TARGET);
+    await workspaces.getOrCreateForBranch('alice/a');
+
+    await gitService.deleteBranch(id(TARGET), 'alice/a', ALICE, { systemCleanup: true });
+    await workspaces.deleteWorkspace(id('alice/a'));
+
+    await expect(git(upstream, ['rev-parse', '--verify', 'refs/heads/alice/a'])).rejects.toThrow();
+    await expect(git(workspaces.repository.dir, ['rev-parse', '--verify', 'refs/heads/alice/a'])).rejects.toThrow();
+    await expect(fs.access(checkoutOf('alice/a'))).rejects.toThrow();
+    expect((await git(checkoutOf(TARGET), ['status', '--porcelain'])).trim()).toBe('');
+  });
+
+  it("finishes a branch's first open raced by git operations on that branch, and a fetch joined from inside one", async () => {
+    // The first request for a branch fans out: the page opens the workspace
+    // while the git layer asks for its status — inside the branch's
+    // reservation, resolving the same workspace — and a listing fetches.
+    // The worktree add waits for running git operations, and they wait for
+    // the open: nothing may wait for itself.
+    await workspaces.getOrCreateForBranch(TARGET);
+    const all = Promise.all([
+      workspaces.getOrCreateForBranch('bob/b'),
+      gitService.status(id('bob/b')),
+      gitService.listBranches(id(TARGET), { freshFetch: true }),
+      gitService.status(id('bob/b')),
+    ]);
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      await Promise.race([
+        all,
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => reject(new Error('deadlocked')), 20_000);
+        }),
+      ]);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+    }
+    expect((await git(checkoutOf('bob/b'), ['rev-parse', '--abbrev-ref', 'HEAD'])).trim()).toBe('bob/b');
+  });
+
+  it('lists branches from one fetch of the repository, strictly', async () => {
+    await workspaces.getOrCreateForBranch(TARGET);
+    const branches = await gitService.listBranches(id(TARGET), { freshFetch: true, strictFetch: true });
+    expect(branches.map((b) => b.name).sort()).toEqual(['alice/a', 'bob/b', TARGET].sort());
+    expect(gitService.lastRemoteContact()?.ok).toBe(true);
+  });
+
+  it("does not list another worktree's local branch once origin no longer has it, so the orphan sweep can take it", async () => {
+    await workspaces.getOrCreateForBranch(TARGET);
+    await workspaces.getOrCreateForBranch('bob/b');
+    // Deleted on the host while its worktree stays open: the repository
+    // still holds bob/b's local ref, as bob's clone held it.
+    await git(upstream, ['branch', '-D', 'bob/b']);
+
+    const fromTarget = await gitService.listBranches(id(TARGET), { freshFetch: true, strictFetch: true });
+    expect(fromTarget.map((b) => b.name).sort()).toEqual(['alice/a', TARGET].sort());
+    // A clone never saw another branch's local ref either: listed from its
+    // own worktree, a branch is its own.
+    const fromBob = await gitService.listBranches(id('bob/b'), { freshFetch: true });
+    expect(fromBob.find((b) => b.name === 'bob/b')?.hasRemote).toBe(false);
+
+    const { removed } = await workspaces.sweepOrphanedWorkspaces(fromTarget.map((b) => b.name));
+    expect(removed).toEqual([id('bob/b')]);
+    await expect(git(workspaces.repository.dir, ['rev-parse', '--verify', 'refs/heads/bob/b'])).rejects.toThrow();
+  });
+});
+
+describe('GitService and the repository administrator', () => {
+  /** The repository, noting whether its administrator's section is held while git runs. */
+  class RecordingRepository extends KbRepository {
+    depth = 0;
+    override exclusive<T>(fn: () => Promise<T>): Promise<T> {
+      return super.exclusive(async () => {
+        this.depth += 1;
+        try { return await fn(); } finally { this.depth -= 1; }
+      });
+    }
+  }
+
+  it('writes the shared config as the administrator, and runs everything else as itself', async () => {
+    const mutex = new WorkspaceMutex();
+    const runner = new NodeGitRunner();
+    const repository = new RecordingRepository({
+      dir: repositoryDirFor(workspacesRoot, 'knowledge-base'),
+      kbRepoUrl: () => upstream,
+      gitRunner: runner,
+    });
+    const recorded = newWorkspaceService(
+      workspacesRoot, upstream, testKbContext(), new NodeFs(), runner, undefined, undefined, repository,
+    );
+    const calls: { args: string[]; held: boolean }[] = [];
+    const recordingRunner = {
+      defaultTimeoutMs: runner.defaultTimeoutMs,
+      credentials: runner.credentials,
+      run: ((cwd: string, args: string[], opts?: never) => {
+        calls.push({ args, held: repository.depth > 0 });
+        return runner.run(cwd, args, opts);
+      }) as NodeGitRunner['run'],
+    };
+    const service = new GitService(recorded, new WorkflowHooks(), testKbContext(), mutex, null, recordingRunner);
+    await recorded.getOrCreateForBranch(TARGET);
+    await recorded.getOrCreateForBranch('alice/a');
+
+    await service.fetch(id(TARGET));
+    await service.changedFilesForPr(id(TARGET), TARGET, 'alice/a');
+    await fs.writeFile(path.join(checkoutOf('alice/a'), 'alice.md'), 'alice edits\n');
+    await service.commitFile(id('alice/a'), ALICE, 'knowledge-base/alice.md', 'alice edits');
+    await service.push(id('alice/a'), ALICE);
+    await service.status(id('alice/a'));
+    // A merge stamps the committer's name and email into the config.
+    const merged = await service.mergeChangeRequest(
+      id(TARGET), 'alice/a', TARGET, { subject: 'alice edits (#1)', body: '' }, ALICE,
+    );
+    expect(merged.kind).toBe('merged');
+    await service.deleteBranch(id(TARGET), 'alice/a', ALICE, { systemCleanup: true });
+
+    // The subcommand, past leading `-c key=value` / `-C dir` options.
+    const sub = (args: string[]) => {
+      let i = 0;
+      while (args[i] === '-c' || args[i] === '-C') i += 2;
+      return { name: args[i], rest: args.slice(i + 1) };
+    };
+    const of = (pred: (s: { name: string; rest: string[] }) => boolean) => calls.filter((c) => pred(sub(c.args)));
+
+    // The config is the one file git refuses a second writer of: every write
+    // to it (the upstream stamp, the committer's name and email, a branch
+    // delete that drops the branch's section) is the administrator's. The
+    // refs, packed-refs and the objects git locks itself, so a fetch, a
+    // commit, a push, a merge and a read run as any worktree's git would.
+    const configRead = (rest: string[]) => rest.some((a) => /^(--get|--get-all|--get-regexp|--list|-l)$/.test(a));
+    const shared = [
+      ...of((s) => s.name === 'config' && !configRead(s.rest)),
+      ...of((s) => s.name === 'branch' && s.rest.some((a) => a === '-D' || a === '-d')),
+    ];
+    const own = [
+      ...of((s) => s.name === 'fetch'),
+      ...of((s) => s.name === 'commit'),
+      ...of((s) => s.name === 'merge'),
+      ...of((s) => s.name === 'push' && !s.rest.includes('-u')),
+      ...of((s) => s.name === 'status'),
+      ...of((s) => s.name === 'config' && configRead(s.rest)),
+    ];
+    for (const name of ['fetch', 'config', 'commit', 'merge', 'push', 'status']) {
+      expect(calls.some((c) => sub(c.args).name === name), name).toBe(true);
+    }
+    expect(of((s) => s.name === 'config' && s.rest.includes('--replace-all')).length).toBeGreaterThan(0);
+    expect(of((s) => s.name === 'config' && s.rest[0] === 'user.name').length).toBeGreaterThan(0);
+    expect(of((s) => s.name === 'config' && s.rest[0] === 'user.email').length).toBeGreaterThan(0);
+    expect(of((s) => s.name === 'branch' && s.rest.some((a) => a === '-D' || a === '-d')).length).toBeGreaterThan(0);
+    expect(shared.length).toBeGreaterThan(3);
+    for (const c of shared) expect(c.held, c.args.join(' ')).toBe(true);
+    for (const c of own) expect(c.held, c.args.join(' ')).toBe(false);
+  });
+});