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

package/dist/branching/collections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/collections.ts"],"sourcesContent":["import type { CollectionConfig } from '../collections/config/types.js'\nimport type { Config } from '../config/types.js'\nimport type { CollectionAfterChangeHook, CollectionBeforeDeleteHook, Where } from '../index.js'\nimport type { SanitizedBranchingConfig } from './types.js'\n\nimport { defaultAccess } from '../auth/defaultAccess.js'\nimport { APIError } from '../errors/index.js'\nimport { wrapInternalEndpoints } from '../utilities/wrapInternalEndpoints.js'\nimport { assertBranchCreatedDocumentsUnreferenced } from './assertBranchCreatedDocumentsUnreferenced.js'\nimport { combineBranchAccess } from './combineBranchAccess.js'\nimport { discardBranchChangesBeforeBranchDeletion } from './discard.js'\nimport { discardBranchHandler } from './endpoints/discard.js'\nimport { mergeBranchHandler } from './endpoints/merge.js'\nimport { loadBranchRow, setBranchRow } from './resolveBranch.js'\nimport {\n  branchChangesCollectionSlug,\n  branchesCollectionSlug,\n  branchMergesCollectionSlug,\n  branchOperations,\n  MAIN_BRANCH,\n  mergeApplicationOutcomes,\n  mergeCleanupOutcomes,\n  mergeRecoveryOutcomes,\n} from './types.js'\n\nexport const getBranchesCollection = (branching: SanitizedBranchingConfig): CollectionConfig => ({\n  slug: branchesCollectionSlug,\n  access: {\n    create: branching.access?.createBranch ?? defaultAccess,\n    delete: combineBranchAccess({\n      readAccess: branching.access?.readBranch ?? defaultAccess,\n      writeAccess: branching.access?.deleteBranch ?? defaultAccess,\n    }),\n    read: branching.access?.readBranch ?? defaultAccess,\n    update: combineBranchAccess({\n      readAccess: branching.access?.readBranch ?? defaultAccess,\n      writeAccess: branching.access?.updateBranch ?? defaultAccess,\n    }),\n  },\n  admin: {\n    defaultColumns: ['name', 'slug', 'status', 'updatedAt'],\n    // Reached only through the branch switcher in the app header, never from the\n    // nav or the dashboard: branches are a scope control, not a content type.\n    hidden: true,\n    useAsTitle: 'name',\n  },\n  labels: {\n    plural: ({ t }) => t('branching:branches'),\n    singular: ({ t }) => t('branching:branch'),\n  },\n  // Deleting a branch drops its shadow rows, and dropping a branch-created\n  // document cascade-deletes every inbound `_rels` row pointing at it — from\n  // main documents too. That is not something to offer behind a multi-select.\n  disableBulkDelete: true,\n  fields: [\n    {\n      name: 'name',\n      type: 'text',\n      required: true,\n    },\n    {\n      name: 'description',\n      type: 'text',\n    },\n    {\n      // Payload's own slug field: it derives from `name`, slugifies, dedupes\n      // against existing branches, and defaults to `required`, `unique` and\n      // `index`. Read-only because editors name a branch; the slug follows.\n      name: 'slug',\n      type: 'slug',\n      admin: { readOnly: true },\n      hooks: {\n        // Sanitization appends custom hooks after the generator, so this has the\n        // last word. Immutable after create: `_branch` stores the slug rather than\n        // a foreign key, so renaming it would orphan every shadow row — and the\n        // generator lets an explicit value from the client win, which is exactly\n        // what must not happen here.\n        beforeChange: [\n          ({ operation, originalDoc, value }) =>\n            operation === 'create' ? value : ((originalDoc as { slug?: string })?.slug ?? value),\n        ],\n      },\n      useAsSlug: 'name',\n      // Permits empty deliberately: the generator populates the slug in\n      // `beforeChange`, which runs after validation.\n      validate: (value: unknown) =>\n        value === MAIN_BRANCH ? `\"${MAIN_BRANCH}\" is a reserved branch name.` : true,\n    },\n    {\n      name: 'status',\n      type: 'select',\n      access: { create: () => false, update: () => false },\n      admin: {\n        // Rendered as a status pill rather than a raw lowercase value: a branch's\n        // status answers the same question a document's draft/published status\n        // does, and the list view already has a visual language for that.\n        components: { Cell: '@payloadcms/ui#BranchStatusCell' },\n        readOnly: true,\n      },\n      defaultValue: 'open',\n      index: true,\n      options: [\n        { label: ({ t }) => t('general:open'), value: 'open' },\n        { label: ({ t }) => t('branching:branchMerging'), value: 'merging' },\n        { label: ({ t }) => t('branching:merged'), value: 'merged' },\n        { label: ({ t }) => t('general:closed'), value: 'closed' },\n      ],\n    },\n    {\n      name: 'mergedAt',\n      type: 'date',\n      access: { create: () => false, update: () => false },\n      admin: { readOnly: true },\n    },\n    {\n      // `\"running\"` while a scheduled merge is running, null otherwise.\n      //\n      // Lives here rather than on the job because it describes the branch, and\n      // because whoever wants it is looking at the branch. An interactive merge streams\n      // its progress to the client that asked for it, so this exists only for the\n      // scheduled case, where nobody is holding a connection. The task writes the marker\n      // before the merge transaction starts so it remains visible without modifying this\n      // branch row concurrently with that transaction.\n      name: 'mergeProgress',\n      type: 'text',\n      access: { create: () => false, update: () => false },\n      admin: { hidden: true, readOnly: true },\n    },\n  ],\n  hooks: {\n    beforeDelete: [deleteBranchStateBeforeDelete],\n  },\n  // Wrapped so the POST body is parsed onto `req.data`, as with every other\n  // built-in endpoint.\n  endpoints: wrapInternalEndpoints([\n    {\n      handler: mergeBranchHandler,\n      method: 'post',\n      path: '/:id/merge',\n    },\n    {\n      handler: discardBranchHandler,\n      method: 'post',\n      path: '/:id/discard',\n    },\n  ]),\n  // `slug` is immutable after creation: `_branch` stores the slug rather than\n  // a foreign key, so renaming it would orphan every shadow row.\n  lockDocuments: false,\n  // Payload 4 enables versions by default, and a branch record is bookkeeping —\n  // a name, a description, a status. Its history is noise, and leaving the default\n  // in place costs every install an extra table. Matches every other core\n  // collection.\n  versions: false,\n})\n\nexport const getBranchChangesCollection = (config: Config): CollectionConfig => {\n  const branching = config.branching as SanitizedBranchingConfig\n\n  const branchable = [...branching.branchableCollections]\n\n  return {\n    slug: branchChangesCollectionSlug,\n    access: {\n      create: () => false,\n      delete: () => false,\n      read: () => false,\n      update: () => false,\n    },\n    admin: {\n      hidden: true,\n    },\n    fields: [\n      {\n        name: 'branch',\n        type: 'text',\n        index: true,\n        required: true,\n      },\n      {\n        name: 'entityType',\n        type: 'select',\n        defaultValue: 'collection',\n        options: ['collection', 'global'],\n      },\n      {\n        name: 'collectionSlug',\n        type: 'text',\n        index: true,\n      },\n      {\n        name: 'documentID',\n        type: 'text',\n        admin: { hidden: true },\n      },\n      {\n        name: 'globalSlug',\n        type: 'text',\n        index: true,\n      },\n      // Polymorphic so it spans collections with different ID types —\n      // auto-increment integers, custom text IDs, ObjectIDs — without a\n      // coercion step that would fail open by silently matching nothing.\n      ...(branchable.length\n        ? ([\n            {\n              name: 'doc',\n              type: 'relationship',\n              index: true,\n              maxDepth: 0,\n              relationTo: branchable,\n            },\n          ] as CollectionConfig['fields'])\n        : []),\n      {\n        name: 'operation',\n        type: 'select',\n        options: [...branchOperations],\n        required: true,\n      },\n      {\n        name: 'baseUpdatedAt',\n        type: 'date',\n      },\n      {\n        name: 'baseVersionID',\n        type: 'text',\n      },\n      {\n        name: 'baseVersionUpdatedAt',\n        type: 'date',\n      },\n    ],\n    hooks: {\n      // A branch marked `merged` had nothing pending. Recording a new change means\n      // it does again, so the label goes back to what is true. Without this, work\n      // resumed on a merged branch would be invisible: `merged` branches are\n      // filtered out of the switcher, so the branch would hold pending changes\n      // nobody could navigate to.\n      afterChange: [reopenBranchOnChange],\n    },\n    indexes: [\n      { fields: ['branch', 'collectionSlug'], unique: false },\n      {\n        fields: ['branch', 'collectionSlug', 'documentID'],\n        requireExists: ['collectionSlug', 'documentID'],\n        unique: true,\n      },\n      {\n        fields: ['branch', 'globalSlug'],\n        requireExists: ['globalSlug'],\n        unique: true,\n      },\n    ],\n    lockDocuments: false,\n    // Registry rows are derived state; versioning them is meaningless.\n    versions: false,\n  }\n}\n\n/**\n * The merge ledger: what each merge event applied, and when.\n *\n * Append-only and read by nobody in the write path, which is the point — it costs\n * the read predicate nothing, unlike retaining consumed change rows and filtering\n * them out of the manifest query on every request.\n */\nexport const getBranchMergesCollection = (): CollectionConfig => ({\n  slug: branchMergesCollectionSlug,\n  access: {\n    create: () => false,\n    delete: () => false,\n    read: ({ req }) => {\n      if (req.user?.id === undefined || !req.user.collection) {\n        return false\n      }\n\n      const identity: Where = {\n        and: [\n          { mergedByCollection: { equals: req.user.collection } },\n          { mergedByID: { equals: String(req.user.id) } },\n        ],\n      }\n\n      if (req.user.collection !== req.payload.config.admin.user) {\n        return identity\n      }\n\n      const legacyIdentity: Where = {\n        and: [\n          { mergedByCollection: { exists: false } },\n          { mergedByID: { equals: String(req.user.id) } },\n        ],\n      }\n\n      return { or: [identity, legacyIdentity] }\n    },\n    update: () => false,\n  },\n  admin: {\n    hidden: true,\n  },\n  fields: [\n    {\n      name: 'branch',\n      type: 'text',\n      index: true,\n      required: true,\n    },\n    {\n      name: 'mergedAt',\n      type: 'date',\n    },\n    {\n      name: 'startedAt',\n      type: 'date',\n    },\n    {\n      name: 'completedAt',\n      type: 'date',\n    },\n    {\n      name: 'targetBranch',\n      type: 'text',\n      defaultValue: MAIN_BRANCH,\n    },\n    {\n      name: 'status',\n      type: 'select',\n      defaultValue: 'succeeded',\n      options: ['inProgress', 'awaitingCommit', 'succeeded', 'failed', 'cleanupFailed'],\n    },\n    {\n      name: 'error',\n      type: 'text',\n    },\n    // Stored rather than related: the ledger has to keep reading correctly after\n    // the user is deleted, renamed, or moved between auth collections.\n    {\n      name: 'mergedByCollection',\n      type: 'text',\n    },\n    {\n      name: 'mergedByID',\n      type: 'text',\n    },\n    {\n      name: 'mergedByLabel',\n      type: 'text',\n    },\n    {\n      // Snapshotted per change, for the same reason. A document merged under one\n      // title and renamed afterwards was merged under the title it had.\n      name: 'changes',\n      type: 'array',\n      fields: [\n        { name: 'changeID', type: 'text' },\n        { name: 'collectionSlug', type: 'text' },\n        { name: 'docID', type: 'text' },\n        { name: 'docTitle', type: 'text' },\n        /** Set instead of `collectionSlug`/`docID` when the merged change was a global. */\n        { name: 'globalSlug', type: 'text' },\n        { name: 'operation', type: 'select', options: [...branchOperations] },\n        {\n          name: 'applicationOutcome',\n          type: 'select',\n          options: [...mergeApplicationOutcomes],\n        },\n        {\n          name: 'recoveryOutcome',\n          type: 'select',\n          options: [...mergeRecoveryOutcomes],\n        },\n        {\n          name: 'cleanupOutcome',\n          type: 'select',\n          options: [...mergeCleanupOutcomes],\n        },\n        { name: 'targetID', type: 'text' },\n        { name: 'sourceID', type: 'text' },\n        { name: 'sourceRevision', type: 'text' },\n        { name: 'sourceUpdatedAt', type: 'date' },\n        { name: 'sourceVersionIDs', type: 'json' },\n        { name: 'beforeVersionID', type: 'text' },\n        { name: 'afterVersionID', type: 'text' },\n        { name: 'error', type: 'text' },\n        { name: 'recoveryError', type: 'text' },\n        { name: 'cleanupError', type: 'text' },\n        // Kept only so merge events written before version-reference history can\n        // still render. New events leave these fields empty.\n        { name: 'before', type: 'json' },\n        { name: 'after', type: 'json' },\n      ],\n    },\n  ],\n  indexes: [\n    { fields: ['branch', 'mergedAt'], unique: false },\n    { fields: ['mergedByCollection', 'mergedByID'], unique: false },\n  ],\n  lockDocuments: false,\n  versions: false,\n})\n\n/** Returns a `merged` branch to `open` as soon as it has a pending change again. */\nconst reopenBranchOnChange: CollectionAfterChangeHook = async ({ doc, operation, req }) => {\n  if (operation !== 'create') {\n    return doc\n  }\n\n  const branch = (doc as { branch?: string }).branch\n\n  if (!branch) {\n    return doc\n  }\n\n  // The same row `assertBranchWritable` just read, rather than a query of its own: this\n  // hook fires on every first touch of a document, and the answer is almost always \"not\n  // merged, nothing to do\".\n  const row = await loadBranchRow({ branch, req })\n\n  if (row?.status === 'merged') {\n    const reopened = await req.payload.update({\n      id: row.id as number | string,\n      collection: branchesCollectionSlug,\n      data: { mergedAt: null, status: 'open' },\n      overrideAccess: true,\n      req,\n    })\n\n    setBranchRow({ branch, req, row: reopened as Record<string, unknown> })\n  }\n\n  return doc\n}\n\nconst deleteBranchStateBeforeDelete: CollectionBeforeDeleteHook = async ({ id, req }) => {\n  const branch = await req.payload.findByID({\n    id,\n    collection: branchesCollectionSlug,\n    depth: 0,\n    overrideAccess: true,\n    req,\n  })\n\n  if (typeof branch.slug !== 'string') {\n    return\n  }\n\n  const branchCreatedChanges = await req.payload.find({\n    collection: branchChangesCollectionSlug,\n    depth: 0,\n    overrideAccess: true,\n    pagination: false,\n    req,\n    where: {\n      and: [{ branch: { equals: branch.slug } }, { operation: { equals: 'create' } }],\n    },\n  })\n  const branchCreatedTargets = branchCreatedChanges.docs.flatMap((change) => {\n    if (change.entityType !== 'collection' || typeof change.collectionSlug !== 'string') {\n      return []\n    }\n\n    const docID = (change.doc as { value?: number | string } | undefined)?.value ?? change.doc\n\n    return typeof docID === 'number' || typeof docID === 'string'\n      ? [{ collectionSlug: change.collectionSlug, docID }]\n      : []\n  })\n\n  await assertBranchCreatedDocumentsUnreferenced({\n    ignoredOwnerBranch: branch.slug,\n    req,\n    targets: branchCreatedTargets,\n  })\n\n  const scheduledMergeConditions: Where[] = [\n    { taskSlug: { equals: 'scheduleMerge' } },\n    { 'input.branch': { equals: branch.slug } },\n  ]\n  const now = new Date().toISOString()\n  const activeScheduledMergeWhere: Where = {\n    and: [\n      ...scheduledMergeConditions,\n      { completedAt: { exists: false } },\n      { processingUntil: { greater_than: now } },\n    ],\n  }\n  const assertNoActiveScheduledMerges = async (): Promise<void> => {\n    const activeScheduledMerges = await req.payload.count({\n      collection: 'payload-jobs',\n      overrideAccess: true,\n      req,\n      where: activeScheduledMergeWhere,\n    })\n\n    if (activeScheduledMerges.totalDocs > 0) {\n      throw new APIError('This branch cannot be deleted while a scheduled merge is running.', 409)\n    }\n  }\n\n  // Check first so a rejected deletion leaves every queued job unchanged.\n  await assertNoActiveScheduledMerges()\n\n  await req.payload.delete({\n    collection: 'payload-jobs',\n    overrideAccess: true,\n    req,\n    where: {\n      and: [\n        ...scheduledMergeConditions,\n        {\n          or: [\n            { completedAt: { exists: true } },\n            { processingUntil: { exists: false } },\n            { processingUntil: { less_than_equal: now } },\n          ],\n        },\n      ],\n    },\n  })\n\n  // A worker can acquire or queue work while inactive jobs are being removed.\n  await assertNoActiveScheduledMerges()\n\n  await discardBranchChangesBeforeBranchDeletion(req.payload, { branch: branch.slug, req })\n\n  await req.payload.delete({\n    collection: branchMergesCollectionSlug,\n    overrideAccess: true,\n    req,\n    where: { branch: { equals: branch.slug } },\n  })\n}\n"],"names":["defaultAccess","APIError","wrapInternalEndpoints","assertBranchCreatedDocumentsUnreferenced","combineBranchAccess","discardBranchChangesBeforeBranchDeletion","discardBranchHandler","mergeBranchHandler","loadBranchRow","setBranchRow","branchChangesCollectionSlug","branchesCollectionSlug","branchMergesCollectionSlug","branchOperations","MAIN_BRANCH","mergeApplicationOutcomes","mergeCleanupOutcomes","mergeRecoveryOutcomes","getBranchesCollection","branching","slug","access","create","createBranch","delete","readAccess","readBranch","writeAccess","deleteBranch","read","update","updateBranch","admin","defaultColumns","hidden","useAsTitle","labels","plural","t","singular","disableBulkDelete","fields","name","type","required","readOnly","hooks","beforeChange","operation","originalDoc","value","useAsSlug","validate","components","Cell","defaultValue","index","options","label","beforeDelete","deleteBranchStateBeforeDelete","endpoints","handler","method","path","lockDocuments","versions","getBranchChangesCollection","config","branchable","branchableCollections","length","maxDepth","relationTo","afterChange","reopenBranchOnChange","indexes","unique","requireExists","getBranchMergesCollection","req","user","id","undefined","collection","identity","and","mergedByCollection","equals","mergedByID","String","payload","legacyIdentity","exists","or","doc","branch","row","status","reopened","data","mergedAt","overrideAccess","findByID","depth","branchCreatedChanges","find","pagination","where","branchCreatedTargets","docs","flatMap","change","entityType","collectionSlug","docID","ignoredOwnerBranch","targets","scheduledMergeConditions","taskSlug","now","Date","toISOString","activeScheduledMergeWhere","completedAt","processingUntil","greater_than","assertNoActiveScheduledMerges","activeScheduledMerges","count","totalDocs","less_than_equal"],"mappings":"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"}

package/dist/branching/combineBranchAccess.d.ts

@@ -0,0 +1,6 @@
+import type { Access } from '../config/types.js';
+export declare const combineBranchAccess: ({ readAccess, writeAccess }: {
+    readAccess: Access;
+    writeAccess: Access;
+}) => Access;
+//# sourceMappingURL=combineBranchAccess.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combineBranchAccess.d.ts","sourceRoot":"","sources":["../../src/branching/combineBranchAccess.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAKhD,eAAO,MAAM,mBAAmB,gCACA;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,KAAG,MAmB3E,CAAA"}

package/dist/branching/combineBranchAccess.js

@@ -0,0 +1,22 @@
+import { hasWhereAccessResult } from '../auth/types.js';
+export const combineBranchAccess = ({ readAccess, writeAccess })=>async (args)=>{
+        const [readResult, writeResult] = await Promise.all([
+            readAccess(args),
+            writeAccess(args)
+        ]);
+        if (!readResult || !writeResult) {
+            return false;
+        }
+        const constraints = [];
+        if (hasWhereAccessResult(readResult)) {
+            constraints.push(readResult);
+        }
+        if (hasWhereAccessResult(writeResult)) {
+            constraints.push(writeResult);
+        }
+        return constraints.length ? {
+            and: constraints
+        } : true;
+    };
+
+//# sourceMappingURL=combineBranchAccess.js.map

package/dist/branching/combineBranchAccess.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/combineBranchAccess.ts"],"sourcesContent":["import type { Access } from '../config/types.js'\nimport type { Where } from '../types/index.js'\n\nimport { hasWhereAccessResult } from '../auth/types.js'\n\nexport const combineBranchAccess =\n  ({ readAccess, writeAccess }: { readAccess: Access; writeAccess: Access }): Access =>\n  async (args) => {\n    const [readResult, writeResult] = await Promise.all([readAccess(args), writeAccess(args)])\n\n    if (!readResult || !writeResult) {\n      return false\n    }\n\n    const constraints: Where[] = []\n\n    if (hasWhereAccessResult(readResult)) {\n      constraints.push(readResult)\n    }\n\n    if (hasWhereAccessResult(writeResult)) {\n      constraints.push(writeResult)\n    }\n\n    return constraints.length ? { and: constraints } : true\n  }\n"],"names":["hasWhereAccessResult","combineBranchAccess","readAccess","writeAccess","args","readResult","writeResult","Promise","all","constraints","push","length","and"],"mappings":"AAGA,SAASA,oBAAoB,QAAQ,mBAAkB;AAEvD,OAAO,MAAMC,sBACX,CAAC,EAAEC,UAAU,EAAEC,WAAW,EAA+C,GACzE,OAAOC;QACL,MAAM,CAACC,YAAYC,YAAY,GAAG,MAAMC,QAAQC,GAAG,CAAC;YAACN,WAAWE;YAAOD,YAAYC;SAAM;QAEzF,IAAI,CAACC,cAAc,CAACC,aAAa;YAC/B,OAAO;QACT;QAEA,MAAMG,cAAuB,EAAE;QAE/B,IAAIT,qBAAqBK,aAAa;YACpCI,YAAYC,IAAI,CAACL;QACnB;QAEA,IAAIL,qBAAqBM,cAAc;YACrCG,YAAYC,IAAI,CAACJ;QACnB;QAEA,OAAOG,YAAYE,MAAM,GAAG;YAAEC,KAAKH;QAAY,IAAI;IACrD,EAAC"}

package/dist/branching/copyUploadFilesToBranch.d.ts

@@ -0,0 +1,9 @@
+import type { SanitizedCollectionConfig } from '../collections/config/types.js';
+import type { PayloadRequest } from '../types/index.js';
+export declare const copyUploadFilesToBranch: ({ branch, collection, doc, req, }: {
+    branch: string;
+    collection: SanitizedCollectionConfig;
+    doc: Record<string, unknown>;
+    req: PayloadRequest;
+}) => Promise<Record<string, unknown>>;
+//# sourceMappingURL=copyUploadFilesToBranch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"copyUploadFilesToBranch.d.ts","sourceRoot":"","sources":["../../src/branching/copyUploadFilesToBranch.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAA;AAC/E,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAiBnE,eAAO,MAAM,uBAAuB,sCAKjC;IACD,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,yBAAyB,CAAA;IACrC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5B,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAuGlC,CAAA"}

package/dist/branching/copyUploadFilesToBranch.js

@@ -0,0 +1,126 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { replaceStoredFileReferences } from '../uploads/fileVersioning/archive.js';
+import { removeUnreferencedStagedObjects } from '../uploads/fileVersioning/cleanup.js';
+import { runFileOperationPlan } from '../uploads/fileVersioning/fileOperationManager.js';
+import { copyLocalFile } from '../uploads/fileVersioning/localStorage.js';
+import { normalizeStorageKey } from '../uploads/fileVersioning/naming.js';
+import { collectStoredFiles, getStoredFileIdentity, withLegacyCloudUploadFileData, withLegacyUploadFileData } from '../uploads/fileVersioning/storedFiles.js';
+import { getBranchUploadFilename } from '../uploads/generateFileData.js';
+import { getSafeFileName, incrementName } from '../uploads/getSafeFilename.js';
+import { markTransactionWrite } from '../utilities/transactionMutationTracker.js';
+export const copyUploadFilesToBranch = async ({ branch, collection, doc, req })=>{
+    if (!collection.upload) {
+        return doc;
+    }
+    const stored = collection.upload.fileOperations ? await withLegacyCloudUploadFileData({
+        collection,
+        doc,
+        req
+    }) : withLegacyUploadFileData({
+        collection,
+        config: req.payload.config,
+        doc
+    });
+    const storedFiles = collectStoredFiles({
+        collection,
+        doc: stored,
+        req
+    });
+    if (!storedFiles.length) {
+        return doc;
+    }
+    const persistedPrefix = typeof stored.prefix === 'string' ? stored.prefix : undefined;
+    const replacements = new Map();
+    const reservedKeys = new Set(storedFiles.map(getStoredFileIdentity));
+    for (const file of storedFiles){
+        const directory = path.posix.dirname(file.key);
+        let filename = getBranchUploadFilename({
+            branch,
+            filename: path.posix.basename(file.key)
+        });
+        while(true){
+            filename = await getSafeFileName({
+                collectionSlug: collection.slug,
+                desiredFilename: filename,
+                prefix: persistedPrefix,
+                req,
+                staticPath: collection.upload.staticDir && !collection.upload.fileOperations ? path.join(collection.upload.staticDir, directory === '.' ? '' : directory) : undefined
+            });
+            const key = normalizeStorageKey({
+                key: directory === '.' ? filename : path.posix.join(directory, filename)
+            });
+            if (!reservedKeys.has(key)) {
+                replacements.set(getStoredFileIdentity(file), key);
+                reservedKeys.add(key);
+                break;
+            }
+            filename = incrementName(filename);
+        }
+    }
+    const branchDocument = replaceStoredFileReferences({
+        files: storedFiles,
+        replacements,
+        version: stored
+    });
+    if (!branchDocument) {
+        return doc;
+    }
+    const fileOperations = collection.upload.fileOperations;
+    const staticDir = collection.upload.staticDir;
+    return runFileOperationPlan({
+        cleanupStagedAfterWriteFailure: (objects)=>removeUnreferencedStagedObjects({
+                collection,
+                objects,
+                req
+            }),
+        req,
+        stage: async ({ trackStagedObject })=>{
+            for (const file of storedFiles){
+                const to = replacements.get(getStoredFileIdentity(file));
+                if (fileOperations) {
+                    await fileOperations.copy({
+                        from: file.key,
+                        req,
+                        to,
+                        trackStagedObject
+                    });
+                } else if (staticDir) {
+                    await copyLocalFile({
+                        from: file.key,
+                        staticDir,
+                        to
+                    });
+                    trackStagedObject({
+                        key: to,
+                        remove: ()=>fs.rm(path.join(staticDir, to), {
+                                force: true
+                            })
+                    });
+                } else {
+                    throw new Error(`Unable to copy upload files for collection ${collection.slug}`);
+                }
+            }
+        },
+        write: async ()=>{
+            const updated = await req.payload.db.updateOne({
+                id: doc.id,
+                branch: false,
+                collection: collection.slug,
+                data: {
+                    filename: branchDocument.filename,
+                    original: branchDocument.original,
+                    url: branchDocument.url,
+                    variants: branchDocument.variants
+                },
+                req
+            });
+            markTransactionWrite({
+                req
+            });
+            return updated;
+        }
+    });
+};
+
+//# sourceMappingURL=copyUploadFilesToBranch.js.map

package/dist/branching/copyUploadFilesToBranch.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/branching/copyUploadFilesToBranch.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { SanitizedCollectionConfig } from '../collections/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../types/index.js'\n\nimport { replaceStoredFileReferences } from '../uploads/fileVersioning/archive.js'\nimport { removeUnreferencedStagedObjects } from '../uploads/fileVersioning/cleanup.js'\nimport { runFileOperationPlan } from '../uploads/fileVersioning/fileOperationManager.js'\nimport { copyLocalFile } from '../uploads/fileVersioning/localStorage.js'\nimport { normalizeStorageKey } from '../uploads/fileVersioning/naming.js'\nimport {\n  collectStoredFiles,\n  getStoredFileIdentity,\n  withLegacyCloudUploadFileData,\n  withLegacyUploadFileData,\n} from '../uploads/fileVersioning/storedFiles.js'\nimport { getBranchUploadFilename } from '../uploads/generateFileData.js'\nimport { getSafeFileName, incrementName } from '../uploads/getSafeFilename.js'\nimport { markTransactionWrite } from '../utilities/transactionMutationTracker.js'\n\nexport const copyUploadFilesToBranch = async ({\n  branch,\n  collection,\n  doc,\n  req,\n}: {\n  branch: string\n  collection: SanitizedCollectionConfig\n  doc: Record<string, unknown>\n  req: PayloadRequest\n}): Promise<Record<string, unknown>> => {\n  if (!collection.upload) {\n    return doc\n  }\n\n  const stored = collection.upload.fileOperations\n    ? await withLegacyCloudUploadFileData({ collection, doc, req })\n    : withLegacyUploadFileData({ collection, config: req.payload.config, doc })\n  const storedFiles = collectStoredFiles({ collection, doc: stored, req })\n\n  if (!storedFiles.length) {\n    return doc\n  }\n\n  const persistedPrefix = typeof stored.prefix === 'string' ? stored.prefix : undefined\n  const replacements = new Map<string, string>()\n  const reservedKeys = new Set(storedFiles.map(getStoredFileIdentity))\n\n  for (const file of storedFiles) {\n    const directory = path.posix.dirname(file.key)\n    let filename = getBranchUploadFilename({\n      branch,\n      filename: path.posix.basename(file.key),\n    })\n\n    while (true) {\n      filename = await getSafeFileName({\n        collectionSlug: collection.slug,\n        desiredFilename: filename,\n        prefix: persistedPrefix,\n        req,\n        staticPath:\n          collection.upload.staticDir && !collection.upload.fileOperations\n            ? path.join(collection.upload.staticDir, directory === '.' ? '' : directory)\n            : undefined,\n      })\n\n      const key = normalizeStorageKey({\n        key: directory === '.' ? filename : path.posix.join(directory, filename),\n      })\n\n      if (!reservedKeys.has(key)) {\n        replacements.set(getStoredFileIdentity(file), key)\n        reservedKeys.add(key)\n        break\n      }\n\n      filename = incrementName(filename)\n    }\n  }\n  const branchDocument = replaceStoredFileReferences({\n    files: storedFiles,\n    replacements,\n    version: stored as JsonObject,\n  })\n\n  if (!branchDocument) {\n    return doc\n  }\n\n  const fileOperations = collection.upload.fileOperations\n  const staticDir = collection.upload.staticDir\n\n  return runFileOperationPlan({\n    cleanupStagedAfterWriteFailure: (objects) =>\n      removeUnreferencedStagedObjects({ collection, objects, req }),\n    req,\n    stage: async ({ trackStagedObject }) => {\n      for (const file of storedFiles) {\n        const to = replacements.get(getStoredFileIdentity(file))!\n\n        if (fileOperations) {\n          await fileOperations.copy({ from: file.key, req, to, trackStagedObject })\n        } else if (staticDir) {\n          await copyLocalFile({ from: file.key, staticDir, to })\n          trackStagedObject({\n            key: to,\n            remove: () => fs.rm(path.join(staticDir, to), { force: true }),\n          })\n        } else {\n          throw new Error(`Unable to copy upload files for collection ${collection.slug}`)\n        }\n      }\n    },\n    write: async () => {\n      const updated = await req.payload.db.updateOne({\n        id: doc.id as number | string,\n        branch: false,\n        collection: collection.slug,\n        data: {\n          filename: branchDocument.filename,\n          original: branchDocument.original,\n          url: branchDocument.url,\n          variants: branchDocument.variants,\n        },\n        req,\n      })\n\n      markTransactionWrite({ req })\n\n      return updated\n    },\n  }) as Promise<Record<string, unknown>>\n}\n"],"names":["fs","path","replaceStoredFileReferences","removeUnreferencedStagedObjects","runFileOperationPlan","copyLocalFile","normalizeStorageKey","collectStoredFiles","getStoredFileIdentity","withLegacyCloudUploadFileData","withLegacyUploadFileData","getBranchUploadFilename","getSafeFileName","incrementName","markTransactionWrite","copyUploadFilesToBranch","branch","collection","doc","req","upload","stored","fileOperations","config","payload","storedFiles","length","persistedPrefix","prefix","undefined","replacements","Map","reservedKeys","Set","map","file","directory","posix","dirname","key","filename","basename","collectionSlug","slug","desiredFilename","staticPath","staticDir","join","has","set","add","branchDocument","files","version","cleanupStagedAfterWriteFailure","objects","stage","trackStagedObject","to","get","copy","from","remove","rm","force","Error","write","updated","db","updateOne","id","data","original","url","variants"],"mappings":"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"}

package/dist/branching/createShadowRow.d.ts

@@ -0,0 +1,70 @@
+import type { PayloadRequest } from '../types/index.js';
+import type { BranchOperation } from './types.js';
+type ShadowSource = {
+    branch: string;
+    id: number | string;
+};
+type Args = {
+    branch: string;
+    collectionSlug: string;
+    data: Record<string, unknown>;
+    /** The canonical document this row represents, for the recovery read on conflict. */
+    docID: number | string;
+    /**
+     * Runs only when this call creates the row, inside the same transaction
+     * as the row create — typically the accompanying
+     * `payload-branch-changes` entry. Never called on the losing side, whose
+     * caller already created (or is creating) its own.
+     */
+    onCreated: (req: PayloadRequest, shadow: Record<string, unknown>) => Promise<unknown>;
+    req: PayloadRequest;
+    /** Copies an exact logical source document instead of creating from data alone. */
+    source?: ShadowSource;
+    /** Uses the request's existing transaction and leaves commit or rollback to its owner. */
+    useAmbientTransaction?: boolean;
+};
+export declare const isRecoverableConcurrentShadowError: (error: unknown) => boolean;
+export declare const isConcurrentShadowOperationError: (error: unknown) => boolean;
+export declare const waitForConcurrentShadowRetry: ({ retryIndex, }: {
+    retryIndex: number;
+}) => Promise<void>;
+export declare const retryConcurrentShadowOperation: <Result>({ onRetry, operation, shouldRetry, waitForRetry, }: {
+    onRetry?: (args: {
+        error: unknown;
+        retryIndex: number;
+    }) => Promise<void> | void;
+    operation: () => Promise<Result>;
+    shouldRetry: ((args: {
+        error: unknown;
+    }) => boolean) | boolean;
+    waitForRetry?: (args: {
+        retryIndex: number;
+    }) => Promise<void>;
+}) => Promise<Result>;
+export declare const findCompetingShadow: ({ branch, collectionSlug, docID, operation, req, }: {
+    branch: string;
+    collectionSlug: string;
+    docID: number | string;
+    operation?: BranchOperation;
+    req: PayloadRequest;
+}) => Promise<null | Record<string, unknown>>;
+/**
+ * Creates a branch's shadow row for a document, safe against two concurrent
+ * first-edits of the same document on the same branch racing to create it.
+ *
+ * The unique index on `(_branchDocID, _branch)` is what turns the losing side
+ * into a rejection instead of a second, duplicate shadow row — but the create
+ * runs in a transaction of its own, isolated from the caller's, rather than
+ * the caller's ambient one. A losing race has to recover with a plain read,
+ * and Postgres refuses any further command on a transaction once one
+ * statement inside it fails — including that read — until it is rolled back.
+ * A transaction of its own can be rolled back and moved past without
+ * disturbing the write the caller is in the middle of.
+ *
+ * An operation that owns the request's existing transaction can opt into
+ * creating the shadow and registry there instead. Errors on that path remain
+ * with the operation owner, which can roll back and retry the full lifecycle.
+ */
+export declare const createShadowRow: ({ branch, collectionSlug, data, docID, onCreated, req, source, useAmbientTransaction, }: Args) => Promise<Record<string, unknown>>;
+export {};
+//# sourceMappingURL=createShadowRow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createShadowRow.d.ts","sourceRoot":"","sources":["../../src/branching/createShadowRow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAcjD,KAAK,YAAY,GAAG;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,IAAI,GAAG;IACV,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC7B,qFAAqF;IACrF,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB;;;;;OAKG;IACH,SAAS,EAAE,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACrF,GAAG,EAAE,cAAc,CAAA;IACnB,mFAAmF;IACnF,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,0FAA0F;IAC1F,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,CAAA;AAsCD,eAAO,MAAM,kCAAkC,UAAW,OAAO,KAAG,OACE,CAAA;AAUtE,eAAO,MAAM,gCAAgC,UAAW,OAAO,KAAG,OACyB,CAAA;AAI3F,eAAO,MAAM,4BAA4B,oBAEtC;IACD,UAAU,EAAE,MAAM,CAAA;CACnB,KAAG,OAAO,CAAC,IAAI,CAIf,CAAA;AAED,eAAO,MAAM,8BAA8B,GAAU,MAAM,sDAKxD;IACD,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAChF,SAAS,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAA;IAChC,WAAW,EAAE,CAAC,CAAC,IAAI,EAAE;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,KAAK,OAAO,CAAC,GAAG,OAAO,CAAA;IAC9D,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAC/D,KAAG,OAAO,CAAC,MAAM,CAmBjB,CAAA;AAED,eAAO,MAAM,mBAAmB,uDAM7B;IACD,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,eAAe,CAAA;IAC3B,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAwDzC,CAAA;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,eAAe,4FASzB,IAAI,KAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8GxC,CAAA"}

package/dist/branching/createShadowRow.js

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