payload 4.0.0-internal.e55ccef → 4.0.0-internal.ea6e8f8

package/dist/uploads/fileVersioning/cloudStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/cloudStorage.ts"],"sourcesContent":["import type { SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../../types/index.js'\nimport type { FileToSave } from '../types.js'\nimport type { StagedObject } from './fileOperationManager.js'\n\nimport { resolveBranchRowID } from '../../branching/resolveBranchRowID.js'\nimport { branchField, branchParentField } from '../../branching/types.js'\nimport { saveVersion } from '../../versions/saveVersion.js'\nimport {\n  collectStoredFiles as collectSavedFiles,\n  removeUnreferencedStagedObjects,\n  scheduleUnreferencedFileCleanup,\n} from './cleanup.js'\nimport { runFileCreationPlan, runFileOperationPlan } from './fileOperationManager.js'\nimport {\n  collectStoredFiles,\n  getStoredFileIdentity,\n  withLegacyCloudUploadFileData,\n} from './storedFiles.js'\n\ntype BranchVersionMetadata = {\n  [branchField]?: null | string\n  [branchParentField]?: null | number | string\n}\n\n/** Preserve the caller's cloud flags; nested Local API calls can replace req.context. */\nexport const captureCloudHookState = ({ req }: { req: PayloadRequest }): (() => void) => {\n  const previousState = ['_payloadManagedCloudStorage', '_payloadManagedCloudMetadata'].map(\n    (key) => ({\n      hasProperty: Object.hasOwn(req.context ?? {}, key),\n      key,\n      value: req.context?.[key],\n    }),\n  )\n\n  return () => {\n    req.context ??= {}\n    for (const { hasProperty, key, value } of previousState) {\n      if (hasProperty) {\n        req.context[key] = value\n      } else {\n        delete req.context[key]\n      }\n    }\n  }\n}\n\nexport const runCloudFileCreation = async <T>({\n  collection,\n  data,\n  files,\n  req,\n  write,\n}: {\n  collection: SanitizedCollectionConfig\n  data: JsonObject\n  files: FileToSave[]\n  req: PayloadRequest\n  write: () => Promise<T>\n}): Promise<T> => {\n  const operations = collection.upload.fileOperations\n\n  if (\n    !operations ||\n    req.context?.skipCloudStorage ||\n    (files.length === 0 && !req.context?._payloadVerifiedProviderOriginal)\n  ) {\n    return write()\n  }\n\n  let metadata: Record<string, unknown> = {}\n\n  return runFileCreationPlan({\n    cleanupStagedAfterWriteFailure: (objects) =>\n      removeUnreferencedStagedObjects({ collection, objects, req }),\n    req,\n    stage: async ({ trackStagedObject }) => {\n      trackClientUploadOriginal({ collection, data, req, trackStagedObject })\n      const staged = await operations.stage({\n        data,\n        files,\n        req,\n        trackStagedObject,\n      })\n      metadata = staged.metadata\n      Object.assign(data, metadata)\n    },\n    // Create's version and afterChange hooks run after the database insert. The\n    // outer create operation restores the previous guard after those hooks finish.\n    write: () => {\n      req.context ??= {}\n      req.context._payloadManagedCloudStorage = true\n      req.context._payloadManagedCloudMetadata = metadata\n      return write()\n    },\n  })\n}\n\nexport const runCloudFileUpdate = async <T>({\n  id,\n  collection,\n  current,\n  data,\n  files,\n  req,\n  write,\n}: {\n  collection: SanitizedCollectionConfig\n  current: JsonObject\n  data: JsonObject\n  files: FileToSave[]\n  id: number | string\n  req: PayloadRequest\n  write: () => Promise<T>\n}): Promise<T> => {\n  const operations = collection.upload.fileOperations\n  const storedCurrent = operations\n    ? await withLegacyCloudUploadFileData({ collection, doc: current, req })\n    : current\n  const nextFiles = collectStoredFiles({\n    collection,\n    doc: { ...storedCurrent, ...data },\n    req,\n    trustGenerated: true,\n  })\n  const currentFiles = collectStoredFiles({ collection, doc: storedCurrent, req })\n  const nextIdentities = new Set(nextFiles.map(getStoredFileIdentity))\n  const hasStoredFileChange =\n    nextIdentities.size !== currentFiles.length ||\n    currentFiles.some((file) => !nextIdentities.has(getStoredFileIdentity(file)))\n\n  if (\n    !operations ||\n    req.context?.skipCloudStorage ||\n    (files.length === 0 && !req.context?._payloadVerifiedProviderOriginal && !hasStoredFileChange)\n  ) {\n    return write()\n  }\n\n  let metadata: Record<string, unknown> = {}\n\n  return runFileOperationPlan({\n    cleanupStagedAfterWriteFailure: (objects) =>\n      removeUnreferencedStagedObjects({ collection, objects, req }),\n    req,\n    stage: async ({ trackStagedObject }) => {\n      if (files.length === 0 && !req.context?._payloadVerifiedProviderOriginal) {\n        return\n      }\n      trackClientUploadOriginal({ collection, data, req, trackStagedObject })\n      const staged = await operations.stage({\n        data,\n        files,\n        req,\n        trackStagedObject,\n      })\n      metadata = staged.metadata\n      Object.assign(data, metadata)\n    },\n    write: async () => {\n      if (\n        collection.versions &&\n        !hasStoredOriginal({ doc: current }) &&\n        hasStoredOriginal({ doc: storedCurrent })\n      ) {\n        await persistLegacyCloudVersions({ id, collection, current: storedCurrent, req })\n      }\n\n      const result = await withCloudHookGuard({\n        metadata,\n        req,\n        write,\n      })\n\n      await scheduleUnreferencedFileCleanup({\n        candidates: await collectSavedFiles({ collection, doc: storedCurrent, req }),\n        collection,\n        req,\n      })\n\n      return result\n    },\n  })\n}\n\n/** Track a verified client-uploaded source, retaining it if another document still references it. */\nconst trackClientUploadOriginal = ({\n  collection,\n  data,\n  req,\n  trackStagedObject,\n}: {\n  collection: SanitizedCollectionConfig\n  data: JsonObject\n  req: PayloadRequest\n  trackStagedObject: (object: StagedObject) => void\n}): void => {\n  const verifiedOriginal = req.context?._payloadVerifiedProviderOriginal as\n    | { key: string }\n    | undefined\n\n  if (!verifiedOriginal) {\n    return\n  }\n\n  const original = collectStoredFiles({ collection, doc: data, req, trustGenerated: true }).find(\n    ({ key, roles }) =>\n      key === verifiedOriginal.key && roles.some((role) => role.type === 'original'),\n  )\n\n  if (!original) {\n    return\n  }\n\n  const object: StagedObject = {\n    key: original.key,\n    remove: () => collection.upload.fileOperations!.delete({ key: original.key, req }),\n  }\n\n  trackStagedObject({\n    key: object.key,\n    remove: () => removeUnreferencedStagedObjects({ collection, objects: [object], req }),\n  })\n}\n\nconst persistLegacyCloudVersions = async ({\n  id,\n  collection,\n  current,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  current: JsonObject\n  id: number | string\n  req: PayloadRequest\n}): Promise<void> => {\n  const versionParent = await resolveBranchRowID({\n    id,\n    collectionSlug: collection.slug,\n    req,\n  })\n  let page = 1\n  let hasVersions = false\n\n  while (true) {\n    const versions = await req.payload.db.findVersions<JsonObject>({\n      branch: false,\n      collection: collection.slug,\n      limit: 100,\n      page,\n      req,\n      where: { parent: { equals: versionParent } },\n    })\n\n    for (const row of versions.docs) {\n      const branchVersion = row as BranchVersionMetadata & typeof row\n\n      hasVersions = true\n      if (hasStoredOriginal({ doc: row.version })) {\n        continue\n      }\n\n      const version = await withLegacyCloudUploadFileData({\n        collection,\n        doc: row.version,\n        req,\n      })\n      if (!hasStoredOriginal({ doc: version })) {\n        continue\n      }\n\n      await req.payload.db.updateVersion({\n        id: row.id,\n        collection: collection.slug,\n        req,\n        versionData: {\n          ...(branchVersion[branchField] !== undefined\n            ? { [branchField]: branchVersion[branchField] }\n            : {}),\n          ...(branchVersion[branchParentField] !== undefined\n            ? { [branchParentField]: branchVersion[branchParentField] }\n            : {}),\n          createdAt: row.createdAt,\n          latest: row.latest,\n          parent: row.parent,\n          publishedLocale: row.publishedLocale,\n          updatedAt: row.updatedAt,\n          version,\n        },\n      })\n    }\n\n    if (versions.docs.length < 100) {\n      break\n    }\n    page += 1\n  }\n\n  if (!hasVersions && hasStoredOriginal({ doc: current })) {\n    await saveVersion({\n      id,\n      collection,\n      docWithLocales: current,\n      draft: false,\n      operation: 'update',\n      payload: req.payload,\n      req,\n    })\n  }\n}\n\nconst hasStoredOriginal = ({ doc }: { doc: JsonObject }): boolean =>\n  Boolean(\n    doc.original &&\n      typeof doc.original === 'object' &&\n      typeof (doc.original as Record<string, unknown>).filename === 'string',\n  )\n\nconst withCloudHookGuard = async <T>({\n  metadata,\n  req,\n  write,\n}: {\n  metadata: Record<string, unknown>\n  req: PayloadRequest\n  write: () => Promise<T>\n}): Promise<T> => {\n  const restoreCloudHookState = captureCloudHookState({ req })\n  req.context ??= {}\n  req.context._payloadManagedCloudStorage = true\n  req.context._payloadManagedCloudMetadata = metadata\n\n  try {\n    return await write()\n  } finally {\n    restoreCloudHookState()\n  }\n}\n"],"names":["resolveBranchRowID","branchField","branchParentField","saveVersion","collectStoredFiles","collectSavedFiles","removeUnreferencedStagedObjects","scheduleUnreferencedFileCleanup","runFileCreationPlan","runFileOperationPlan","getStoredFileIdentity","withLegacyCloudUploadFileData","captureCloudHookState","req","previousState","map","key","hasProperty","Object","hasOwn","context","value","runCloudFileCreation","collection","data","files","write","operations","upload","fileOperations","skipCloudStorage","length","_payloadVerifiedProviderOriginal","metadata","cleanupStagedAfterWriteFailure","objects","stage","trackStagedObject","trackClientUploadOriginal","staged","assign","_payloadManagedCloudStorage","_payloadManagedCloudMetadata","runCloudFileUpdate","id","current","storedCurrent","doc","nextFiles","trustGenerated","currentFiles","nextIdentities","Set","hasStoredFileChange","size","some","file","has","versions","hasStoredOriginal","persistLegacyCloudVersions","result","withCloudHookGuard","candidates","verifiedOriginal","original","find","roles","role","type","object","remove","delete","versionParent","collectionSlug","slug","page","hasVersions","payload","db","findVersions","branch","limit","where","parent","equals","row","docs","branchVersion","version","updateVersion","versionData","undefined","createdAt","latest","publishedLocale","updatedAt","docWithLocales","draft","operation","Boolean","filename","restoreCloudHookState"],"mappings":"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"}

package/dist/uploads/fileVersioning/fileOperationManager.d.ts

@@ -0,0 +1,65 @@
+import type { PayloadRequest } from '../../types/index.js';
+import type { FileToSave } from '../types.js';
+export type StagedObject = {
+    key: string;
+    remove: () => Promise<void>;
+};
+type RunFileOperationPlanArgs<T> = {
+    cleanupStagedAfterWriteFailure?: (objects: StagedObject[]) => Promise<void>;
+    req: PayloadRequest;
+    stage: (args: {
+        trackStagedObject: (object: StagedObject) => void;
+    }) => Promise<void>;
+    write: (args: {
+        trackStagedObject: (object: StagedObject) => void;
+    }) => Promise<T>;
+};
+/** Same-transaction request proxies must finish their files with the owning request. */
+export declare const shareFileOperationScope: ({ owner, req, }: {
+    owner: PayloadRequest;
+    req: PayloadRequest;
+}) => void;
+/** Keeps no-transaction cleanup pending until an outer upload operation finishes. */
+export declare const beginFileOperationScope: ({ req }: {
+    req: PayloadRequest;
+}) => void;
+export declare const completeFileOperationScope: ({ req, }: {
+    req: PayloadRequest;
+}) => Promise<void>;
+export declare const abortFileOperationScope: ({ req }: {
+    req: PayloadRequest;
+}) => Promise<void>;
+/** Runs cleanup after the outer operation and its database transaction succeed. */
+export declare const deferFileCleanup: ({ cleanup, req, shouldCleanupAfterFailure, }: {
+    cleanup: () => Promise<void>;
+    req: PayloadRequest;
+    /** Enable only for cleanup that rechecks persisted references before deleting. */
+    shouldCleanupAfterFailure?: boolean;
+}) => Promise<void>;
+/** Stages owned objects before writing document or version data. */
+export declare const runFileOperationPlan: <T>({ cleanupStagedAfterWriteFailure, req, stage, write, }: RunFileOperationPlanArgs<T>) => Promise<T>;
+/** Creates use the same rollback and outer-scope compensation without an existing document. */
+export declare const runFileCreationPlan: <T>({ cleanupStagedAfterWriteFailure, req, stage, write, }: {
+    cleanupStagedAfterWriteFailure?: (objects: StagedObject[]) => Promise<void>;
+    req: PayloadRequest;
+    stage: (args: {
+        trackStagedObject: (object: StagedObject) => void;
+    }) => Promise<void>;
+    write: () => Promise<T>;
+}) => Promise<T>;
+/** Writes each planned local object exclusively and registers only completed writes for rollback. */
+export declare const stageLocalUploadFiles: ({ files, staticDir, trackStagedObject, }: {
+    files: FileToSave[];
+    staticDir: string;
+    trackStagedObject: (object: StagedObject) => void;
+}) => Promise<void>;
+/** Called only after the owning database transaction commits. */
+export declare const commitFileOperations: ({ req }: {
+    req: PayloadRequest;
+}) => Promise<void>;
+/** Called only after the owning database transaction rolls back. */
+export declare const rollbackFileOperations: ({ req }: {
+    req: PayloadRequest;
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=fileOperationManager.d.ts.map

package/dist/uploads/fileVersioning/fileOperationManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fileOperationManager.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/fileOperationManager.ts"],"names":[],"mappings":"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"}

package/dist/uploads/fileVersioning/fileOperationManager.js

@@ -0,0 +1,324 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { hasActiveTransaction } from '../../utilities/initTransaction.js';
+const requests = new WeakMap();
+const requestOwners = new WeakMap();
+/** Same-transaction request proxies must finish their files with the owning request. */ export const shareFileOperationScope = ({ owner, req })=>{
+    requestOwners.set(req, requestOwners.get(owner) ?? owner);
+};
+/** Keeps no-transaction cleanup pending until an outer upload operation finishes. */ export const beginFileOperationScope = ({ req })=>{
+    getRequestState({
+        req
+    }).depth += 1;
+};
+export const completeFileOperationScope = async ({ req })=>{
+    const state = requests.get(requestOwners.get(req) ?? req);
+    if (!state) {
+        return;
+    }
+    state.depth -= 1;
+    if (state.depth === 0 && (!await hasActiveTransaction({
+        req
+    }) || state.isCommitted)) {
+        await flushCleanup({
+            req,
+            state
+        });
+    }
+};
+export const abortFileOperationScope = async ({ req })=>{
+    const state = requests.get(requestOwners.get(req) ?? req);
+    if (!state) {
+        return;
+    }
+    state.depth -= 1;
+    if (state.depth === 0 && !await hasActiveTransaction({
+        req
+    })) {
+        await reconcileFailedAttempts({
+            req,
+            state
+        });
+    }
+};
+/** Runs cleanup after the outer operation and its database transaction succeed. */ export const deferFileCleanup = async ({ cleanup, req, shouldCleanupAfterFailure })=>{
+    const state = getRequestState({
+        req
+    });
+    state.pending.push({
+        cleanup,
+        shouldCleanupAfterFailure,
+        staged: new Map()
+    });
+    if (state.depth === 0 && (!await hasActiveTransaction({
+        req
+    }) || state.isCommitted)) {
+        await flushCleanup({
+            req,
+            state
+        });
+    }
+};
+/** Stages owned objects before writing document or version data. */ export const runFileOperationPlan = async ({ cleanupStagedAfterWriteFailure, req, stage, write })=>{
+    const requestState = getRequestState({
+        req
+    });
+    const attempt = {
+        cleanupStagedAfterWriteFailure,
+        staged: new Map()
+    };
+    let hasStartedWrite = false;
+    let hasSucceeded = false;
+    const trackStagedObject = createStagedObjectTracker({
+        attempt
+    });
+    requestState.depth += 1;
+    try {
+        await stage({
+            trackStagedObject
+        });
+        hasStartedWrite = true;
+        const result = await write({
+            trackStagedObject
+        });
+        requestState.pending.push(attempt);
+        hasSucceeded = true;
+        return result;
+    } catch (err) {
+        if (!hasStartedWrite) {
+            await compensate({
+                attempt,
+                req
+            });
+        } else if (await hasActiveTransaction({
+            req
+        })) {
+            requestState.pending.push({
+                staged: attempt.staged
+            });
+        } else {
+            await cleanupStagedObjectsAfterWriteFailure({
+                attempt,
+                req
+            });
+        }
+        throw err;
+    } finally{
+        await finishFileOperation({
+            hasSucceeded,
+            req,
+            state: requestState
+        });
+    }
+};
+/** Creates use the same rollback and outer-scope compensation without an existing document. */ export const runFileCreationPlan = async ({ cleanupStagedAfterWriteFailure, req, stage, write })=>{
+    const requestState = getRequestState({
+        req
+    });
+    const attempt = {
+        cleanupStagedAfterWriteFailure,
+        staged: new Map()
+    };
+    let hasStartedWrite = false;
+    let hasSucceeded = false;
+    const trackStagedObject = createStagedObjectTracker({
+        attempt
+    });
+    requestState.depth += 1;
+    try {
+        await stage({
+            trackStagedObject
+        });
+        hasStartedWrite = true;
+        const result = await write();
+        requestState.pending.push(attempt);
+        hasSucceeded = true;
+        return result;
+    } catch (err) {
+        if (!hasStartedWrite) {
+            await compensate({
+                attempt,
+                req
+            });
+        } else if (await hasActiveTransaction({
+            req
+        })) {
+            requestState.pending.push(attempt);
+        } else {
+            await cleanupStagedObjectsAfterWriteFailure({
+                attempt,
+                req
+            });
+        }
+        throw err;
+    } finally{
+        await finishFileOperation({
+            hasSucceeded,
+            req,
+            state: requestState
+        });
+    }
+};
+/** Writes each planned local object exclusively and registers only completed writes for rollback. */ export const stageLocalUploadFiles = async ({ files, staticDir, trackStagedObject })=>{
+    const directory = path.resolve(staticDir);
+    for (const file of files){
+        const destination = path.resolve(file.path);
+        const key = path.relative(directory, destination);
+        if (!key || key.startsWith('..') || path.isAbsolute(key)) {
+            throw new Error('Upload destination is outside its storage directory');
+        }
+        if ('sourcePath' in file) {
+            await fs.copyFile(file.sourcePath, destination, fs.constants.COPYFILE_EXCL);
+            trackStagedObject({
+                key,
+                remove: ()=>fs.rm(destination, {
+                        force: true
+                    })
+            });
+        } else {
+            const handle = await fs.open(destination, 'wx');
+            trackStagedObject({
+                key,
+                remove: ()=>fs.rm(destination, {
+                        force: true
+                    })
+            });
+            try {
+                await handle.writeFile(file.buffer);
+            } finally{
+                await handle.close();
+            }
+        }
+    }
+};
+/** Called only after the owning database transaction commits. */ export const commitFileOperations = async ({ req })=>{
+    const state = requests.get(requestOwners.get(req) ?? req);
+    if (!state) {
+        return;
+    }
+    state.isCommitted = true;
+    if (state.depth === 0) {
+        await flushCleanup({
+            req,
+            state
+        });
+    }
+};
+/** Called only after the owning database transaction rolls back. */ export const rollbackFileOperations = async ({ req })=>{
+    const state = requests.get(requestOwners.get(req) ?? req);
+    if (!state) {
+        return;
+    }
+    requests.delete(requestOwners.get(req) ?? req);
+    for (const attempt of state.pending.reverse()){
+        await compensate({
+            attempt,
+            req
+        });
+    }
+};
+const getRequestState = ({ req })=>{
+    let state = requests.get(requestOwners.get(req) ?? req);
+    if (!state) {
+        state = {
+            depth: 0,
+            isCommitted: false,
+            pending: []
+        };
+        requests.set(requestOwners.get(req) ?? req, state);
+    }
+    return state;
+};
+const createStagedObjectTracker = ({ attempt })=>(object)=>{
+        if (attempt.staged.has(object.key)) {
+            throw new Error(`Storage object was staged twice: ${object.key}`);
+        }
+        attempt.staged.set(object.key, object);
+    };
+const finishFileOperation = async ({ hasSucceeded, req, state })=>{
+    state.depth -= 1;
+    if (state.depth === 0) {
+        if (hasSucceeded && (!await hasActiveTransaction({
+            req
+        }) || state.isCommitted)) {
+            await flushCleanup({
+                req,
+                state
+            });
+        } else if (!await hasActiveTransaction({
+            req
+        })) {
+            requests.delete(requestOwners.get(req) ?? req);
+        }
+    }
+};
+const flushCleanup = async ({ req, state })=>{
+    if (await hasActiveTransaction({
+        req
+    }) && !state.isCommitted) {
+        return;
+    }
+    requests.delete(requestOwners.get(req) ?? req);
+    for (const attempt of state.pending){
+        await runDeferredCleanup({
+            attempt,
+            req
+        });
+    }
+};
+const reconcileFailedAttempts = async ({ req, state })=>{
+    requests.delete(requestOwners.get(req) ?? req);
+    for (const attempt of state.pending){
+        await cleanupStagedObjectsAfterWriteFailure({
+            attempt,
+            req
+        });
+        if (attempt.shouldCleanupAfterFailure) {
+            await runDeferredCleanup({
+                attempt,
+                req
+            });
+        }
+    }
+};
+const runDeferredCleanup = async ({ attempt, req })=>{
+    try {
+        await attempt.cleanup?.();
+    } catch (err) {
+        req.payload.logger.error({
+            err,
+            msg: 'Failed to clean up an unreferenced upload file'
+        });
+    }
+};
+const cleanupStagedObjectsAfterWriteFailure = async ({ attempt, req })=>{
+    if (!attempt.cleanupStagedAfterWriteFailure || !attempt.staged.size) {
+        return;
+    }
+    try {
+        await attempt.cleanupStagedAfterWriteFailure([
+            ...attempt.staged.values()
+        ].reverse());
+    } catch (err) {
+        req.payload.logger.error({
+            err,
+            msg: 'Failed to reconcile staged upload files after an operation failure'
+        });
+    }
+};
+const compensate = async ({ attempt, req })=>{
+    for (const object of [
+        ...attempt.staged.values()
+    ].reverse()){
+        try {
+            await object.remove();
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: `Failed to remove staged upload file ${object.key}`
+            });
+        }
+    }
+};
+
+//# sourceMappingURL=fileOperationManager.js.map

package/dist/uploads/fileVersioning/fileOperationManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/fileOperationManager.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { PayloadRequest } from '../../types/index.js'\nimport type { FileToSave } from '../types.js'\n\nimport { hasActiveTransaction } from '../../utilities/initTransaction.js'\n\nexport type StagedObject = {\n  key: string\n  remove: () => Promise<void>\n}\n\ntype Attempt = {\n  cleanup?: () => Promise<void>\n  cleanupStagedAfterWriteFailure?: (objects: StagedObject[]) => Promise<void>\n  shouldCleanupAfterFailure?: boolean\n  staged: Map<string, StagedObject>\n}\n\ntype RequestState = {\n  depth: number\n  isCommitted: boolean\n  pending: Attempt[]\n}\n\ntype RunFileOperationPlanArgs<T> = {\n  cleanupStagedAfterWriteFailure?: (objects: StagedObject[]) => Promise<void>\n  req: PayloadRequest\n  stage: (args: { trackStagedObject: (object: StagedObject) => void }) => Promise<void>\n  write: (args: { trackStagedObject: (object: StagedObject) => void }) => Promise<T>\n}\n\nconst requests = new WeakMap<PayloadRequest, RequestState>()\nconst requestOwners = new WeakMap<PayloadRequest, PayloadRequest>()\n\n/** Same-transaction request proxies must finish their files with the owning request. */\nexport const shareFileOperationScope = ({\n  owner,\n  req,\n}: {\n  owner: PayloadRequest\n  req: PayloadRequest\n}): void => {\n  requestOwners.set(req, requestOwners.get(owner) ?? owner)\n}\n\n/** Keeps no-transaction cleanup pending until an outer upload operation finishes. */\nexport const beginFileOperationScope = ({ req }: { req: PayloadRequest }): void => {\n  getRequestState({ req }).depth += 1\n}\n\nexport const completeFileOperationScope = async ({\n  req,\n}: {\n  req: PayloadRequest\n}): Promise<void> => {\n  const state = requests.get(requestOwners.get(req) ?? req)\n\n  if (!state) {\n    return\n  }\n\n  state.depth -= 1\n  if (state.depth === 0 && (!(await hasActiveTransaction({ req })) || state.isCommitted)) {\n    await flushCleanup({ req, state })\n  }\n}\n\nexport const abortFileOperationScope = async ({ req }: { req: PayloadRequest }): Promise<void> => {\n  const state = requests.get(requestOwners.get(req) ?? req)\n\n  if (!state) {\n    return\n  }\n\n  state.depth -= 1\n\n  if (state.depth === 0 && !(await hasActiveTransaction({ req }))) {\n    await reconcileFailedAttempts({ req, state })\n  }\n}\n\n/** Runs cleanup after the outer operation and its database transaction succeed. */\nexport const deferFileCleanup = async ({\n  cleanup,\n  req,\n  shouldCleanupAfterFailure,\n}: {\n  cleanup: () => Promise<void>\n  req: PayloadRequest\n  /** Enable only for cleanup that rechecks persisted references before deleting. */\n  shouldCleanupAfterFailure?: boolean\n}): Promise<void> => {\n  const state = getRequestState({ req })\n  state.pending.push({ cleanup, shouldCleanupAfterFailure, staged: new Map() })\n  if (state.depth === 0 && (!(await hasActiveTransaction({ req })) || state.isCommitted)) {\n    await flushCleanup({ req, state })\n  }\n}\n\n/** Stages owned objects before writing document or version data. */\nexport const runFileOperationPlan = async <T>({\n  cleanupStagedAfterWriteFailure,\n  req,\n  stage,\n  write,\n}: RunFileOperationPlanArgs<T>): Promise<T> => {\n  const requestState = getRequestState({ req })\n  const attempt: Attempt = { cleanupStagedAfterWriteFailure, staged: new Map() }\n  let hasStartedWrite = false\n  let hasSucceeded = false\n  const trackStagedObject = createStagedObjectTracker({ attempt })\n\n  requestState.depth += 1\n\n  try {\n    await stage({ trackStagedObject })\n\n    hasStartedWrite = true\n    const result = await write({ trackStagedObject })\n\n    requestState.pending.push(attempt)\n    hasSucceeded = true\n\n    return result\n  } catch (err) {\n    if (!hasStartedWrite) {\n      await compensate({ attempt, req })\n    } else if (await hasActiveTransaction({ req })) {\n      requestState.pending.push({ staged: attempt.staged })\n    } else {\n      await cleanupStagedObjectsAfterWriteFailure({ attempt, req })\n    }\n\n    throw err\n  } finally {\n    await finishFileOperation({ hasSucceeded, req, state: requestState })\n  }\n}\n\n/** Creates use the same rollback and outer-scope compensation without an existing document. */\nexport const runFileCreationPlan = async <T>({\n  cleanupStagedAfterWriteFailure,\n  req,\n  stage,\n  write,\n}: {\n  cleanupStagedAfterWriteFailure?: (objects: StagedObject[]) => Promise<void>\n  req: PayloadRequest\n  stage: (args: { trackStagedObject: (object: StagedObject) => void }) => Promise<void>\n  write: () => Promise<T>\n}): Promise<T> => {\n  const requestState = getRequestState({ req })\n  const attempt: Attempt = { cleanupStagedAfterWriteFailure, staged: new Map() }\n  let hasStartedWrite = false\n  let hasSucceeded = false\n  const trackStagedObject = createStagedObjectTracker({ attempt })\n\n  requestState.depth += 1\n\n  try {\n    await stage({ trackStagedObject })\n\n    hasStartedWrite = true\n    const result = await write()\n\n    requestState.pending.push(attempt)\n    hasSucceeded = true\n    return result\n  } catch (err) {\n    if (!hasStartedWrite) {\n      await compensate({ attempt, req })\n    } else if (await hasActiveTransaction({ req })) {\n      requestState.pending.push(attempt)\n    } else {\n      await cleanupStagedObjectsAfterWriteFailure({ attempt, req })\n    }\n    throw err\n  } finally {\n    await finishFileOperation({ hasSucceeded, req, state: requestState })\n  }\n}\n\n/** Writes each planned local object exclusively and registers only completed writes for rollback. */\nexport const stageLocalUploadFiles = async ({\n  files,\n  staticDir,\n  trackStagedObject,\n}: {\n  files: FileToSave[]\n  staticDir: string\n  trackStagedObject: (object: StagedObject) => void\n}): Promise<void> => {\n  const directory = path.resolve(staticDir)\n\n  for (const file of files) {\n    const destination = path.resolve(file.path)\n    const key = path.relative(directory, destination)\n\n    if (!key || key.startsWith('..') || path.isAbsolute(key)) {\n      throw new Error('Upload destination is outside its storage directory')\n    }\n\n    if ('sourcePath' in file) {\n      await fs.copyFile(file.sourcePath, destination, fs.constants.COPYFILE_EXCL)\n      trackStagedObject({\n        key,\n        remove: () => fs.rm(destination, { force: true }),\n      })\n    } else {\n      const handle = await fs.open(destination, 'wx')\n      trackStagedObject({\n        key,\n        remove: () => fs.rm(destination, { force: true }),\n      })\n      try {\n        await handle.writeFile(file.buffer)\n      } finally {\n        await handle.close()\n      }\n    }\n  }\n}\n\n/** Called only after the owning database transaction commits. */\nexport const commitFileOperations = async ({ req }: { req: PayloadRequest }): Promise<void> => {\n  const state = requests.get(requestOwners.get(req) ?? req)\n\n  if (!state) {\n    return\n  }\n\n  state.isCommitted = true\n\n  if (state.depth === 0) {\n    await flushCleanup({ req, state })\n  }\n}\n\n/** Called only after the owning database transaction rolls back. */\nexport const rollbackFileOperations = async ({ req }: { req: PayloadRequest }): Promise<void> => {\n  const state = requests.get(requestOwners.get(req) ?? req)\n\n  if (!state) {\n    return\n  }\n\n  requests.delete(requestOwners.get(req) ?? req)\n  for (const attempt of state.pending.reverse()) {\n    await compensate({ attempt, req })\n  }\n}\n\nconst getRequestState = ({ req }: { req: PayloadRequest }): RequestState => {\n  let state = requests.get(requestOwners.get(req) ?? req)\n\n  if (!state) {\n    state = { depth: 0, isCommitted: false, pending: [] }\n    requests.set(requestOwners.get(req) ?? req, state)\n  }\n\n  return state\n}\n\nconst createStagedObjectTracker =\n  ({ attempt }: { attempt: Attempt }) =>\n  (object: StagedObject): void => {\n    if (attempt.staged.has(object.key)) {\n      throw new Error(`Storage object was staged twice: ${object.key}`)\n    }\n\n    attempt.staged.set(object.key, object)\n  }\n\nconst finishFileOperation = async ({\n  hasSucceeded,\n  req,\n  state,\n}: {\n  hasSucceeded: boolean\n  req: PayloadRequest\n  state: RequestState\n}): Promise<void> => {\n  state.depth -= 1\n\n  if (state.depth === 0) {\n    if (hasSucceeded && (!(await hasActiveTransaction({ req })) || state.isCommitted)) {\n      await flushCleanup({ req, state })\n    } else if (!(await hasActiveTransaction({ req }))) {\n      requests.delete(requestOwners.get(req) ?? req)\n    }\n  }\n}\n\nconst flushCleanup = async ({\n  req,\n  state,\n}: {\n  req: PayloadRequest\n  state: RequestState\n}): Promise<void> => {\n  if ((await hasActiveTransaction({ req })) && !state.isCommitted) {\n    return\n  }\n\n  requests.delete(requestOwners.get(req) ?? req)\n\n  for (const attempt of state.pending) {\n    await runDeferredCleanup({ attempt, req })\n  }\n}\n\nconst reconcileFailedAttempts = async ({\n  req,\n  state,\n}: {\n  req: PayloadRequest\n  state: RequestState\n}): Promise<void> => {\n  requests.delete(requestOwners.get(req) ?? req)\n\n  for (const attempt of state.pending) {\n    await cleanupStagedObjectsAfterWriteFailure({ attempt, req })\n    if (attempt.shouldCleanupAfterFailure) {\n      await runDeferredCleanup({ attempt, req })\n    }\n  }\n}\n\nconst runDeferredCleanup = async ({\n  attempt,\n  req,\n}: {\n  attempt: Attempt\n  req: PayloadRequest\n}): Promise<void> => {\n  try {\n    await attempt.cleanup?.()\n  } catch (err) {\n    req.payload.logger.error({ err, msg: 'Failed to clean up an unreferenced upload file' })\n  }\n}\n\nconst cleanupStagedObjectsAfterWriteFailure = async ({\n  attempt,\n  req,\n}: {\n  attempt: Attempt\n  req: PayloadRequest\n}): Promise<void> => {\n  if (!attempt.cleanupStagedAfterWriteFailure || !attempt.staged.size) {\n    return\n  }\n\n  try {\n    await attempt.cleanupStagedAfterWriteFailure([...attempt.staged.values()].reverse())\n  } catch (err) {\n    req.payload.logger.error({\n      err,\n      msg: 'Failed to reconcile staged upload files after an operation failure',\n    })\n  }\n}\n\nconst compensate = async ({\n  attempt,\n  req,\n}: {\n  attempt: Attempt\n  req: PayloadRequest\n}): Promise<void> => {\n  for (const object of [...attempt.staged.values()].reverse()) {\n    try {\n      await object.remove()\n    } catch (err) {\n      req.payload.logger.error({\n        err,\n        msg: `Failed to remove staged upload file ${object.key}`,\n      })\n    }\n  }\n}\n"],"names":["fs","path","hasActiveTransaction","requests","WeakMap","requestOwners","shareFileOperationScope","owner","req","set","get","beginFileOperationScope","getRequestState","depth","completeFileOperationScope","state","isCommitted","flushCleanup","abortFileOperationScope","reconcileFailedAttempts","deferFileCleanup","cleanup","shouldCleanupAfterFailure","pending","push","staged","Map","runFileOperationPlan","cleanupStagedAfterWriteFailure","stage","write","requestState","attempt","hasStartedWrite","hasSucceeded","trackStagedObject","createStagedObjectTracker","result","err","compensate","cleanupStagedObjectsAfterWriteFailure","finishFileOperation","runFileCreationPlan","stageLocalUploadFiles","files","staticDir","directory","resolve","file","destination","key","relative","startsWith","isAbsolute","Error","copyFile","sourcePath","constants","COPYFILE_EXCL","remove","rm","force","handle","open","writeFile","buffer","close","commitFileOperations","rollbackFileOperations","delete","reverse","object","has","runDeferredCleanup","payload","logger","error","msg","size","values"],"mappings":"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"}

package/dist/uploads/fileVersioning/localStorage.d.ts

@@ -0,0 +1,9 @@
+type LocalFileOperationArgs = {
+    from: string;
+    staticDir: string;
+    to: string;
+};
+/** Copies a managed local object to a previously unused key. */
+export declare const copyLocalFile: ({ from, staticDir, to, }: LocalFileOperationArgs) => Promise<void>;
+export {};
+//# sourceMappingURL=localStorage.d.ts.map

package/dist/uploads/fileVersioning/localStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localStorage.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/localStorage.ts"],"names":[],"mappings":"AAKA,KAAK,sBAAsB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,gEAAgE;AAChE,eAAO,MAAM,aAAa,6BAIvB,sBAAsB,KAAG,OAAO,CAAC,IAAI,CAKvC,CAAA"}

package/dist/uploads/fileVersioning/localStorage.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeStorageKey } from './naming.js';
+/** Copies a managed local object to a previously unused key. */ export const copyLocalFile = async ({ from, staticDir, to })=>{
+    const { destination, source } = await resolvePaths({
+        from,
+        staticDir,
+        to
+    });
+    await fs.copyFile(source, destination, fs.constants.COPYFILE_EXCL);
+    await fs.stat(destination);
+};
+const resolvePaths = async ({ from, staticDir, to })=>{
+    const root = await fs.realpath(staticDir);
+    const source = path.resolve(root, normalizeStorageKey({
+        key: from
+    }));
+    const destination = path.resolve(root, normalizeStorageKey({
+        key: to
+    }));
+    if (source === destination || !isWithinRoot({
+        root,
+        target: source
+    })) {
+        throw new Error('Invalid local storage source');
+    }
+    if (!isWithinRoot({
+        root,
+        target: destination
+    })) {
+        throw new Error('Invalid local storage destination');
+    }
+    const sourcePath = await fs.realpath(source);
+    if (!isWithinRoot({
+        root,
+        target: sourcePath
+    })) {
+        throw new Error('Local storage source escapes its directory');
+    }
+    await ensureSafeDestinationDirectory({
+        directory: path.dirname(destination),
+        root
+    });
+    const destinationParent = await fs.realpath(path.dirname(destination));
+    if (destinationParent !== root && !isWithinRoot({
+        root,
+        target: destinationParent
+    })) {
+        throw new Error('Local storage path escapes its directory');
+    }
+    return {
+        destination,
+        source
+    };
+};
+const ensureSafeDestinationDirectory = async ({ directory, root })=>{
+    let current = root;
+    for (const segment of path.relative(root, directory).split(path.sep)){
+        if (!segment) {
+            continue;
+        }
+        current = path.join(current, segment);
+        try {
+            const entry = await fs.lstat(current);
+            if (!entry.isDirectory() || entry.isSymbolicLink()) {
+                throw new Error('Local storage destination contains a non-directory path');
+            }
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+            await fs.mkdir(current);
+        }
+    }
+};
+const isWithinRoot = ({ root, target })=>target.startsWith(`${root}${path.sep}`);
+
+//# sourceMappingURL=localStorage.js.map

package/dist/uploads/fileVersioning/localStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/localStorage.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport { normalizeStorageKey } from './naming.js'\n\ntype LocalFileOperationArgs = {\n  from: string\n  staticDir: string\n  to: string\n}\n\n/** Copies a managed local object to a previously unused key. */\nexport const copyLocalFile = async ({\n  from,\n  staticDir,\n  to,\n}: LocalFileOperationArgs): Promise<void> => {\n  const { destination, source } = await resolvePaths({ from, staticDir, to })\n\n  await fs.copyFile(source, destination, fs.constants.COPYFILE_EXCL)\n  await fs.stat(destination)\n}\n\nconst resolvePaths = async ({ from, staticDir, to }: LocalFileOperationArgs) => {\n  const root = await fs.realpath(staticDir)\n  const source = path.resolve(root, normalizeStorageKey({ key: from }))\n  const destination = path.resolve(root, normalizeStorageKey({ key: to }))\n\n  if (source === destination || !isWithinRoot({ root, target: source })) {\n    throw new Error('Invalid local storage source')\n  }\n  if (!isWithinRoot({ root, target: destination })) {\n    throw new Error('Invalid local storage destination')\n  }\n\n  const sourcePath = await fs.realpath(source)\n\n  if (!isWithinRoot({ root, target: sourcePath })) {\n    throw new Error('Local storage source escapes its directory')\n  }\n\n  await ensureSafeDestinationDirectory({ directory: path.dirname(destination), root })\n\n  const destinationParent = await fs.realpath(path.dirname(destination))\n\n  if (destinationParent !== root && !isWithinRoot({ root, target: destinationParent })) {\n    throw new Error('Local storage path escapes its directory')\n  }\n\n  return { destination, source }\n}\n\nconst ensureSafeDestinationDirectory = async ({\n  directory,\n  root,\n}: {\n  directory: string\n  root: string\n}): Promise<void> => {\n  let current = root\n\n  for (const segment of path.relative(root, directory).split(path.sep)) {\n    if (!segment) {\n      continue\n    }\n\n    current = path.join(current, segment)\n    try {\n      const entry = await fs.lstat(current)\n\n      if (!entry.isDirectory() || entry.isSymbolicLink()) {\n        throw new Error('Local storage destination contains a non-directory path')\n      }\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {\n        throw err\n      }\n\n      await fs.mkdir(current)\n    }\n  }\n}\n\nconst isWithinRoot = ({ root, target }: { root: string; target: string }): boolean =>\n  target.startsWith(`${root}${path.sep}`)\n"],"names":["fs","path","normalizeStorageKey","copyLocalFile","from","staticDir","to","destination","source","resolvePaths","copyFile","constants","COPYFILE_EXCL","stat","root","realpath","resolve","key","isWithinRoot","target","Error","sourcePath","ensureSafeDestinationDirectory","directory","dirname","destinationParent","current","segment","relative","split","sep","join","entry","lstat","isDirectory","isSymbolicLink","err","code","mkdir","startsWith"],"mappings":"AAAA,OAAOA,QAAQ,mBAAkB;AACjC,OAAOC,UAAU,YAAW;AAE5B,SAASC,mBAAmB,QAAQ,cAAa;AAQjD,8DAA8D,GAC9D,OAAO,MAAMC,gBAAgB,OAAO,EAClCC,IAAI,EACJC,SAAS,EACTC,EAAE,EACqB;IACvB,MAAM,EAAEC,WAAW,EAAEC,MAAM,EAAE,GAAG,MAAMC,aAAa;QAAEL;QAAMC;QAAWC;IAAG;IAEzE,MAAMN,GAAGU,QAAQ,CAACF,QAAQD,aAAaP,GAAGW,SAAS,CAACC,aAAa;IACjE,MAAMZ,GAAGa,IAAI,CAACN;AAChB,EAAC;AAED,MAAME,eAAe,OAAO,EAAEL,IAAI,EAAEC,SAAS,EAAEC,EAAE,EAA0B;IACzE,MAAMQ,OAAO,MAAMd,GAAGe,QAAQ,CAACV;IAC/B,MAAMG,SAASP,KAAKe,OAAO,CAACF,MAAMZ,oBAAoB;QAAEe,KAAKb;IAAK;IAClE,MAAMG,cAAcN,KAAKe,OAAO,CAACF,MAAMZ,oBAAoB;QAAEe,KAAKX;IAAG;IAErE,IAAIE,WAAWD,eAAe,CAACW,aAAa;QAAEJ;QAAMK,QAAQX;IAAO,IAAI;QACrE,MAAM,IAAIY,MAAM;IAClB;IACA,IAAI,CAACF,aAAa;QAAEJ;QAAMK,QAAQZ;IAAY,IAAI;QAChD,MAAM,IAAIa,MAAM;IAClB;IAEA,MAAMC,aAAa,MAAMrB,GAAGe,QAAQ,CAACP;IAErC,IAAI,CAACU,aAAa;QAAEJ;QAAMK,QAAQE;IAAW,IAAI;QAC/C,MAAM,IAAID,MAAM;IAClB;IAEA,MAAME,+BAA+B;QAAEC,WAAWtB,KAAKuB,OAAO,CAACjB;QAAcO;IAAK;IAElF,MAAMW,oBAAoB,MAAMzB,GAAGe,QAAQ,CAACd,KAAKuB,OAAO,CAACjB;IAEzD,IAAIkB,sBAAsBX,QAAQ,CAACI,aAAa;QAAEJ;QAAMK,QAAQM;IAAkB,IAAI;QACpF,MAAM,IAAIL,MAAM;IAClB;IAEA,OAAO;QAAEb;QAAaC;IAAO;AAC/B;AAEA,MAAMc,iCAAiC,OAAO,EAC5CC,SAAS,EACTT,IAAI,EAIL;IACC,IAAIY,UAAUZ;IAEd,KAAK,MAAMa,WAAW1B,KAAK2B,QAAQ,CAACd,MAAMS,WAAWM,KAAK,CAAC5B,KAAK6B,GAAG,EAAG;QACpE,IAAI,CAACH,SAAS;YACZ;QACF;QAEAD,UAAUzB,KAAK8B,IAAI,CAACL,SAASC;QAC7B,IAAI;YACF,MAAMK,QAAQ,MAAMhC,GAAGiC,KAAK,CAACP;YAE7B,IAAI,CAACM,MAAME,WAAW,MAAMF,MAAMG,cAAc,IAAI;gBAClD,MAAM,IAAIf,MAAM;YAClB;QACF,EAAE,OAAOgB,KAAK;YACZ,IAAI,AAACA,IAA8BC,IAAI,KAAK,UAAU;gBACpD,MAAMD;YACR;YAEA,MAAMpC,GAAGsC,KAAK,CAACZ;QACjB;IACF;AACF;AAEA,MAAMR,eAAe,CAAC,EAAEJ,IAAI,EAAEK,MAAM,EAAoC,GACtEA,OAAOoB,UAAU,CAAC,GAAGzB,OAAOb,KAAK6B,GAAG,EAAE"}

package/dist/uploads/fileVersioning/markHistoricalFileURLs.d.ts

@@ -0,0 +1,8 @@
+import type { PayloadRequest } from '../../types/index.js';
+export declare const markHistoricalFileURLs: <T extends Record<string, unknown>>({ collectionSlug, doc, req, versionID, }: {
+    collectionSlug: string;
+    doc: T;
+    req: PayloadRequest;
+    versionID: number | string;
+}) => T;
+//# sourceMappingURL=markHistoricalFileURLs.d.ts.map

package/dist/uploads/fileVersioning/markHistoricalFileURLs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markHistoricalFileURLs.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/markHistoricalFileURLs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,4CAKrE;IACD,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,EAAE,CAAC,CAAA;IACN,GAAG,EAAE,cAAc,CAAA;IACnB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;CAC3B,KAAG,CAmDH,CAAA"}

package/dist/uploads/fileVersioning/markHistoricalFileURLs.js

@@ -0,0 +1,49 @@
+export const markHistoricalFileURLs = ({ collectionSlug, doc, req, versionID })=>{
+    const serverURL = req.payload.config.serverURL;
+    const apiRoute = req.payload.config.routes.api;
+    const filePath = `${apiRoute}/${collectionSlug}/file/`;
+    const mark = (value)=>{
+        if (typeof value !== 'string') {
+            return value;
+        }
+        if (!value.startsWith('/') && !(serverURL && value.startsWith(serverURL))) {
+            return value;
+        }
+        const url = new URL(value, serverURL || 'http://payload.local');
+        if (!url.pathname.startsWith(filePath) || url.searchParams.has('version')) {
+            return value;
+        }
+        return `${value}${value.includes('?') ? '&' : '?'}version=${encodeURIComponent(String(versionID))}`;
+    };
+    const marked = {
+        ...doc
+    };
+    if (typeof doc.url === 'string') {
+        marked.url = mark(doc.url);
+    }
+    if (doc.original && typeof doc.original === 'object' && !Array.isArray(doc.original)) {
+        const original = doc.original;
+        marked.original = typeof original.url === 'string' ? {
+            ...original,
+            url: mark(original.url)
+        } : original;
+    }
+    if (doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)) {
+        marked.variants = Object.fromEntries(Object.entries(doc.variants).map(([name, size])=>size && typeof size === 'object' && !Array.isArray(size) && typeof size.url === 'string' ? [
+                name,
+                {
+                    ...size,
+                    url: mark(size.url)
+                }
+            ] : [
+                name,
+                size
+            ]));
+    }
+    if (typeof doc.thumbnailURL === 'string') {
+        marked.thumbnailURL = mark(doc.thumbnailURL);
+    }
+    return marked;
+};
+
+//# sourceMappingURL=markHistoricalFileURLs.js.map

package/dist/uploads/fileVersioning/markHistoricalFileURLs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/markHistoricalFileURLs.ts"],"sourcesContent":["import type { PayloadRequest } from '../../types/index.js'\n\nexport const markHistoricalFileURLs = <T extends Record<string, unknown>>({\n  collectionSlug,\n  doc,\n  req,\n  versionID,\n}: {\n  collectionSlug: string\n  doc: T\n  req: PayloadRequest\n  versionID: number | string\n}): T => {\n  const serverURL = req.payload.config.serverURL\n  const apiRoute = req.payload.config.routes.api\n  const filePath = `${apiRoute}/${collectionSlug}/file/`\n  const mark = (value: unknown): unknown => {\n    if (typeof value !== 'string') {\n      return value\n    }\n    if (!value.startsWith('/') && !(serverURL && value.startsWith(serverURL))) {\n      return value\n    }\n\n    const url = new URL(value, serverURL || 'http://payload.local')\n\n    if (!url.pathname.startsWith(filePath) || url.searchParams.has('version')) {\n      return value\n    }\n\n    return `${value}${value.includes('?') ? '&' : '?'}version=${encodeURIComponent(String(versionID))}`\n  }\n\n  const marked: Record<string, unknown> = { ...doc }\n\n  if (typeof doc.url === 'string') {\n    marked.url = mark(doc.url)\n  }\n\n  if (doc.original && typeof doc.original === 'object' && !Array.isArray(doc.original)) {\n    const original = doc.original as Record<string, unknown>\n    marked.original =\n      typeof original.url === 'string' ? { ...original, url: mark(original.url) } : original\n  }\n\n  if (doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)) {\n    marked.variants = Object.fromEntries(\n      Object.entries(doc.variants).map(([name, size]) =>\n        size &&\n        typeof size === 'object' &&\n        !Array.isArray(size) &&\n        typeof (size as Record<string, unknown>).url === 'string'\n          ? [name, { ...size, url: mark((size as Record<string, unknown>).url) }]\n          : [name, size],\n      ),\n    )\n  }\n\n  if (typeof doc.thumbnailURL === 'string') {\n    marked.thumbnailURL = mark(doc.thumbnailURL)\n  }\n\n  return marked as T\n}\n"],"names":["markHistoricalFileURLs","collectionSlug","doc","req","versionID","serverURL","payload","config","apiRoute","routes","api","filePath","mark","value","startsWith","url","URL","pathname","searchParams","has","includes","encodeURIComponent","String","marked","original","Array","isArray","variants","Object","fromEntries","entries","map","name","size","thumbnailURL"],"mappings":"AAEA,OAAO,MAAMA,yBAAyB,CAAoC,EACxEC,cAAc,EACdC,GAAG,EACHC,GAAG,EACHC,SAAS,EAMV;IACC,MAAMC,YAAYF,IAAIG,OAAO,CAACC,MAAM,CAACF,SAAS;IAC9C,MAAMG,WAAWL,IAAIG,OAAO,CAACC,MAAM,CAACE,MAAM,CAACC,GAAG;IAC9C,MAAMC,WAAW,GAAGH,SAAS,CAAC,EAAEP,eAAe,MAAM,CAAC;IACtD,MAAMW,OAAO,CAACC;QACZ,IAAI,OAAOA,UAAU,UAAU;YAC7B,OAAOA;QACT;QACA,IAAI,CAACA,MAAMC,UAAU,CAAC,QAAQ,CAAET,CAAAA,aAAaQ,MAAMC,UAAU,CAACT,UAAS,GAAI;YACzE,OAAOQ;QACT;QAEA,MAAME,MAAM,IAAIC,IAAIH,OAAOR,aAAa;QAExC,IAAI,CAACU,IAAIE,QAAQ,CAACH,UAAU,CAACH,aAAaI,IAAIG,YAAY,CAACC,GAAG,CAAC,YAAY;YACzE,OAAON;QACT;QAEA,OAAO,GAAGA,QAAQA,MAAMO,QAAQ,CAAC,OAAO,MAAM,IAAI,QAAQ,EAAEC,mBAAmBC,OAAOlB,aAAa;IACrG;IAEA,MAAMmB,SAAkC;QAAE,GAAGrB,GAAG;IAAC;IAEjD,IAAI,OAAOA,IAAIa,GAAG,KAAK,UAAU;QAC/BQ,OAAOR,GAAG,GAAGH,KAAKV,IAAIa,GAAG;IAC3B;IAEA,IAAIb,IAAIsB,QAAQ,IAAI,OAAOtB,IAAIsB,QAAQ,KAAK,YAAY,CAACC,MAAMC,OAAO,CAACxB,IAAIsB,QAAQ,GAAG;QACpF,MAAMA,WAAWtB,IAAIsB,QAAQ;QAC7BD,OAAOC,QAAQ,GACb,OAAOA,SAAST,GAAG,KAAK,WAAW;YAAE,GAAGS,QAAQ;YAAET,KAAKH,KAAKY,SAAST,GAAG;QAAE,IAAIS;IAClF;IAEA,IAAItB,IAAIyB,QAAQ,IAAI,OAAOzB,IAAIyB,QAAQ,KAAK,YAAY,CAACF,MAAMC,OAAO,CAACxB,IAAIyB,QAAQ,GAAG;QACpFJ,OAAOI,QAAQ,GAAGC,OAAOC,WAAW,CAClCD,OAAOE,OAAO,CAAC5B,IAAIyB,QAAQ,EAAEI,GAAG,CAAC,CAAC,CAACC,MAAMC,KAAK,GAC5CA,QACA,OAAOA,SAAS,YAChB,CAACR,MAAMC,OAAO,CAACO,SACf,OAAO,AAACA,KAAiClB,GAAG,KAAK,WAC7C;gBAACiB;gBAAM;oBAAE,GAAGC,IAAI;oBAAElB,KAAKH,KAAK,AAACqB,KAAiClB,GAAG;gBAAE;aAAE,GACrE;gBAACiB;gBAAMC;aAAK;IAGtB;IAEA,IAAI,OAAO/B,IAAIgC,YAAY,KAAK,UAAU;QACxCX,OAAOW,YAAY,GAAGtB,KAAKV,IAAIgC,YAAY;IAC7C;IAEA,OAAOX;AACT,EAAC"}