canopycms 0.12.1 → 0.13.0

package/dist/api/merge-conflicts.js

@@ -6,6 +6,10 @@
  */
 import path from 'node:path';
 import { z } from 'zod';
+import { SYNC_BRANCH_ACTION } from '../base-update.js';
+import { operatingStrategy } from '../operating-mode/index.js';
+import { enqueueTask } from '../task-queue/cms-task-queue.js';
+import { getTaskQueueDir } from '../task-queue/task-queue-config.js';
 import { entryRefFromRepoPath, entryRefFromRepoPathShape, parseEntryParts, } from '../content-listing.js';
 import { BranchSyncingError, ContentConflictError, ContentStore, ContentStoreError, EntryGoneError, } from '../content-store.js';
 import { keyOfDataPath } from '../merge/conflict-path.js';
@@ -127,12 +131,28 @@ const mayAccess = (record, checkAccess, user, level) => {
         return admin;
     return [record.address, record.recordedAddress ?? record.address].every((at) => checkAccess(at, level).allowed);
 };
+/**
+ * Wake the worker's git sync for `branch`, whose last open choice was just resolved, so the pull
+ * request's conflicts status (worker/conflicts-status.ts) turns to success within a sync's rest: a
+ * required check would otherwise hold the merge until the next regular cycle. Only where a worker
+ * answers the queue; best-effort, as that next cycle sets it anyway.
+ */
+async function wakeConflictsStatus(config, branch) {
+    if (operatingStrategy(config.mode).baseUpdateRunsInRequest())
+        return;
+    try {
+        await enqueueTask(getTaskQueueDir(config), { action: SYNC_BRANCH_ACTION, payload: { branch } });
+    }
+    catch (err) {
+        canopyLogWarn(`CanopyCMS: Could not queue a sync for ${branch} after its last conflict was resolved:`, getErrorMessage(err));
+    }
+}
 /**
  * Change the record's entries by `change`, under the record's locks, then `branch.json`
- * `conflictFiles` to match. `change` returning null writes nothing. Resolves the entries written,
- * or null.
+ * `conflictFiles` to match, and wake the worker when that resolved the last open choice.
+ * `change` returning null writes nothing. Resolves the entries written, or null.
  */
