payload 4.0.0-internal.e7d4ebc → 4.0.0-internal.ee5d8bd

package/dist/uploads/fetchWithRedirects.js

@@ -0,0 +1,53 @@
+import { APIError } from '../errors/APIError.js';
+import { isURLAllowed } from '../utilities/isURLAllowed.js';
+import { safeFetch } from './safeFetch.js';
+export const parseFileURL = (url, base)=>{
+    try {
+        const parsedURL = new URL(url, base);
+        if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {
+            throw new APIError('External file URLs must use HTTP or HTTPS.', 400);
+        }
+        return parsedURL;
+    } catch (error) {
+        if (error instanceof APIError) {
+            throw error;
+        }
+        throw new APIError('Invalid external file URL.', 400);
+    }
+};
+/**
+ * Fetches a file, checking each redirect against the allow list and SSRF restrictions.
+ * Returns the unread response so callers can either stream it or buffer it into a Payload File.
+ * Callers enforce any initial URL restrictions; existing uploads may also use same-origin URLs.
+ */ export const fetchWithRedirects = async ({ allowList, getHeaders, headers, skipSafeFetch, timeout, url })=>{
+    const maxRedirects = 3;
+    for(let redirectCount = 0;; redirectCount++){
+        // Explicitly allowed URLs may point to private hosts, such as an internal CDN.
+        const shouldSkipSafeFetch = skipSafeFetch === true || Array.isArray(skipSafeFetch) && isURLAllowed(url, skipSafeFetch) || allowList && isURLAllowed(url, allowList);
+        const response = await (shouldSkipSafeFetch ? fetch : safeFetch)(url, {
+            credentials: 'include',
+            headers: getHeaders ? getHeaders(url) : headers,
+            redirect: 'manual',
+            signal: timeout ? AbortSignal.timeout(timeout) : undefined
+        });
+        if (response.status >= 300 && response.status < 400) {
+            if (redirectCount >= maxRedirects) {
+                throw new APIError(`Too many redirects (max ${maxRedirects})`, 403);
+            }
+            const location = response.headers.get('location');
+            if (location) {
+                url = parseFileURL(location, parseFileURL(url)).href;
+                if (allowList && !isURLAllowed(url, allowList)) {
+                    throw new APIError('Redirect target is not allowed.', 400);
+                }
+                continue;
+            }
+        }
+        return {
+            response,
+            url
+        };
+    }
+};
+
+//# sourceMappingURL=fetchWithRedirects.js.map

