@bevel-software/platform-core-backend 0.35.0 → 0.37.0

package/src/modules/version-control/__tests__/public-surface.test.ts

@@ -0,0 +1,114 @@
+import type express from 'express';
+import { describe, expect, it } from 'vitest';
+import {
+  isUserScoped,
+  isWorkspaceScoped,
+  type IVersionControlService,
+  type VersionControlEventPayload,
+} from '@bevel-software/platform-shared';
+import type { IAccessControl } from '../../access/index.js';
+import type { AuthService } from '../../auth/index.js';
+import type { WorkspaceService } from '../../workspace/index.js';
+import {
+  createEventsRoutes,
+  createVersionControlRoutes,
+  VersionControlEventBus,
+  type IEventDelivery,
+} from '../index.js';
+
+/**
+ * The module's name is internal; what it mounts is not. The frontend, the
+ * enterprise and customer scripts call these paths, and every open tab
+ * switches on these event kinds, so a rename of the module must move none of
+ * them. The `/workflow/` prefix stays until a core major.
+ */
+
+type Layer = { route?: { path: string; methods: Record<string, boolean> } };
+
+function routesOf(router: express.Router): string[] {
+  return (router.stack as Layer[]).flatMap((layer) =>
+    layer.route ? Object.keys(layer.route.methods).map((m) => `${m.toUpperCase()} ${layer.route!.path}`) : [],
+  );
+}
+
+const VERSION_CONTROL_ROUTES = [
+  'GET /workspace/:id/workflow/branches',
+  'POST /workspace/:id/workflow/branches',
+  'DELETE /workspace/:id/workflow/branches/:name',
+  'GET /workspace/:id/workflow/branch-status',
+  'POST /workspace/:id/workflow/share',
+  'POST /workspace/:id/workflow/refresh-remotes',
+  'POST /workspace/:id/workflow/update-from-remote',
+  'GET /workspace/:id/workflow/fork-base',
+  'GET /workspace/:id/workflow/pending-changes',
+  'POST /workspace/:id/workflow/changes',
+  'GET /workspace/:id/workflow/changes',
+  'GET /workspace/:id/workflow/compare-file',
+  'GET /workspace/:id/workflow/show-file',
+  'GET /workspace/:id/workflow/file-at-change',
+  'POST /workspace/:id/workflow/locks',
+  'DELETE /workspace/:id/workflow/locks',
+  'POST /workspace/:id/workflow/locks/checkpoint',
+  'POST /workspace/:id/workflow/locks/heartbeat',
+  'GET /workspace/:id/workflow/locks',
+  'GET /workflow/change-requests',
+  'GET /workflow/change-requests/mine',
+  'GET /workflow/change-requests/for-me',
+  'GET /workflow/change-requests/under-folder',
+  'POST /workflow/change-requests/under-folder/remove',
+  'GET /workflow/change-requests/:number',
+  'GET /workflow/change-requests/:number/detail',
+  'DELETE /workflow/change-requests/:number',
+  'PATCH /workflow/change-requests/:number',
+  'POST /workflow/change-requests/:number/files/revert',
+  'POST /workflow/change-requests',
+  'POST /workflow/change-requests/:number/update-from-target',
+  'GET /workflow/change-requests/:number/fork-point-file',
+  'POST /workflow/change-requests/:number/files/approve',
+  'DELETE /workflow/change-requests/:number/files/approve',
+  'POST /workflow/change-requests/:number/reject',
+  'POST /workflow/change-requests/:number/merge',
+];
+
+/** The kinds the delivery filters scope by name; every other kind is broadcast. */
+const WORKSPACE_SCOPED_KINDS = [
+  'file-changed',
+  'lock-acquired',
+  'lock-released',
+  'fs-tree-changed',
+  'document-unreadable',
+  'git-sync-failed',
+  'git-sync-recovered',
+];
+const USER_SCOPED_KINDS = ['agent-tool-call', 'agent-connected', 'branch-switched', 'change-request-merge-failed'];
+
+describe('version-control public surface', () => {
+  it('mounts every REST route at the path it had before the module was renamed', () => {
+    const router = createVersionControlRoutes(
+      {} as IVersionControlService,
+      {} as WorkspaceService,
+      {} as AuthService,
+      new VersionControlEventBus(),
+      {} as IAccessControl,
+      'knowledge-base',
+    );
+    expect(routesOf(router)).toEqual(VERSION_CONTROL_ROUTES);
+  });
+
+  it('mounts the live-event stream at /events', () => {
+    const router = createEventsRoutes(new VersionControlEventBus(), (_req, _res, next) => next(), {} as IEventDelivery);
+    expect(routesOf(router)).toEqual(['GET /events', 'POST /events/:sessionId/focus']);
+  });
+
+  it('scopes the workspace and user SSE event kinds by the names they had before the module was renamed', () => {
+    // Through the shared contract's exported scope rule: a kind renamed there
+    // stops being scoped and the filters would broadcast it. The broadcast
+    // kinds are a type-only union, held by the typecheck of the code that emits them.
+    const scopeOf = (kind: string) => {
+      const event = { kind } as VersionControlEventPayload;
+      return isWorkspaceScoped(event) ? 'workspace' : isUserScoped(event) ? 'user' : 'broadcast';
+    };
+    expect(WORKSPACE_SCOPED_KINDS.map(scopeOf)).toEqual(WORKSPACE_SCOPED_KINDS.map(() => 'workspace'));
+    expect(USER_SCOPED_KINDS.map(scopeOf)).toEqual(USER_SCOPED_KINDS.map(() => 'user'));
+  });
+});

