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

package/dist/branching/effectiveOperations.js

@@ -0,0 +1,472 @@
+import { APIError } from '../errors/index.js';
+import { batchProcessing } from '../utilities/batchProcessing.js';
+import { extractRelationshipID } from '../utilities/extractRelationshipID.js';
+import { traverseForLocalizedFields } from '../utilities/traverseForLocalizedFields.js';
+import { branchDocIDField, branchField, MAIN_BRANCH } from './types.js';
+const effectiveOperationReadBatchSize = 400;
+/**
+ * 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 const resolveEffectiveOperations = async ({ branch, changes, payload, req })=>{
+    const shadowsByChange = await readChangeShadows({
+        branch,
+        changes,
+        payload,
+        req
+    });
+    const resolved = [];
+    for (const change of changes){
+        const collectionSlug = change.collectionSlug;
+        const docID = getBranchChangeDocumentID({
+            change,
+            collectionSlug
+        });
+        const shadow = shadowsByChange.get(changeKey({
+            collectionSlug,
+            docID
+        })) ?? null;
+        if (!shadow) {
+            throw new APIError(`The ${collectionSlug} branch row for document ${String(docID)} is missing.`, 409);
+        }
+        resolved.push({
+            change,
+            collectionSlug,
+            docID,
+            shadow,
+            writes: await resolveWrites({
+                branch,
+                change,
+                collectionSlug,
+                docID,
+                payload,
+                req,
+                shadow
+            })
+        });
+    }
+    return resolved;
+};
+const changeKey = ({ collectionSlug, docID })=>`${collectionSlug}:${String(docID)}`;
+const readChangeShadows = async ({ branch, changes, payload, req })=>{
+    const changesByCollection = new Map();
+    const shadowsByChange = new Map();
+    for (const change of changes){
+        const collectionSlug = change.collectionSlug;
+        const collectionChanges = changesByCollection.get(collectionSlug) ?? [];
+        collectionChanges.push(change);
+        changesByCollection.set(collectionSlug, collectionChanges);
+    }
+    for (const [collectionSlug, collectionChanges] of changesByCollection){
+        await batchProcessing({
+            batchSize: effectiveOperationReadBatchSize,
+            input: collectionChanges,
+            processBatch: async ({ batch })=>{
+                const createdDocumentIDs = batch.filter(({ operation })=>operation === 'create').map((change)=>getBranchChangeDocumentID({
+                        change,
+                        collectionSlug
+                    }));
+                const existingDocumentIDs = batch.filter(({ operation })=>operation !== 'create').map((change)=>getBranchChangeDocumentID({
+                        change,
+                        collectionSlug
+                    }));
+                const identityQueries = [];
+                if (createdDocumentIDs.length) {
+                    identityQueries.push({
+                        id: {
+                            in: createdDocumentIDs
+                        }
+                    });
+                }
+                if (existingDocumentIDs.length) {
+                    identityQueries.push({
+                        [branchDocIDField]: {
+                            in: existingDocumentIDs
+                        }
+                    });
+                }
+                const identityQuery = identityQueries.length === 1 ? identityQueries[0] : {
+                    or: identityQueries
+                };
+                const { docs } = await payload.db.find({
+                    branch: false,
+                    collection: collectionSlug,
+                    limit: batch.length,
+                    pagination: false,
+                    req,
+                    where: {
+                        and: [
+                            {
+                                [branchField]: {
+                                    equals: branch
+                                }
+                            },
+                            identityQuery
+                        ]
+                    }
+                });
+                for (const shadow of docs){
+                    const docID = extractRelationshipID({
+                        relationship: shadow[branchDocIDField] ?? shadow.id
+                    });
+                    if (docID === undefined) {
+                        continue;
+                    }
+                    shadowsByChange.set(changeKey({
+                        collectionSlug,
+                        docID
+                    }), shadow);
+                }
+            }
+        });
+    }
+    return shadowsByChange;
+};
+const getBranchChangeDocumentID = ({ change, collectionSlug })=>{
+    const docID = extractRelationshipID({
+        relationship: change.doc
+    });
+    if (docID === undefined) {
+        throw new APIError(`The ${collectionSlug} branch change has no document ID.`, 409);
+    }
+    return docID;
+};
+const resolveWrites = async ({ branch, change, collectionSlug, docID, payload, req, shadow })=>{
+    if (change.operation === 'delete') {
+        return [
+            {
+                data: {},
+                draft: false,
+                operation: 'delete'
+            }
+        ];
+    }
+    if (!shadow) {
+        return [];
+    }
+    const collectionConfig = payload.collections[collectionSlug]?.config;
+    const hasDrafts = Boolean(collectionConfig?.versions?.drafts);
+    // Without drafts there is no publish to distinguish: every row is live, so the
+    // row itself is the whole change and ordinary update permission covers it.
+    if (!hasDrafts) {
+        return [
+            ...getTrashAccessWrites({
+                collectionSlug,
+                payload,
+                shadow
+            }),
+            {
+                data: shadow,
+                draft: false,
+                operation: change.operation === 'create' ? 'create' : 'update'
+            }
+        ];
+    }
+    const rowIsPublished = isPublished(shadow._status);
+    const newerDraft = await findNewerDraft({
+        collectionSlug,
+        payload,
+        req,
+        shadow
+    });
+    if (change.operation === 'create') {
+        // Only the latest source state is applied. If a branch published and then
+        // drafted, the draft creates an unpublished target without replaying the
+        // earlier publication first.
+        return [
+            ...getTrashAccessWrites({
+                collectionSlug,
+                payload,
+                shadow
+            }),
+            {
+                data: newerDraft ?? shadow,
+                draft: Boolean(newerDraft) || !rowIsPublished,
+                operation: 'create'
+            }
+        ];
+    }
+    // Forked. Only a publish rewrites the shadow row, so a row still carrying the
+    // `updatedAt` it was forked with means nothing was published on this branch —
+    // whatever the branch changed lives entirely in its draft chain, and main's
+    // published row must survive the merge untouched.
+    //
+    // The timestamp is a fast path, not the answer. A fork and the publish that follows it
+    // can land in the same millisecond, and then the two are equal for a branch that really
+    // did publish — which made the merge apply *nothing at all* while still reporting the
+    // change as merged, and consume it. So an equal timestamp falls through to the question
+    // it was standing in for: did this branch publish a version of its own?
+    const publishedOnBranch = rowIsPublished && (!matchesForkPoint({
+        baseUpdatedAt: change.baseUpdatedAt,
+        shadow
+    }) || await hasBranchPublishedVersion({
+        branch,
+        collectionSlug,
+        payload,
+        req,
+        shadow
+    }));
+    const trashStateWrite = await resolveTrashStateWrite({
+        collectionSlug,
+        docID,
+        payload,
+        req,
+        shadow
+    });
+    if (newerDraft) {
+        return [
+            ...trashStateWrite ? [
+                {
+                    ...trashStateWrite,
+                    trashState: 'apply'
+                }
+            ] : getTrashAccessWrites({
+                collectionSlug,
+                payload,
+                shadow
+            }),
+            {
+                data: newerDraft,
+                draft: true,
+                operation: 'update'
+            }
+        ];
+    }
+    if (!publishedOnBranch) {
+        // Nothing to apply when the branch has neither published nor drafted: the
+        // fork itself is not a change to main.
+        return [
+            ...trashStateWrite ? [
+                {
+                    ...trashStateWrite,
+                    trashState: 'apply'
+                }
+            ] : getTrashAccessWrites({
+                collectionSlug,
+                payload,
+                shadow
+            })
+        ];
+    }
+    const writes = [
+        ...trashStateWrite ? [
+            {
+                ...trashStateWrite,
+                trashState: 'access'
+            }
+        ] : getTrashAccessWrites({
+            collectionSlug,
+            payload,
+            shadow
+        }),
+        {
+            data: shadow,
+            draft: false,
+            operation: 'publish'
+        }
+    ];
+    return writes;
+};
+const getTrashAccessWrites = ({ collectionSlug, payload, shadow })=>{
+    if (!payload.collections[collectionSlug]?.config.trash || shadow.deletedAt == null) {
+        return [];
+    }
+    return [
+        {
+            data: shadow,
+            draft: false,
+            operation: 'delete',
+            trashState: 'access'
+        }
+    ];
+};
+const resolveTrashStateWrite = async ({ collectionSlug, docID, payload, req, shadow })=>{
+    if (!payload.collections[collectionSlug]?.config.trash) {
+        return null;
+    }
+    const main = await payload.db.findOne({
+        branch: false,
+        collection: collectionSlug,
+        req,
+        where: {
+            and: [
+                {
+                    [branchField]: {
+                        equals: MAIN_BRANCH
+                    }
+                },
+                {
+                    id: {
+                        equals: docID
+                    }
+                }
+            ]
+        }
+    });
+    if (!main || toTrashState(main.deletedAt) === toTrashState(shadow.deletedAt)) {
+        return null;
+    }
+    return {
+        data: shadow,
+        draft: false,
+        operation: shadow.deletedAt == null ? 'update' : 'delete'
+    };
+};
+const toTrashState = (value)=>{
+    if (value == null) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return value.getTime();
+    }
+    if (typeof value !== 'number' && typeof value !== 'string') {
+        return null;
+    }
+    const time = new Date(value).getTime();
+    return Number.isNaN(time) ? value : time;
+};
+/**
+ * Whether a row is published, whether or not its status is localized.
+ *
+ * With localization enabled, `_status` is stored per locale, so a raw row carries an
+ * object rather than a string. Read as a scalar it is never `'published'` — which made
+ * every publish on a branch look like a fork nobody had touched, so merging a localized
+ * document applied **nothing** to main while consuming the change and reporting success.
+ *
+ * Published in any locale counts. The per-locale writes that follow carry each locale's own
+ * status, so this only decides whether a publish is part of the merge at all.
+ */ const isPublished = (status)=>{
+    if (typeof status === 'object' && status !== null) {
+        return Object.values(status).includes('published');
+    }
+    return status === 'published';
+};
+/**
+ * Whether this branch published a version of its own for the document.
+ *
+ * A fork copies the row, not its version chain, so a branch that has only forked owns no
+ * versions at all. One carrying a published version of its own has published on the
+ * branch, whatever the row's timestamp says.
+ */ const hasBranchPublishedVersion = async ({ branch, collectionSlug, payload, req, shadow })=>{
+    if (!payload.collections[collectionSlug]?.config.versions) {
+        return false;
+    }
+    const locales = payload.config.localization ? payload.config.localization.localeCodes : [
+        undefined
+    ];
+    for (const locale of locales){
+        const { docs } = await payload.db.findVersions({
+            branch: false,
+            collection: collectionSlug,
+            limit: 1,
+            locale,
+            pagination: false,
+            req,
+            where: {
+                and: [
+                    {
+                        parent: {
+                            equals: shadow.id
+                        }
+                    },
+                    {
+                        [branchField]: {
+                            equals: branch
+                        }
+                    },
+                    {
+                        'version._status': {
+                            equals: 'published'
+                        }
+                    }
+                ]
+            }
+        });
+        if (docs.length > 0) {
+            return true;
+        }
+    }
+    return false;
+};
+/**
+ * The branch's newest version when it sits above the branch's published row.
+ *
+ * Returns null when the newest version *is* the published state, so that a
+ * publish is not applied twice — once as the row and again as its own version.
+ */ const findNewerDraft = async ({ collectionSlug, payload, req, shadow })=>{
+    const collectionConfig = payload.collections[collectionSlug].config;
+    const localization = payload.config.localization;
+    const hasLocalizedFields = traverseForLocalizedFields(collectionConfig.fields);
+    const locale = localization ? hasLocalizedFields ? 'all' : req.locale && req.locale !== 'all' ? req.locale : localization.defaultLocale : undefined;
+    const { docs } = await payload.db.findVersions({
+        branch: false,
+        collection: collectionSlug,
+        limit: 1,
+        locale,
+        pagination: false,
+        req,
+        sort: '-updatedAt',
+        where: {
+            and: [
+                {
+                    latest: {
+                        equals: true
+                    }
+                },
+                {
+                    parent: {
+                        equals: shadow.id
+                    }
+                }
+            ]
+        }
+    });
+    const latest = docs?.[0];
+    const version = latest?.version;
+    if (!version || !isDraft({
+        locale,
+        status: version._status
+    })) {
+        return null;
+    }
+    return version;
+};
+const isDraft = ({ locale, status })=>{
+    if (typeof status === 'object' && status !== null) {
+        if (locale && locale !== 'all') {
+            return status[locale] === 'draft';
+        }
+        return Object.values(status).includes('draft');
+    }
+    return status === 'draft';
+};
+/**
+ * Whether the shadow row is still exactly as forked.
+ *
+ * `baseUpdatedAt` is stored as a date and may come back as a `Date` or a string
+ * depending on the adapter, so both sides are normalised before comparing.
+ */ const matchesForkPoint = ({ baseUpdatedAt, shadow })=>{
+    if (!baseUpdatedAt || !shadow.updatedAt) {
+        return false;
+    }
+    return toTime(baseUpdatedAt) === toTime(shadow.updatedAt);
+};
+const toTime = (value)=>{
+    const time = new Date(value).getTime();
+    return Number.isNaN(time) ? null : time;
+};
+/** The distinct operations a change needs permission for. */ export const operationsForChange = (resolved)=>[
+        ...new Set(resolved.writes.map((write)=>write.operation))
+    ];
+
+//# sourceMappingURL=effectiveOperations.js.map

