@bevel-software/platform-core-backend 0.6.0 → 0.7.0

package/src/modules/workflow/__tests__/workflow.service.deleted-branch-sweep.test.ts

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { configureBranchModel } from '@bevel-software/platform-shared';
+import type { GitService } from '../git/git.service.js';
+import type { PullRequestService } from '../git/pull-request.service.js';
+import type { IReviewWorkflowService } from '../review-workflow/review-workflow.interface.js';
+import type { WorkspaceService } from '../../workspace/workspace.service.js';
+import type { IAccessControl } from '../../access/access-control.interface.js';
+import type { FileLockService } from '../file-lock.service.js';
+import type { PendingCommitsService } from '../pending-commits.service.js';
+import type { Database } from '../../database/connection.js';
+import { WorkflowService } from '../workflow.service.js';
+
+/**
+ * `closeChangeRequestsWithDeletedBranches` — the boot sweep that retires
+ * change requests whose branch is gone.
+ *
+ * Everything here is about NOT closing the wrong thing. A change request is
+ * somebody's proposal and the row is the only surviving evidence of it once
+ * the branch has been deleted, so the interesting cases are the ones where
+ * the sweep must keep its hands off.
+ */
+
+interface OpenRow {
+  number: number;
+  sourceBranch: string;
+}
+
+/**
+ * DB stub: `select().from().where()` resolves the open rows, and
+ * `update().set().where().returning()` records each close and reports one
+ * affected row (the guarded update succeeding).
+ */
+function makeDb(open: OpenRow[], closedOut: number[]) {
+  const db = {
+    select: () => ({ from: () => ({ where: async () => open }) }),
+    update: () => ({
+      set: () => ({
+        where: (cond: unknown) => ({
+          returning: async () => {
+            // The number is not recoverable from the drizzle condition object,
+            // so the caller records it via the `onClose` hook below instead.
+            void cond;
+            return [{ id: 'row' }];
+          },
+        }),
+      }),
+    }),
+  };
+  void closedOut;
+  return db as unknown as Database;
+}
+
+function makeService(open: OpenRow[], listBranches: () => Promise<{ name: string }[]>) {
+  const invalidated: number[] = [];
+  const emitted: unknown[] = [];
+  const git = { listBranches: vi.fn(listBranches) } as unknown as GitService;
+  const prs = {
+    invalidateDetailCache: vi.fn((n: number) => invalidated.push(n)),
+  } as unknown as PullRequestService;
+  const svc = new WorkflowService(
+    makeDb(open, []),
+    git,
+    prs,
+    {} as IReviewWorkflowService,
+    {} as WorkspaceService,
+    {} as IAccessControl,
+    {} as FileLockService,
+    {} as PendingCommitsService,
+    'knowledge-base',
+  );
+  (svc as unknown as { events?: { emit(e: unknown): void } }).events = {
+    emit: (e: unknown) => emitted.push(e),
+  };
+  return { svc, git, invalidated, emitted };
+}
+
+beforeEach(() => {
+  configureBranchModel({
+    defaultBranch: 'target-company-state',
+    protectedBranches: ['current-company-state', 'target-company-state'],
+  });
+});
+
+describe('closeChangeRequestsWithDeletedBranches', () => {
+  it('closes a request whose source branch is gone', async () => {
+    const { svc, invalidated, emitted } = makeService(
+      [{ number: 7, sourceBranch: 'demo2' }],
+      async () => [{ name: 'target-company-state' }, { name: 'alice/live-work' }],
+    );
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(1);
+    // The open lists cache per request; a closed one has to drop out of them.
+    expect(invalidated).toEqual([7]);
+    expect(emitted).toEqual([{ kind: 'change-request-rejected', number: 7 }]);
+  });
+
+  it('leaves a request whose branch still exists', async () => {
+    const { svc, invalidated } = makeService(
+      [{ number: 7, sourceBranch: 'alice/live-work' }],
+      async () => [{ name: 'target-company-state' }, { name: 'alice/live-work' }],
+    );
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(0);
+    expect(invalidated).toEqual([]);
+  });
+
+  /**
+   * The reason the verdict comes from `listBranches({ freshFetch: true })`
+   * rather than from the `unknown branch` error the open-list already throws:
+   * that error means "missing from THIS workspace's refs", which a clone that
+   * never fetched somebody else's branch reports identically. Only origin can
+   * answer the question being asked.
+   */
+  it('asks for a FRESH fetch, so origin decides rather than a stale clone', async () => {
+    const { svc, git } = makeService([{ number: 7, sourceBranch: 'x' }], async () => [
+      { name: 'x' },
+    ]);
+    await svc.closeChangeRequestsWithDeletedBranches();
+    expect(git.listBranches).toHaveBeenCalledWith('target-company-state', { freshFetch: true });
+  });
+
+  /**
+   * "Could not reach origin" and "the branch was deleted" are indistinguishable
+   * from in here, and only one of them is a reason to close somebody's
+   * proposal. So a failure closes NOTHING — the sweep runs again next boot.
+   */
+  it('closes nothing when the branch list cannot be fetched', async () => {
+    const { svc, invalidated } = makeService(
+      [{ number: 7, sourceBranch: 'demo2' }],
+      async () => {
+        throw new Error('origin unreachable');
+      },
+    );
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(0);
+    expect(invalidated).toEqual([]);
+  });
+
+  /**
+   * An empty branch list means the clone is broken, not that every branch in
+   * the repository was deleted at once — and acting on it would close EVERY
+   * open request in one pass. The most destructive possible reading of an
+   * ambiguous signal, so it is refused explicitly.
+   */
+  it('closes nothing when the branch list comes back empty', async () => {
+    const { svc, invalidated } = makeService(
+      [
+        { number: 7, sourceBranch: 'demo2' },
+        { number: 8, sourceBranch: 'other' },
+      ],
+      async () => [],
+    );
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(0);
+    expect(invalidated).toEqual([]);
+  });
+
+  it('does not fetch at all when nothing is open', async () => {
+    const { svc, git } = makeService([], async () => [{ name: 'target-company-state' }]);
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(0);
+    expect(git.listBranches).not.toHaveBeenCalled();
+  });
+
+  it('closes several in one pass and leaves the live ones', async () => {
+    const { svc, invalidated } = makeService(
+      [
+        { number: 1, sourceBranch: 'juan/onboarding-import-mr92q9vx4a9e' },
+        { number: 3, sourceBranch: 'juan-legal-test-cr' },
+        { number: 7, sourceBranch: 'demo2' },
+        { number: 9, sourceBranch: 'alice/live-work' },
+      ],
+      async () => [{ name: 'target-company-state' }, { name: 'alice/live-work' }],
+    );
+    await expect(svc.closeChangeRequestsWithDeletedBranches()).resolves.toBe(3);
+    expect(invalidated).toEqual([1, 3, 7]);
+  });
+});