-const changeRecord = async (branchContext, change) => {
+const changeRecord = async (config, branchContext, change) => {
     const state = await new MergeConflictStore(branchContext.branchRoot).update((current) => {
         if (current === null)
             return null;
@@ -144,6 +164,10 @@ const changeRecord = async (branchContext, change) => {
     await getBranchMetadataFileManager(branchContext.branchRoot, branchContext.baseRoot).update((existing) => existing?.branch.name === branchContext.branch.name
         ? { branch: conflictFilesOf(state.entries) }
         : null, { keepUpdatedAt: true });
+    // Each change takes a choice off, so none open now means this one took the last.
+    if (openConflictCount(state.entries) === 0 && !state.held) {
+        await wakeConflictsStatus(config, branchContext.branch.name);
+    }
     return state.entries;
 };
 /**
@@ -152,9 +176,9 @@ const changeRecord = async (branchContext, change) => {
  * call once the entry is written, inside its locks: the record's own locks come after them in
  * the one lock order (docs/concurrency.md).
  */
-export async function clearFieldConflicts(branchContext, contentId, resolved) {
+export async function clearFieldConflicts(config, branchContext, contentId, resolved) {
     let cleared = [];
-    await changeRecord(branchContext, (entries) => {
+    await changeRecord(config, branchContext, (entries) => {
         const next = withoutResolvedFields(entries, contentId, resolved);
         cleared = next.cleared;
         return next.cleared.length > 0 ? next.entries : null;
@@ -408,6 +432,8 @@ const resolveBodySchema = z.object({
      * field by field with the latest version (`unreadable`).
      */
     choice: z.enum(['keep', 'delete', 'restore', 'use-latest']),
+    /** The card promised the entry stays deleted: a `keep` is refused if it is in the tree now. */
+    entryGone: z.literal(true).optional(),
 });
 /** Which kinds of record each choice resolves. */
 const CHOICE_KINDS = {
@@ -489,10 +515,16 @@ const resolveHandler = async (gc, ctx, req, params, body) => {
         if (current?.kind !== entry.kind || current.mergeSha !== body.mergeSha) {
             throw new ConflictChangedError();
         }
+        // Read afresh: a restore since the drawer opened would make "keep it deleted" untrue.
+        if (body.entryGone) {
+            store.invalidateIndex();
+            if ((await store.idIndex()).findById(body.id) !== null)
+                throw new ConflictChangedError();
+        }
     };
     // Clears the record as it stands under its lock, refusing when a merge changed it since.
     const clear = async () => {
-        const written = await changeRecord(branchContext, (now) => {
+        const written = await changeRecord(ctx.services.config, branchContext, (now) => {
             const current = now[body.id];
             if (current?.kind === 'fields' && current.mergeSha === body.mergeSha) {
                 const { [body.id]: _kept, ...rest } = now;
@@ -628,7 +660,7 @@ const resolveEntryConflict = defineEndpoint({
  * clashed is lost, and the values stay as the merges left them. Under the content-write lock, as a
  * merge's record is written.
  */
-const releaseHoldHandler = async (gc) => {
+const releaseHoldHandler = async (gc, ctx) => {
     const { branchRoot } = gc.branchContext;
     try {
         const written = await withContentWriteLock(branchRoot, () => new MergeConflictStore(branchRoot).update((current) => {
@@ -636,6 +668,9 @@ const releaseHoldHandler = async (gc) => {
                 return null;
             return { ...current, held: undefined };
         }));
+        if (written !== null && openConflictCount(written.entries) === 0) {
+            await wakeConflictsStatus(ctx.services.config, gc.branchContext.branch.name);
+        }
         return { ok: true, status: 200, data: { released: written !== null } };
     }
     catch (err) {

package/dist/api/types.d.ts

@@ -70,6 +70,7 @@ export interface ApiResponse<TData = unknown> {
  * another name can pass; no other create failure carries it. `OPEN_CONFLICTS`: a submit or approval
  * was refused while a merge's conflicts are open on the branch (a 409, merge-conflicts.ts).
  * `CONFLICT_CHANGED`: a resolve-entry named a conflict the record no longer holds as shown (a 409);
- * re-read the branch's conflicts.
+ * re-read the branch's conflicts. `BRANCH_MOVED`: an approval or a request for changes named a commit
+ * other than the branch's head, or none (a 409, api/branch-review.ts); reload the branch first.
  */
-export type ApiErrorCode = 'SCHEMA_UNAVAILABLE' | 'WORKER_FAILED' | 'WRITE_OUTCOME_UNKNOWN' | 'ENTRY_GONE' | 'EDITOR_MODE_MISMATCH' | 'SETTINGS_CHANGED' | 'BRANCH_SYNCING' | 'BRANCH_NAME_REFUSED' | 'OPEN_CONFLICTS' | 'CONFLICT_CHANGED';
+export type ApiErrorCode = 'SCHEMA_UNAVAILABLE' | 'WORKER_FAILED' | 'WRITE_OUTCOME_UNKNOWN' | 'ENTRY_GONE' | 'EDITOR_MODE_MISMATCH' | 'SETTINGS_CHANGED' | 'BRANCH_SYNCING' | 'BRANCH_NAME_REFUSED' | 'OPEN_CONFLICTS' | 'CONFLICT_CHANGED' | 'BRANCH_MOVED';

package/dist/base-update.d.ts

@@ -22,5 +22,11 @@ export declare const BASE_UPDATE_EARLY_RETRY_MS: number;
  * so a later one is corrupt and is never waited on.
  */
 export declare const BASE_UPDATE_CLOCK_SKEW_MS = 60000;
+/**
+ * How a run in the request (operating-mode `baseUpdateRunsInRequest`) went: it answered the
+ * request; a lock held it back; or the branch clones from a remote other than the workspace's
+ * `remote.git`, the only one such a run fetches.
+ */
+export type BaseUpdateRun = 'answered' | 'busy' | 'other-remote';
 /** Whether the branch's latest request for the latest changes is still unanswered. */
 export declare function isBaseUpdatePending(branch: Pick<BranchMetadata, 'baseUpdateRequestedAt' | 'lastBaseUpdate'>): boolean;

package/dist/branch-metadata-file.d.ts

@@ -83,6 +83,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
         lastAt: string;
     }>>;
     historyRewrittenFrom: z.ZodOptional<z.ZodString>;
+    historyRewrittenTo: z.ZodOptional<z.ZodString>;
     lastGitHubTip: z.ZodOptional<z.ZodString>;
     keptOverGitHub: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     rewrittenOnGitHub: z.ZodOptional<z.ZodString>;
@@ -121,6 +122,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
             name?: string | undefined;
         }>;
         at: z.ZodString;
+        commit: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         at: string;
         state: "approved" | "changes-requested";
@@ -128,6 +130,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
             userId: string;
             name?: string | undefined;
         };
+        commit?: string | undefined;
     }, {
         at: string;
         state: "approved" | "changes-requested";
@@ -135,8 +138,10 @@ export declare const branchMetadataSchema: z.ZodObject<{
             userId: string;
             name?: string | undefined;
         };
+        commit?: string | undefined;
     }>>>;
     baseUpdateRequestedAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    latestChangesWaiting: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     lastBaseUpdate: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         at: z.ZodString;
         outcome: z.ZodEnum<["merged", "up-to-date", "conflicts", "failed"]>;
@@ -216,6 +221,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
         lastAt: string;
     }>>;
     historyRewrittenFrom: z.ZodOptional<z.ZodString>;
+    historyRewrittenTo: z.ZodOptional<z.ZodString>;
     lastGitHubTip: z.ZodOptional<z.ZodString>;
     keptOverGitHub: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     rewrittenOnGitHub: z.ZodOptional<z.ZodString>;
@@ -254,6 +260,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
             name?: string | undefined;
         }>;
         at: z.ZodString;
+        commit: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         at: string;
         state: "approved" | "changes-requested";
@@ -261,6 +268,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
             userId: string;
             name?: string | undefined;
         };
+        commit?: string | undefined;
     }, {
         at: string;
         state: "approved" | "changes-requested";
@@ -268,8 +276,10 @@ export declare const branchMetadataSchema: z.ZodObject<{
             userId: string;
             name?: string | undefined;
         };
+        commit?: string | undefined;
     }>>>;
     baseUpdateRequestedAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    latestChangesWaiting: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     lastBaseUpdate: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         at: z.ZodString;
         outcome: z.ZodEnum<["merged", "up-to-date", "conflicts", "failed"]>;
@@ -349,6 +359,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
         lastAt: string;
     }>>;
     historyRewrittenFrom: z.ZodOptional<z.ZodString>;
+    historyRewrittenTo: z.ZodOptional<z.ZodString>;
     lastGitHubTip: z.ZodOptional<z.ZodString>;
     keptOverGitHub: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     rewrittenOnGitHub: z.ZodOptional<z.ZodString>;
@@ -387,6 +398,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
             name?: string | undefined;
         }>;
         at: z.ZodString;
+        commit: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         at: string;
         state: "approved" | "changes-requested";
@@ -394,6 +406,7 @@ export declare const branchMetadataSchema: z.ZodObject<{
             userId: string;
             name?: string | undefined;
         };
+        commit?: string | undefined;
     }, {
         at: string;
         state: "approved" | "changes-requested";
@@ -401,8 +414,10 @@ export declare const branchMetadataSchema: z.ZodObject<{
             userId: string;
             name?: string | undefined;
         };
+        commit?: string | undefined;
     }>>>;
     baseUpdateRequestedAt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    latestChangesWaiting: z.ZodCatch<z.ZodOptional<z.ZodString>>;
     lastBaseUpdate: z.ZodCatch<z.ZodOptional<z.ZodObject<{
         at: z.ZodString;
         outcome: z.ZodEnum<["merged", "up-to-date", "conflicts", "failed"]>;

package/dist/branch-metadata-file.js

@@ -82,6 +82,7 @@ const branchMetadataShape = {
         .object({ message: z.string(), firstAt: z.string(), lastAt: z.string() })
         .optional(),
     historyRewrittenFrom: z.string().optional(),
+    historyRewrittenTo: z.string().optional(),
     lastGitHubTip: z.string().optional(),
     keptOverGitHub: z.array(z.string()).optional(),
     rewrittenOnGitHub: z.string().optional(),
@@ -99,16 +100,19 @@ const branchMetadataShape = {
     ])
         .optional()
         .catch(undefined),
-    // Dropped when malformed: it only decorates the PR body, so it never fails a read.
+    // Dropped when malformed, never failing a read: it decorates the PR body, and without `commit`
+    // the worker judges a move against the clone's head before it (worker/github-commits.ts).
     review: z
         .object({
         state: z.enum(['approved', 'changes-requested']),
         by: z.object({ userId: z.string(), name: z.string().optional() }),
         at: z.string(),
+        commit: z.string().optional(),
     })
         .optional()
         .catch(undefined),
     baseUpdateRequestedAt: z.string().optional().catch(undefined),
+    latestChangesWaiting: z.string().optional().catch(undefined),
     // Dropped when malformed: it only ends the editor's wait, which then times out instead.
     lastBaseUpdate: z
         .object({