@bevel-software/platform-core-backend 0.3.2 → 0.4.1

package/src/modules/workflow/__tests__/pending-commits.enqueue-if-absent.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PendingCommitsService } from '../pending-commits.service.js';
+import type { Database } from '../../database/connection.js';
+
+/**
+ * `enqueueIfAbsent` backs the pull-conflict recovery dispatch: it must
+ * insert only when NO row exists for the (workspace, branch, path) in ANY
+ * status. A plain `enqueue` would refresh an existing pending row and reset
+ * its retry counters — and the dispatch path fires on every sync attempt,
+ * so those resets would starve the worker's ladder and the recovery agent
+ * would never spawn. A `needs_attention` row must also block re-entry (the
+ * ladder already escalated to a human; more agent runs are just a loop).
+ *
+ * Fake drizzle chain, same shape as the vault tests — the queue's SQL-level
+ * behavior (claim fencing etc.) is covered elsewhere; this pins the
+ * check-then-insert decision logic.
+ */
+interface SelectChain extends PromiseLike<unknown> {
+  from: (...args: unknown[]) => SelectChain;
+  where: (...args: unknown[]) => SelectChain;
+}
+
+interface InsertChain extends PromiseLike<unknown> {
+  values: (...args: unknown[]) => InsertChain;
+}
+
+function makeFakeDb(existingCount: number) {
+  const inserted: unknown[] = [];
+  const selectChain: SelectChain = {
+    from: vi.fn(() => selectChain),
+    where: vi.fn(() => selectChain),
+    then: (onF, onR) => Promise.resolve([{ count: existingCount }]).then(onF, onR),
+  };
+  const insertChain: InsertChain = {
+    values: vi.fn((v: unknown) => {
+      inserted.push(v);
+      return insertChain;
+    }),
+    then: (onF, onR) => Promise.resolve(undefined).then(onF, onR),
+  };
+  const db = {
+    select: vi.fn(() => selectChain),
+    insert: vi.fn(() => insertChain),
+  } as unknown as Database;
+  return { db, inserted };
+}
+
+const INPUT = {
+  workspaceId: 'razvan.radulescu/feature',
+  branch: 'razvan.radulescu/feature',
+  path: 'PR-Overviews/PR-7.html',
+  authorEmail: 'Alice@Example.com',
+  authorName: 'Alice',
+};
+
+describe('PendingCommitsService.enqueueIfAbsent', () => {
+  it('inserts (canonical workspace id, lowercased email) when no row exists', async () => {
+    const { db, inserted } = makeFakeDb(0);
+    const svc = new PendingCommitsService(db);
+
+    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(true);
+
+    expect(inserted).toHaveLength(1);
+    expect(inserted[0]).toMatchObject({
+      // Same canonicalization as `enqueue` — the worker claims per the
+      // ENCODED `knownWorkspaces()` id, so a decoded id would never drain.
+      workspaceId: 'razvan.radulescu%2Ffeature',
+      branch: 'razvan.radulescu/feature',
+      path: 'PR-Overviews/PR-7.html',
+      authorEmail: 'alice@example.com',
+      authorName: 'Alice',
+    });
+  });
+
+  it('is a no-op when ANY row exists for the tuple (pending, running, or needs_attention)', async () => {
+    const { db, inserted } = makeFakeDb(1);
+    const svc = new PendingCommitsService(db);
+
+    await expect(svc.enqueueIfAbsent(INPUT)).resolves.toBe(false);
+    expect(inserted).toHaveLength(0);
+  });
+});

package/src/modules/workflow/__tests__/workflow.service.facade.test.ts

@@ -12,6 +12,7 @@ import type { IAccessControl } from '../../access/access-control.interface.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService } from '../pending-commits.service.js';
 import { WorkflowService } from '../workflow.service.js';
+import { PullRebaseConflictError } from '../workflow.errors.js';
 import type { Database } from '../../database/connection.js';
 
 // The facade tests never exercise `openChangeRequest` (the only method that