package/src/modules/{workflow/__tests__/workflow.routes.folder-proposals.test.ts → version-control/__tests__/version-control.routes.folder-proposals.test.ts}

@@ -2,13 +2,13 @@ import type { Server } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import express from 'express';
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import type { AuthUser, IWorkflowService } from '@bevel-software/platform-shared';
+import type { AuthUser, IVersionControlService } from '@bevel-software/platform-shared';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import type { AuthService } from '../../auth/auth.service.js';
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import { WorkflowEventBus } from '../event-bus.js';
-import { WorkflowDomainError } from '../../../shared/domain-errors.js';
-import { createWorkflowRoutes } from '../workflow.routes.js';
+import { VersionControlEventBus } from '../event-bus.js';
+import { VersionControlDomainError } from '../../../shared/domain-errors.js';
+import { createVersionControlRoutes } from '../version-control.routes.js';
 
 /**
  * The two routes a folder delete calls. What they must get right on their
@@ -23,14 +23,14 @@ const ALICE: AuthUser = { id: 'u-alice', email: 'alice@example.com', name: 'Alic
 describe('folder change-request routes', () => {
   let server: Server;
   let baseUrl: string;
-  const workflow = {
+  const versionControl = {
     changeRequestsUnderFolder: vi.fn(),
     removeFolderFromChangeRequests: vi.fn(),
   };
 
   beforeEach(async () => {
-    workflow.changeRequestsUnderFolder.mockReset();
-    workflow.removeFolderFromChangeRequests.mockReset();
+    versionControl.changeRequestsUnderFolder.mockReset();
+    versionControl.removeFolderFromChangeRequests.mockReset();
     const app = express();
     app.use(express.json());
     app.use('/api', (req, _res, next) => {
@@ -39,11 +39,11 @@ describe('folder change-request routes', () => {
     });
     app.use(
       '/api',
-      createWorkflowRoutes(
-        workflow as unknown as IWorkflowService,
+      createVersionControlRoutes(
+        versionControl as unknown as IVersionControlService,
         {} as WorkspaceService,
         { getUserById: vi.fn(async () => ALICE) } as unknown as AuthService,
-        new WorkflowEventBus(),
+        new VersionControlEventBus(),
         {} as IAccessControl,
         'knowledge-base',
       ),
@@ -59,15 +59,15 @@ describe('folder change-request routes', () => {
   });
 
   it('lists the requests under a folder for the caller', async () => {
-    workflow.changeRequestsUnderFolder.mockResolvedValue([{ number: 12, mayRemove: true }]);
+    versionControl.changeRequestsUnderFolder.mockResolvedValue([{ number: 12, mayRemove: true }]);
     const res = await fetch(`${baseUrl}/api/workflow/change-requests/under-folder?path=Data%2FReports%2F`);
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ requests: [{ number: 12, mayRemove: true }] });
-    expect(workflow.changeRequestsUnderFolder).toHaveBeenCalledWith('Data/Reports', ALICE);
+    expect(versionControl.changeRequestsUnderFolder).toHaveBeenCalledWith('Data/Reports', ALICE);
   });
 
   it('removes the folder from the requests', async () => {
-    workflow.removeFolderFromChangeRequests.mockResolvedValue([
+    versionControl.removeFolderFromChangeRequests.mockResolvedValue([
       { number: 12, removedPaths: ['Data/Reports/a.md'], withdrawn: true },
     ]);
     const res = await fetch(`${baseUrl}/api/workflow/change-requests/under-folder/remove`, {
@@ -77,7 +77,7 @@ describe('folder change-request routes', () => {
     });
     expect(res.status).toBe(200);
     expect((await res.json()).results[0]).toMatchObject({ number: 12, withdrawn: true });
-    expect(workflow.removeFolderFromChangeRequests).toHaveBeenCalledWith('Data/Reports', ALICE);
+    expect(versionControl.removeFolderFromChangeRequests).toHaveBeenCalledWith('Data/Reports', ALICE);
   });
 
   const MALFORMED = [
@@ -100,7 +100,7 @@ describe('folder change-request routes', () => {
       `${baseUrl}/api/workflow/change-requests/under-folder?path=${encodeURIComponent(folder)}`,
     );
     expect(res.status).toBe(400);
-    expect(workflow.changeRequestsUnderFolder).not.toHaveBeenCalled();
+    expect(versionControl.changeRequestsUnderFolder).not.toHaveBeenCalled();
   });
 
   it.each(MALFORMED)('refuses to remove the folder %j before the service sees it', async (folder) => {
@@ -110,12 +110,12 @@ describe('folder change-request routes', () => {
       body: JSON.stringify({ path: folder }),
     });
     expect(res.status).toBe(400);
-    expect(workflow.removeFolderFromChangeRequests).not.toHaveBeenCalled();
+    expect(versionControl.removeFolderFromChangeRequests).not.toHaveBeenCalled();
   });
 
   it('keeps the service’s refusal status', async () => {
-    workflow.removeFolderFromChangeRequests.mockRejectedValue(
-      new WorkflowDomainError("You can't remove proposed changes from #40", 403),
+    versionControl.removeFolderFromChangeRequests.mockRejectedValue(
+      new VersionControlDomainError("You can't remove proposed changes from #40", 403),
     );
     const res = await fetch(`${baseUrl}/api/workflow/change-requests/under-folder/remove`, {
       method: 'POST',

package/src/modules/{workflow/__tests__/workflow.routes.fork-point-file.test.ts → version-control/__tests__/version-control.routes.fork-point-file.test.ts}

@@ -2,12 +2,12 @@ import type { Server } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import express from 'express';
 import { describe, it, expect, afterEach, vi } from 'vitest';
-import type { IWorkflowService } from '@bevel-software/platform-shared';
+import type { IVersionControlService } from '@bevel-software/platform-shared';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import type { AuthService } from '../../auth/auth.service.js';
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import type { WorkflowEventBus } from '../event-bus.js';
-import { createWorkflowRoutes } from '../workflow.routes.js';
+import type { VersionControlEventBus } from '../event-bus.js';
+import { createVersionControlRoutes } from '../version-control.routes.js';
 
 /**
  * The "before" side of a request dialog's diff is the file at the request's
@@ -23,7 +23,7 @@ async function makeHarness() {
   const canReadAtRef = vi.fn(async (_w: string, _r: string, _e: string, p: string) =>
     p.includes('Secret') ? false : p.includes('Unknown') ? null : true,
   );
-  const workflow = {
+  const versionControl = {
     getChangeRequest: vi.fn(async (n: number) => (n === 7 ? CR : null)),
     fileAtForkPoint: vi.fn(async () => 'price: 100\n'),
     changeRequestForkPoint: vi.fn(async (): Promise<string | null> => SHA),
@@ -39,11 +39,11 @@ async function makeHarness() {
   });
   app.use(
     '/api',
-    createWorkflowRoutes(
-      workflow as unknown as IWorkflowService,
+    createVersionControlRoutes(
+      versionControl as unknown as IVersionControlService,
       workspaceService,
       { getUserById: vi.fn(async () => USER) } as unknown as AuthService,
-      { subscribe: vi.fn(), publish: vi.fn() } as unknown as WorkflowEventBus,
+      { subscribe: vi.fn(), publish: vi.fn() } as unknown as VersionControlEventBus,
       { canReadAtRef } as unknown as IAccessControl,
       'knowledge-base',
     ),
@@ -52,7 +52,7 @@ async function makeHarness() {
     const s = app.listen(0, () => resolve(s));
   });
   const { port } = server.address() as AddressInfo;
-  return { server, workflow, canReadAtRef, baseUrl: `http://127.0.0.1:${port}` };
+  return { server, versionControl, canReadAtRef, baseUrl: `http://127.0.0.1:${port}` };
 }
 
 describe('GET /workflow/change-requests/:number/fork-point-file', () => {
@@ -75,7 +75,7 @@ describe('GET /workflow/change-requests/:number/fork-point-file', () => {
       USER.email,
       'Sales/Deal.md',
     );
-    expect(h.workflow.fileAtForkPoint).toHaveBeenCalledWith(
+    expect(h.versionControl.fileAtForkPoint).toHaveBeenCalledWith(
       'ws-alice',
       'current-company-state',
       SHA,
@@ -87,14 +87,14 @@ describe('GET /workflow/change-requests/:number/fork-point-file', () => {
     h = await makeHarness();
     expect((await get(7, 'Secret/x.md')).status).toBe(403);
     expect((await get(7, 'Unknown/x.md')).status).toBe(403);
-    expect(h.workflow.fileAtForkPoint).not.toHaveBeenCalled();
+    expect(h.versionControl.fileAtForkPoint).not.toHaveBeenCalled();
   });
 
   it('refuses a workspace-prefixed path and an unknown request', async () => {
     h = await makeHarness();
     expect((await get(7, 'knowledge-base/Secret/x.md')).status).toBe(400);
     expect((await get(8, 'Sales/Deal.md')).status).toBe(404);
-    expect(h.workflow.fileAtForkPoint).not.toHaveBeenCalled();
+    expect(h.versionControl.fileAtForkPoint).not.toHaveBeenCalled();
   });
 
   it("without a sha, resolves the request's current fork point (the file page's boxes)", async () => {
@@ -102,26 +102,26 @@ describe('GET /workflow/change-requests/:number/fork-point-file', () => {
     const res = await get(7, 'Sales/Deal.md', '');
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ content: 'price: 100\n', forkSha: SHA });
-    expect(h.workflow.changeRequestForkPoint).toHaveBeenCalledWith(
+    expect(h.versionControl.changeRequestForkPoint).toHaveBeenCalledWith(
       'ws-alice',
       'current-company-state',
       'alice/deal',
     );
-    expect(h.workflow.fileAtForkPoint).toHaveBeenCalledWith('ws-alice', 'current-company-state', SHA, 'Sales/Deal.md');
+    expect(h.versionControl.fileAtForkPoint).toHaveBeenCalledWith('ws-alice', 'current-company-state', SHA, 'Sales/Deal.md');
   });
 
   it('branches with no shared history answer forkSha: null, and read nothing', async () => {
     h = await makeHarness();
-    h.workflow.changeRequestForkPoint.mockResolvedValueOnce(null);
+    h.versionControl.changeRequestForkPoint.mockResolvedValueOnce(null);
     const res = await get(7, 'Sales/Deal.md', '');
     expect(await res.json()).toEqual({ content: null, forkSha: null });
-    expect(h.workflow.fileAtForkPoint).not.toHaveBeenCalled();
+    expect(h.versionControl.fileAtForkPoint).not.toHaveBeenCalled();
   });
 
   it('a denied read never resolves the fork point either', async () => {
     h = await makeHarness();
     expect((await get(7, 'Secret/x.md', '')).status).toBe(403);
-    expect(h.workflow.changeRequestForkPoint).not.toHaveBeenCalled();
+    expect(h.versionControl.changeRequestForkPoint).not.toHaveBeenCalled();
   });
 
   it('refuses a missing path and a non-numeric request before authorizing anything', async () => {
@@ -129,7 +129,7 @@ describe('GET /workflow/change-requests/:number/fork-point-file', () => {
     expect((await fetch(`${h.baseUrl}/api/workflow/change-requests/7/fork-point-file?sha=${SHA}`)).status).toBe(400);
     expect((await fetch(`${h.baseUrl}/api/workflow/change-requests/abc/fork-point-file?path=Sales%2FDeal.md`)).status).toBe(400);
     expect(h.canReadAtRef).not.toHaveBeenCalled();
-    expect(h.workflow.fileAtForkPoint).not.toHaveBeenCalled();
+    expect(h.versionControl.fileAtForkPoint).not.toHaveBeenCalled();
   });
 
   it('an access-model error fails closed, not open', async () => {
@@ -137,12 +137,12 @@ describe('GET /workflow/change-requests/:number/fork-point-file', () => {
     h.canReadAtRef.mockRejectedValueOnce(new Error('access tree unreadable'));
     const res = await get(7, 'Sales/Deal.md');
     expect(res.status).toBeGreaterThanOrEqual(500);
-    expect(h.workflow.fileAtForkPoint).not.toHaveBeenCalled();
+    expect(h.versionControl.fileAtForkPoint).not.toHaveBeenCalled();
   });
 
   it('a failing git read surfaces as an error, never as an empty file', async () => {
     h = await makeHarness();
-    h.workflow.fileAtForkPoint.mockRejectedValueOnce(new Error('git exploded'));
+    h.versionControl.fileAtForkPoint.mockRejectedValueOnce(new Error('git exploded'));
     const res = await get(7, 'Sales/Deal.md');
     expect(res.status).toBeGreaterThanOrEqual(500);
   });

package/src/modules/{workflow/__tests__/workflow.routes.history-read-gate.test.ts → version-control/__tests__/version-control.routes.history-read-gate.test.ts}

@@ -2,12 +2,12 @@ import type { Server } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import express from 'express';
 import { describe, it, expect, afterEach, vi } from 'vitest';
-import type { IWorkflowService } from '@bevel-software/platform-shared';
+import type { IVersionControlService } from '@bevel-software/platform-shared';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import type { AuthService } from '../../auth/auth.service.js';
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import type { WorkflowEventBus } from '../event-bus.js';
-import { createWorkflowRoutes } from '../workflow.routes.js';
+import type { VersionControlEventBus } from '../event-bus.js';
+import { createVersionControlRoutes } from '../version-control.routes.js';
 import {
   VersionNotOnBranchError,
   VERSION_NOT_ON_BRANCH_MESSAGE,
@@ -26,7 +26,7 @@ interface Harness {
   server: Server;
   canRead: ReturnType<typeof vi.fn>;
   canReadAtRef: ReturnType<typeof vi.fn>;
-  workflow: {
+  versionControl: {
     listChangesForFile: ReturnType<typeof vi.fn>;
     compareFile: ReturnType<typeof vi.fn>;
     showFileAtChange: ReturnType<typeof vi.fn>;
@@ -39,7 +39,7 @@ async function makeHarness(): Promise<Harness> {
   const canRead = vi.fn(async (_w: string, _e: string, p: string) => allow(p));
   const canReadAtRef = vi.fn(async (_w: string, _r: string, _e: string, p: string) => allow(p));
   const accessControl = { canRead, canReadAtRef } as unknown as IAccessControl;
-  const workflow = {
+  const versionControl = {
     listChangesForFile: vi.fn(async () => []),
     compareFile: vi.fn(async (_w: string, _p: string, from: string, to: string, authorize?: (s: { from: string[]; to: string[] }) => Promise<void>) => {
       // Each branch resolves to its served commit and, for `b`, a second one (a
@@ -60,11 +60,11 @@ async function makeHarness(): Promise<Harness> {
   });
   app.use(
     '/api',
-    createWorkflowRoutes(
-      workflow as unknown as IWorkflowService,
+    createVersionControlRoutes(
+      versionControl as unknown as IVersionControlService,
       {} as unknown as WorkspaceService,
       authService,
-      { subscribe: vi.fn(), publish: vi.fn() } as unknown as WorkflowEventBus,
+      { subscribe: vi.fn(), publish: vi.fn() } as unknown as VersionControlEventBus,
       accessControl,
       KB,
     ),
@@ -73,7 +73,7 @@ async function makeHarness(): Promise<Harness> {
     const s = app.listen(0, () => resolve(s));
   });
   const addr = server.address() as AddressInfo;
-  return { server, canRead, canReadAtRef, workflow, baseUrl: `http://127.0.0.1:${addr.port}` };
+  return { server, canRead, canReadAtRef, versionControl, baseUrl: `http://127.0.0.1:${addr.port}` };
 }
 
 function close(s: Server): Promise<void> {
@@ -101,7 +101,7 @@ describe('history routes enforce the read model', () => {
     expect((await get(route.replace('%s', OPEN))).status).toBe(200);
     expect((await get(route.replace('%s', SECRET))).status).toBe(403);
     // The denial happened BEFORE the service — nothing read the repository.
-    const calls = h.workflow[method].mock.calls as unknown[][];
+    const calls = h.versionControl[method].mock.calls as unknown[][];
     expect(calls.length).toBe(1);
     expect(String(calls[0][1])).toContain('Open');
   });
@@ -115,7 +115,7 @@ describe('history routes enforce the read model', () => {
       const res = await get(`/changes?path=${encodeURIComponent(p)}`);
       expect(res.status).toBe(400);
     }
-    expect(h.workflow.listChangesForFile).not.toHaveBeenCalled();
+    expect(h.versionControl.listChangesForFile).not.toHaveBeenCalled();
   });
 
   it('compare-file authorizes at the two commits the diff was served from, never at a ref', async () => {
@@ -156,7 +156,7 @@ describe('history routes enforce the read model', () => {
       // there learns the wrong thing. The bytes route carries the same rule,
       // so neither can be read around through the other.
       h = await makeHarness();
-      h.workflow[method].mockRejectedValueOnce(new VersionNotOnBranchError());
+      h.versionControl[method].mockRejectedValueOnce(new VersionNotOnBranchError());
       const res = await get(route.replace('%s', OPEN));
       expect(res.status).toBe(404);
       expect(((await res.json()) as { error: string }).error).toBe(
@@ -170,6 +170,6 @@ describe('history routes enforce the read model', () => {
     h.canRead.mockRejectedValueOnce(new Error('access tree unreadable'));
     const res = await get(`/changes?path=${OPEN}`);
     expect(res.status).toBeGreaterThanOrEqual(500);
-    expect(h.workflow.listChangesForFile).not.toHaveBeenCalled();
+    expect(h.versionControl.listChangesForFile).not.toHaveBeenCalled();
   });
 });

package/src/modules/{workflow/__tests__/workflow.routes.lock-path.test.ts → version-control/__tests__/version-control.routes.lock-path.test.ts}

@@ -3,19 +3,19 @@ import type { AddressInfo } from 'node:net';
 import express from 'express';
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { testKbContext } from '../../../__tests__/kb-context.js';
-import type { AuthUser, Change, IWorkflowService } from '@bevel-software/platform-shared';
+import type { AuthUser, Change, IVersionControlService } from '@bevel-software/platform-shared';
 import type { Database } from '../../database/connection.js';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import type { AuthService } from '../../auth/auth.service.js';
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
 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 { IChangeRequestReviewService } from '../change-request-review/change-request-review.interface.js';
 import { FileLockService } from '../file-lock.service.js';
 import type { PendingCommitsService } from '../pending-commits.service.js';
-import { WorkflowEventBus } from '../event-bus.js';
-import { WorkflowService } from '../workflow.service.js';
-import { createWorkflowRoutes } from '../workflow.routes.js';
+import { VersionControlEventBus } from '../event-bus.js';
+import { VersionControlService } from '../version-control.service.js';
+import { createVersionControlRoutes } from '../version-control.routes.js';
 import { makeFakeLockDb, type FakeLockDb } from './fake-file-lock-db.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
@@ -26,7 +26,7 @@ import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
  * same lock whichever spelling of the file the client sends, and refuse the
  * spellings the file verbs refuse with the same status.
  *
- * Wired end to end on purpose. A spy on `IWorkflowService` would only prove
+ * Wired end to end on purpose. A spy on `IVersionControlService` would only prove
  * the routes pass a string along, and the whole question is which row that
  * string lands on.
  */