package/src/modules/workflow/workflow.service.ts

@@ -41,7 +41,7 @@ import type {
   OpenChangeRequestInput,
   PostChangeRequestCommentInput,
 } from '@bevel-software/platform-shared';
-import { isProtectedBranch } from '@bevel-software/platform-shared';
+import { isProtectedBranch, DEFAULT_BRANCH } from '@bevel-software/platform-shared';
 import { and, eq } from 'drizzle-orm';
 import type { Database } from '../database/connection.js';
 import { changeRequests } from '../database/schema.js';
@@ -1536,6 +1536,86 @@ export class WorkflowService implements IWorkflowService {
     return true;
   }
 
+  /**
+   * Close every open change request whose source branch no longer exists.
+   *
+   * A change request is a proposal to merge a branch. When that branch is
+   * gone — deleted after a manual merge, pruned as abandoned, or left behind
+   * by a feature that has itself been removed — the request cannot be read,
+   * reviewed, applied or declined. It is not a pending decision, it is a
+   * tombstone, and it costs more than tidiness: `listOpenPrs` resolves each
+   * open request's changed paths, so every one of these throws
+   * `unknown branch` on every poll, filling the log and slowing the list it
+   * appears in.
+   *
+   * CLOSED, NOT DELETED. The row is evidence — who proposed what, when, and
+   * that it was never applied — and it is the only remaining trace once the
+   * branch is gone. Closing takes it out of every open list (which is the
+   * whole visible problem) while a `state = 'closed'` row can still be read,
+   * counted, and reopened by hand. Deleting would make this sweep the one
+   * operation in the workflow that destroys history without a human asking.
+   *
+   * ONE fetch, then a set lookup. The freshness matters more than the cost:
+   * `changedPathsForPr` fails when the branch is missing from THAT
+   * workspace's refs, which is not the same thing as missing from origin —
+   * a clone that never fetched a branch someone else created reports exactly
+   * the same error. Closing on that signal would eat live requests. So the
+   * verdict comes from `listBranches({ freshFetch: true })`, which fetches
+   * with prune and unions local heads with origin's, on a single workspace.
+   *
+   * Fails SAFE: any error listing branches abandons the sweep entirely rather
+   * than closing anything, because "I could not reach origin" and "the branch
+   * is gone" are indistinguishable from the inside and only one of them is a
+   * reason to act.
+   *
+   * Returns how many it closed.
+   */
+  async closeChangeRequestsWithDeletedBranches(): Promise<number> {
+    const open = await this.db
+      .select({ number: changeRequests.number, sourceBranch: changeRequests.sourceBranch })
+      .from(changeRequests)
+      .where(eq(changeRequests.state, 'open'));
+    if (open.length === 0) return 0;
+
+    let live: Set<string>;
+    try {
+      const branches = await this.git.listBranches(workspaceIdForBranch(DEFAULT_BRANCH), {
+        freshFetch: true,
+      });
+      live = new Set(branches.map((b) => b.name));
+    } catch (err) {
+      console.warn('[cr] branch sweep skipped — could not list branches:', err);
+      return 0;
+    }
+    // An empty branch list means something is wrong with the clone, not that
+    // every branch in the repo was deleted at once. Refuse to act on it.
+    if (live.size === 0) {
+      console.warn('[cr] branch sweep skipped — branch list came back empty');
+      return 0;
+    }
+
+    let closed = 0;
+    for (const cr of open) {
+      if (live.has(cr.sourceBranch)) continue;
+      const now = new Date();
+      // Guarded on `state = 'open'`, so a merge or withdraw racing this call
+      // wins and this becomes a no-op.
+      const updated = await this.db
+        .update(changeRequests)
+        .set({ state: 'closed', closedAt: now, updatedAt: now })
+        .where(and(eq(changeRequests.number, cr.number), eq(changeRequests.state, 'open')))
+        .returning({ id: changeRequests.id });
+      if (updated.length === 0) continue;
+      this.prs.invalidateDetailCache(cr.number);
+      this.events?.emit({ kind: 'change-request-rejected', number: cr.number });
+      console.log(
+        `[cr] closed change request #${cr.number}: source branch "${cr.sourceBranch}" no longer exists`,
+      );
+      closed++;
+    }
+    return closed;
+  }
+
   /**
    * Reject (close-without-merging) a change request. Per PLAN.md spec, the
    * authorized set is: