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

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 as VersionRow[]\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"}

package/dist/uploads/fileVersioning/cleanup.js

@@ -0,0 +1,288 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { deferFileCleanup } from './fileOperationManager.js';
+import { normalizeStorageKey } from './naming.js';
+import { collectStoredFiles as collectStoredFileLocations, getStoredFileIdentity, withLegacyCloudUploadFileData } from './storedFiles.js';
+const pageSize = 100;
+export const collectStoredFiles = async ({ collection, doc, req })=>{
+    const stored = await withLegacyCloudUploadFileData({
+        collection,
+        doc,
+        req
+    });
+    return collectStoredFileLocations({
+        collection,
+        doc: stored,
+        req
+    });
+};
+/** Reads all saved versions in batches before a parent or its history is deleted. */ export const collectVersionFiles = async ({ collection, parentID, req, where })=>{
+    const files = [];
+    let page = 1;
+    while(true){
+        const versions = await req.payload.db.findVersions({
+            collection: collection.slug,
+            limit: pageSize,
+            page,
+            req,
+            where: where ? {
+                and: [
+                    {
+                        parent: {
+                            equals: parentID
+                        }
+                    },
+                    where
+                ]
+            } : {
+                parent: {
+                    equals: parentID
+                }
+            }
+        });
+        for (const row of versions.docs){
+            files.push(...await collectStoredFiles({
+                collection,
+                doc: row.version,
+                req
+            }));
+        }
+        if (versions.docs.length < pageSize) {
+            return files;
+        }
+        page += 1;
+    }
+};
+/** Confirms that deleted references have no survivors before and after commit. */ export const scheduleUnreferencedFileCleanup = async ({ candidates, collection, req })=>{
+    const unique = new Map(candidates.map((file)=>[
+            getStoredFileIdentity(file),
+            file
+        ]));
+    if (!unique.size) {
+        return;
+    }
+    const unreferenced = await findUnreferenced({
+        candidates: [
+            ...unique.values()
+        ],
+        collection,
+        req
+    });
+    if (!unreferenced.length) {
+        return;
+    }
+    await deferFileCleanup({
+        cleanup: async ()=>{
+            const stillUnreferenced = await findUnreferenced({
+                candidates: unreferenced,
+                collection,
+                req
+            });
+            for (const file of stillUnreferenced){
+                try {
+                    await deleteStoredFile({
+                        collection,
+                        file,
+                        req
+                    });
+                } catch (err) {
+                    req.payload.logger.error({
+                        err,
+                        msg: `Failed to delete unreferenced upload file ${file.key}. Verify the object is unreferenced and remove it manually.`
+                    });
+                }
+            }
+        },
+        req,
+        shouldCleanupAfterFailure: true
+    });
+};
+/** Removes objects staged by a failed write unless a persisted document or version references them. */ export const removeUnreferencedStagedObjects = async ({ collection, objects, req })=>{
+    const unreferenced = await findUnreferenced({
+        candidates: objects.map(({ key })=>({
+                key,
+                roles: []
+            })),
+        collection,
+        req
+    });
+    const identities = new Set(unreferenced.map(getStoredFileIdentity));
+    for (const object of objects){
+        if (!identities.has(getStoredFileIdentity(object))) {
+            continue;
+        }
+        try {
+            await object.remove();
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: `Failed to remove staged upload file ${object.key}`
+            });
+        }
+    }
+};
+const findUnreferenced = async ({ candidates, collection, req })=>{
+    const variantsField = collection.flattenedFields.find((field)=>field.name === 'variants');
+    const variantNames = variantsField?.type === 'group' ? variantsField.flattenedFields.filter((field)=>field.type === 'group' && field.flattenedFields.some((nested)=>nested.name === 'filename')).map((field)=>field.name) : [];
+    const filenamePaths = [
+        'filename',
+        'original.filename',
+        ...variantNames.map((name)=>`variants.${name}.filename`)
+    ];
+    // A removed schema field cannot prove the absence of historical references.
+    // Retain those variant objects until their saved location data is migrated.
+    const remaining = new Map(candidates.filter((file)=>file.roles.every((role)=>role.type !== 'size' || variantNames.includes(role.sizeKey))).map((file)=>[
+            getStoredFileIdentity(file),
+            file
+        ]));
+    const representationSelect = {
+        _objectKey: true,
+        filename: true,
+        prefix: true,
+        url: true
+    };
+    const select = {
+        ...representationSelect,
+        filesize: true,
+        mimeType: true,
+        original: representationSelect,
+        ...variantNames.length ? {
+            variants: Object.fromEntries(variantNames.map((name)=>[
+                    name,
+                    representationSelect
+                ]))
+        } : {}
+    };
+    // Legacy filenames may include folders. Match every possible filename suffix,
+    // then verify the adapter's complete key before accepting a reference.
+    const filenames = [
+        ...new Set([
+            ...remaining.values()
+        ].flatMap(({ key })=>{
+            const parts = normalizeStorageKey({
+                key
+            }).split('/');
+            return parts.map((_, index)=>parts.slice(index).join('/'));
+        }))
+    ];
+    for(let offset = 0; offset < filenames.length && remaining.size; offset += pageSize){
+        const batch = filenames.slice(offset, offset + pageSize);
+        const where = {
+            or: filenamePaths.map((field)=>({
+                    [field]: {
+                        in: batch
+                    }
+                }))
+        };
+        let page = 1;
+        while(remaining.size){
+            const docs = await req.payload.db.find({
+                collection: collection.slug,
+                limit: pageSize,
+                page,
+                pagination: true,
+                req,
+                select,
+                sort: 'id',
+                where
+            });
+            for (const doc of docs.docs){
+                await removeReferenced({
+                    collection,
+                    doc,
+                    remaining,
+                    req
+                });
+            }
+            if (docs.docs.length < pageSize) {
+                break;
+            }
+            page += 1;
+        }
+        if (collection.versions) {
+            page = 1;
+            const versionWhere = {
+                or: filenamePaths.map((field)=>({
+                        [`version.${field}`]: {
+                            in: batch
+                        }
+                    }))
+            };
+            while(remaining.size){
+                const versions = await req.payload.db.findVersions({
+                    collection: collection.slug,
+                    limit: pageSize,
+                    page,
+                    pagination: true,
+                    req,
+                    select: {
+                        version: select
+                    },
+                    sort: 'id',
+                    where: versionWhere
+                });
+                for (const row of versions.docs){
+                    await removeReferenced({
+                        collection,
+                        doc: row.version,
+                        remaining,
+                        req
+                    });
+                }
+                if (versions.docs.length < pageSize) {
+                    break;
+                }
+                page += 1;
+            }
+        }
+    }
+    return [
+        ...remaining.values()
+    ];
+};
+const removeReferenced = async ({ collection, doc, remaining, req })=>{
+    for (const file of (await collectStoredFiles({
+        collection,
+        doc,
+        req
+    }))){
+        remaining.delete(getStoredFileIdentity(file));
+    }
+};
+const deleteStoredFile = async ({ collection, file, req })=>{
+    const operations = collection.upload.fileOperations;
+    if (!operations) {
+        const staticDir = collection.upload.staticDir;
+        if (!staticDir) {
+            throw new Error(`No local storage directory is configured for ${collection.slug}`);
+        }
+        const key = normalizeStorageKey({
+            key: file.key
+        });
+        const directory = await fs.realpath(staticDir);
+        const target = path.resolve(directory, key);
+        const relative = path.relative(directory, target);
+        if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error(`Invalid local storage key: ${key}`);
+        }
+        try {
+            const parent = await fs.realpath(path.dirname(target));
+            const parentRelative = path.relative(directory, parent);
+            if (parentRelative.startsWith('..') || path.isAbsolute(parentRelative)) {
+                throw new Error(`Local storage key escapes its directory: ${key}`);
+            }
+            await fs.unlink(target);
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+        return;
+    }
+    await operations.delete({
+        key: file.key,
+        req
+    });
+};
+
+//# sourceMappingURL=cleanup.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/cleanup.ts"],"sourcesContent":["import fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { JsonObject, PayloadRequest, SelectType, Where } from '../../types/index.js'\nimport type { StagedObject } from './fileOperationManager.js'\nimport type { StoredFile, StoredFileList } from './types.js'\n\nimport { deferFileCleanup } from './fileOperationManager.js'\nimport { normalizeStorageKey } from './naming.js'\nimport {\n  collectStoredFiles as collectStoredFileLocations,\n  getStoredFileIdentity,\n  withLegacyCloudUploadFileData,\n} from './storedFiles.js'\n\nconst pageSize = 100\n\nexport const collectStoredFiles = async ({\n  collection,\n  doc,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  doc: JsonObject\n  req: PayloadRequest\n}): Promise<StoredFileList> => {\n  const stored = await withLegacyCloudUploadFileData({\n    collection,\n    doc,\n    req,\n  })\n\n  return collectStoredFileLocations({ collection, doc: stored, req })\n}\n\n/** Reads all saved versions in batches before a parent or its history is deleted. */\nexport const collectVersionFiles = async ({\n  collection,\n  parentID,\n  req,\n  where,\n}: {\n  collection: SanitizedCollectionConfig\n  parentID: number | string\n  req: PayloadRequest\n  where?: Where\n}): Promise<StoredFileList> => {\n  const files: StoredFileList = []\n  let page = 1\n\n  while (true) {\n    const versions = await req.payload.db.findVersions<JsonObject>({\n      collection: collection.slug,\n      limit: pageSize,\n      page,\n      req,\n      where: where\n        ? { and: [{ parent: { equals: parentID } }, where] }\n        : { parent: { equals: parentID } },\n    })\n\n    for (const row of versions.docs) {\n      files.push(...(await collectStoredFiles({ collection, doc: row.version, req })))\n    }\n\n    if (versions.docs.length < pageSize) {\n      return files\n    }\n    page += 1\n  }\n}\n\n/** Confirms that deleted references have no survivors before and after commit. */\nexport const scheduleUnreferencedFileCleanup = async ({\n  candidates,\n  collection,\n  req,\n}: {\n  candidates: StoredFileList\n  collection: SanitizedCollectionConfig\n  req: PayloadRequest\n}): Promise<void> => {\n  const unique = new Map(candidates.map((file) => [getStoredFileIdentity(file), file]))\n\n  if (!unique.size) {\n    return\n  }\n\n  const unreferenced = await findUnreferenced({ candidates: [...unique.values()], collection, req })\n\n  if (!unreferenced.length) {\n    return\n  }\n\n  await deferFileCleanup({\n    cleanup: async () => {\n      const stillUnreferenced = await findUnreferenced({\n        candidates: unreferenced,\n        collection,\n        req,\n      })\n\n      for (const file of stillUnreferenced) {\n        try {\n          await deleteStoredFile({ collection, file, req })\n        } catch (err) {\n          req.payload.logger.error({\n            err,\n            msg: `Failed to delete unreferenced upload file ${file.key}. Verify the object is unreferenced and remove it manually.`,\n          })\n        }\n      }\n    },\n    req,\n    shouldCleanupAfterFailure: true,\n  })\n}\n\n/** Removes objects staged by a failed write unless a persisted document or version references them. */\nexport const removeUnreferencedStagedObjects = async ({\n  collection,\n  objects,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  objects: StagedObject[]\n  req: PayloadRequest\n}): Promise<void> => {\n  const unreferenced = await findUnreferenced({\n    candidates: objects.map(({ key }) => ({ key, roles: [] })),\n    collection,\n    req,\n  })\n  const identities = new Set(unreferenced.map(getStoredFileIdentity))\n\n  for (const object of objects) {\n    if (!identities.has(getStoredFileIdentity(object))) {\n      continue\n    }\n\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\nconst findUnreferenced = async ({\n  candidates,\n  collection,\n  req,\n}: {\n  candidates: StoredFileList\n  collection: SanitizedCollectionConfig\n  req: PayloadRequest\n}): Promise<StoredFileList> => {\n  const variantsField = collection.flattenedFields.find((field) => field.name === 'variants')\n  const variantNames =\n    variantsField?.type === 'group'\n      ? variantsField.flattenedFields\n          .filter(\n            (field) =>\n              field.type === 'group' &&\n              field.flattenedFields.some((nested) => nested.name === 'filename'),\n          )\n          .map((field) => field.name)\n      : []\n  const filenamePaths = [\n    'filename',\n    'original.filename',\n    ...variantNames.map((name) => `variants.${name}.filename`),\n  ]\n  // A removed schema field cannot prove the absence of historical references.\n  // Retain those variant objects until their saved location data is migrated.\n  const remaining = new Map(\n    candidates\n      .filter((file) =>\n        file.roles.every((role) => role.type !== 'size' || variantNames.includes(role.sizeKey)),\n      )\n      .map((file) => [getStoredFileIdentity(file), file]),\n  )\n  const representationSelect: SelectType = {\n    _objectKey: true,\n    filename: true,\n    prefix: true,\n    url: true,\n  }\n  const select: SelectType = {\n    ...representationSelect,\n    filesize: true,\n    mimeType: true,\n    original: representationSelect,\n    ...(variantNames.length\n      ? { variants: Object.fromEntries(variantNames.map((name) => [name, representationSelect])) }\n      : {}),\n  }\n  // Legacy filenames may include folders. Match every possible filename suffix,\n  // then verify the adapter's complete key before accepting a reference.\n  const filenames = [\n    ...new Set(\n      [...remaining.values()].flatMap(({ key }) => {\n        const parts = normalizeStorageKey({ key }).split('/')\n        return parts.map((_, index) => parts.slice(index).join('/'))\n      }),\n    ),\n  ]\n\n  for (let offset = 0; offset < filenames.length && remaining.size; offset += pageSize) {\n    const batch = filenames.slice(offset, offset + pageSize)\n    const where: Where = { or: filenamePaths.map((field) => ({ [field]: { in: batch } })) }\n    let page = 1\n\n    while (remaining.size) {\n      const docs = await req.payload.db.find<JsonObject>({\n        collection: collection.slug,\n        limit: pageSize,\n        page,\n        pagination: true,\n        req,\n        select,\n        sort: 'id',\n        where,\n      })\n\n      for (const doc of docs.docs) {\n        await removeReferenced({ collection, doc, remaining, req })\n      }\n      if (docs.docs.length < pageSize) {\n        break\n      }\n      page += 1\n    }\n\n    if (collection.versions) {\n      page = 1\n      const versionWhere: Where = {\n        or: filenamePaths.map((field) => ({ [`version.${field}`]: { in: batch } })),\n      }\n\n      while (remaining.size) {\n        const versions = await req.payload.db.findVersions<JsonObject>({\n          collection: collection.slug,\n          limit: pageSize,\n          page,\n          pagination: true,\n          req,\n          select: { version: select },\n          sort: 'id',\n          where: versionWhere,\n        })\n\n        for (const row of versions.docs) {\n          await removeReferenced({ collection, doc: row.version, remaining, req })\n        }\n        if (versions.docs.length < pageSize) {\n          break\n        }\n        page += 1\n      }\n    }\n  }\n\n  return [...remaining.values()]\n}\n\nconst removeReferenced = async ({\n  collection,\n  doc,\n  remaining,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  doc: JsonObject\n  remaining: Map<string, StoredFile>\n  req: PayloadRequest\n}): Promise<void> => {\n  for (const file of await collectStoredFiles({ collection, doc, req })) {\n    remaining.delete(getStoredFileIdentity(file))\n  }\n}\n\nconst deleteStoredFile = async ({\n  collection,\n  file,\n  req,\n}: {\n  collection: SanitizedCollectionConfig\n  file: StoredFile\n  req: PayloadRequest\n}): Promise<void> => {\n  const operations = collection.upload.fileOperations\n  if (!operations) {\n    const staticDir = collection.upload.staticDir\n\n    if (!staticDir) {\n      throw new Error(`No local storage directory is configured for ${collection.slug}`)\n    }\n\n    const key = normalizeStorageKey({ key: file.key })\n    const directory = await fs.realpath(staticDir)\n    const target = path.resolve(directory, key)\n    const relative = path.relative(directory, target)\n\n    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {\n      throw new Error(`Invalid local storage key: ${key}`)\n    }\n\n    try {\n      const parent = await fs.realpath(path.dirname(target))\n      const parentRelative = path.relative(directory, parent)\n\n      if (parentRelative.startsWith('..') || path.isAbsolute(parentRelative)) {\n        throw new Error(`Local storage key escapes its directory: ${key}`)\n      }\n\n      await fs.unlink(target)\n    } catch (err) {\n      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {\n        throw err\n      }\n    }\n\n    return\n  }\n\n  await operations.delete({ key: file.key, req })\n}\n"],"names":["fs","path","deferFileCleanup","normalizeStorageKey","collectStoredFiles","collectStoredFileLocations","getStoredFileIdentity","withLegacyCloudUploadFileData","pageSize","collection","doc","req","stored","collectVersionFiles","parentID","where","files","page","versions","payload","db","findVersions","slug","limit","and","parent","equals","row","docs","push","version","length","scheduleUnreferencedFileCleanup","candidates","unique","Map","map","file","size","unreferenced","findUnreferenced","values","cleanup","stillUnreferenced","deleteStoredFile","err","logger","error","msg","key","shouldCleanupAfterFailure","removeUnreferencedStagedObjects","objects","roles","identities","Set","object","has","remove","variantsField","flattenedFields","find","field","name","variantNames","type","filter","some","nested","filenamePaths","remaining","every","role","includes","sizeKey","representationSelect","_objectKey","filename","prefix","url","select","filesize","mimeType","original","variants","Object","fromEntries","filenames","flatMap","parts","split","_","index","slice","join","offset","batch","or","in","pagination","sort","removeReferenced","versionWhere","delete","operations","upload","fileOperations","staticDir","Error","directory","realpath","target","resolve","relative","startsWith","isAbsolute","dirname","parentRelative","unlink","code"],"mappings":"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"}