@@ -50,6 +51,7 @@ function makePendingCommits(): PendingCommitsService {
   // behavior is covered by `pending-commits.service.test.ts`.
   return {
     enqueue: vi.fn().mockResolvedValue(undefined),
+    enqueueIfAbsent: vi.fn().mockResolvedValue(true),
     claimNext: vi.fn().mockResolvedValue(null),
     markSucceeded: vi.fn().mockResolvedValue(undefined),
     markTransientFailure: vi.fn().mockResolvedValue(undefined),
@@ -327,6 +329,48 @@ describe('WorkflowService — change request delegation + cache invalidation', (
     );
     expect(prs.invalidateDetailCache).toHaveBeenCalledWith(4);
   });
+
+  it('mergeChangeRequest still merges when the post-merge pull conflicts, and queues recovery on the TARGET workspace', async () => {
+    const prs = makePrs();
+    const reviewWorkflow = makeReviewWorkflow();
+    const mergeResult = { prNumber: 4, sha: 'abc', mergedAt: 't' };
+    (reviewWorkflow.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
+    (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({ branch: 'alice/feat', base: 'main' });
+
+    const git = makeGit();
+    const conflict = new PullRebaseConflictError(
+      'main',
+      // Deliberately unsorted — the representative row must be the smallest.
+      ['b-second.md', 'a-first.md'],
+      'git rebase failed: could not apply deadbee',
+    );
+    (git.pull as ReturnType<typeof vi.fn>).mockRejectedValue(conflict);
+    const workspaceService = makeWorkspaceService();
+    // Return an id that ISN'T derivable from the branch name, pinning that
+    // the dispatch uses the id `getOrCreateForBranch` returned rather than
+    // re-deriving it.
+    (workspaceService.getOrCreateForBranch as ReturnType<typeof vi.fn>).mockResolvedValue({
+      id: 'resolved-target-ws',
+    });
+    const pending = makePendingCommits();
+    const svc = new WorkflowService(makeDb(), git, prs, reviewWorkflow, workspaceService, makeAccessControl(), makeFileLockService(), pending, 'knowledge-base');
+
+    const outcome = await svc.mergeChangeRequest(
+      4, makeUser(), 'sha', [], 'open', 'PR title', 'main', 'w1', { bypass: true },
+    );
+
+    // The merge already landed on origin — a stuck target workspace must not
+    // fail the response.
+    expect(outcome).toEqual({ kind: 'merged', result: mergeResult });
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledTimes(1);
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledWith({
+      workspaceId: 'resolved-target-ws',
+      branch: 'main',
+      path: 'a-first.md',
+      authorEmail: 'alice@example.com',
+      authorName: 'Alice',
+    });
+  });
 });
 
 describe('WorkflowService — file lock delegation', () => {

package/src/modules/workflow/__tests__/workflow.service.releaseLock.test.ts

@@ -11,6 +11,7 @@ import { WorkflowEventBus } from '../event-bus.js';
 import { WorkflowService } from '../workflow.service.js';
 import type { Database } from '../../database/connection.js';
 import {
+  PullRebaseConflictError,
   PushNeedsAgentResolutionError,
   WorkflowValidationError,
 } from '../workflow.errors.js';
@@ -66,6 +67,7 @@ function makeFileLocks(holderUserId: string): FileLockService {
 function makePending(): PendingCommitsService {
   return {
     enqueue: vi.fn().mockResolvedValue(undefined),
+    enqueueIfAbsent: vi.fn().mockResolvedValue(true),
     claimNext: vi.fn().mockResolvedValue(null),
     markSucceeded: vi.fn().mockResolvedValue(undefined),
     markTransientFailure: vi.fn().mockResolvedValue(undefined),
@@ -82,6 +84,7 @@ function makeGit(overrides: Partial<{
   pushBehavior: 'ok' | 'nff' | 'auth-fail';
   pullBehavior: 'ok' | 'fail';
   pushAfterPullBehavior: 'ok' | 'fail';
+  hasUnpushedCommits: boolean;
 }> = {}): GitService {
   const commitFileResult = overrides.commitFile === undefined ? CHANGE : overrides.commitFile;
   const pushBehavior = overrides.pushBehavior ?? 'ok';
@@ -90,6 +93,7 @@ function makeGit(overrides: Partial<{
   let pushCalls = 0;
   return {
     commitFile: vi.fn().mockResolvedValue(commitFileResult),
+    hasUnpushedCommits: vi.fn().mockResolvedValue(overrides.hasUnpushedCommits ?? false),
     push: vi.fn().mockImplementation(async () => {
       pushCalls++;
       const phase = pushCalls === 1 ? pushBehavior : pushAfterPullBehavior;
@@ -265,10 +269,10 @@ describe('WorkflowService.runPendingCommit — worker entry point', () => {
     });
   });
 
-  it('skips push + file-changed when commitFile reports nothing dirty (double-enqueue, identical bytes)', async () => {
+  it('skips push + file-changed on a no-op commit with nothing unpushed (double-enqueue, identical bytes)', async () => {
     // The worker treats a no-op commit as success and drops the row.
     // No push, no SSE event — there's no new sha for clients to see.
-    const git = makeGit({ commitFile: null });
+    const git = makeGit({ commitFile: null, hasUnpushedCommits: false });
     const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
 
     await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER);
@@ -278,6 +282,41 @@ describe('WorkflowService.runPendingCommit — worker entry point', () => {
     expect(emitSpy).not.toHaveBeenCalled();
   });
 
+  it('STILL pushes on a no-op commit when the branch is ahead of origin (stranded autosave commit)', async () => {
+    // Regression: the autosave path commits locally with a best-effort
+    // push. When that push fails, the eventual queue row finds a CLEAN
+    // tree — and the old early-return treated it as success, dropping the
+    // row without ever pushing. The local commit stayed stranded forever
+    // and the recovery ladder never started.
+    const git = makeGit({ commitFile: null, hasUnpushedCommits: true });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+
+    await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER);
+
+    expect(git.push).toHaveBeenCalledTimes(1);
+    // No new commit → still no file-changed (there's no new sha).
+    expect(emitSpy).not.toHaveBeenCalled();
+  });
+
+  it('no-op commit + unpushed + conflicting divergence throws so the worker ladder takes over', async () => {
+    // The stranded-commit case where origin ALSO moved with a conflicting
+    // change (the production stuck-workspace state): push rejects non-FF,
+    // the cooperative pull conflicts — the typed error must reach the
+    // worker so its retry → recovery-agent ladder runs.
+    const git = makeGit({
+      commitFile: null,
+      hasUnpushedCommits: true,
+      pushBehavior: 'nff',
+      pullBehavior: 'fail',
+    });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
+
+    await expect(svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER)).rejects.toBeInstanceOf(
+      PushNeedsAgentResolutionError,
+    );
+    expect(emitSpy).not.toHaveBeenCalled();
+  });
+
   it('recovers from non-fast-forward push via pull --rebase + retry, emits file-changed exactly once', async () => {
     // Teammate pushed to the same branch between our commit and our
     // push. The cooperative path pulls + retries — this is the case
@@ -338,3 +377,73 @@ describe('WorkflowService.runPendingCommit — worker entry point', () => {
     expect(emitSpy).not.toHaveBeenCalled();
   });
 });
+
+describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch', () => {
+  const CONFLICT = new PullRebaseConflictError(
+    'main',
+    ['PR-Overviews/PR-7.html', 'other.md'],
+    'git rebase failed: could not apply 0d7b463',
+  );
+
+  function makeConflictingGit(err: unknown): GitService {
+    return {
+      pull: vi.fn().mockRejectedValue(err),
+    } as unknown as GitService;
+  }
+
+  it('queues ONE recovery row (first conflicted path, triggering user) and rethrows', async () => {
+    const pending = makePending();
+    const svc = makeFacade(
+      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+    );
+
+    await expect(svc.updateFromRemote('main', USER)).rejects.toBe(CONFLICT);
+
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledTimes(1);
+    expect(pending.enqueueIfAbsent).toHaveBeenCalledWith({
+      workspaceId: 'main',
+      branch: 'main',
+      path: 'PR-Overviews/PR-7.html',
+      authorEmail: USER.email,
+      authorName: USER.name,
+    });
+    // `enqueue` (counter-resetting refresh) must NOT be used here — repeated
+    // sync attempts would starve the worker's ladder.
+    expect(pending.enqueue).not.toHaveBeenCalled();
+  });
+
+  it('falls back to the recovery-bot identity when no user is available', async () => {
+    const pending = makePending();
+    const svc = makeFacade(
+      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+    );
+
+    await expect(svc.updateFromRemote('main')).rejects.toBe(CONFLICT);
+
+    const input = (pending.enqueueIfAbsent as ReturnType<typeof vi.fn>).mock.calls[0][0];
+    expect(input.authorEmail).toContain('recovery-bot@');
+  });
+
+  it('does NOT queue recovery for a non-conflict pull failure (transient fetch error)', async () => {
+    const pending = makePending();
+    const transient = new Error('git fetch failed: could not resolve host');
+    const svc = makeFacade(
+      makeConflictingGit(transient), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+    );
+
+    await expect(svc.updateFromRemote('main', USER)).rejects.toBe(transient);
+    expect(pending.enqueueIfAbsent).not.toHaveBeenCalled();
+  });
+
+  it('a queue hiccup does not mask the conflict error', async () => {
+    const pending = makePending();
+    (pending.enqueueIfAbsent as ReturnType<typeof vi.fn>).mockRejectedValue(
+      new Error('db down'),
+    );
+    const svc = makeFacade(
+      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+    );
+
+    await expect(svc.updateFromRemote('main', USER)).rejects.toBe(CONFLICT);
+  });
+});