@@ -55,7 +55,7 @@ interface Harness {
   enqueue: ReturnType<typeof vi.fn>;
   commitFile: ReturnType<typeof vi.fn>;
   /** The service behind the routes, for the in-process callers (an agent's edits) that use it directly. */
-  workflow: IWorkflowService;
+  versionControl: IVersionControlService;
   /** The read rule the status read consults; every file is readable unless a test says otherwise. */
   canRead: ReturnType<typeof vi.fn>;
   /** Whose credentials the next request carries. */
@@ -75,12 +75,12 @@ async function makeHarness(): Promise<Harness> {
     enqueue,
     hasLiveRowFor: vi.fn().mockResolvedValue(false),
   } as unknown as PendingCommitsService;
-  const events = new WorkflowEventBus();
-  const workflow = new WorkflowService(
+  const events = new VersionControlEventBus();
+  const versionControl = new VersionControlService(
     {} as unknown as Database,
     git,
     {} as PullRequestService,
-    {} as IReviewWorkflowService,
+    {} as IChangeRequestReviewService,
     {} as WorkspaceService,
     {} as IAccessControl,
     new FileLockService(fake.db),
@@ -104,8 +104,8 @@ async function makeHarness(): Promise<Harness> {
   });
   app.use(
     '/api',
-    createWorkflowRoutes(
-      workflow as unknown as IWorkflowService,
+    createVersionControlRoutes(
+      versionControl as unknown as IVersionControlService,
       {} as unknown as WorkspaceService,
       authService,
       events,
@@ -123,7 +123,7 @@ async function makeHarness(): Promise<Harness> {
     fake,
     enqueue,
     commitFile,
-    workflow: workflow as unknown as IWorkflowService,
+    versionControl: versionControl as unknown as IVersionControlService,
     canRead,
     actAs: (user) => {
       current = user;
@@ -356,19 +356,19 @@ describe('lock routes coordinate on one workspace identity', () => {
   it("holds a file taken in the app against an agent's edit, and frees it on release", async () => {
     expect(await (await acquire()).json()).toMatchObject({ acquired: true });
 
-    await expect(h.workflow.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, BOB)).resolves.toMatchObject({
+    await expect(h.versionControl.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, BOB)).resolves.toMatchObject({
       acquired: false,
       lock: { holderUserId: ALICE.id },
     });
 
     expect((await release()).status).toBe(200);
-    await expect(h.workflow.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, BOB)).resolves.toMatchObject({
+    await expect(h.versionControl.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, BOB)).resolves.toMatchObject({
       acquired: true,
     });
   });
 
   it("holds a file an agent took against the app, which reads its status", async () => {
-    await h.workflow.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, ALICE);
+    await h.versionControl.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, ALICE);
 
     expect(await (await status()).json()).toMatchObject({ lock: { holderUserId: ALICE.id } });
     h.actAs(BOB);
@@ -380,7 +380,7 @@ describe('lock routes coordinate on one workspace identity', () => {
     // An agent's lock is found from the app's spelling, so the status read
     // must not name its holder to someone the file is hidden from.
     h.canRead.mockImplementation(async (_ws: string, email: string) => email !== BOB.email);
-    await h.workflow.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, ALICE);
+    await h.versionControl.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, ALICE);
     h.actAs(BOB);
 
     const rawStatus = () =>
@@ -447,7 +447,7 @@ describe('lock routes coordinate on one workspace identity', () => {
       expect(await (await status()).json()).toMatchObject({ lock: { holderUserId: ALICE.id } });
       h.actAs(BOB);
       expect(await (await acquire()).json()).toMatchObject({ acquired: false, lock: { holderUserId: ALICE.id } });
-      await expect(h.workflow.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, BOB)).resolves.toMatchObject({
+      await expect(h.versionControl.acquireLock(workspaceIdForBranch(BRANCH), BRANCH, CANONICAL, BOB)).resolves.toMatchObject({
         acquired: false,
       });
       // No second row was written beside it.

package/src/modules/{workflow/__tests__/workflow.routes.open-change-request.test.ts → version-control/__tests__/version-control.routes.open-change-request.test.ts}

@@ -2,12 +2,12 @@ import type { Server } from 'node:http';
 import type { AddressInfo } from 'node:net';
 import express from 'express';
 import { describe, it, expect, afterEach, vi } from 'vitest';
-import type { AuthUser, IWorkflowService } from '@bevel-software/platform-shared';
+import type { AuthUser, IVersionControlService } from '@bevel-software/platform-shared';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import type { AuthService } from '../../auth/auth.service.js';
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import { WorkflowEventBus } from '../event-bus.js';
-import { createWorkflowRoutes } from '../workflow.routes.js';
+import { VersionControlEventBus } from '../event-bus.js';
+import { createVersionControlRoutes } from '../version-control.routes.js';
 
 /**
  * `POST /api/workflow/change-requests` answers the opened request as the
@@ -18,7 +18,7 @@ import { createWorkflowRoutes } from '../workflow.routes.js';
 
 const ALICE: AuthUser = { id: '11111111-1111-4111-8111-111111111111', email: 'alice@example.com', name: 'Alice' };
 
-async function serve(workflow: Partial<IWorkflowService>): Promise<{ server: Server; baseUrl: string }> {
+async function serve(versionControl: Partial<IVersionControlService>): Promise<{ server: Server; baseUrl: string }> {
   const authService = { getUserById: vi.fn(async () => ALICE) } as unknown as AuthService;
   const workspaceService = {
     getOrCreateForBranch: vi.fn(async (branch: string) => ({ id: encodeURIComponent(branch) })),
@@ -31,11 +31,11 @@ async function serve(workflow: Partial<IWorkflowService>): Promise<{ server: Ser
   });
   app.use(
     '/api',
-    createWorkflowRoutes(
-      workflow as IWorkflowService,
+    createVersionControlRoutes(
+      versionControl as IVersionControlService,
       workspaceService,
       authService,
-      new WorkflowEventBus(),
+      new VersionControlEventBus(),
       {} as unknown as IAccessControl,
       'knowledge-base',
     ),