package/dist/uploads/fetchWithRedirects.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/fetchWithRedirects.ts"],"sourcesContent":["import type { AllowList, UploadConfig } from './types.js'\n\nimport { APIError } from '../errors/APIError.js'\nimport { isURLAllowed } from '../utilities/isURLAllowed.js'\nimport { safeFetch } from './safeFetch.js'\n\nexport const parseFileURL = (url: string, base?: URL): URL => {\n  try {\n    const parsedURL = new URL(url, base)\n\n    if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {\n      throw new APIError('External file URLs must use HTTP or HTTPS.', 400)\n    }\n\n    return parsedURL\n  } catch (error) {\n    if (error instanceof APIError) {\n      throw error\n    }\n\n    throw new APIError('Invalid external file URL.', 400)\n  }\n}\n\n/**\n * Fetches a file, checking each redirect against the allow list and SSRF restrictions.\n * Returns the unread response so callers can either stream it or buffer it into a Payload File.\n * Callers enforce any initial URL restrictions; existing uploads may also use same-origin URLs.\n */\nexport const fetchWithRedirects = async ({\n  allowList,\n  getHeaders,\n  headers,\n  skipSafeFetch,\n  timeout,\n  url,\n}: {\n  allowList?: AllowList\n  getHeaders?: (url: string) => Record<string, string>\n  headers?: Record<string, string>\n  skipSafeFetch?: UploadConfig['skipSafeFetch']\n  timeout?: number\n  url: string\n}): Promise<{ response: Response; url: string }> => {\n  const maxRedirects = 3\n\n  for (let redirectCount = 0; ; redirectCount++) {\n    // Explicitly allowed URLs may point to private hosts, such as an internal CDN.\n    const shouldSkipSafeFetch =\n      skipSafeFetch === true ||\n      (Array.isArray(skipSafeFetch) && isURLAllowed(url, skipSafeFetch)) ||\n      (allowList && isURLAllowed(url, allowList))\n\n    const response = await (shouldSkipSafeFetch ? fetch : safeFetch)(url, {\n      credentials: 'include',\n      headers: getHeaders ? getHeaders(url) : headers,\n      redirect: 'manual',\n      signal: timeout ? AbortSignal.timeout(timeout) : undefined,\n    })\n\n    if (response.status >= 300 && response.status < 400) {\n      if (redirectCount >= maxRedirects) {\n        throw new APIError(`Too many redirects (max ${maxRedirects})`, 403)\n      }\n\n      const location = response.headers.get('location')\n\n      if (location) {\n        url = parseFileURL(location, parseFileURL(url)).href\n\n        if (allowList && !isURLAllowed(url, allowList)) {\n          throw new APIError('Redirect target is not allowed.', 400)\n        }\n\n        continue\n      }\n    }\n\n    return { response, url }\n  }\n}\n"],"names":["APIError","isURLAllowed","safeFetch","parseFileURL","url","base","parsedURL","URL","protocol","error","fetchWithRedirects","allowList","getHeaders","headers","skipSafeFetch","timeout","maxRedirects","redirectCount","shouldSkipSafeFetch","Array","isArray","response","fetch","credentials","redirect","signal","AbortSignal","undefined","status","location","get","href"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,wBAAuB;AAChD,SAASC,YAAY,QAAQ,+BAA8B;AAC3D,SAASC,SAAS,QAAQ,iBAAgB;AAE1C,OAAO,MAAMC,eAAe,CAACC,KAAaC;IACxC,IAAI;QACF,MAAMC,YAAY,IAAIC,IAAIH,KAAKC;QAE/B,IAAIC,UAAUE,QAAQ,KAAK,WAAWF,UAAUE,QAAQ,KAAK,UAAU;YACrE,MAAM,IAAIR,SAAS,8CAA8C;QACnE;QAEA,OAAOM;IACT,EAAE,OAAOG,OAAO;QACd,IAAIA,iBAAiBT,UAAU;YAC7B,MAAMS;QACR;QAEA,MAAM,IAAIT,SAAS,8BAA8B;IACnD;AACF,EAAC;AAED;;;;CAIC,GACD,OAAO,MAAMU,qBAAqB,OAAO,EACvCC,SAAS,EACTC,UAAU,EACVC,OAAO,EACPC,aAAa,EACbC,OAAO,EACPX,GAAG,EAQJ;IACC,MAAMY,eAAe;IAErB,IAAK,IAAIC,gBAAgB,IAAKA,gBAAiB;QAC7C,+EAA+E;QAC/E,MAAMC,sBACJJ,kBAAkB,QACjBK,MAAMC,OAAO,CAACN,kBAAkBb,aAAaG,KAAKU,kBAClDH,aAAaV,aAAaG,KAAKO;QAElC,MAAMU,WAAW,MAAM,AAACH,CAAAA,sBAAsBI,QAAQpB,SAAQ,EAAGE,KAAK;YACpEmB,aAAa;YACbV,SAASD,aAAaA,WAAWR,OAAOS;YACxCW,UAAU;YACVC,QAAQV,UAAUW,YAAYX,OAAO,CAACA,WAAWY;QACnD;QAEA,IAAIN,SAASO,MAAM,IAAI,OAAOP,SAASO,MAAM,GAAG,KAAK;YACnD,IAAIX,iBAAiBD,cAAc;gBACjC,MAAM,IAAIhB,SAAS,CAAC,wBAAwB,EAAEgB,aAAa,CAAC,CAAC,EAAE;YACjE;YAEA,MAAMa,WAAWR,SAASR,OAAO,CAACiB,GAAG,CAAC;YAEtC,IAAID,UAAU;gBACZzB,MAAMD,aAAa0B,UAAU1B,aAAaC,MAAM2B,IAAI;gBAEpD,IAAIpB,aAAa,CAACV,aAAaG,KAAKO,YAAY;oBAC9C,MAAM,IAAIX,SAAS,mCAAmC;gBACxD;gBAEA;YACF;QACF;QAEA,OAAO;YAAEqB;YAAUjB;QAAI;IACzB;AACF,EAAC"}

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

@@ -0,0 +1,29 @@
+import type { SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { JsonObject, PayloadRequest } from '../../types/index.js';
+import type { FileToSave } from '../types.js';
+import type { StagedObject } from './fileOperationManager.js';
+import type { StoredFileList } from './types.js';
+export declare const runLocalFileUpdate: <T>({ id, collection, current, files, next, req, write, }: {
+    collection: SanitizedCollectionConfig;
+    current: JsonObject;
+    files: FileToSave[];
+    id: number | string;
+    next: JsonObject;
+    req: PayloadRequest;
+    write: () => Promise<T>;
+}) => Promise<T>;
+/** Preserves outgoing local objects and repairs every retained version that referenced them. */
+export declare const archiveOutgoingLocalFiles: ({ id, collection, current, next, req, trackStagedObject, }: {
+    collection: SanitizedCollectionConfig;
+    current: JsonObject;
+    id: number | string;
+    next: JsonObject;
+    req: PayloadRequest;
+    trackStagedObject: (object: StagedObject) => void;
+}) => Promise<void>;
+export declare const replaceStoredFileReferences: ({ files, replacements, version, }: {
+    files: StoredFileList;
+    replacements: Map<string, string>;
+    version: JsonObject;
+}) => JsonObject | undefined;
+//# sourceMappingURL=archive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/archive.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAElF,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAuBhD,eAAO,MAAM,kBAAkB,GAAU,CAAC,yDAQvC;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,OAAO,EAAE,UAAU,CAAA;IACnB,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,KAAK,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,CAAA;CACxB,KAAG,OAAO,CAAC,CAAC,CA0DZ,CAAA;AA4BD,gGAAgG;AAChG,eAAO,MAAM,yBAAyB,+DAOnC;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,OAAO,EAAE,UAAU,CAAA;IACnB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,GAAG,EAAE,cAAc,CAAA;IACnB,iBAAiB,EAAE,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,CAAA;CAClD,KAAG,OAAO,CAAC,IAAI,CAkHf,CAAA;AA2CD,eAAO,MAAM,2BAA2B,sCAIrC;IACD,KAAK,EAAE,cAAc,CAAA;IACrB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,OAAO,EAAE,UAAU,CAAA;CACpB,KAAG,UAAU,GAAG,SA+ChB,CAAA"}

package/dist/uploads/fileVersioning/archive.js

@@ -0,0 +1,277 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { saveVersion } from '../../versions/saveVersion.js';
+import { removeUnreferencedStagedObjects, scheduleUnreferencedFileCleanup } from './cleanup.js';
+import { runFileOperationPlan, stageLocalUploadFiles } from './fileOperationManager.js';
+import { copyLocalFile } from './localStorage.js';
+import { getArchivedFilename } from './naming.js';
+import { collectStoredFiles, getStoredFileIdentity, withLegacyUploadFileData } from './storedFiles.js';
+export const runLocalFileUpdate = async ({ id, collection, current, files, next, req, write })=>{
+    const storedCurrent = withLegacyUploadFileData({
+        collection,
+        config: req.payload.config,
+        doc: current
+    });
+    const nextDoc = {
+        ...storedCurrent,
+        ...next
+    };
+    if (!hasLocalFileChange({
+        collection,
+        config: req.payload.config,
+        current,
+        hasNewFiles: files.length > 0,
+        next: nextDoc,
+        req
+    })) {
+        return write();
+    }
+    return runFileOperationPlan({
+        cleanupStagedAfterWriteFailure: (objects)=>removeUnreferencedStagedObjects({
+                collection,
+                objects,
+                req
+            }),
+        req,
+        stage: ({ trackStagedObject })=>stageLocalUploadFiles({
+                files,
+                staticDir: collection.upload.staticDir,
+                trackStagedObject
+            }),
+        write: async ({ trackStagedObject })=>{
+            await archiveOutgoingLocalFiles({
+                id,
+                collection,
+                current,
+                next: nextDoc,
+                req,
+                trackStagedObject
+            });
+            const result = await write();
+            await scheduleUnreferencedFileCleanup({
+                candidates: getOutgoingLocalFiles({
+                    collection,
+                    config: req.payload.config,
+                    current,
+                    next: nextDoc,
+                    req
+                }),
+                collection,
+                req
+            });
+            return result;
+        }
+    });
+};
+/** Also detects removals, which have no new upload to stage. */ const hasLocalFileChange = ({ collection, config, current, hasNewFiles, next, req })=>!collection.upload.disableLocalStorage && (hasNewFiles || getOutgoingLocalFiles({
+        collection,
+        config,
+        current,
+        next,
+        req
+    }).length > 0);
+/** Preserves outgoing local objects and repairs every retained version that referenced them. */ export const archiveOutgoingLocalFiles = async ({ id, collection, current, next, req, trackStagedObject })=>{
+    const outgoing = getOutgoingLocalFiles({
+        collection,
+        config: req.payload.config,
+        current,
+        next,
+        req
+    });
+    if (!outgoing.length || !collection.versions) {
+        return;
+    }
+    const currentWithState = withLegacyUploadFileData({
+        collection,
+        config: req.payload.config,
+        doc: current
+    });
+    let versions = await getVersions({
+        id,
+        collection,
+        req
+    });
+    if (!versions.length) {
+        await saveVersion({
+            id,
+            collection,
+            docWithLocales: currentWithState,
+            draft: false,
+            operation: 'update',
+            payload: req.payload,
+            req
+        });
+        versions = await getVersions({
+            id,
+            collection,
+            req
+        });
+    }
+    const replacements = new Map();
+    for (const file of outgoing){
+        const identity = getStoredFileIdentity(file);
+        const newestVersion = versions.find(({ version })=>{
+            const stored = withLegacyUploadFileData({
+                collection,
+                config: req.payload.config,
+                doc: version
+            });
+            return collectStoredFiles({
+                collection,
+                doc: stored,
+                req
+            }).some((candidate)=>getStoredFileIdentity(candidate) === identity);
+        });
+        if (!newestVersion) {
+            continue;
+        }
+        const directory = path.posix.dirname(file.key);
+        let archivedKey;
+        let suffix = 0;
+        while(true){
+            const archivedFilename = getArchivedFilename({
+                filename: path.posix.basename(file.key),
+                versionID: suffix ? `${newestVersion.id}-${suffix}` : newestVersion.id
+            });
+            archivedKey = directory === '.' ? archivedFilename : `${directory}/${archivedFilename}`;
+            try {
+                await copyLocalFile({
+                    from: file.key,
+                    staticDir: collection.upload.staticDir,
+                    to: archivedKey
+                });
+                break;
+            } catch (err) {
+                if (err.code !== 'EEXIST') {
+                    throw err;
+                }
+                suffix += 1;
+            }
+        }
+        trackStagedObject({
+            key: archivedKey,
+            remove: ()=>fs.rm(path.join(collection.upload.staticDir, archivedKey), {
+                    force: true
+                })
+        });
+        replacements.set(identity, archivedKey);
+    }
+    for (const row of versions){
+        const stored = withLegacyUploadFileData({
+            collection,
+            config: req.payload.config,
+            doc: row.version
+        });
+        const version = replaceStoredFileReferences({
+            files: collectStoredFiles({
+                collection,
+                doc: stored,
+                req
+            }),
+            replacements,
+            version: stored
+        });
+        if (!version) {
+            continue;
+        }
+        await req.payload.db.updateVersion({
+            id: row.id,
+            collection: collection.slug,
+            req,
+            versionData: {
+                createdAt: row.createdAt,
+                latest: row.latest,
+                parent: row.parent,
+                publishedLocale: row.publishedLocale,
+                updatedAt: row.updatedAt,
+                version
+            }
+        });
+    }
+};
+const getOutgoingLocalFiles = ({ collection, config, current, next, req })=>{
+    const currentWithState = withLegacyUploadFileData({
+        collection,
+        config,
+        doc: current
+    });
+    const currentFiles = collectStoredFiles({
+        collection,
+        doc: currentWithState,
+        req
+    });
+    const nextFiles = collectStoredFiles({
+        collection,
+        doc: next,
+        req,
+        trustGenerated: true
+    });
+    const nextIdentities = new Set(nextFiles.map(getStoredFileIdentity));
+    return currentFiles.filter((file)=>!nextIdentities.has(getStoredFileIdentity(file)));
+};
+const getVersions = async ({ id, collection, req })=>{
+    const { docs } = await req.payload.db.findVersions({
+        collection: collection.slug,
+        limit: 0,
+        pagination: false,
+        req,
+        sort: '-updatedAt',
+        where: {
+            parent: {
+                equals: id
+            }
+        }
+    });
+    return docs;
+};
+export const replaceStoredFileReferences = ({ files, replacements, version })=>{
+    if (!files.length) {
+        return;
+    }
+    const archived = structuredClone(version);
+    let hasChanged = false;
+    for (const file of files){
+        const archivedKey = replacements.get(getStoredFileIdentity(file));
+        if (!archivedKey) {
+            continue;
+        }
+        const archivedFilename = path.posix.basename(archivedKey);
+        for (const role of file.roles){
+            let stored;
+            switch(role.type){
+                case 'default':
+                    stored = archived;
+                    break;
+                case 'original':
+                    stored = archived.original;
+                    break;
+                case 'size':
+                    stored = archived.variants?.[role.sizeKey];
+                    break;
+            }
+            if (typeof stored?.filename === 'string') {
+                const previousFilename = stored.filename;
+                const directory = path.posix.dirname(previousFilename);
+                const filename = directory === '.' ? archivedFilename : `${directory}/${archivedFilename}`;
+                stored.filename = filename;
+                stored.url = replaceURLFilename({
+                    filename,
+                    previousFilename,
+                    url: stored.url
+                });
+                hasChanged = true;
+            }
+        }
+    }
+    return hasChanged ? archived : undefined;
+};
+const replaceURLFilename = ({ filename, previousFilename, url })=>{
+    if (typeof url !== 'string') {
+        return url;
+    }
+    const previous = encodeURIComponent(previousFilename);
+    const index = url.lastIndexOf(`/${previous}`);
+    return index < 0 ? url : `${url.slice(0, index + 1)}${encodeURIComponent(filename)}${url.slice(index + 1 + previous.length)}`;
+};
+
+//# sourceMappingURL=archive.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/archive.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { Config } from '../../config/types.js'\nimport type { JsonObject, PayloadRequest } from '../../types/index.js'\nimport type { FileToSave } from '../types.js'\nimport type { StagedObject } from './fileOperationManager.js'\nimport type { StoredFileList } from './types.js'\n\nimport { saveVersion } from '../../versions/saveVersion.js'\nimport { removeUnreferencedStagedObjects, scheduleUnreferencedFileCleanup } from './cleanup.js'\nimport { runFileOperationPlan, stageLocalUploadFiles } from './fileOperationManager.js'\nimport { copyLocalFile } from './localStorage.js'\nimport { getArchivedFilename } from './naming.js'\nimport {\n  collectStoredFiles,\n  getStoredFileIdentity,\n  withLegacyUploadFileData,\n} from './storedFiles.js'\n\ntype VersionRow = {\n  createdAt: string\n  id: number | string\n  latest?: boolean\n  parent: number | string\n  publishedLocale?: string\n  updatedAt: string\n  version: JsonObject\n}\n\nexport const runLocalFileUpdate = async <T>({\n  id,\n  collection,\n  current,\n  files,\n  next,\n  req,\n  write,\n}: {\n  collection: SanitizedCollectionConfig\n  current: JsonObject\n  files: FileToSave[]\n  id: number | string\n  next: JsonObject\n  req: PayloadRequest\n  write: () => Promise<T>\n}): Promise<T> => {\n  const storedCurrent = withLegacyUploadFileData({\n    collection,\n    config: req.payload.config,\n    doc: current,\n  })\n  const nextDoc = { ...storedCurrent, ...next }\n\n  if (\n    !hasLocalFileChange({\n      collection,\n      config: req.payload.config,\n      current,\n      hasNewFiles: files.length > 0,\n      next: nextDoc,\n      req,\n    })\n  ) {\n    return write()\n  }\n\n  return runFileOperationPlan({\n    cleanupStagedAfterWriteFailure: (objects) =>\n      removeUnreferencedStagedObjects({ collection, objects, req }),\n    req,\n    stage: ({ trackStagedObject }) =>\n      stageLocalUploadFiles({\n        files,\n        staticDir: collection.upload.staticDir!,\n        trackStagedObject,\n      }),\n    write: async ({ trackStagedObject }) => {\n      await archiveOutgoingLocalFiles({\n        id,\n        collection,\n        current,\n        next: nextDoc,\n        req,\n        trackStagedObject,\n      })\n\n      const result = await write()\n\n      await scheduleUnreferencedFileCleanup({\n        candidates: getOutgoingLocalFiles({\n          collection,\n          config: req.payload.config,\n          current,\n          next: nextDoc,\n          req,\n        }),\n        collection,\n        req,\n      })\n\n      return result\n    },\n  })\n}\n\n/** Also detects removals, which have no new upload to stage. */\nconst hasLocalFileChange = ({\n  collection,\n  config,\n  current,\n  hasNewFiles,\n  next,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  config: Pick<Config, 'routes' | 'serverURL'>\n  current: JsonObject\n  hasNewFiles: boolean\n  next: JsonObject\n  req: PayloadRequest\n}): boolean =>\n  !collection.upload.disableLocalStorage &&\n  (hasNewFiles ||\n    getOutgoingLocalFiles({\n      collection,\n      config,\n      current,\n      next,\n      req,\n    }).length > 0)\n\n/** Preserves outgoing local objects and repairs every retained version that referenced them. */\nexport const archiveOutgoingLocalFiles = async ({\n  id,\n  collection,\n  current,\n  next,\n  req,\n  trackStagedObject,\n}: {\n  collection: SanitizedCollectionConfig\n  current: JsonObject\n  id: number | string\n  next: JsonObject\n  req: PayloadRequest\n  trackStagedObject: (object: StagedObject) => void\n}): Promise<void> => {\n  const outgoing = getOutgoingLocalFiles({\n    collection,\n    config: req.payload.config,\n    current,\n    next,\n    req,\n  })\n\n  if (!outgoing.length || !collection.versions) {\n    return\n  }\n\n  const currentWithState = withLegacyUploadFileData({\n    collection,\n    config: req.payload.config,\n    doc: current,\n  })\n  let versions = await getVersions({ id, collection, req })\n\n  if (!versions.length) {\n    await saveVersion({\n      id,\n      collection,\n      docWithLocales: currentWithState,\n      draft: false,\n      operation: 'update',\n      payload: req.payload,\n      req,\n    })\n    versions = await getVersions({ id, collection, req })\n  }\n\n  const replacements = new Map<string, string>()\n  for (const file of outgoing) {\n    const identity = getStoredFileIdentity(file)\n    const newestVersion = versions.find(({ version }) => {\n      const stored = withLegacyUploadFileData({\n        collection,\n        config: req.payload.config,\n        doc: version,\n      })\n\n      return collectStoredFiles({ collection, doc: stored, req }).some(\n        (candidate) => getStoredFileIdentity(candidate) === identity,\n      )\n    })\n\n    if (!newestVersion) {\n      continue\n    }\n\n    const directory = path.posix.dirname(file.key)\n    let archivedKey: string\n    let suffix = 0\n\n    while (true) {\n      const archivedFilename = getArchivedFilename({\n        filename: path.posix.basename(file.key),\n        versionID: suffix ? `${newestVersion.id}-${suffix}` : newestVersion.id,\n      })\n      archivedKey = directory === '.' ? archivedFilename : `${directory}/${archivedFilename}`\n\n      try {\n        await copyLocalFile({\n          from: file.key,\n          staticDir: collection.upload.staticDir!,\n          to: archivedKey,\n        })\n        break\n      } catch (err) {\n        if ((err as NodeJS.ErrnoException).code !== 'EEXIST') {\n          throw err\n        }\n        suffix += 1\n      }\n    }\n    trackStagedObject({\n      key: archivedKey,\n      remove: () => fs.rm(path.join(collection.upload.staticDir!, archivedKey), { force: true }),\n    })\n    replacements.set(identity, archivedKey)\n  }\n\n  for (const row of versions) {\n    const stored = withLegacyUploadFileData({\n      collection,\n      config: req.payload.config,\n      doc: row.version,\n    })\n    const version = replaceStoredFileReferences({\n      files: collectStoredFiles({ collection, doc: stored, req }),\n      replacements,\n      version: stored,\n    })\n\n    if (!version) {\n      continue\n    }\n\n    await req.payload.db.updateVersion({\n      id: row.id,\n      collection: collection.slug,\n      req,\n      versionData: {\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\nconst getOutgoingLocalFiles = ({\n  collection,\n  config,\n  current,\n  next,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  config: Pick<Config, 'routes' | 'serverURL'>\n  current: JsonObject\n  next: JsonObject\n  req: PayloadRequest\n}): StoredFileList => {\n  const currentWithState = withLegacyUploadFileData({ collection, config, doc: current })\n  const currentFiles = collectStoredFiles({ collection, doc: currentWithState, req })\n  const nextFiles = collectStoredFiles({ collection, doc: next, req, trustGenerated: true })\n  const nextIdentities = new Set(nextFiles.map(getStoredFileIdentity))\n  return currentFiles.filter((file) => !nextIdentities.has(getStoredFileIdentity(file)))\n}\n\nconst getVersions = async ({\n  id,\n  collection,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  id: number | string\n  req: PayloadRequest\n}): Promise<VersionRow[]> => {\n  const { docs } = await req.payload.db.findVersions<JsonObject>({\n    collection: collection.slug,\n    limit: 0,\n    pagination: false,\n    req,\n    sort: '-updatedAt',\n    where: { parent: { equals: id } },\n  })\n\n  return docs\n}\n\nexport const replaceStoredFileReferences = ({\n  files,\n  replacements,\n  version,\n}: {\n  files: StoredFileList\n  replacements: Map<string, string>\n  version: JsonObject\n}): JsonObject | undefined => {\n  if (!files.length) {\n    return\n  }\n\n  const archived = structuredClone(version)\n  let hasChanged = false\n\n  for (const file of files) {\n    const archivedKey = replacements.get(getStoredFileIdentity(file))\n\n    if (!archivedKey) {\n      continue\n    }\n\n    const archivedFilename = path.posix.basename(archivedKey)\n\n    for (const role of file.roles) {\n      let stored: JsonObject | undefined\n      switch (role.type) {\n        case 'default':\n          stored = archived\n          break\n        case 'original':\n          stored = archived.original as JsonObject | undefined\n          break\n        case 'size':\n          stored = (archived.variants as Record<string, JsonObject> | undefined)?.[role.sizeKey]\n          break\n      }\n\n      if (typeof stored?.filename === 'string') {\n        const previousFilename = stored.filename\n        const directory = path.posix.dirname(previousFilename)\n        const filename = directory === '.' ? archivedFilename : `${directory}/${archivedFilename}`\n        stored.filename = filename\n        stored.url = replaceURLFilename({\n          filename,\n          previousFilename,\n          url: stored.url,\n        })\n        hasChanged = true\n      }\n    }\n  }\n\n  return hasChanged ? archived : undefined\n}\n\nconst replaceURLFilename = ({\n  filename,\n  previousFilename,\n  url,\n}: {\n  filename: string\n  previousFilename: string\n  url: unknown\n}): unknown => {\n  if (typeof url !== 'string') {\n    return url\n  }\n\n  const previous = encodeURIComponent(previousFilename)\n  const index = url.lastIndexOf(`/${previous}`)\n\n  return index < 0\n    ? url\n    : `${url.slice(0, index + 1)}${encodeURIComponent(filename)}${url.slice(index + 1 + previous.length)}`\n}\n"],"names":["fs","path","saveVersion","removeUnreferencedStagedObjects","scheduleUnreferencedFileCleanup","runFileOperationPlan","stageLocalUploadFiles","copyLocalFile","getArchivedFilename","collectStoredFiles","getStoredFileIdentity","withLegacyUploadFileData","runLocalFileUpdate","id","collection","current","files","next","req","write","storedCurrent","config","payload","doc","nextDoc","hasLocalFileChange","hasNewFiles","length","cleanupStagedAfterWriteFailure","objects","stage","trackStagedObject","staticDir","upload","archiveOutgoingLocalFiles","result","candidates","getOutgoingLocalFiles","disableLocalStorage","outgoing","versions","currentWithState","getVersions","docWithLocales","draft","operation","replacements","Map","file","identity","newestVersion","find","version","stored","some","candidate","directory","posix","dirname","key","archivedKey","suffix","archivedFilename","filename","basename","versionID","from","to","err","code","remove","rm","join","force","set","row","replaceStoredFileReferences","db","updateVersion","slug","versionData","createdAt","latest","parent","publishedLocale","updatedAt","currentFiles","nextFiles","trustGenerated","nextIdentities","Set","map","filter","has","docs","findVersions","limit","pagination","sort","where","equals","archived","structuredClone","hasChanged","get","role","roles","type","original","variants","sizeKey","previousFilename","url","replaceURLFilename","undefined","previous","encodeURIComponent","index","lastIndexOf","slice"],"mappings":"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"}

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

@@ -0,0 +1,29 @@
+import type { SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { JsonObject, PayloadRequest, Where } from '../../types/index.js';
+import type { StagedObject } from './fileOperationManager.js';
+import type { StoredFileList } from './types.js';
+export declare const collectStoredFiles: ({ collection, doc, req, }: {
+    collection: SanitizedCollectionConfig;
+    doc: JsonObject;
+    req: PayloadRequest;
+}) => Promise<StoredFileList>;
+/** Reads all saved versions in batches before a parent or its history is deleted. */
+export declare const collectVersionFiles: ({ collection, parentID, req, where, }: {
+    collection: SanitizedCollectionConfig;
+    parentID: number | string;
+    req: PayloadRequest;
+    where?: Where;
+}) => Promise<StoredFileList>;
+/** Confirms that deleted references have no survivors before and after commit. */
+export declare const scheduleUnreferencedFileCleanup: ({ candidates, collection, req, }: {
+    candidates: StoredFileList;
+    collection: SanitizedCollectionConfig;
+    req: PayloadRequest;
+}) => Promise<void>;
+/** Removes objects staged by a failed write unless a persisted document or version references them. */
+export declare const removeUnreferencedStagedObjects: ({ collection, objects, req, }: {
+    collection: SanitizedCollectionConfig;
+    objects: StagedObject[];
+    req: PayloadRequest;
+}) => Promise<void>;
+//# sourceMappingURL=cleanup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cleanup.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/cleanup.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAc,KAAK,EAAE,MAAM,sBAAsB,CAAA;AACzF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAc,cAAc,EAAE,MAAM,YAAY,CAAA;AAY5D,eAAO,MAAM,kBAAkB,8BAI5B;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,GAAG,EAAE,UAAU,CAAA;IACf,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,cAAc,CAQzB,CAAA;AAED,qFAAqF;AACrF,eAAO,MAAM,mBAAmB,0CAK7B;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAAA;IACzB,GAAG,EAAE,cAAc,CAAA;IACnB,KAAK,CAAC,EAAE,KAAK,CAAA;CACd,KAAG,OAAO,CAAC,cAAc,CAwBzB,CAAA;AAED,kFAAkF;AAClF,eAAO,MAAM,+BAA+B,qCAIzC;IACD,UAAU,EAAE,cAAc,CAAA;IAC1B,UAAU,EAAE,yBAAyB,CAAA;IACrC,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,IAAI,CAmCf,CAAA;AAED,uGAAuG;AACvG,eAAO,MAAM,+BAA+B,kCAIzC;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,OAAO,EAAE,YAAY,EAAE,CAAA;IACvB,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,IAAI,CAsBf,CAAA"}