payload 4.0.0-internal.e7d4ebc → 4.0.0-internal.ea6e8f8

package/dist/branching/createShadowRow.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/createShadowRow.ts"],"sourcesContent":["import type { PayloadRequest } from '../types/index.js'\nimport type { BranchOperation } from './types.js'\n\nimport { APIError } from '../errors/index.js'\nimport { ValidationError } from '../errors/ValidationError.js'\nimport { shareFileOperationScope } from '../uploads/fileVersioning/fileOperationManager.js'\nimport {\n  commitTransaction,\n  isUnknownTransactionCommitResult,\n} from '../utilities/commitTransaction.js'\nimport { initTransaction } from '../utilities/initTransaction.js'\nimport { isolateObjectProperty } from '../utilities/isolateObjectProperty.js'\nimport { killTransaction } from '../utilities/killTransaction.js'\nimport { branchChangesCollectionSlug, branchDocIDField, branchField } from './types.js'\n\ntype ShadowSource = {\n  branch: string\n  id: number | string\n}\n\ntype Args = {\n  branch: string\n  collectionSlug: string\n  data: Record<string, unknown>\n  /** The canonical document this row represents, for the recovery read on conflict. */\n  docID: number | string\n  /**\n   * Runs only when this call creates the row, inside the same transaction\n   * as the row create — typically the accompanying\n   * `payload-branch-changes` entry. Never called on the losing side, whose\n   * caller already created (or is creating) its own.\n   */\n  onCreated: (req: PayloadRequest, shadow: Record<string, unknown>) => Promise<unknown>\n  req: PayloadRequest\n  /** Copies an exact logical source document instead of creating from data alone. */\n  source?: ShadowSource\n  /** Uses the request's existing transaction and leaves commit or rollback to its owner. */\n  useAmbientTransaction?: boolean\n}\n\nconst isShadowUniquenessError = (error: unknown): error is ValidationError =>\n  error instanceof ValidationError &&\n  error.data.errors.some(({ path }) =>\n    path\n      .split(',')\n      .map((fieldPath) => fieldPath.trim())\n      .some(\n        (fieldPath) =>\n          fieldPath === branchDocIDField ||\n          fieldPath === '_branch_doc_id' ||\n          fieldPath === '_branchdocid_id' ||\n          fieldPath === 'documentID' ||\n          fieldPath === branchField,\n      ),\n  )\n\nconst isTransientTransactionError = (error: unknown): boolean => {\n  if (isUnknownTransactionCommitResult(error)) {\n    return false\n  }\n\n  if (!error || typeof error !== 'object') {\n    return false\n  }\n\n  const labeledError = error as {\n    errorLabels?: string[]\n    hasErrorLabel?: (label: string) => boolean\n  }\n\n  return (\n    labeledError.hasErrorLabel?.('TransientTransactionError') === true ||\n    labeledError.errorLabels?.includes('TransientTransactionError') === true\n  )\n}\n\nexport const isRecoverableConcurrentShadowError = (error: unknown): boolean =>\n  isShadowUniquenessError(error) || isTransientTransactionError(error)\n\nconst concurrentShadowOperationErrors = new WeakSet<object>()\n\nconst markConcurrentShadowOperationError = (error: unknown): void => {\n  if (error && typeof error === 'object') {\n    concurrentShadowOperationErrors.add(error)\n  }\n}\n\nexport const isConcurrentShadowOperationError = (error: unknown): boolean =>\n  Boolean(error && typeof error === 'object' && concurrentShadowOperationErrors.has(error))\n\nconst maximumConcurrentShadowAttempts = 8\n\nexport const waitForConcurrentShadowRetry = async ({\n  retryIndex,\n}: {\n  retryIndex: number\n}): Promise<void> => {\n  const delayMilliseconds = Math.min(25 * 2 ** retryIndex, 100)\n\n  await new Promise((resolve) => setTimeout(resolve, delayMilliseconds))\n}\n\nexport const retryConcurrentShadowOperation = async <Result>({\n  onRetry,\n  operation,\n  shouldRetry,\n  waitForRetry = waitForConcurrentShadowRetry,\n}: {\n  onRetry?: (args: { error: unknown; retryIndex: number }) => Promise<void> | void\n  operation: () => Promise<Result>\n  shouldRetry: ((args: { error: unknown }) => boolean) | boolean\n  waitForRetry?: (args: { retryIndex: number }) => Promise<void>\n}): Promise<Result> => {\n  for (let attemptIndex = 0; attemptIndex < maximumConcurrentShadowAttempts; attemptIndex++) {\n    try {\n      return await operation()\n    } catch (error) {\n      const hasAnotherAttempt = attemptIndex < maximumConcurrentShadowAttempts - 1\n      const isRetryAllowed =\n        typeof shouldRetry === 'function' ? shouldRetry({ error }) : shouldRetry\n\n      if (!isRetryAllowed || !hasAnotherAttempt || !isRecoverableConcurrentShadowError(error)) {\n        throw error\n      }\n\n      await onRetry?.({ error, retryIndex: attemptIndex })\n      await waitForRetry({ retryIndex: attemptIndex })\n    }\n  }\n\n  throw new Error('Concurrent shadow retry attempts were exhausted.')\n}\n\nexport const findCompetingShadow = async ({\n  branch,\n  collectionSlug,\n  docID,\n  operation,\n  req,\n}: {\n  branch: string\n  collectionSlug: string\n  docID: number | string\n  operation?: BranchOperation\n  req: PayloadRequest\n}): Promise<null | Record<string, unknown>> => {\n  // A caller transaction keeps its earlier snapshot and cannot observe the winner. Read without\n  // that transaction, and allow a short bounded period for the winner to become visible.\n  const recoveryReq = isolateObjectProperty(req, ['transactionID'])\n\n  delete recoveryReq.transactionID\n\n  for (let attemptIndex = 0; attemptIndex < maximumConcurrentShadowAttempts; attemptIndex++) {\n    if (attemptIndex > 0) {\n      await waitForConcurrentShadowRetry({ retryIndex: attemptIndex - 1 })\n    }\n\n    const winner = (await req.payload.db.findOne({\n      branch: false,\n      collection: collectionSlug,\n      req: recoveryReq,\n      where: {\n        and: [{ [branchField]: { equals: branch } }, { [branchDocIDField]: { equals: docID } }],\n      },\n    })) as null | Record<string, unknown>\n\n    if (winner) {\n      const change = await req.payload.db.findOne({\n        collection: branchChangesCollectionSlug,\n        req: recoveryReq,\n        where: {\n          and: [\n            { branch: { equals: branch } },\n            { collectionSlug: { equals: collectionSlug } },\n            { documentID: { equals: String(docID) } },\n          ],\n        },\n      })\n\n      if (!change) {\n        if (attemptIndex < maximumConcurrentShadowAttempts - 1) {\n          continue\n        }\n\n        throw new APIError(\n          `The ${collectionSlug} branch row for document ${String(docID)} has no change record.`,\n          409,\n        )\n      }\n\n      const authoritativeOperation = (change as { operation?: BranchOperation }).operation\n\n      if (operation && authoritativeOperation !== operation) {\n        return null\n      }\n\n      return winner\n    }\n  }\n\n  return null\n}\n\n/**\n * Creates a branch's shadow row for a document, safe against two concurrent\n * first-edits of the same document on the same branch racing to create it.\n *\n * The unique index on `(_branchDocID, _branch)` is what turns the losing side\n * into a rejection instead of a second, duplicate shadow row — but the create\n * runs in a transaction of its own, isolated from the caller's, rather than\n * the caller's ambient one. A losing race has to recover with a plain read,\n * and Postgres refuses any further command on a transaction once one\n * statement inside it fails — including that read — until it is rolled back.\n * A transaction of its own can be rolled back and moved past without\n * disturbing the write the caller is in the middle of.\n *\n * An operation that owns the request's existing transaction can opt into\n * creating the shadow and registry there instead. Errors on that path remain\n * with the operation owner, which can roll back and retry the full lifecycle.\n */\nexport const createShadowRow = async ({\n  branch,\n  collectionSlug,\n  data,\n  docID,\n  onCreated,\n  req,\n  source,\n  useAmbientTransaction = false,\n}: Args): Promise<Record<string, unknown>> => {\n  if (useAmbientTransaction) {\n    const ambient = isolateObjectProperty(req, ['file'])\n    const transactionID = await ambient.transactionID\n\n    if (!transactionID) {\n      throw new Error('Ambient shadow creation requires an active transaction.')\n    }\n\n    shareFileOperationScope({ owner: req, req: ambient })\n\n    try {\n      const shadow = await createShadowContent({\n        branch,\n        collectionSlug,\n        data,\n        req: ambient,\n        source,\n      })\n\n      await onCreated(ambient, shadow)\n\n      return shadow\n    } catch (error) {\n      if (isRecoverableConcurrentShadowError(error)) {\n        markConcurrentShadowOperationError(error)\n      }\n\n      throw error\n    }\n  }\n\n  // Registry writes use the same request so that they share the branch fork's transaction.\n  // A nested Local API create clears `req.file` when no file is supplied, so isolate that\n  // property as well or an upload replacement disappears before the real branch update runs.\n  const isolated = isolateObjectProperty(req, ['file', 'transactionID'])\n\n  delete isolated.transactionID\n\n  const shouldCommit = await initTransaction(isolated)\n\n  if (!shouldCommit) {\n    shareFileOperationScope({ owner: req, req: isolated })\n  }\n\n  let shadow: Record<string, unknown>\n\n  try {\n    shadow = await createShadowContent({\n      branch,\n      collectionSlug,\n      data,\n      req: isolated,\n      source,\n    })\n  } catch (error) {\n    await killTransaction(isolated)\n\n    if (!isRecoverableConcurrentShadowError(error)) {\n      throw error\n    }\n\n    const winner = await findCompetingShadow({ branch, collectionSlug, docID, req })\n\n    if (!winner) {\n      markConcurrentShadowOperationError(error)\n      throw error\n    }\n\n    return winner\n  }\n\n  try {\n    await onCreated(isolated, shadow)\n\n    if (shouldCommit) {\n      await commitTransaction(isolated)\n    }\n\n    return shadow\n  } catch (error) {\n    await killTransaction(isolated)\n\n    if (shouldCommit && isRecoverableConcurrentShadowError(error)) {\n      const winner = await findCompetingShadow({ branch, collectionSlug, docID, req })\n\n      if (winner) {\n        return winner\n      }\n\n      markConcurrentShadowOperationError(error)\n    }\n\n    const shadowID = shadow.id\n\n    if (!shouldCommit && (typeof shadowID === 'string' || typeof shadowID === 'number')) {\n      try {\n        await isolated.payload.db.deleteOne({\n          branch: false,\n          collection: collectionSlug,\n          req: isolated,\n          where: { id: { equals: shadowID } },\n        })\n      } catch {\n        // The callback error remains the reason this operation failed.\n      }\n    }\n\n    throw error\n  }\n}\n\nconst createShadowContent = async ({\n  branch,\n  collectionSlug,\n  data,\n  req,\n  source,\n}: {\n  branch: string\n  collectionSlug: string\n  data: Record<string, unknown>\n  req: PayloadRequest\n  source?: ShadowSource\n}): Promise<Record<string, unknown>> => {\n  if (source) {\n    return req.payload.db.copy({\n      collection: collectionSlug,\n      data: {\n        ...data,\n        [branchDocIDField]: source.id,\n        [branchField]: branch,\n      },\n      req,\n      where: {\n        and: [\n          { [branchField]: { equals: source.branch } },\n          {\n            or: [{ id: { equals: source.id } }, { [branchDocIDField]: { equals: source.id } }],\n          },\n        ],\n      },\n    }) as Promise<Record<string, unknown>>\n  }\n\n  return req.payload.db.create({\n    collection: collectionSlug,\n    data,\n    req,\n  }) as Promise<Record<string, unknown>>\n}\n"],"names":["APIError","ValidationError","shareFileOperationScope","commitTransaction","isUnknownTransactionCommitResult","initTransaction","isolateObjectProperty","killTransaction","branchChangesCollectionSlug","branchDocIDField","branchField","isShadowUniquenessError","error","data","errors","some","path","split","map","fieldPath","trim","isTransientTransactionError","labeledError","hasErrorLabel","errorLabels","includes","isRecoverableConcurrentShadowError","concurrentShadowOperationErrors","WeakSet","markConcurrentShadowOperationError","add","isConcurrentShadowOperationError","Boolean","has","maximumConcurrentShadowAttempts","waitForConcurrentShadowRetry","retryIndex","delayMilliseconds","Math","min","Promise","resolve","setTimeout","retryConcurrentShadowOperation","onRetry","operation","shouldRetry","waitForRetry","attemptIndex","hasAnotherAttempt","isRetryAllowed","Error","findCompetingShadow","branch","collectionSlug","docID","req","recoveryReq","transactionID","winner","payload","db","findOne","collection","where","and","equals","change","documentID","String","authoritativeOperation","createShadowRow","onCreated","source","useAmbientTransaction","ambient","owner","shadow","createShadowContent","isolated","shouldCommit","shadowID","id","deleteOne","copy","or","create"],"mappings":"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"}

package/dist/branching/discard.d.ts

@@ -0,0 +1,52 @@
+import type { Payload, PayloadRequest } from '../types/index.js';
+import type { BranchOperation } from './types.js';
+export type DiscardedChange = {
+    changeID: number | string;
+    /** Absent for a global. */
+    collectionSlug?: string;
+    /** Absent for a global. */
+    docID?: number | string;
+    entityType: 'collection' | 'global';
+    globalSlug?: string;
+    operation: BranchOperation;
+};
+export type DiscardResult = {
+    discarded: DiscardedChange[];
+};
+export type DiscardOptions = {
+    branch: string;
+    /** Change IDs to discard. Omit to discard everything pending on the branch. */
+    changes?: (number | string)[];
+    /**
+     * Skip branch read and discard access checks.
+     *
+     * @default false
+     */
+    overrideAccess?: boolean;
+    req?: PayloadRequest;
+    user?: NonNullable<PayloadRequest['user']>;
+};
+/**
+ * Throws away a branch's changes, returning the documents to main's state.
+ *
+ * The mirror of merge, and structurally simpler: merge has to reconcile with
+ * production, while discard only has to forget. Every operation reduces to the same
+ * act — drop the branch's row — because the branch's row *is* the change:
+ *
+ * - **create** — the row is the document, so dropping it removes it from the branch.
+ * - **update** — the row is the branch's copy, so dropping it makes the branch read
+ *   through to main again.
+ * - **delete** — the row is the tombstone, so dropping it un-hides main's document.
+ *
+ * Nothing on `main` is touched in any of the three, which is why this needs no
+ * per-document preflight the way merge does (§13): a branch is a proposal, and
+ * withdrawing a proposal is not a production write.
+ *
+ * Before a branch-created row is removed, reference checks verify that no surviving
+ * document, global or version still points to it. Rows removed by the same discard
+ * are excluded from that check.
+ */
+export declare const discardBranchChanges: (payload: Payload, options: DiscardOptions) => Promise<DiscardResult>;
+/** Removes all state for a branch that its owning collection row is about to delete. */
+export declare const discardBranchChangesBeforeBranchDeletion: (payload: Payload, { branch, req }: Pick<DiscardOptions, 'branch' | 'req'>) => Promise<DiscardResult>;
+//# sourceMappingURL=discard.d.ts.map

package/dist/branching/discard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discard.d.ts","sourceRoot":"","sources":["../../src/branching/discard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AA+BjD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,2BAA2B;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,UAAU,EAAE,YAAY,GAAG,QAAQ,CAAA;IACnC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,eAAe,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,eAAe,EAAE,CAAA;CAC7B,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,+EAA+E;IAC/E,OAAO,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAA;IAC7B;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,CAAC,EAAE,cAAc,CAAA;IACpB,IAAI,CAAC,EAAE,WAAW,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAA;CAC3C,CAAA;AAMD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,YACtB,OAAO,WACP,cAAc,KACtB,OAAO,CAAC,aAAa,CACgE,CAAA;AAExF,wFAAwF;AACxF,eAAO,MAAM,wCAAwC,YAC1C,OAAO,mBACC,IAAI,CAAC,cAAc,EAAE,QAAQ,GAAG,KAAK,CAAC,KACtD,OAAO,CAAC,aAAa,CAMpB,CAAA"}

package/dist/branching/discard.js

@@ -0,0 +1,428 @@
+import { deleteUploadFilesExclusiveToDocument } from '../uploads/deleteUploadFilesExclusiveToDocument.js';
+import { collectStoredFiles, scheduleUnreferencedFileCleanup } from '../uploads/fileVersioning/cleanup.js';
+import { commitTransaction } from '../utilities/commitTransaction.js';
+import { createPayloadRequest } from '../utilities/createPayloadRequest.js';
+import { initTransaction } from '../utilities/initTransaction.js';
+import { killTransaction } from '../utilities/killTransaction.js';
+import { beginDeferredCleanupScope, clearDeferredCleanupScope, flushDeferredCleanupScope } from '../utilities/transactionCallbacks.js';
+import { assertBranchActionAccess } from './assertBranchActionAccess.js';
+import { assertBranchCreatedDocumentsUnreferenced } from './assertBranchCreatedDocumentsUnreferenced.js';
+import { assertBranchWritable } from './assertBranchWritable.js';
+import { refreshBranchState, resetBranchState, withoutBranch } from './resolveBranch.js';
+import { selectBranchChanges } from './selectBranchChanges.js';
+import { branchChangesCollectionSlug, branchDocIDField, branchesCollectionSlug, branchField, branchParentField, MAIN_BRANCH } from './types.js';
+import { deleteBranchGlobalVersionChain, deleteBranchVersionChain } from './versions.js';
+/**
+ * Throws away a branch's changes, returning the documents to main's state.
+ *
+ * The mirror of merge, and structurally simpler: merge has to reconcile with
+ * production, while discard only has to forget. Every operation reduces to the same
+ * act — drop the branch's row — because the branch's row *is* the change:
+ *
+ * - **create** — the row is the document, so dropping it removes it from the branch.
+ * - **update** — the row is the branch's copy, so dropping it makes the branch read
+ *   through to main again.
+ * - **delete** — the row is the tombstone, so dropping it un-hides main's document.
+ *
+ * Nothing on `main` is touched in any of the three, which is why this needs no
+ * per-document preflight the way merge does (§13): a branch is a proposal, and
+ * withdrawing a proposal is not a production write.
+ *
+ * Before a branch-created row is removed, reference checks verify that no surviving
+ * document, global or version still points to it. Rows removed by the same discard
+ * are excluded from that check.
+ */ export const discardBranchChanges = async (payload, options)=>discardBranchChangesInternal(payload, {
+        ...options,
+        shouldCheckBranchWritable: true
+    });
+/** Removes all state for a branch that its owning collection row is about to delete. */ export const discardBranchChangesBeforeBranchDeletion = async (payload, { branch, req })=>discardBranchChangesInternal(payload, {
+        branch,
+        overrideAccess: true,
+        req,
+        shouldCheckBranchWritable: false
+    });
+const discardBranchChangesInternal = async (payload, { branch, changes: selected, overrideAccess = false, req: incomingReq, shouldCheckBranchWritable, user })=>{
+    // `branch: false` throughout, as with merge: the rows being dropped are addressed
+    // by their real primary keys, so the read predicate must not be in the way.
+    const req = incomingReq ? withoutBranch(incomingReq) : await createPayloadRequest({
+        branch: false,
+        payload,
+        user
+    });
+    if (user && !req.user) {
+        req.user = user;
+    }
+    const branchDocs = await payload.find({
+        collection: branchesCollectionSlug,
+        limit: 1,
+        overrideAccess,
+        pagination: false,
+        req,
+        where: {
+            slug: {
+                equals: branch
+            }
+        }
+    });
+    if (!branchDocs.docs[0]) {
+        throw new Error(`Branch "${branch}" was not found.`);
+    }
+    const branchDoc = branchDocs.docs[0];
+    if (!overrideAccess) {
+        await assertBranchActionAccess({
+            action: 'discardBranch',
+            branchDoc,
+            req
+        });
+    }
+    // Discarding is a write, so a closed branch refuses it — its archive is a record,
+    // and a record that can be edited is not one.
+    if (shouldCheckBranchWritable) {
+        await assertBranchWritable({
+            branch,
+            req
+        });
+    }
+    const allChanges = await payload.find({
+        collection: branchChangesCollectionSlug,
+        overrideAccess: true,
+        pagination: false,
+        req,
+        sort: 'createdAt',
+        where: {
+            branch: {
+                equals: branch
+            }
+        }
+    });
+    const applicable = selectBranchChanges({
+        changes: allChanges.docs,
+        selected
+    });
+    const result = {
+        discarded: []
+    };
+    if (!applicable.length) {
+        return result;
+    }
+    // Gated on `req.transactionID`, not on whether a `req` was passed in: a discard
+    // triggered over HTTP hands in a `req` of its own that has no transaction on it
+    // yet, and it must get one just as much as a Local API call would.
+    const shouldCommit = await initTransaction(req);
+    const cleanupScope = await beginDeferredCleanupScope({
+        req
+    });
+    const uploadCleanupPlans = [];
+    const plannedUploadIdentities = new Set();
+    try {
+        const shadowsByChangeID = new Map();
+        const ignoredGlobalOwnerBranches = new Map();
+        const ignoredOwnerRowIDs = new Map();
+        for (const change of applicable){
+            if (change.entityType === 'global') {
+                if (typeof change.globalSlug === 'string') {
+                    ignoredGlobalOwnerBranches.set(change.globalSlug, new Set([
+                        branch
+                    ]));
+                }
+                continue;
+            }
+            const collectionSlug = change.collectionSlug;
+            const docID = change.doc?.value ?? change.doc;
+            const shadow = await payload.db.findOne({
+                branch: false,
+                collection: collectionSlug,
+                req,
+                where: {
+                    and: [
+                        {
+                            [branchField]: {
+                                equals: branch
+                            }
+                        },
+                        {
+                            or: [
+                                {
+                                    id: {
+                                        equals: docID
+                                    }
+                                },
+                                {
+                                    [branchDocIDField]: {
+                                        equals: docID
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            });
+            shadowsByChangeID.set(String(change.id), shadow);
+            if (shadow?.id !== undefined && shadow.id !== null) {
+                const ignoredIDs = ignoredOwnerRowIDs.get(collectionSlug) ?? new Set();
+                ignoredIDs.add(shadow.id);
+                ignoredOwnerRowIDs.set(collectionSlug, ignoredIDs);
+            }
+        }
+        await assertBranchCreatedDocumentsUnreferenced({
+            ignoredGlobalOwnerBranches,
+            ignoredOwnerBranch: selected ? undefined : branch,
+            ignoredOwnerRowIDs,
+            req,
+            targets: applicable.flatMap((change)=>{
+                if (change.entityType === 'global' || change.operation !== 'create' || typeof change.collectionSlug !== 'string') {
+                    return [];
+                }
+                const docID = change.doc?.value ?? change.doc;
+                return typeof docID === 'number' || typeof docID === 'string' ? [
+                    {
+                        collectionSlug: change.collectionSlug,
+                        docID
+                    }
+                ] : [];
+            })
+        });
+        for (const change of applicable){
+            // A global has no shadow row to look up and no tombstone to undo: its branch copy
+            // *is* the change, so dropping the copy is the entire discard, and the branch reads
+            // through to main again immediately.
+            if (change.entityType === 'global') {
+                const globalSlug = change.globalSlug;
+                if (!payload.db.deleteBranchGlobal) {
+                    throw new Error(`The database adapter cannot remove a branch's copy of a global, so "${globalSlug}" cannot be discarded.`);
+                }
+                await deleteBranchGlobalVersionChain({
+                    branch,
+                    globalSlug,
+                    payload,
+                    req
+                });
+                await payload.db.deleteBranchGlobal({
+                    branch,
+                    globalSlug,
+                    req
+                });
+                await payload.delete({
+                    id: change.id,
+                    collection: branchChangesCollectionSlug,
+                    overrideAccess: true,
+                    req
+                });
+                result.discarded.push({
+                    changeID: change.id,
+                    entityType: 'global',
+                    globalSlug,
+                    operation: 'update'
+                });
+                continue;
+            }
+            const collectionSlug = change.collectionSlug;
+            const docID = change.doc?.value ?? change.doc;
+            const shadow = shadowsByChangeID.get(String(change.id));
+            if (shadow) {
+                const collectionConfig = payload.collections[collectionSlug].config;
+                if (collectionConfig.upload) {
+                    const retainedDoc = change.operation === 'create' ? null : await payload.db.findOne({
+                        branch: false,
+                        collection: collectionSlug,
+                        req,
+                        where: {
+                            and: [
+                                {
+                                    [branchField]: {
+                                        equals: MAIN_BRANCH
+                                    }
+                                },
+                                {
+                                    id: {
+                                        equals: docID
+                                    }
+                                }
+                            ]
+                        }
+                    });
+                    const versionDocuments = await readBranchVersionDocuments({
+                        branch,
+                        collectionSlug,
+                        payload,
+                        req,
+                        rowID: shadow.id
+                    });
+                    const sourceDocuments = change.operation === 'create' ? versionDocuments : [
+                        shadow,
+                        ...versionDocuments
+                    ];
+                    if (change.operation === 'create') {
+                        plannedUploadIdentities.add(`${collectionSlug}:${getUploadIdentity(shadow)}`);
+                    }
+                    for (const sourceDoc of sourceDocuments){
+                        const identity = `${collectionSlug}:${getUploadIdentity(sourceDoc)}`;
+                        if (!plannedUploadIdentities.has(identity)) {
+                            plannedUploadIdentities.add(identity);
+                            uploadCleanupPlans.push({
+                                collectionSlug,
+                                retainedDoc,
+                                sourceDoc
+                            });
+                        }
+                    }
+                }
+                if (change.operation === 'create') {
+                    await payload.delete({
+                        id: shadow.id,
+                        branch: false,
+                        collection: collectionSlug,
+                        overrideAccess: true,
+                        req,
+                        trash: true
+                    });
+                } else {
+                    await deleteBranchVersionChain({
+                        branch,
+                        collectionSlug,
+                        payload,
+                        req,
+                        rowID: shadow.id
+                    });
+                    await payload.db.deleteOne({
+                        branch: false,
+                        collection: collectionSlug,
+                        req,
+                        where: {
+                            id: {
+                                equals: shadow.id
+                            }
+                        }
+                    });
+                }
+            }
+            await payload.delete({
+                id: change.id,
+                collection: branchChangesCollectionSlug,
+                overrideAccess: true,
+                req
+            });
+            result.discarded.push({
+                changeID: change.id,
+                collectionSlug,
+                docID: docID,
+                entityType: 'collection',
+                operation: change.operation
+            });
+        }
+        for (const { collectionSlug, retainedDoc, sourceDoc } of uploadCleanupPlans){
+            const collectionConfig = payload.collections[collectionSlug].config;
+            const candidates = await collectStoredFiles({
+                collection: collectionConfig,
+                doc: sourceDoc,
+                req
+            });
+            if (candidates.length) {
+                await scheduleUnreferencedFileCleanup({
+                    candidates,
+                    collection: collectionConfig,
+                    req
+                });
+                if (!collectionConfig.upload.fileOperations) {
+                    await collectionConfig.upload.deleteFiles?.({
+                        req,
+                        retainedDoc,
+                        sourceDoc
+                    });
+                }
+            } else {
+                await deleteUploadFilesExclusiveToDocument({
+                    collectionConfig,
+                    config: payload.config,
+                    req,
+                    retainedDoc,
+                    sourceDoc
+                });
+            }
+        }
+        if (cleanupScope) {
+            await flushDeferredCleanupScope({
+                req,
+                scope: cleanupScope
+            });
+        }
+        if (shouldCommit) {
+            await commitTransaction(req);
+        }
+    } catch (error) {
+        if (cleanupScope) {
+            clearDeferredCleanupScope({
+                req,
+                scope: cleanupScope
+            });
+        }
+        if (shouldCommit) {
+            await killTransaction(req);
+        }
+        throw error;
+    } finally{
+        if (incomingReq) {
+            refreshBranchState(incomingReq);
+        }
+    }
+    // The manifest this request memoized still lists the discarded documents as
+    // shadowed, which would hide main's copies from any later read on this request.
+    resetBranchState(req);
+    return result;
+};
+const readBranchVersionDocuments = async ({ branch, collectionSlug, payload, req, rowID })=>{
+    if (!payload.collections[collectionSlug]?.config.versions) {
+        return [];
+    }
+    const { docs } = await payload.db.findVersions({
+        branch: false,
+        collection: collectionSlug,
+        limit: 0,
+        pagination: false,
+        req,
+        where: {
+            and: [
+                {
+                    parent: {
+                        equals: rowID
+                    }
+                },
+                {
+                    [branchField]: {
+                        equals: branch
+                    }
+                },
+                {
+                    [branchParentField]: {
+                        exists: true
+                    }
+                }
+            ]
+        }
+    });
+    return docs.flatMap((version)=>version.version && typeof version.version === 'object' && !Array.isArray(version.version) ? [
+            version.version
+        ] : []);
+};
+const getUploadIdentity = (doc)=>{
+    const variantFilenames = doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants) ? Object.entries(doc.variants).flatMap(([name, variant])=>{
+        if (!variant || typeof variant !== 'object' || Array.isArray(variant)) {
+            return [];
+        }
+        const filename = variant.filename;
+        return typeof filename === 'string' ? [
+            [
+                name,
+                filename
+            ]
+        ] : [];
+    }).sort(([left], [right])=>left.localeCompare(right)) : [];
+    return JSON.stringify({
+        filename: doc.filename,
+        objectKey: doc._objectKey,
+        prefix: doc.prefix,
+        variants: variantFilenames
+    });
+};
+
+//# sourceMappingURL=discard.js.map

package/dist/branching/discard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/discard.ts"],"sourcesContent":["import type { Payload, PayloadRequest } from '../types/index.js'\nimport type { BranchOperation } from './types.js'\n\nimport { deleteUploadFilesExclusiveToDocument } from '../uploads/deleteUploadFilesExclusiveToDocument.js'\nimport {\n  collectStoredFiles,\n  scheduleUnreferencedFileCleanup,\n} from '../uploads/fileVersioning/cleanup.js'\nimport { commitTransaction } from '../utilities/commitTransaction.js'\nimport { createPayloadRequest } from '../utilities/createPayloadRequest.js'\nimport { initTransaction } from '../utilities/initTransaction.js'\nimport { killTransaction } from '../utilities/killTransaction.js'\nimport {\n  beginDeferredCleanupScope,\n  clearDeferredCleanupScope,\n  flushDeferredCleanupScope,\n} from '../utilities/transactionCallbacks.js'\nimport { assertBranchActionAccess } from './assertBranchActionAccess.js'\nimport { assertBranchCreatedDocumentsUnreferenced } from './assertBranchCreatedDocumentsUnreferenced.js'\nimport { assertBranchWritable } from './assertBranchWritable.js'\nimport { refreshBranchState, resetBranchState, withoutBranch } from './resolveBranch.js'\nimport { selectBranchChanges } from './selectBranchChanges.js'\nimport {\n  branchChangesCollectionSlug,\n  branchDocIDField,\n  branchesCollectionSlug,\n  branchField,\n  branchParentField,\n  MAIN_BRANCH,\n} from './types.js'\nimport { deleteBranchGlobalVersionChain, deleteBranchVersionChain } from './versions.js'\n\nexport type DiscardedChange = {\n  changeID: number | string\n  /** Absent for a global. */\n  collectionSlug?: string\n  /** Absent for a global. */\n  docID?: number | string\n  entityType: 'collection' | 'global'\n  globalSlug?: string\n  operation: BranchOperation\n}\n\nexport type DiscardResult = {\n  discarded: DiscardedChange[]\n}\n\nexport type DiscardOptions = {\n  branch: string\n  /** Change IDs to discard. Omit to discard everything pending on the branch. */\n  changes?: (number | string)[]\n  /**\n   * Skip branch read and discard access checks.\n   *\n   * @default false\n   */\n  overrideAccess?: boolean\n  req?: PayloadRequest\n  user?: NonNullable<PayloadRequest['user']>\n}\n\ntype DiscardInternalOptions = {\n  shouldCheckBranchWritable: boolean\n} & DiscardOptions\n\n/**\n * Throws away a branch's changes, returning the documents to main's state.\n *\n * The mirror of merge, and structurally simpler: merge has to reconcile with\n * production, while discard only has to forget. Every operation reduces to the same\n * act — drop the branch's row — because the branch's row *is* the change:\n *\n * - **create** — the row is the document, so dropping it removes it from the branch.\n * - **update** — the row is the branch's copy, so dropping it makes the branch read\n *   through to main again.\n * - **delete** — the row is the tombstone, so dropping it un-hides main's document.\n *\n * Nothing on `main` is touched in any of the three, which is why this needs no\n * per-document preflight the way merge does (§13): a branch is a proposal, and\n * withdrawing a proposal is not a production write.\n *\n * Before a branch-created row is removed, reference checks verify that no surviving\n * document, global or version still points to it. Rows removed by the same discard\n * are excluded from that check.\n */\nexport const discardBranchChanges = async (\n  payload: Payload,\n  options: DiscardOptions,\n): Promise<DiscardResult> =>\n  discardBranchChangesInternal(payload, { ...options, shouldCheckBranchWritable: true })\n\n/** Removes all state for a branch that its owning collection row is about to delete. */\nexport const discardBranchChangesBeforeBranchDeletion = async (\n  payload: Payload,\n  { branch, req }: Pick<DiscardOptions, 'branch' | 'req'>,\n): Promise<DiscardResult> =>\n  discardBranchChangesInternal(payload, {\n    branch,\n    overrideAccess: true,\n    req,\n    shouldCheckBranchWritable: false,\n  })\n\nconst discardBranchChangesInternal = async (\n  payload: Payload,\n  {\n    branch,\n    changes: selected,\n    overrideAccess = false,\n    req: incomingReq,\n    shouldCheckBranchWritable,\n    user,\n  }: DiscardInternalOptions,\n): Promise<DiscardResult> => {\n  // `branch: false` throughout, as with merge: the rows being dropped are addressed\n  // by their real primary keys, so the read predicate must not be in the way.\n  const req = incomingReq\n    ? withoutBranch(incomingReq)\n    : await createPayloadRequest({ branch: false, payload, user })\n\n  if (user && !req.user) {\n    req.user = user\n  }\n\n  const branchDocs = await payload.find({\n    collection: branchesCollectionSlug,\n    limit: 1,\n    overrideAccess,\n    pagination: false,\n    req,\n    where: { slug: { equals: branch } },\n  })\n\n  if (!branchDocs.docs[0]) {\n    throw new Error(`Branch \"${branch}\" was not found.`)\n  }\n\n  const branchDoc = branchDocs.docs[0]\n\n  if (!overrideAccess) {\n    await assertBranchActionAccess({ action: 'discardBranch', branchDoc, req })\n  }\n\n  // Discarding is a write, so a closed branch refuses it — its archive is a record,\n  // and a record that can be edited is not one.\n  if (shouldCheckBranchWritable) {\n    await assertBranchWritable({ branch, req })\n  }\n\n  const allChanges = await payload.find({\n    collection: branchChangesCollectionSlug,\n    overrideAccess: true,\n    pagination: false,\n    req,\n    sort: 'createdAt',\n    where: {\n      branch: { equals: branch },\n    },\n  })\n\n  const applicable = selectBranchChanges({ changes: allChanges.docs, selected })\n\n  const result: DiscardResult = { discarded: [] }\n\n  if (!applicable.length) {\n    return result\n  }\n\n  // Gated on `req.transactionID`, not on whether a `req` was passed in: a discard\n  // triggered over HTTP hands in a `req` of its own that has no transaction on it\n  // yet, and it must get one just as much as a Local API call would.\n  const shouldCommit = await initTransaction(req)\n  const cleanupScope = await beginDeferredCleanupScope({ req })\n  const uploadCleanupPlans: {\n    collectionSlug: string\n    retainedDoc: null | Record<string, unknown>\n    sourceDoc: Record<string, unknown>\n  }[] = []\n  const plannedUploadIdentities = new Set<string>()\n\n  try {\n    const shadowsByChangeID = new Map<string, null | Record<string, unknown>>()\n    const ignoredGlobalOwnerBranches = new Map<string, Set<string>>()\n    const ignoredOwnerRowIDs = new Map<string, Set<number | string>>()\n\n    for (const change of applicable) {\n      if (change.entityType === 'global') {\n        if (typeof change.globalSlug === 'string') {\n          ignoredGlobalOwnerBranches.set(change.globalSlug, new Set([branch]))\n        }\n\n        continue\n      }\n\n      const collectionSlug = change.collectionSlug as string\n      const docID = (change.doc as { value?: number | string })?.value ?? change.doc\n      const shadow = (await payload.db.findOne({\n        branch: false,\n        collection: collectionSlug,\n        req,\n        where: {\n          and: [\n            { [branchField]: { equals: branch } },\n            { or: [{ id: { equals: docID } }, { [branchDocIDField]: { equals: docID } }] },\n          ],\n        },\n      })) as null | Record<string, unknown>\n\n      shadowsByChangeID.set(String(change.id), shadow)\n\n      if (shadow?.id !== undefined && shadow.id !== null) {\n        const ignoredIDs = ignoredOwnerRowIDs.get(collectionSlug) ?? new Set<number | string>()\n\n        ignoredIDs.add(shadow.id as number | string)\n        ignoredOwnerRowIDs.set(collectionSlug, ignoredIDs)\n      }\n    }\n\n    await assertBranchCreatedDocumentsUnreferenced({\n      ignoredGlobalOwnerBranches,\n      ignoredOwnerBranch: selected ? undefined : branch,\n      ignoredOwnerRowIDs,\n      req,\n      targets: applicable.flatMap((change) => {\n        if (\n          change.entityType === 'global' ||\n          change.operation !== 'create' ||\n          typeof change.collectionSlug !== 'string'\n        ) {\n          return []\n        }\n\n        const docID = (change.doc as { value?: number | string })?.value ?? change.doc\n\n        return typeof docID === 'number' || typeof docID === 'string'\n          ? [{ collectionSlug: change.collectionSlug, docID }]\n          : []\n      }),\n    })\n\n    for (const change of applicable) {\n      // A global has no shadow row to look up and no tombstone to undo: its branch copy\n      // *is* the change, so dropping the copy is the entire discard, and the branch reads\n      // through to main again immediately.\n      if (change.entityType === 'global') {\n        const globalSlug = change.globalSlug as string\n\n        if (!payload.db.deleteBranchGlobal) {\n          throw new Error(\n            `The database adapter cannot remove a branch's copy of a global, so \"${globalSlug}\" cannot be discarded.`,\n          )\n        }\n\n        await deleteBranchGlobalVersionChain({ branch, globalSlug, payload, req })\n        await payload.db.deleteBranchGlobal({ branch, globalSlug, req })\n\n        await payload.delete({\n          id: change.id,\n          collection: branchChangesCollectionSlug,\n          overrideAccess: true,\n          req,\n        })\n\n        result.discarded.push({\n          changeID: change.id,\n          entityType: 'global',\n          globalSlug,\n          operation: 'update',\n        })\n\n        continue\n      }\n\n      const collectionSlug = change.collectionSlug as string\n      const docID = (change.doc as { value?: number | string })?.value ?? change.doc\n      const shadow = shadowsByChangeID.get(String(change.id))\n\n      if (shadow) {\n        const collectionConfig = payload.collections[collectionSlug]!.config\n\n        if (collectionConfig.upload) {\n          const retainedDoc =\n            change.operation === 'create'\n              ? null\n              : ((await payload.db.findOne({\n                  branch: false,\n                  collection: collectionSlug,\n                  req,\n                  where: {\n                    and: [{ [branchField]: { equals: MAIN_BRANCH } }, { id: { equals: docID } }],\n                  },\n                })) as null | Record<string, unknown>)\n          const versionDocuments = await readBranchVersionDocuments({\n            branch,\n            collectionSlug,\n            payload,\n            req,\n            rowID: shadow.id as number | string,\n          })\n          const sourceDocuments =\n            change.operation === 'create' ? versionDocuments : [shadow, ...versionDocuments]\n\n          if (change.operation === 'create') {\n            plannedUploadIdentities.add(`${collectionSlug}:${getUploadIdentity(shadow)}`)\n          }\n\n          for (const sourceDoc of sourceDocuments) {\n            const identity = `${collectionSlug}:${getUploadIdentity(sourceDoc)}`\n\n            if (!plannedUploadIdentities.has(identity)) {\n              plannedUploadIdentities.add(identity)\n              uploadCleanupPlans.push({ collectionSlug, retainedDoc, sourceDoc })\n            }\n          }\n        }\n\n        if (change.operation === 'create') {\n          await payload.delete({\n            id: shadow.id as number | string,\n            branch: false,\n            collection: collectionSlug,\n            overrideAccess: true,\n            req,\n            trash: true,\n          })\n        } else {\n          await deleteBranchVersionChain({\n            branch,\n            collectionSlug,\n            payload,\n            req,\n            rowID: shadow.id as number | string,\n          })\n\n          await payload.db.deleteOne({\n            branch: false,\n            collection: collectionSlug,\n            req,\n            where: { id: { equals: shadow.id } },\n          })\n        }\n      }\n\n      await payload.delete({\n        id: change.id,\n        collection: branchChangesCollectionSlug,\n        overrideAccess: true,\n        req,\n      })\n\n      result.discarded.push({\n        changeID: change.id,\n        collectionSlug,\n        docID: docID as number | string,\n        entityType: 'collection',\n        operation: change.operation as BranchOperation,\n      })\n    }\n\n    for (const { collectionSlug, retainedDoc, sourceDoc } of uploadCleanupPlans) {\n      const collectionConfig = payload.collections[collectionSlug]!.config\n      const candidates = await collectStoredFiles({\n        collection: collectionConfig,\n        doc: sourceDoc,\n        req,\n      })\n\n      if (candidates.length) {\n        await scheduleUnreferencedFileCleanup({ candidates, collection: collectionConfig, req })\n\n        if (!collectionConfig.upload.fileOperations) {\n          await collectionConfig.upload.deleteFiles?.({ req, retainedDoc, sourceDoc })\n        }\n      } else {\n        await deleteUploadFilesExclusiveToDocument({\n          collectionConfig,\n          config: payload.config,\n          req,\n          retainedDoc,\n          sourceDoc,\n        })\n      }\n    }\n\n    if (cleanupScope) {\n      await flushDeferredCleanupScope({ req, scope: cleanupScope })\n    }\n    if (shouldCommit) {\n      await commitTransaction(req)\n    }\n  } catch (error) {\n    if (cleanupScope) {\n      clearDeferredCleanupScope({ req, scope: cleanupScope })\n    }\n\n    if (shouldCommit) {\n      await killTransaction(req)\n    }\n    throw error\n  } finally {\n    if (incomingReq) {\n      refreshBranchState(incomingReq)\n    }\n  }\n\n  // The manifest this request memoized still lists the discarded documents as\n  // shadowed, which would hide main's copies from any later read on this request.\n  resetBranchState(req)\n\n  return result\n}\n\nconst readBranchVersionDocuments = async ({\n  branch,\n  collectionSlug,\n  payload,\n  req,\n  rowID,\n}: {\n  branch: string\n  collectionSlug: string\n  payload: Payload\n  req: PayloadRequest\n  rowID: number | string\n}): Promise<Record<string, unknown>[]> => {\n  if (!payload.collections[collectionSlug]?.config.versions) {\n    return []\n  }\n\n  const { docs } = await payload.db.findVersions({\n    branch: false,\n    collection: collectionSlug,\n    limit: 0,\n    pagination: false,\n    req,\n    where: {\n      and: [\n        { parent: { equals: rowID } },\n        { [branchField]: { equals: branch } },\n        { [branchParentField]: { exists: true } },\n      ],\n    },\n  })\n\n  return docs.flatMap((version) =>\n    version.version && typeof version.version === 'object' && !Array.isArray(version.version)\n      ? [version.version as Record<string, unknown>]\n      : [],\n  )\n}\n\nconst getUploadIdentity = (doc: Record<string, unknown>): string => {\n  const variantFilenames =\n    doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)\n      ? Object.entries(doc.variants)\n          .flatMap(([name, variant]) => {\n            if (!variant || typeof variant !== 'object' || Array.isArray(variant)) {\n              return []\n            }\n\n            const filename = (variant as Record<string, unknown>).filename\n\n            return typeof filename === 'string' ? [[name, filename] as [string, string]] : []\n          })\n          .sort(([left], [right]) => left.localeCompare(right))\n      : []\n\n  return JSON.stringify({\n    filename: doc.filename,\n    objectKey: doc._objectKey,\n    prefix: doc.prefix,\n    variants: variantFilenames,\n  })\n}\n"],"names":["deleteUploadFilesExclusiveToDocument","collectStoredFiles","scheduleUnreferencedFileCleanup","commitTransaction","createPayloadRequest","initTransaction","killTransaction","beginDeferredCleanupScope","clearDeferredCleanupScope","flushDeferredCleanupScope","assertBranchActionAccess","assertBranchCreatedDocumentsUnreferenced","assertBranchWritable","refreshBranchState","resetBranchState","withoutBranch","selectBranchChanges","branchChangesCollectionSlug","branchDocIDField","branchesCollectionSlug","branchField","branchParentField","MAIN_BRANCH","deleteBranchGlobalVersionChain","deleteBranchVersionChain","discardBranchChanges","payload","options","discardBranchChangesInternal","shouldCheckBranchWritable","discardBranchChangesBeforeBranchDeletion","branch","req","overrideAccess","changes","selected","incomingReq","user","branchDocs","find","collection","limit","pagination","where","slug","equals","docs","Error","branchDoc","action","allChanges","sort","applicable","result","discarded","length","shouldCommit","cleanupScope","uploadCleanupPlans","plannedUploadIdentities","Set","shadowsByChangeID","Map","ignoredGlobalOwnerBranches","ignoredOwnerRowIDs","change","entityType","globalSlug","set","collectionSlug","docID","doc","value","shadow","db","findOne","and","or","id","String","undefined","ignoredIDs","get","add","ignoredOwnerBranch","targets","flatMap","operation","deleteBranchGlobal","delete","push","changeID","collectionConfig","collections","config","upload","retainedDoc","versionDocuments","readBranchVersionDocuments","rowID","sourceDocuments","getUploadIdentity","sourceDoc","identity","has","trash","deleteOne","candidates","fileOperations","deleteFiles","scope","error","versions","findVersions","parent","exists","version","Array","isArray","variantFilenames","variants","Object","entries","name","variant","filename","left","right","localeCompare","JSON","stringify","objectKey","_objectKey","prefix"],"mappings":"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"}

package/dist/branching/effectiveOperations.d.ts

@@ -0,0 +1,55 @@
+import type { Payload, PayloadRequest } from '../types/index.js';
+/**
+ * What a change will actually do to `main` when merged, which is not always what
+ * it did on the branch. Editing a published document on a branch is a `publish`
+ * against main and needs publish permission; saving a draft on that same
+ * document is an ordinary `update` that must leave main's published row alone.
+ */
+export type EffectiveOperation = 'create' | 'delete' | 'publish' | 'update';
+/** One write against main for the selected source state or its Trash transition. */
+export type EffectiveWrite = {
+    /** The document state to write. */
+    data: Record<string, unknown>;
+    /** Whether the write is a draft save rather than a publish. */
+    draft: boolean;
+    operation: EffectiveOperation;
+    /**
+     * A row-level Trash transition that accompanies versioned content.
+     *
+     * `apply` updates main. `access` only adds the required permission check
+     * because a later published write already carries the same `deletedAt` state.
+     */
+    trashState?: 'access' | 'apply';
+};
+export type ResolvedChange = {
+    change: Record<string, any>;
+    collectionSlug: string;
+    docID: number | string;
+    shadow: null | Record<string, unknown>;
+    /** The latest source-state write and any separate Trash transition. */
+    writes: EffectiveWrite[];
+};
+/**
+ * Resolves what each pending change will do to main.
+ *
+ * The shadow row alone cannot answer this. A fork copies main's row wholesale, so
+ * a document forked from a published main row carries `_status: 'published'` even
+ * when every edit made on the branch was a draft save — and draft saves never
+ * touch the main row (§7), so the row still holds main's own pre-fork values.
+ * Reading only the row therefore reports a `publish` of values main already has:
+ * a merge that claims success and changes nothing.
+ *
+ * The branch's newest *version* is the missing half. `baseUpdatedAt`, recorded on
+ * the registry row at fork time, separates the two cases the row cannot: the
+ * shadow row's `updatedAt` still matching it means the branch never published,
+ * because only a publish rewrites that row.
+ */
+export declare const resolveEffectiveOperations: ({ branch, changes, payload, req, }: {
+    branch: string;
+    changes: Record<string, any>[];
+    payload: Payload;
+    req: PayloadRequest;
+}) => Promise<ResolvedChange[]>;
+/** The distinct operations a change needs permission for. */
+export declare const operationsForChange: (resolved: ResolvedChange) => EffectiveOperation[];
+//# sourceMappingURL=effectiveOperations.d.ts.map

package/dist/branching/effectiveOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectiveOperations.d.ts","sourceRoot":"","sources":["../../src/branching/effectiveOperations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,cAAc,EAAS,MAAM,mBAAmB,CAAA;AAUvE;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAA;AAE3E,oFAAoF;AACpF,MAAM,MAAM,cAAc,GAAG;IAC3B,mCAAmC;IACnC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,+DAA+D;IAC/D,KAAK,EAAE,OAAO,CAAA;IACd,SAAS,EAAE,kBAAkB,CAAA;IAC7B;;;;;OAKG;IACH,UAAU,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAA;CAChC,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC3B,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,uEAAuE;IACvE,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,0BAA0B,uCAKpC;IACD,MAAM,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAA;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,cAAc,EAAE,CA0B3B,CAAA;AA6bD,6DAA6D;AAC7D,eAAO,MAAM,mBAAmB,aAAc,cAAc,KAAG,kBAAkB,EAEhF,CAAA"}