package/dist/branching/effectiveOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/effectiveOperations.ts"],"sourcesContent":["import type { Payload, PayloadRequest, Where } from '../types/index.js'\n\nimport { APIError } from '../errors/index.js'\nimport { batchProcessing } from '../utilities/batchProcessing.js'\nimport { extractRelationshipID } from '../utilities/extractRelationshipID.js'\nimport { traverseForLocalizedFields } from '../utilities/traverseForLocalizedFields.js'\nimport { branchDocIDField, branchField, MAIN_BRANCH } from './types.js'\n\nconst effectiveOperationReadBatchSize = 400\n\n/**\n * What a change will actually do to `main` when merged, which is not always what\n * it did on the branch. Editing a published document on a branch is a `publish`\n * against main and needs publish permission; saving a draft on that same\n * document is an ordinary `update` that must leave main's published row alone.\n */\nexport type EffectiveOperation = 'create' | 'delete' | 'publish' | 'update'\n\n/** One write against main for the selected source state or its Trash transition. */\nexport type EffectiveWrite = {\n  /** The document state to write. */\n  data: Record<string, unknown>\n  /** Whether the write is a draft save rather than a publish. */\n  draft: boolean\n  operation: EffectiveOperation\n  /**\n   * A row-level Trash transition that accompanies versioned content.\n   *\n   * `apply` updates main. `access` only adds the required permission check\n   * because a later published write already carries the same `deletedAt` state.\n   */\n  trashState?: 'access' | 'apply'\n}\n\nexport type ResolvedChange = {\n  change: Record<string, any>\n  collectionSlug: string\n  docID: number | string\n  shadow: null | Record<string, unknown>\n  /** The latest source-state write and any separate Trash transition. */\n  writes: EffectiveWrite[]\n}\n\n/**\n * Resolves what each pending change will do to main.\n *\n * The shadow row alone cannot answer this. A fork copies main's row wholesale, so\n * a document forked from a published main row carries `_status: 'published'` even\n * when every edit made on the branch was a draft save — and draft saves never\n * touch the main row (§7), so the row still holds main's own pre-fork values.\n * Reading only the row therefore reports a `publish` of values main already has:\n * a merge that claims success and changes nothing.\n *\n * The branch's newest *version* is the missing half. `baseUpdatedAt`, recorded on\n * the registry row at fork time, separates the two cases the row cannot: the\n * shadow row's `updatedAt` still matching it means the branch never published,\n * because only a publish rewrites that row.\n */\nexport const resolveEffectiveOperations = async ({\n  branch,\n  changes,\n  payload,\n  req,\n}: {\n  branch: string\n  changes: Record<string, any>[]\n  payload: Payload\n  req: PayloadRequest\n}): Promise<ResolvedChange[]> => {\n  const shadowsByChange = await readChangeShadows({ branch, changes, payload, req })\n  const resolved: ResolvedChange[] = []\n\n  for (const change of changes) {\n    const collectionSlug = change.collectionSlug as string\n    const docID = getBranchChangeDocumentID({ change, collectionSlug })\n    const shadow = shadowsByChange.get(changeKey({ collectionSlug, docID })) ?? null\n\n    if (!shadow) {\n      throw new APIError(\n        `The ${collectionSlug} branch row for document ${String(docID)} is missing.`,\n        409,\n      )\n    }\n\n    resolved.push({\n      change,\n      collectionSlug,\n      docID,\n      shadow,\n      writes: await resolveWrites({ branch, change, collectionSlug, docID, payload, req, shadow }),\n    })\n  }\n\n  return resolved\n}\n\nconst changeKey = ({\n  collectionSlug,\n  docID,\n}: {\n  collectionSlug: string\n  docID: number | string\n}): string => `${collectionSlug}:${String(docID)}`\n\nconst readChangeShadows = async ({\n  branch,\n  changes,\n  payload,\n  req,\n}: {\n  branch: string\n  changes: Record<string, any>[]\n  payload: Payload\n  req: PayloadRequest\n}): Promise<Map<string, Record<string, unknown>>> => {\n  const changesByCollection = new Map<string, Record<string, any>[]>()\n  const shadowsByChange = new Map<string, Record<string, unknown>>()\n\n  for (const change of changes) {\n    const collectionSlug = change.collectionSlug as string\n    const collectionChanges = changesByCollection.get(collectionSlug) ?? []\n\n    collectionChanges.push(change)\n    changesByCollection.set(collectionSlug, collectionChanges)\n  }\n\n  for (const [collectionSlug, collectionChanges] of changesByCollection) {\n    await batchProcessing({\n      batchSize: effectiveOperationReadBatchSize,\n      input: collectionChanges,\n      processBatch: async ({ batch }) => {\n        const createdDocumentIDs = batch\n          .filter(({ operation }) => operation === 'create')\n          .map((change) => getBranchChangeDocumentID({ change, collectionSlug }))\n        const existingDocumentIDs = batch\n          .filter(({ operation }) => operation !== 'create')\n          .map((change) => getBranchChangeDocumentID({ change, collectionSlug }))\n        const identityQueries: Where[] = []\n\n        if (createdDocumentIDs.length) {\n          identityQueries.push({ id: { in: createdDocumentIDs } })\n        }\n\n        if (existingDocumentIDs.length) {\n          identityQueries.push({ [branchDocIDField]: { in: existingDocumentIDs } })\n        }\n\n        const identityQuery: Where =\n          identityQueries.length === 1 ? identityQueries[0]! : { or: identityQueries }\n        const { docs } = await payload.db.find({\n          branch: false,\n          collection: collectionSlug,\n          limit: batch.length,\n          pagination: false,\n          req,\n          where: {\n            and: [{ [branchField]: { equals: branch } }, identityQuery],\n          },\n        })\n\n        for (const shadow of docs as Record<string, unknown>[]) {\n          const docID = extractRelationshipID({\n            relationship: shadow[branchDocIDField] ?? shadow.id,\n          })\n\n          if (docID === undefined) {\n            continue\n          }\n\n          shadowsByChange.set(changeKey({ collectionSlug, docID }), shadow)\n        }\n      },\n    })\n  }\n\n  return shadowsByChange\n}\n\nconst getBranchChangeDocumentID = ({\n  change,\n  collectionSlug,\n}: {\n  change: Record<string, any>\n  collectionSlug: string\n}): number | string => {\n  const docID = extractRelationshipID({ relationship: change.doc })\n\n  if (docID === undefined) {\n    throw new APIError(`The ${collectionSlug} branch change has no document ID.`, 409)\n  }\n\n  return docID\n}\n\nconst resolveWrites = async ({\n  branch,\n  change,\n  collectionSlug,\n  docID,\n  payload,\n  req,\n  shadow,\n}: {\n  branch: string\n  change: Record<string, any>\n  collectionSlug: string\n  docID: number | string\n  payload: Payload\n  req: PayloadRequest\n  shadow: null | Record<string, unknown>\n}): Promise<EffectiveWrite[]> => {\n  if (change.operation === 'delete') {\n    return [{ data: {}, draft: false, operation: 'delete' }]\n  }\n\n  if (!shadow) {\n    return []\n  }\n\n  const collectionConfig = payload.collections[collectionSlug]?.config\n  const hasDrafts = Boolean(collectionConfig?.versions?.drafts)\n\n  // Without drafts there is no publish to distinguish: every row is live, so the\n  // row itself is the whole change and ordinary update permission covers it.\n  if (!hasDrafts) {\n    return [\n      ...getTrashAccessWrites({ collectionSlug, payload, shadow }),\n      {\n        data: shadow,\n        draft: false,\n        operation: change.operation === 'create' ? 'create' : 'update',\n      },\n    ]\n  }\n\n  const rowIsPublished = isPublished(shadow._status)\n  const newerDraft = await findNewerDraft({ collectionSlug, payload, req, shadow })\n\n  if (change.operation === 'create') {\n    // Only the latest source state is applied. If a branch published and then\n    // drafted, the draft creates an unpublished target without replaying the\n    // earlier publication first.\n    return [\n      ...getTrashAccessWrites({ collectionSlug, payload, shadow }),\n      {\n        data: newerDraft ?? shadow,\n        draft: Boolean(newerDraft) || !rowIsPublished,\n        operation: 'create',\n      },\n    ]\n  }\n\n  // Forked. Only a publish rewrites the shadow row, so a row still carrying the\n  // `updatedAt` it was forked with means nothing was published on this branch —\n  // whatever the branch changed lives entirely in its draft chain, and main's\n  // published row must survive the merge untouched.\n  //\n  // The timestamp is a fast path, not the answer. A fork and the publish that follows it\n  // can land in the same millisecond, and then the two are equal for a branch that really\n  // did publish — which made the merge apply *nothing at all* while still reporting the\n  // change as merged, and consume it. So an equal timestamp falls through to the question\n  // it was standing in for: did this branch publish a version of its own?\n  const publishedOnBranch =\n    rowIsPublished &&\n    (!matchesForkPoint({ baseUpdatedAt: change.baseUpdatedAt, shadow }) ||\n      (await hasBranchPublishedVersion({ branch, collectionSlug, payload, req, shadow })))\n  const trashStateWrite = await resolveTrashStateWrite({\n    collectionSlug,\n    docID,\n    payload,\n    req,\n    shadow,\n  })\n\n  if (newerDraft) {\n    return [\n      ...(trashStateWrite\n        ? [{ ...trashStateWrite, trashState: 'apply' as const }]\n        : getTrashAccessWrites({ collectionSlug, payload, shadow })),\n      { data: newerDraft, draft: true, operation: 'update' },\n    ]\n  }\n\n  if (!publishedOnBranch) {\n    // Nothing to apply when the branch has neither published nor drafted: the\n    // fork itself is not a change to main.\n    return [\n      ...(trashStateWrite\n        ? [{ ...trashStateWrite, trashState: 'apply' as const }]\n        : getTrashAccessWrites({ collectionSlug, payload, shadow })),\n    ]\n  }\n\n  const writes: EffectiveWrite[] = [\n    ...(trashStateWrite\n      ? [{ ...trashStateWrite, trashState: 'access' as const }]\n      : getTrashAccessWrites({ collectionSlug, payload, shadow })),\n    { data: shadow, draft: false, operation: 'publish' },\n  ]\n\n  return writes\n}\n\nconst getTrashAccessWrites = ({\n  collectionSlug,\n  payload,\n  shadow,\n}: {\n  collectionSlug: string\n  payload: Payload\n  shadow: Record<string, unknown>\n}): EffectiveWrite[] => {\n  if (!payload.collections[collectionSlug]?.config.trash || shadow.deletedAt == null) {\n    return []\n  }\n\n  return [\n    {\n      data: shadow,\n      draft: false,\n      operation: 'delete',\n      trashState: 'access',\n    },\n  ]\n}\n\nconst resolveTrashStateWrite = async ({\n  collectionSlug,\n  docID,\n  payload,\n  req,\n  shadow,\n}: {\n  collectionSlug: string\n  docID: number | string\n  payload: Payload\n  req: PayloadRequest\n  shadow: Record<string, unknown>\n}): Promise<EffectiveWrite | null> => {\n  if (!payload.collections[collectionSlug]?.config.trash) {\n    return null\n  }\n\n  const main = (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\n  if (!main || toTrashState(main.deletedAt) === toTrashState(shadow.deletedAt)) {\n    return null\n  }\n\n  return {\n    data: shadow,\n    draft: false,\n    operation: shadow.deletedAt == null ? 'update' : 'delete',\n  }\n}\n\nconst toTrashState = (value: unknown): null | number | string => {\n  if (value == null) {\n    return null\n  }\n\n  if (value instanceof Date) {\n    return value.getTime()\n  }\n\n  if (typeof value !== 'number' && typeof value !== 'string') {\n    return null\n  }\n\n  const time = new Date(value).getTime()\n\n  return Number.isNaN(time) ? value : time\n}\n\n/**\n * Whether a row is published, whether or not its status is localized.\n *\n * With localization enabled, `_status` is stored per locale, so a raw row carries an\n * object rather than a string. Read as a scalar it is never `'published'` — which made\n * every publish on a branch look like a fork nobody had touched, so merging a localized\n * document applied **nothing** to main while consuming the change and reporting success.\n *\n * Published in any locale counts. The per-locale writes that follow carry each locale's own\n * status, so this only decides whether a publish is part of the merge at all.\n */\nconst isPublished = (status: unknown): boolean => {\n  if (typeof status === 'object' && status !== null) {\n    return Object.values(status as Record<string, unknown>).includes('published')\n  }\n\n  return status === 'published'\n}\n\n/**\n * Whether this branch published a version of its own for the document.\n *\n * A fork copies the row, not its version chain, so a branch that has only forked owns no\n * versions at all. One carrying a published version of its own has published on the\n * branch, whatever the row's timestamp says.\n */\nconst hasBranchPublishedVersion = async ({\n  branch,\n  collectionSlug,\n  payload,\n  req,\n  shadow,\n}: {\n  branch: string\n  collectionSlug: string\n  payload: Payload\n  req: PayloadRequest\n  shadow: Record<string, unknown>\n}): Promise<boolean> => {\n  if (!payload.collections[collectionSlug]?.config.versions) {\n    return false\n  }\n\n  const locales = payload.config.localization\n    ? payload.config.localization.localeCodes\n    : [undefined]\n\n  for (const locale of locales) {\n    const { docs } = await payload.db.findVersions({\n      branch: false,\n      collection: collectionSlug,\n      limit: 1,\n      locale,\n      pagination: false,\n      req,\n      where: {\n        and: [\n          { parent: { equals: shadow.id } },\n          { [branchField]: { equals: branch } },\n          { 'version._status': { equals: 'published' } },\n        ],\n      },\n    })\n\n    if (docs.length > 0) {\n      return true\n    }\n  }\n\n  return false\n}\n\n/**\n * The branch's newest version when it sits above the branch's published row.\n *\n * Returns null when the newest version *is* the published state, so that a\n * publish is not applied twice — once as the row and again as its own version.\n */\nconst findNewerDraft = async ({\n  collectionSlug,\n  payload,\n  req,\n  shadow,\n}: {\n  collectionSlug: string\n  payload: Payload\n  req: PayloadRequest\n  shadow: Record<string, unknown>\n}): Promise<null | Record<string, unknown>> => {\n  const collectionConfig = payload.collections[collectionSlug]!.config\n  const localization = payload.config.localization\n  const hasLocalizedFields = traverseForLocalizedFields(collectionConfig.fields)\n  const locale = localization\n    ? hasLocalizedFields\n      ? 'all'\n      : req.locale && req.locale !== 'all'\n        ? req.locale\n        : localization.defaultLocale\n    : undefined\n  const { docs } = await payload.db.findVersions({\n    branch: false,\n    collection: collectionSlug,\n    limit: 1,\n    locale,\n    pagination: false,\n    req,\n    sort: '-updatedAt',\n    where: { and: [{ latest: { equals: true } }, { parent: { equals: shadow.id } }] },\n  })\n\n  const latest = docs?.[0] as { version?: Record<string, unknown> } | undefined\n  const version = latest?.version\n\n  if (!version || !isDraft({ locale, status: version._status })) {\n    return null\n  }\n\n  return version\n}\n\nconst isDraft = ({ locale, status }: { locale?: string; status: unknown }): boolean => {\n  if (typeof status === 'object' && status !== null) {\n    if (locale && locale !== 'all') {\n      return (status as Record<string, unknown>)[locale] === 'draft'\n    }\n\n    return Object.values(status as Record<string, unknown>).includes('draft')\n  }\n\n  return status === 'draft'\n}\n\n/**\n * Whether the shadow row is still exactly as forked.\n *\n * `baseUpdatedAt` is stored as a date and may come back as a `Date` or a string\n * depending on the adapter, so both sides are normalised before comparing.\n */\nconst matchesForkPoint = ({\n  baseUpdatedAt,\n  shadow,\n}: {\n  baseUpdatedAt: unknown\n  shadow: Record<string, unknown>\n}): boolean => {\n  if (!baseUpdatedAt || !shadow.updatedAt) {\n    return false\n  }\n\n  return toTime(baseUpdatedAt) === toTime(shadow.updatedAt)\n}\n\nconst toTime = (value: unknown): null | number => {\n  const time = new Date(value as string).getTime()\n\n  return Number.isNaN(time) ? null : time\n}\n\n/** The distinct operations a change needs permission for. */\nexport const operationsForChange = (resolved: ResolvedChange): EffectiveOperation[] => [\n  ...new Set(resolved.writes.map((write) => write.operation)),\n]\n"],"names":["APIError","batchProcessing","extractRelationshipID","traverseForLocalizedFields","branchDocIDField","branchField","MAIN_BRANCH","effectiveOperationReadBatchSize","resolveEffectiveOperations","branch","changes","payload","req","shadowsByChange","readChangeShadows","resolved","change","collectionSlug","docID","getBranchChangeDocumentID","shadow","get","changeKey","String","push","writes","resolveWrites","changesByCollection","Map","collectionChanges","set","batchSize","input","processBatch","batch","createdDocumentIDs","filter","operation","map","existingDocumentIDs","identityQueries","length","id","in","identityQuery","or","docs","db","find","collection","limit","pagination","where","and","equals","relationship","undefined","doc","data","draft","collectionConfig","collections","config","hasDrafts","Boolean","versions","drafts","getTrashAccessWrites","rowIsPublished","isPublished","_status","newerDraft","findNewerDraft","publishedOnBranch","matchesForkPoint","baseUpdatedAt","hasBranchPublishedVersion","trashStateWrite","resolveTrashStateWrite","trashState","trash","deletedAt","main","findOne","toTrashState","value","Date","getTime","time","Number","isNaN","status","Object","values","includes","locales","localization","localeCodes","locale","findVersions","parent","hasLocalizedFields","fields","defaultLocale","sort","latest","version","isDraft","updatedAt","toTime","operationsForChange","Set","write"],"mappings":"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"}

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

@@ -0,0 +1,15 @@
+import type { PayloadHandler } from '../../config/types.js';
+/**
+ * `POST /<branches>/:id/discard`
+ *
+ * Throws away pending changes, or the subset named in `changes`.
+ *
+ * No per-document preflight, unlike merge: discarding touches only the branch's own
+ * rows and leaves `main` exactly as it was, so there is no production permission to
+ * check on the collections those rows belong to. Reaching the branch still requires
+ * being able to read it, a closed branch refuses outright, and — because discard
+ * permanently destroys the branch's pending work, including documents that exist
+ * only on this branch — it also requires discard access, not merely read access.
+ */
+export declare const discardBranchHandler: PayloadHandler;
+//# sourceMappingURL=discard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discard.d.ts","sourceRoot":"","sources":["../../../src/branching/endpoints/discard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAS3D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAmClC,CAAA"}

package/dist/branching/endpoints/discard.js

@@ -0,0 +1,55 @@
+import { Forbidden, NotFound } from '../../errors/index.js';
+import { headersWithCors } from '../../utilities/headersWithCors.js';
+import { httpStatus } from '../../utilities/httpStatus.js';
+import { assertBranchActionAccess } from '../assertBranchActionAccess.js';
+import { discardBranchChanges } from '../discard.js';
+import { branchesCollectionSlug } from '../types.js';
+/**
+ * `POST /<branches>/:id/discard`
+ *
+ * Throws away pending changes, or the subset named in `changes`.
+ *
+ * No per-document preflight, unlike merge: discarding touches only the branch's own
+ * rows and leaves `main` exactly as it was, so there is no production permission to
+ * check on the collections those rows belong to. Reaching the branch still requires
+ * being able to read it, a closed branch refuses outright, and — because discard
+ * permanently destroys the branch's pending work, including documents that exist
+ * only on this branch — it also requires discard access, not merely read access.
+ */ export const discardBranchHandler = async (req)=>{
+    const { payload, routeParams } = req;
+    const id = routeParams?.id;
+    if (!req.user) {
+        throw new Forbidden(req.t);
+    }
+    const branchDoc = await payload.findByID({
+        id,
+        collection: branchesCollectionSlug,
+        disableErrors: true,
+        overrideAccess: false,
+        req
+    });
+    if (!branchDoc) {
+        throw new NotFound(req.t);
+    }
+    await assertBranchActionAccess({
+        action: 'discardBranch',
+        branchDoc,
+        req
+    });
+    const body = req.data ?? {};
+    const result = await discardBranchChanges(payload, {
+        branch: branchDoc.slug,
+        changes: body.changes,
+        overrideAccess: true,
+        req
+    });
+    return Response.json(result, {
+        headers: headersWithCors({
+            headers: new Headers(),
+            req
+        }),
+        status: httpStatus.OK
+    });
+};
+
+//# sourceMappingURL=discard.js.map

package/dist/branching/endpoints/discard.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/branching/endpoints/discard.ts"],"sourcesContent":["import type { PayloadHandler } from '../../config/types.js'\n\nimport { Forbidden, NotFound } from '../../errors/index.js'\nimport { headersWithCors } from '../../utilities/headersWithCors.js'\nimport { httpStatus } from '../../utilities/httpStatus.js'\nimport { assertBranchActionAccess } from '../assertBranchActionAccess.js'\nimport { discardBranchChanges } from '../discard.js'\nimport { branchesCollectionSlug } from '../types.js'\n\n/**\n * `POST /<branches>/:id/discard`\n *\n * Throws away pending changes, or the subset named in `changes`.\n *\n * No per-document preflight, unlike merge: discarding touches only the branch's own\n * rows and leaves `main` exactly as it was, so there is no production permission to\n * check on the collections those rows belong to. Reaching the branch still requires\n * being able to read it, a closed branch refuses outright, and — because discard\n * permanently destroys the branch's pending work, including documents that exist\n * only on this branch — it also requires discard access, not merely read access.\n */\nexport const discardBranchHandler: PayloadHandler = async (req) => {\n  const { payload, routeParams } = req\n  const id = routeParams?.id as number | string\n\n  if (!req.user) {\n    throw new Forbidden(req.t)\n  }\n\n  const branchDoc = await payload.findByID({\n    id,\n    collection: branchesCollectionSlug,\n    disableErrors: true,\n    overrideAccess: false,\n    req,\n  })\n\n  if (!branchDoc) {\n    throw new NotFound(req.t)\n  }\n\n  await assertBranchActionAccess({ action: 'discardBranch', branchDoc, req })\n\n  const body = (req.data ?? {}) as { changes?: (number | string)[] }\n\n  const result = await discardBranchChanges(payload, {\n    branch: branchDoc.slug as string,\n    changes: body.changes,\n    overrideAccess: true,\n    req,\n  })\n\n  return Response.json(result, {\n    headers: headersWithCors({ headers: new Headers(), req }),\n    status: httpStatus.OK,\n  })\n}\n"],"names":["Forbidden","NotFound","headersWithCors","httpStatus","assertBranchActionAccess","discardBranchChanges","branchesCollectionSlug","discardBranchHandler","req","payload","routeParams","id","user","t","branchDoc","findByID","collection","disableErrors","overrideAccess","action","body","data","result","branch","slug","changes","Response","json","headers","Headers","status","OK"],"mappings":"AAEA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,wBAAuB;AAC3D,SAASC,eAAe,QAAQ,qCAAoC;AACpE,SAASC,UAAU,QAAQ,gCAA+B;AAC1D,SAASC,wBAAwB,QAAQ,iCAAgC;AACzE,SAASC,oBAAoB,QAAQ,gBAAe;AACpD,SAASC,sBAAsB,QAAQ,cAAa;AAEpD;;;;;;;;;;;CAWC,GACD,OAAO,MAAMC,uBAAuC,OAAOC;IACzD,MAAM,EAAEC,OAAO,EAAEC,WAAW,EAAE,GAAGF;IACjC,MAAMG,KAAKD,aAAaC;IAExB,IAAI,CAACH,IAAII,IAAI,EAAE;QACb,MAAM,IAAIZ,UAAUQ,IAAIK,CAAC;IAC3B;IAEA,MAAMC,YAAY,MAAML,QAAQM,QAAQ,CAAC;QACvCJ;QACAK,YAAYV;QACZW,eAAe;QACfC,gBAAgB;QAChBV;IACF;IAEA,IAAI,CAACM,WAAW;QACd,MAAM,IAAIb,SAASO,IAAIK,CAAC;IAC1B;IAEA,MAAMT,yBAAyB;QAAEe,QAAQ;QAAiBL;QAAWN;IAAI;IAEzE,MAAMY,OAAQZ,IAAIa,IAAI,IAAI,CAAC;IAE3B,MAAMC,SAAS,MAAMjB,qBAAqBI,SAAS;QACjDc,QAAQT,UAAUU,IAAI;QACtBC,SAASL,KAAKK,OAAO;QACrBP,gBAAgB;QAChBV;IACF;IAEA,OAAOkB,SAASC,IAAI,CAACL,QAAQ;QAC3BM,SAAS1B,gBAAgB;YAAE0B,SAAS,IAAIC;YAAWrB;QAAI;QACvDsB,QAAQ3B,WAAW4B,EAAE;IACvB;AACF,EAAC"}

package/dist/branching/endpoints/merge.d.ts

@@ -0,0 +1,34 @@
+import type { PayloadHandler } from '../../config/types.js';
+import type { MergeResult } from '../merge.js';
+import type { MergeProgress } from '../types.js';
+/**
+ * One line of the streamed merge response.
+ *
+ * NDJSON rather than server-sent events: the client is a `fetch` reading a
+ * `ReadableStream`, not an `EventSource`, so the framing SSE adds buys nothing —
+ * and one JSON object per line is trivially parseable from a reader loop.
+ */
+export type MergeStreamEvent = {
+    message: string;
+    type: 'error';
+} | {
+    result: MergeResult;
+    type: 'complete';
+} | ({
+    type: 'progress';
+} & MergeProgress);
+/**
+ * `POST /<branches>/:id/merge`
+ *
+ * Runs with `overrideAccess: false` and the authenticated user, so the
+ * per-document preflight applies. This is the boundary at which branching's
+ * access model is actually enforced. The Local API uses the same secure default;
+ * trusted server-side callers must opt in to bypassing it.
+ *
+ * `stream: true` switches the response to NDJSON progress events. A merge walks
+ * an arbitrary number of documents one at a time, so the admin panel needs to
+ * report where it is; streaming the loop it already runs avoids inventing a job
+ * and a polling endpoint to carry that state.
+ */
+export declare const mergeBranchHandler: PayloadHandler;
+//# sourceMappingURL=merge.d.ts.map

package/dist/branching/endpoints/merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../../src/branching/endpoints/merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAShD;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAClC;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,UAAU,CAAA;CAAE,GACzC,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,GAAG,aAAa,CAAC,CAAA;AAE1C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,EAAE,cA4DhC,CAAA"}