payload 4.0.0-internal.bc5cf8c → 4.0.0-internal.bf4bcce

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"}

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

@@ -0,0 +1,12 @@
+/** Validates and returns a complete, canonical key supplied by the storage path builder or provider. */
+export declare const normalizeStorageKey: ({ key }: {
+    key: string;
+}) => string;
+export declare const getOriginalFilename: ({ filename }: {
+    filename: string;
+}) => string;
+export declare const getArchivedFilename: ({ filename, versionID, }: {
+    filename: string;
+    versionID: number | string;
+}) => string;
+//# sourceMappingURL=naming.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"naming.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/naming.ts"],"names":[],"mappings":"AAAA,wGAAwG;AACxG,eAAO,MAAM,mBAAmB,YAAa;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,KAAG,MAY9D,CAAA;AAED,eAAO,MAAM,mBAAmB,iBAAkB;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,KAAG,MACzB,CAAA;AAEhD,eAAO,MAAM,mBAAmB,6BAG7B;IACD,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;CAC3B,KAAG,MAUH,CAAA"}

package/dist/uploads/fileVersioning/naming.js

@@ -0,0 +1,47 @@
+/** Validates and returns a complete, canonical key supplied by the storage path builder or provider. */ export const normalizeStorageKey = ({ key })=>{
+    if (!key || key.startsWith('/') || key.includes('\\') || key.includes('\0') || key.split('/').some((segment)=>!segment || segment === '.' || segment === '..')) {
+        throw new Error('Unsafe managed storage key');
+    }
+    return key;
+};
+export const getOriginalFilename = ({ filename })=>insertSuffix({
+        filename,
+        suffix: 'original'
+    });
+export const getArchivedFilename = ({ filename, versionID })=>{
+    const id = String(versionID);
+    if (!id) {
+        throw new Error('An archived file requires a version ID');
+    }
+    const safeID = /^[\w-]+$/.test(id) ? id : `~${Buffer.from(id).toString('base64url')}`;
+    return insertSuffix({
+        filename,
+        suffix: safeID
+    });
+};
+const insertSuffix = ({ filename, suffix })=>{
+    const { extension, stem } = splitFilename({
+        filename
+    });
+    return `${stem}-${suffix}${extension}`;
+};
+const splitFilename = ({ filename })=>{
+    assertSafeFilename({
+        filename
+    });
+    const extensionIndex = filename.lastIndexOf('.');
+    return extensionIndex > 0 ? {
+        extension: filename.slice(extensionIndex),
+        stem: filename.slice(0, extensionIndex)
+    } : {
+        extension: '',
+        stem: filename
+    };
+};
+const assertSafeFilename = ({ filename })=>{
+    if (!filename || filename === '.' || filename === '..' || filename.includes('/') || filename.includes('\\') || filename.includes('\0')) {
+        throw new Error('Unsafe managed filename');
+    }
+};
+
+//# sourceMappingURL=naming.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/naming.ts"],"sourcesContent":["/** Validates and returns a complete, canonical key supplied by the storage path builder or provider. */\nexport const normalizeStorageKey = ({ key }: { key: string }): string => {\n  if (\n    !key ||\n    key.startsWith('/') ||\n    key.includes('\\\\') ||\n    key.includes('\\0') ||\n    key.split('/').some((segment) => !segment || segment === '.' || segment === '..')\n  ) {\n    throw new Error('Unsafe managed storage key')\n  }\n\n  return key\n}\n\nexport const getOriginalFilename = ({ filename }: { filename: string }): string =>\n  insertSuffix({ filename, suffix: 'original' })\n\nexport const getArchivedFilename = ({\n  filename,\n  versionID,\n}: {\n  filename: string\n  versionID: number | string\n}): string => {\n  const id = String(versionID)\n\n  if (!id) {\n    throw new Error('An archived file requires a version ID')\n  }\n\n  const safeID = /^[\\w-]+$/.test(id) ? id : `~${Buffer.from(id).toString('base64url')}`\n\n  return insertSuffix({ filename, suffix: safeID })\n}\n\nconst insertSuffix = ({ filename, suffix }: { filename: string; suffix: string }): string => {\n  const { extension, stem } = splitFilename({ filename })\n\n  return `${stem}-${suffix}${extension}`\n}\n\nconst splitFilename = ({ filename }: { filename: string }): { extension: string; stem: string } => {\n  assertSafeFilename({ filename })\n\n  const extensionIndex = filename.lastIndexOf('.')\n\n  return extensionIndex > 0\n    ? { extension: filename.slice(extensionIndex), stem: filename.slice(0, extensionIndex) }\n    : { extension: '', stem: filename }\n}\n\nconst assertSafeFilename = ({ filename }: { filename: string }): void => {\n  if (\n    !filename ||\n    filename === '.' ||\n    filename === '..' ||\n    filename.includes('/') ||\n    filename.includes('\\\\') ||\n    filename.includes('\\0')\n  ) {\n    throw new Error('Unsafe managed filename')\n  }\n}\n"],"names":["normalizeStorageKey","key","startsWith","includes","split","some","segment","Error","getOriginalFilename","filename","insertSuffix","suffix","getArchivedFilename","versionID","id","String","safeID","test","Buffer","from","toString","extension","stem","splitFilename","assertSafeFilename","extensionIndex","lastIndexOf","slice"],"mappings":"AAAA,sGAAsG,GACtG,OAAO,MAAMA,sBAAsB,CAAC,EAAEC,GAAG,EAAmB;IAC1D,IACE,CAACA,OACDA,IAAIC,UAAU,CAAC,QACfD,IAAIE,QAAQ,CAAC,SACbF,IAAIE,QAAQ,CAAC,SACbF,IAAIG,KAAK,CAAC,KAAKC,IAAI,CAAC,CAACC,UAAY,CAACA,WAAWA,YAAY,OAAOA,YAAY,OAC5E;QACA,MAAM,IAAIC,MAAM;IAClB;IAEA,OAAON;AACT,EAAC;AAED,OAAO,MAAMO,sBAAsB,CAAC,EAAEC,QAAQ,EAAwB,GACpEC,aAAa;QAAED;QAAUE,QAAQ;IAAW,GAAE;AAEhD,OAAO,MAAMC,sBAAsB,CAAC,EAClCH,QAAQ,EACRI,SAAS,EAIV;IACC,MAAMC,KAAKC,OAAOF;IAElB,IAAI,CAACC,IAAI;QACP,MAAM,IAAIP,MAAM;IAClB;IAEA,MAAMS,SAAS,WAAWC,IAAI,CAACH,MAAMA,KAAK,CAAC,CAAC,EAAEI,OAAOC,IAAI,CAACL,IAAIM,QAAQ,CAAC,cAAc;IAErF,OAAOV,aAAa;QAAED;QAAUE,QAAQK;IAAO;AACjD,EAAC;AAED,MAAMN,eAAe,CAAC,EAAED,QAAQ,EAAEE,MAAM,EAAwC;IAC9E,MAAM,EAAEU,SAAS,EAAEC,IAAI,EAAE,GAAGC,cAAc;QAAEd;IAAS;IAErD,OAAO,GAAGa,KAAK,CAAC,EAAEX,SAASU,WAAW;AACxC;AAEA,MAAME,gBAAgB,CAAC,EAAEd,QAAQ,EAAwB;IACvDe,mBAAmB;QAAEf;IAAS;IAE9B,MAAMgB,iBAAiBhB,SAASiB,WAAW,CAAC;IAE5C,OAAOD,iBAAiB,IACpB;QAAEJ,WAAWZ,SAASkB,KAAK,CAACF;QAAiBH,MAAMb,SAASkB,KAAK,CAAC,GAAGF;IAAgB,IACrF;QAAEJ,WAAW;QAAIC,MAAMb;IAAS;AACtC;AAEA,MAAMe,qBAAqB,CAAC,EAAEf,QAAQ,EAAwB;IAC5D,IACE,CAACA,YACDA,aAAa,OACbA,aAAa,QACbA,SAASN,QAAQ,CAAC,QAClBM,SAASN,QAAQ,CAAC,SAClBM,SAASN,QAAQ,CAAC,OAClB;QACA,MAAM,IAAII,MAAM;IAClB;AACF"}

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

@@ -0,0 +1,11 @@
+import type { Collection, TypeWithID } from '../../collections/config/types.js';
+import type { PayloadRequest } from '../../types/index.js';
+/** Finds an exact saved object reference, including sizes removed from the current config. */
+export declare const resolveHistoricalFile: ({ collection, filename, prefix, req, versionID, }: {
+    collection: Collection;
+    filename: string;
+    prefix?: string;
+    req: PayloadRequest;
+    versionID: string;
+}) => Promise<TypeWithID>;
+//# sourceMappingURL=resolveHistoricalFile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveHistoricalFile.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/resolveHistoricalFile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA;AAC/E,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAatE,8FAA8F;AAC9F,eAAO,MAAM,qBAAqB,sDAM/B;IACD,UAAU,EAAE,UAAU,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,EAAE,cAAc,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;CAClB,KAAG,OAAO,CAAC,UAAU,CAmCrB,CAAA"}