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

package/dist/uploads/fileVersioning/resolveHistoricalFile.js

@@ -0,0 +1,73 @@
+import { Forbidden } from '../../errors/Forbidden.js';
+import { NotFound } from '../../errors/NotFound.js';
+import { checkFileAccess } from '../checkFileAccess.js';
+import { collectStoredFiles, withLegacyCloudUploadFileData } from './storedFiles.js';
+/** Finds an exact saved object reference, including sizes removed from the current config. */ export const resolveHistoricalFile = async ({ collection, filename, prefix, req, versionID })=>{
+    const { docs } = await req.payload.db.findVersions({
+        collection: collection.config.slug,
+        limit: 1,
+        req,
+        where: {
+            id: {
+                equals: versionID
+            }
+        }
+    });
+    const matched = docs[0];
+    // Check both policies before exposing a missing version or a filename mismatch.
+    await checkFileAccess({
+        collection,
+        documentID: matched?.parent,
+        filename,
+        req
+    });
+    const authorized = await req.payload.findVersionByID({
+        id: versionID,
+        collection: collection.config.slug,
+        depth: 0,
+        overrideAccess: false,
+        req,
+        showHiddenFields: true
+    });
+    if (!authorized) {
+        throw new Forbidden(req.t);
+    }
+    if (!matched) {
+        throw new NotFound(req.t);
+    }
+    const historical = await resolveVersionFile({
+        collection,
+        filename,
+        prefix,
+        req,
+        row: matched
+    });
+    if (!historical) {
+        throw new NotFound(req.t);
+    }
+    return historical;
+};
+const resolveVersionFile = async ({ collection, filename, prefix, req, row })=>{
+    const saved = await withLegacyCloudUploadFileData({
+        collection: collection.config,
+        doc: row.version,
+        req
+    });
+    const hasFile = collectStoredFiles({
+        collection: collection.config,
+        doc: saved,
+        req
+    }).some((file)=>file.roles.some((role)=>{
+            const representation = role.type === 'size' ? saved.variants?.[role.sizeKey] : role.type === 'original' ? saved.original : saved;
+            return representation?.filename === filename && (!prefix || representation.prefix === prefix);
+        }));
+    if (!hasFile) {
+        return;
+    }
+    return {
+        ...saved,
+        id: row.parent
+    };
+};
+
+//# sourceMappingURL=resolveHistoricalFile.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/resolveHistoricalFile.ts"],"sourcesContent":["import type { Collection, TypeWithID } from '../../collections/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../../types/index.js'\n\nimport { Forbidden } from '../../errors/Forbidden.js'\nimport { NotFound } from '../../errors/NotFound.js'\nimport { checkFileAccess } from '../checkFileAccess.js'\nimport { collectStoredFiles, withLegacyCloudUploadFileData } from './storedFiles.js'\n\ntype StoredVersion = {\n  id: number | string\n  parent: number | string\n  version: JsonObject\n}\n\n/** Finds an exact saved object reference, including sizes removed from the current config. */\nexport const resolveHistoricalFile = async ({\n  collection,\n  filename,\n  prefix,\n  req,\n  versionID,\n}: {\n  collection: Collection\n  filename: string\n  prefix?: string\n  req: PayloadRequest\n  versionID: string\n}): Promise<TypeWithID> => {\n  const { docs } = await req.payload.db.findVersions<JsonObject>({\n    collection: collection.config.slug,\n    limit: 1,\n    req,\n    where: { id: { equals: versionID } },\n  })\n  const matched = docs[0]\n\n  // Check both policies before exposing a missing version or a filename mismatch.\n  await checkFileAccess({ collection, documentID: matched?.parent, filename, req })\n  const authorized = await req.payload.findVersionByID({\n    id: versionID,\n    collection: collection.config.slug,\n    depth: 0,\n    overrideAccess: false,\n    req,\n    showHiddenFields: true,\n  })\n\n  if (!authorized) {\n    throw new Forbidden(req.t)\n  }\n\n  if (!matched) {\n    throw new NotFound(req.t)\n  }\n\n  const historical = await resolveVersionFile({ collection, filename, prefix, req, row: matched })\n\n  if (!historical) {\n    throw new NotFound(req.t)\n  }\n\n  return historical\n}\n\nconst resolveVersionFile = async ({\n  collection,\n  filename,\n  prefix,\n  req,\n  row,\n}: {\n  collection: Collection\n  filename: string\n  prefix?: string\n  req: PayloadRequest\n  row: StoredVersion\n}): Promise<TypeWithID | undefined> => {\n  const saved = await withLegacyCloudUploadFileData({\n    collection: collection.config,\n    doc: row.version,\n    req,\n  })\n  const hasFile = collectStoredFiles({ collection: collection.config, doc: saved, req }).some(\n    (file) =>\n      file.roles.some((role) => {\n        const representation =\n          role.type === 'size'\n            ? (saved.variants as Record<string, JsonObject> | undefined)?.[role.sizeKey]\n            : role.type === 'original'\n              ? (saved.original as JsonObject | undefined)\n              : saved\n        return (\n          representation?.filename === filename && (!prefix || representation.prefix === prefix)\n        )\n      }),\n  )\n\n  if (!hasFile) {\n    return\n  }\n\n  return { ...saved, id: row.parent } as TypeWithID\n}\n"],"names":["Forbidden","NotFound","checkFileAccess","collectStoredFiles","withLegacyCloudUploadFileData","resolveHistoricalFile","collection","filename","prefix","req","versionID","docs","payload","db","findVersions","config","slug","limit","where","id","equals","matched","documentID","parent","authorized","findVersionByID","depth","overrideAccess","showHiddenFields","t","historical","resolveVersionFile","row","saved","doc","version","hasFile","some","file","roles","role","representation","type","variants","sizeKey","original"],"mappings":"AAGA,SAASA,SAAS,QAAQ,4BAA2B;AACrD,SAASC,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,eAAe,QAAQ,wBAAuB;AACvD,SAASC,kBAAkB,EAAEC,6BAA6B,QAAQ,mBAAkB;AAQpF,4FAA4F,GAC5F,OAAO,MAAMC,wBAAwB,OAAO,EAC1CC,UAAU,EACVC,QAAQ,EACRC,MAAM,EACNC,GAAG,EACHC,SAAS,EAOV;IACC,MAAM,EAAEC,IAAI,EAAE,GAAG,MAAMF,IAAIG,OAAO,CAACC,EAAE,CAACC,YAAY,CAAa;QAC7DR,YAAYA,WAAWS,MAAM,CAACC,IAAI;QAClCC,OAAO;QACPR;QACAS,OAAO;YAAEC,IAAI;gBAAEC,QAAQV;YAAU;QAAE;IACrC;IACA,MAAMW,UAAUV,IAAI,CAAC,EAAE;IAEvB,gFAAgF;IAChF,MAAMT,gBAAgB;QAAEI;QAAYgB,YAAYD,SAASE;QAAQhB;QAAUE;IAAI;IAC/E,MAAMe,aAAa,MAAMf,IAAIG,OAAO,CAACa,eAAe,CAAC;QACnDN,IAAIT;QACJJ,YAAYA,WAAWS,MAAM,CAACC,IAAI;QAClCU,OAAO;QACPC,gBAAgB;QAChBlB;QACAmB,kBAAkB;IACpB;IAEA,IAAI,CAACJ,YAAY;QACf,MAAM,IAAIxB,UAAUS,IAAIoB,CAAC;IAC3B;IAEA,IAAI,CAACR,SAAS;QACZ,MAAM,IAAIpB,SAASQ,IAAIoB,CAAC;IAC1B;IAEA,MAAMC,aAAa,MAAMC,mBAAmB;QAAEzB;QAAYC;QAAUC;QAAQC;QAAKuB,KAAKX;IAAQ;IAE9F,IAAI,CAACS,YAAY;QACf,MAAM,IAAI7B,SAASQ,IAAIoB,CAAC;IAC1B;IAEA,OAAOC;AACT,EAAC;AAED,MAAMC,qBAAqB,OAAO,EAChCzB,UAAU,EACVC,QAAQ,EACRC,MAAM,EACNC,GAAG,EACHuB,GAAG,EAOJ;IACC,MAAMC,QAAQ,MAAM7B,8BAA8B;QAChDE,YAAYA,WAAWS,MAAM;QAC7BmB,KAAKF,IAAIG,OAAO;QAChB1B;IACF;IACA,MAAM2B,UAAUjC,mBAAmB;QAAEG,YAAYA,WAAWS,MAAM;QAAEmB,KAAKD;QAAOxB;IAAI,GAAG4B,IAAI,CACzF,CAACC,OACCA,KAAKC,KAAK,CAACF,IAAI,CAAC,CAACG;YACf,MAAMC,iBACJD,KAAKE,IAAI,KAAK,SACTT,MAAMU,QAAQ,EAA6C,CAACH,KAAKI,OAAO,CAAC,GAC1EJ,KAAKE,IAAI,KAAK,aACXT,MAAMY,QAAQ,GACfZ;YACR,OACEQ,gBAAgBlC,aAAaA,YAAa,CAAA,CAACC,UAAUiC,eAAejC,MAAM,KAAKA,MAAK;QAExF;IAGJ,IAAI,CAAC4B,SAAS;QACZ;IACF;IAEA,OAAO;QAAE,GAAGH,KAAK;QAAEd,IAAIa,IAAIT,MAAM;IAAC;AACpC"}

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

@@ -0,0 +1,12 @@
+import type { SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { JsonObject, PayloadRequest } from '../../types/index.js';
+/** Copies the selected stored files before making that version current. */
+export declare const runStoredFileRestore: <T>({ id, collection, current, req, selected, write, }: {
+    collection: SanitizedCollectionConfig;
+    current: JsonObject;
+    id: number | string;
+    req: PayloadRequest;
+    selected: JsonObject;
+    write: (restored: JsonObject) => Promise<T>;
+}) => Promise<T>;
+//# sourceMappingURL=restore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"restore.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/restore.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAClF,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAetE,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,GAAU,CAAC,sDAOzC;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,OAAO,EAAE,UAAU,CAAA;IACnB,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;IACnB,GAAG,EAAE,cAAc,CAAA;IACnB,QAAQ,EAAE,UAAU,CAAA;IACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,UAAU,KAAK,OAAO,CAAC,CAAC,CAAC,CAAA;CAC5C,KAAG,OAAO,CAAC,CAAC,CAmIZ,CAAA"}

package/dist/uploads/fileVersioning/restore.js

@@ -0,0 +1,147 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { APIError } from '../../errors/APIError.js';
+import { archiveOutgoingLocalFiles, replaceStoredFileReferences } from './archive.js';
+import { removeUnreferencedStagedObjects, scheduleUnreferencedFileCleanup } from './cleanup.js';
+import { runFileOperationPlan } from './fileOperationManager.js';
+import { copyLocalFile } from './localStorage.js';
+import { getArchivedFilename } from './naming.js';
+import { collectStoredFiles, getStoredFileIdentity, withLegacyCloudUploadFileData } from './storedFiles.js';
+/** Copies the selected stored files before making that version current. */ export const runStoredFileRestore = async ({ id, collection, current, req, selected, write })=>{
+    const stored = await withLegacyCloudUploadFileData({
+        collection,
+        doc: selected,
+        req
+    });
+    const configuredSizeKeys = new Set(collection.upload.variants?.map(({ name })=>name) ?? []);
+    const storedFiles = collectStoredFiles({
+        collection,
+        doc: stored,
+        req
+    }).flatMap((file)=>{
+        const roles = file.roles.filter((role)=>role.type !== 'size' || configuredSizeKeys.has(role.sizeKey));
+        return roles.length ? [
+            {
+                ...file,
+                roles
+            }
+        ] : [];
+    });
+    const selectedVariants = stored.variants && typeof stored.variants === 'object' && !Array.isArray(stored.variants) ? stored.variants : {};
+    const currentVariants = current.variants && typeof current.variants === 'object' && !Array.isArray(current.variants) ? current.variants : {};
+    // SQL adapters flatten variant groups, so clearing the group alone leaves its fields behind.
+    const restoredVariants = Object.fromEntries([
+        ...new Set([
+            ...Object.keys(currentVariants),
+            ...Object.keys(selectedVariants)
+        ])
+    ].map((sizeKey)=>[
+            sizeKey,
+            configuredSizeKeys.has(sizeKey) && selectedVariants[sizeKey] ? selectedVariants[sizeKey] : {
+                _objectKey: null,
+                filename: null,
+                filesize: null,
+                height: null,
+                mimeType: null,
+                prefix: null,
+                url: null,
+                width: null
+            }
+        ]));
+    const selectedForCurrent = {
+        ...stored,
+        variants: restoredVariants
+    };
+    const staticDir = collection.upload.staticDir;
+    const cloudOperations = collection.upload.fileOperations;
+    if (storedFiles.length && !cloudOperations && (collection.upload.disableLocalStorage || !staticDir)) {
+        throw new APIError('No configured storage adapter can restore this file.', 400);
+    }
+    const currentStored = await withLegacyCloudUploadFileData({
+        collection,
+        doc: current,
+        req
+    });
+    const currentFiles = collectStoredFiles({
+        collection,
+        doc: currentStored,
+        req
+    });
+    if (!storedFiles.length && !currentFiles.length) {
+        return write(selectedForCurrent);
+    }
+    const currentIdentities = new Set(currentFiles.map(getStoredFileIdentity));
+    const replacements = new Map();
+    let restored = selectedForCurrent;
+    return runFileOperationPlan({
+        cleanupStagedAfterWriteFailure: (objects)=>removeUnreferencedStagedObjects({
+                collection,
+                objects,
+                req
+            }),
+        req,
+        stage: async ({ trackStagedObject })=>{
+            for (const file of storedFiles){
+                if (currentIdentities.has(getStoredFileIdentity(file))) {
+                    continue;
+                }
+                const directory = path.posix.dirname(file.key);
+                const filename = getArchivedFilename({
+                    filename: path.posix.basename(file.key),
+                    versionID: randomUUID()
+                });
+                const key = directory === '.' ? filename : `${directory}/${filename}`;
+                if (!cloudOperations && staticDir) {
+                    await copyLocalFile({
+                        from: file.key,
+                        staticDir,
+                        to: key
+                    });
+                    trackStagedObject({
+                        key,
+                        remove: ()=>fs.rm(path.join(staticDir, key), {
+                                force: true
+                            })
+                    });
+                } else if (cloudOperations) {
+                    await cloudOperations.copy({
+                        from: file.key,
+                        req,
+                        to: key,
+                        trackStagedObject
+                    });
+                } else {
+                    throw new Error('No storage operation can restore this file');
+                }
+                replacements.set(getStoredFileIdentity(file), key);
+            }
+            restored = replaceStoredFileReferences({
+                files: storedFiles,
+                replacements,
+                version: selectedForCurrent
+            }) ?? selectedForCurrent;
+        },
+        write: async ({ trackStagedObject })=>{
+            if (staticDir && !collection.upload.disableLocalStorage) {
+                await archiveOutgoingLocalFiles({
+                    id,
+                    collection,
+                    current,
+                    next: restored,
+                    req,
+                    trackStagedObject
+                });
+            }
+            const result = await write(restored);
+            await scheduleUnreferencedFileCleanup({
+                candidates: currentFiles,
+                collection,
+                req
+            });
+            return result;
+        }
+    });
+};
+
+//# sourceMappingURL=restore.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/restore.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { JsonObject, PayloadRequest } from '../../types/index.js'\nimport type { StoredFileList } from './types.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { archiveOutgoingLocalFiles, replaceStoredFileReferences } from './archive.js'\nimport { removeUnreferencedStagedObjects, scheduleUnreferencedFileCleanup } from './cleanup.js'\nimport { runFileOperationPlan } from './fileOperationManager.js'\nimport { copyLocalFile } from './localStorage.js'\nimport { getArchivedFilename } from './naming.js'\nimport {\n  collectStoredFiles,\n  getStoredFileIdentity,\n  withLegacyCloudUploadFileData,\n} from './storedFiles.js'\n\n/** Copies the selected stored files before making that version current. */\nexport const runStoredFileRestore = async <T>({\n  id,\n  collection,\n  current,\n  req,\n  selected,\n  write,\n}: {\n  collection: SanitizedCollectionConfig\n  current: JsonObject\n  id: number | string\n  req: PayloadRequest\n  selected: JsonObject\n  write: (restored: JsonObject) => Promise<T>\n}): Promise<T> => {\n  const stored = await withLegacyCloudUploadFileData({\n    collection,\n    doc: selected,\n    req,\n  })\n  const configuredSizeKeys = new Set(collection.upload.variants?.map(({ name }) => name) ?? [])\n  const storedFiles: StoredFileList = collectStoredFiles({ collection, doc: stored, req }).flatMap(\n    (file) => {\n      const roles = file.roles.filter(\n        (role) => role.type !== 'size' || configuredSizeKeys.has(role.sizeKey),\n      )\n      return roles.length ? [{ ...file, roles }] : []\n    },\n  )\n  const selectedVariants =\n    stored.variants && typeof stored.variants === 'object' && !Array.isArray(stored.variants)\n      ? stored.variants\n      : {}\n  const currentVariants =\n    current.variants && typeof current.variants === 'object' && !Array.isArray(current.variants)\n      ? current.variants\n      : {}\n  // SQL adapters flatten variant groups, so clearing the group alone leaves its fields behind.\n  const restoredVariants = Object.fromEntries(\n    [...new Set([...Object.keys(currentVariants), ...Object.keys(selectedVariants)])].map(\n      (sizeKey) => [\n        sizeKey,\n        configuredSizeKeys.has(sizeKey) && selectedVariants[sizeKey]\n          ? selectedVariants[sizeKey]\n          : {\n              _objectKey: null,\n              filename: null,\n              filesize: null,\n              height: null,\n              mimeType: null,\n              prefix: null,\n              url: null,\n              width: null,\n            },\n      ],\n    ),\n  )\n  const selectedForCurrent = { ...stored, variants: restoredVariants }\n\n  const staticDir = collection.upload.staticDir\n  const cloudOperations = collection.upload.fileOperations\n  if (\n    storedFiles.length &&\n    !cloudOperations &&\n    (collection.upload.disableLocalStorage || !staticDir)\n  ) {\n    throw new APIError('No configured storage adapter can restore this file.', 400)\n  }\n\n  const currentStored = await withLegacyCloudUploadFileData({\n    collection,\n    doc: current,\n    req,\n  })\n  const currentFiles = collectStoredFiles({ collection, doc: currentStored, req })\n\n  if (!storedFiles.length && !currentFiles.length) {\n    return write(selectedForCurrent)\n  }\n\n  const currentIdentities = new Set(currentFiles.map(getStoredFileIdentity))\n  const replacements = new Map<string, string>()\n  let restored: JsonObject = selectedForCurrent\n\n  return runFileOperationPlan({\n    cleanupStagedAfterWriteFailure: (objects) =>\n      removeUnreferencedStagedObjects({ collection, objects, req }),\n    req,\n    stage: async ({ trackStagedObject }) => {\n      for (const file of storedFiles) {\n        if (currentIdentities.has(getStoredFileIdentity(file))) {\n          continue\n        }\n\n        const directory = path.posix.dirname(file.key)\n        const filename = getArchivedFilename({\n          filename: path.posix.basename(file.key),\n          versionID: randomUUID(),\n        })\n        const key = directory === '.' ? filename : `${directory}/${filename}`\n\n        if (!cloudOperations && staticDir) {\n          await copyLocalFile({ from: file.key, staticDir, to: key })\n          trackStagedObject({\n            key,\n            remove: () => fs.rm(path.join(staticDir, key), { force: true }),\n          })\n        } else if (cloudOperations) {\n          await cloudOperations.copy({ from: file.key, req, to: key, trackStagedObject })\n        } else {\n          throw new Error('No storage operation can restore this file')\n        }\n        replacements.set(getStoredFileIdentity(file), key)\n      }\n\n      restored =\n        replaceStoredFileReferences({\n          files: storedFiles,\n          replacements,\n          version: selectedForCurrent,\n        }) ?? selectedForCurrent\n    },\n    write: async ({ trackStagedObject }) => {\n      if (staticDir && !collection.upload.disableLocalStorage) {\n        await archiveOutgoingLocalFiles({\n          id,\n          collection,\n          current,\n          next: restored,\n          req,\n          trackStagedObject,\n        })\n      }\n\n      const result = await write(restored)\n\n      await scheduleUnreferencedFileCleanup({\n        candidates: currentFiles,\n        collection,\n        req,\n      })\n\n      return result\n    },\n  })\n}\n"],"names":["randomUUID","fs","path","APIError","archiveOutgoingLocalFiles","replaceStoredFileReferences","removeUnreferencedStagedObjects","scheduleUnreferencedFileCleanup","runFileOperationPlan","copyLocalFile","getArchivedFilename","collectStoredFiles","getStoredFileIdentity","withLegacyCloudUploadFileData","runStoredFileRestore","id","collection","current","req","selected","write","stored","doc","configuredSizeKeys","Set","upload","variants","map","name","storedFiles","flatMap","file","roles","filter","role","type","has","sizeKey","length","selectedVariants","Array","isArray","currentVariants","restoredVariants","Object","fromEntries","keys","_objectKey","filename","filesize","height","mimeType","prefix","url","width","selectedForCurrent","staticDir","cloudOperations","fileOperations","disableLocalStorage","currentStored","currentFiles","currentIdentities","replacements","Map","restored","cleanupStagedAfterWriteFailure","objects","stage","trackStagedObject","directory","posix","dirname","key","basename","versionID","from","to","remove","rm","join","force","copy","Error","set","files","version","next","result","candidates"],"mappings":"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"}

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

@@ -0,0 +1,23 @@
+import type { CollectionConfig, SanitizedCollectionConfig } from '../../collections/config/types.js';
+import type { Config } from '../../config/types.js';
+import type { PayloadRequest } from '../../types/index.js';
+import type { StoredFileIdentity, StoredFileList } from './types.js';
+export declare const getStoredFileIdentity: ({ key }: StoredFileIdentity) => string;
+/** Builds the file list from the locations saved on each stored representation. */
+export declare const collectStoredFiles: ({ collection, doc, req, trustGenerated, }: {
+    collection: SanitizedCollectionConfig;
+    doc: Record<string, unknown>;
+    req: PayloadRequest;
+    trustGenerated?: boolean;
+}) => StoredFileList;
+export declare const withLegacyUploadFileData: ({ collection, config, doc, }: {
+    collection: CollectionConfig;
+    config: Pick<Config, 'routes' | 'serverURL'>;
+    doc: Record<string, unknown>;
+}) => Record<string, unknown>;
+export declare const withLegacyCloudUploadFileData: <T extends Record<string, unknown>>({ collection, doc, req, }: {
+    collection: CollectionConfig;
+    doc: T;
+    req: PayloadRequest;
+}) => Promise<T>;
+//# sourceMappingURL=storedFiles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"storedFiles.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/storedFiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AACpG,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE1D,OAAO,KAAK,EACV,kBAAkB,EAClB,cAAc,EAGf,MAAM,YAAY,CAAA;AAKnB,eAAO,MAAM,qBAAqB,YAAa,kBAAkB,KAAG,MACtC,CAAA;AA+B9B,mFAAmF;AACnF,eAAO,MAAM,kBAAkB,8CAK5B;IACD,UAAU,EAAE,yBAAyB,CAAA;IACrC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC5B,GAAG,EAAE,cAAc,CAAA;IACnB,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB,KAAG,cAoDH,CAAA;AAED,eAAO,MAAM,wBAAwB,iCAIlC;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,GAAG,WAAW,CAAC,CAAA;IAC5C,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC7B,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CA+DzB,CAAA;AAED,eAAO,MAAM,6BAA6B,GAAU,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,6BAIlF;IACD,UAAU,EAAE,gBAAgB,CAAA;IAC5B,GAAG,EAAE,CAAC,CAAA;IACN,GAAG,EAAE,cAAc,CAAA;CACpB,KAAG,OAAO,CAAC,CAAC,CA+CZ,CAAA"}

package/dist/uploads/fileVersioning/storedFiles.js

@@ -0,0 +1,185 @@
+import { generateFilePathOrURL } from '../generateFilePathOrURL.js';
+import { normalizeStorageKey } from './naming.js';
+export const getStoredFileIdentity = ({ key })=>normalizeStorageKey({
+        key
+    });
+const createStoredFileList = ({ references })=>{
+    const files = [];
+    const fileByIdentity = new Map();
+    for (const { key, role } of references){
+        validateRole({
+            role
+        });
+        const normalizedKey = normalizeStorageKey({
+            key
+        });
+        const identity = getStoredFileIdentity({
+            key: normalizedKey
+        });
+        let file = fileByIdentity.get(identity);
+        if (!file) {
+            file = {
+                key: normalizedKey,
+                roles: []
+            };
+            fileByIdentity.set(identity, file);
+            files.push(file);
+        }
+        if (!file.roles.some((existingRole)=>isSameRole({
+                first: existingRole,
+                second: role
+            }))) {
+            file.roles.push(role);
+        }
+    }
+    return files;
+};
+/** Builds the file list from the locations saved on each stored representation. */ export const collectStoredFiles = ({ collection, doc, req, trustGenerated = false })=>{
+    const upload = collection.upload;
+    const operations = upload.fileOperations;
+    const references = [];
+    const add = (value, role)=>{
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return;
+        }
+        const representation = value;
+        if (typeof representation.filename !== 'string') {
+            return;
+        }
+        const filename = representation.filename;
+        if (!operations && !trustGenerated && representation.url !== generateFilePathOrURL({
+            collectionSlug: collection.slug,
+            config: req.payload.config,
+            filename,
+            relative: true,
+            urlOrPath: undefined
+        })) {
+            return;
+        }
+        const prefix = typeof representation.prefix === 'string' ? representation.prefix : undefined;
+        const _objectKey = typeof representation._objectKey === 'string' ? representation._objectKey : undefined;
+        const key = operations ? operations.resolveStorageKey({
+            _objectKey,
+            filename,
+            prefix
+        }) : filename;
+        references.push({
+            key,
+            role
+        });
+    };
+    // Older uploads without an original have not been identified as Payload-managed.
+    if (!doc.original || typeof doc.original !== 'object' || typeof doc.original.filename !== 'string') {
+        return [];
+    }
+    add(doc, {
+        type: 'default'
+    });
+    add(doc.original, {
+        type: 'original'
+    });
+    if (doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)) {
+        for (const [sizeKey, value] of Object.entries(doc.variants)){
+            add(value, {
+                type: 'size',
+                sizeKey
+            });
+        }
+    }
+    return createStoredFileList({
+        references
+    });
+};
+export const withLegacyUploadFileData = ({ collection, config, doc })=>{
+    const upload = typeof collection.upload === 'object' ? collection.upload : {};
+    const filename = doc.filename;
+    const url = doc.url;
+    const filesize = doc.filesize;
+    const mimeType = doc.mimeType;
+    const hasStoredOriginal = doc.original && typeof doc.original === 'object' && !Array.isArray(doc.original) && Object.values(doc.original).some((value)=>value !== null && value !== undefined);
+    if (hasStoredOriginal) {
+        return doc;
+    }
+    if (typeof filename !== 'string' || typeof url !== 'string' || typeof filesize !== 'number' || typeof mimeType !== 'string' || upload.disableLocalStorage || upload.adapter) {
+        return doc;
+    }
+    const expectedURL = generateFilePathOrURL({
+        collectionSlug: collection.slug,
+        config,
+        filename,
+        relative: true,
+        urlOrPath: undefined
+    });
+    if (url !== expectedURL) {
+        return doc;
+    }
+    try {
+        normalizeStorageKey({
+            key: filename
+        });
+    } catch  {
+        return doc;
+    }
+    const original = {
+        filename,
+        filesize,
+        mimeType,
+        url
+    };
+    if (typeof doc.width === 'number') {
+        original.width = doc.width;
+    }
+    if (typeof doc.height === 'number') {
+        original.height = doc.height;
+    }
+    return {
+        ...doc,
+        original
+    };
+};
+export const withLegacyCloudUploadFileData = async ({ collection, doc, req })=>{
+    const stored = withLegacyUploadFileData({
+        collection,
+        config: req.payload.config,
+        doc
+    });
+    const operations = typeof collection.upload === 'object' ? collection.upload.fileOperations : undefined;
+    if (stored.original && typeof stored.original === 'object' && typeof stored.original.filename === 'string' || !operations?.hasLegacyFile || typeof stored.filename !== 'string' || typeof stored.url !== 'string' || typeof stored.filesize !== 'number' || typeof stored.mimeType !== 'string') {
+        return stored;
+    }
+    if (!await operations.hasLegacyFile({
+        doc: stored,
+        req
+    })) {
+        return stored;
+    }
+    const variants = stored.variants && typeof stored.variants === 'object' ? Object.fromEntries(Object.entries(stored.variants).map(([name, value])=>[
+            name,
+            value && typeof value === 'object' ? {
+                ...value,
+                _objectKey: stored._objectKey,
+                prefix: stored.prefix
+            } : value
+        ])) : stored.variants;
+    return Object.assign({}, doc, stored, {
+        original: {
+            _objectKey: stored._objectKey,
+            filename: stored.filename,
+            filesize: stored.filesize,
+            height: stored.height,
+            mimeType: stored.mimeType,
+            prefix: stored.prefix,
+            url: stored.url,
+            width: stored.width
+        },
+        variants
+    });
+};
+const isSameRole = ({ first, second })=>first.type === second.type && (first.type !== 'size' || second.type === 'size' && first.sizeKey === second.sizeKey);
+const validateRole = ({ role })=>{
+    if (role.type === 'size' && (!role.sizeKey || role.sizeKey.includes('/'))) {
+        throw new Error('A stored variant requires a safe size key');
+    }
+};
+
+//# sourceMappingURL=storedFiles.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/storedFiles.ts"],"sourcesContent":["import type { CollectionConfig, SanitizedCollectionConfig } from '../../collections/config/types.js'\nimport type { Config } from '../../config/types.js'\nimport type { PayloadRequest } from '../../types/index.js'\nimport type { OriginalFileData } from '../types.js'\nimport type {\n  StoredFileIdentity,\n  StoredFileList,\n  StoredFileReference,\n  StoredFileRole,\n} from './types.js'\n\nimport { generateFilePathOrURL } from '../generateFilePathOrURL.js'\nimport { normalizeStorageKey } from './naming.js'\n\nexport const getStoredFileIdentity = ({ key }: StoredFileIdentity): string =>\n  normalizeStorageKey({ key })\n\nconst createStoredFileList = ({\n  references,\n}: {\n  references: StoredFileReference[]\n}): StoredFileList => {\n  const files: StoredFileList = []\n  const fileByIdentity = new Map<string, StoredFileList[number]>()\n\n  for (const { key, role } of references) {\n    validateRole({ role })\n\n    const normalizedKey = normalizeStorageKey({ key })\n    const identity = getStoredFileIdentity({ key: normalizedKey })\n    let file = fileByIdentity.get(identity)\n\n    if (!file) {\n      file = { key: normalizedKey, roles: [] }\n      fileByIdentity.set(identity, file)\n      files.push(file)\n    }\n\n    if (!file.roles.some((existingRole) => isSameRole({ first: existingRole, second: role }))) {\n      file.roles.push(role)\n    }\n  }\n\n  return files\n}\n\n/** Builds the file list from the locations saved on each stored representation. */\nexport const collectStoredFiles = ({\n  collection,\n  doc,\n  req,\n  trustGenerated = false,\n}: {\n  collection: SanitizedCollectionConfig\n  doc: Record<string, unknown>\n  req: PayloadRequest\n  trustGenerated?: boolean\n}): StoredFileList => {\n  const upload = collection.upload\n  const operations = upload.fileOperations\n  const references: StoredFileReference[] = []\n  const add = (value: unknown, role: StoredFileRole) => {\n    if (!value || typeof value !== 'object' || Array.isArray(value)) {\n      return\n    }\n    const representation = value as Record<string, unknown>\n    if (typeof representation.filename !== 'string') {\n      return\n    }\n    const filename = representation.filename\n    if (\n      !operations &&\n      !trustGenerated &&\n      representation.url !==\n        generateFilePathOrURL({\n          collectionSlug: collection.slug,\n          config: req.payload.config,\n          filename,\n          relative: true,\n          urlOrPath: undefined,\n        })\n    ) {\n      return\n    }\n    const prefix = typeof representation.prefix === 'string' ? representation.prefix : undefined\n    const _objectKey =\n      typeof representation._objectKey === 'string' ? representation._objectKey : undefined\n    const key = operations\n      ? operations.resolveStorageKey({ _objectKey, filename, prefix })\n      : filename\n    references.push({ key, role })\n  }\n\n  // Older uploads without an original have not been identified as Payload-managed.\n  if (\n    !doc.original ||\n    typeof doc.original !== 'object' ||\n    typeof (doc.original as Record<string, unknown>).filename !== 'string'\n  ) {\n    return []\n  }\n  add(doc, { type: 'default' })\n  add(doc.original, { type: 'original' })\n  if (doc.variants && typeof doc.variants === 'object' && !Array.isArray(doc.variants)) {\n    for (const [sizeKey, value] of Object.entries(doc.variants)) {\n      add(value, { type: 'size', sizeKey })\n    }\n  }\n  return createStoredFileList({ references })\n}\n\nexport const withLegacyUploadFileData = ({\n  collection,\n  config,\n  doc,\n}: {\n  collection: CollectionConfig\n  config: Pick<Config, 'routes' | 'serverURL'>\n  doc: Record<string, unknown>\n}): Record<string, unknown> => {\n  const upload = typeof collection.upload === 'object' ? collection.upload : {}\n  const filename = doc.filename\n  const url = doc.url\n  const filesize = doc.filesize\n  const mimeType = doc.mimeType\n\n  const hasStoredOriginal =\n    doc.original &&\n    typeof doc.original === 'object' &&\n    !Array.isArray(doc.original) &&\n    Object.values(doc.original).some((value) => value !== null && value !== undefined)\n\n  if (hasStoredOriginal) {\n    return doc\n  }\n\n  if (\n    typeof filename !== 'string' ||\n    typeof url !== 'string' ||\n    typeof filesize !== 'number' ||\n    typeof mimeType !== 'string' ||\n    upload.disableLocalStorage ||\n    upload.adapter\n  ) {\n    return doc\n  }\n\n  const expectedURL = generateFilePathOrURL({\n    collectionSlug: collection.slug,\n    config,\n    filename,\n    relative: true,\n    urlOrPath: undefined,\n  })\n\n  if (url !== expectedURL) {\n    return doc\n  }\n\n  try {\n    normalizeStorageKey({ key: filename })\n  } catch {\n    return doc\n  }\n\n  const original: OriginalFileData = {\n    filename,\n    filesize,\n    mimeType,\n    url,\n  }\n  if (typeof doc.width === 'number') {\n    original.width = doc.width\n  }\n  if (typeof doc.height === 'number') {\n    original.height = doc.height\n  }\n\n  return {\n    ...doc,\n    original,\n  }\n}\n\nexport const withLegacyCloudUploadFileData = async <T extends Record<string, unknown>>({\n  collection,\n  doc,\n  req,\n}: {\n  collection: CollectionConfig\n  doc: T\n  req: PayloadRequest\n}): Promise<T> => {\n  const stored = withLegacyUploadFileData({ collection, config: req.payload.config, doc })\n  const operations =\n    typeof collection.upload === 'object' ? collection.upload.fileOperations : undefined\n\n  if (\n    (stored.original &&\n      typeof stored.original === 'object' &&\n      typeof (stored.original as Record<string, unknown>).filename === 'string') ||\n    !operations?.hasLegacyFile ||\n    typeof stored.filename !== 'string' ||\n    typeof stored.url !== 'string' ||\n    typeof stored.filesize !== 'number' ||\n    typeof stored.mimeType !== 'string'\n  ) {\n    return stored as T\n  }\n\n  if (!(await operations.hasLegacyFile({ doc: stored, req }))) {\n    return stored as T\n  }\n\n  const variants =\n    stored.variants && typeof stored.variants === 'object'\n      ? Object.fromEntries(\n          Object.entries(stored.variants).map(([name, value]) => [\n            name,\n            value && typeof value === 'object'\n              ? { ...value, _objectKey: stored._objectKey, prefix: stored.prefix }\n              : value,\n          ]),\n        )\n      : stored.variants\n\n  return Object.assign({}, doc, stored, {\n    original: {\n      _objectKey: stored._objectKey,\n      filename: stored.filename,\n      filesize: stored.filesize,\n      height: stored.height,\n      mimeType: stored.mimeType,\n      prefix: stored.prefix,\n      url: stored.url,\n      width: stored.width,\n    },\n    variants,\n  })\n}\n\nconst isSameRole = ({ first, second }: { first: StoredFileRole; second: StoredFileRole }) =>\n  first.type === second.type &&\n  (first.type !== 'size' || (second.type === 'size' && first.sizeKey === second.sizeKey))\n\nconst validateRole = ({ role }: { role: StoredFileRole }): void => {\n  if (role.type === 'size' && (!role.sizeKey || role.sizeKey.includes('/'))) {\n    throw new Error('A stored variant requires a safe size key')\n  }\n}\n"],"names":["generateFilePathOrURL","normalizeStorageKey","getStoredFileIdentity","key","createStoredFileList","references","files","fileByIdentity","Map","role","validateRole","normalizedKey","identity","file","get","roles","set","push","some","existingRole","isSameRole","first","second","collectStoredFiles","collection","doc","req","trustGenerated","upload","operations","fileOperations","add","value","Array","isArray","representation","filename","url","collectionSlug","slug","config","payload","relative","urlOrPath","undefined","prefix","_objectKey","resolveStorageKey","original","type","variants","sizeKey","Object","entries","withLegacyUploadFileData","filesize","mimeType","hasStoredOriginal","values","disableLocalStorage","adapter","expectedURL","width","height","withLegacyCloudUploadFileData","stored","hasLegacyFile","fromEntries","map","name","assign","includes","Error"],"mappings":"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"}

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

@@ -0,0 +1,18 @@
+export type StoredFileRole = {
+    sizeKey: string;
+    type: 'size';
+} | {
+    type: 'default' | 'original';
+};
+/** One stored file. It can be both the original upload and the default file. */
+export type StoredFile = {
+    key: string;
+    roles: StoredFileRole[];
+};
+export type StoredFileList = StoredFile[];
+export type StoredFileReference = {
+    key: string;
+    role: StoredFileRole;
+};
+export type StoredFileIdentity = Pick<StoredFile, 'key'>;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/uploads/fileVersioning/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,SAAS,GAAG,UAAU,CAAA;CAAE,CAAA;AAEjG,gFAAgF;AAChF,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,cAAc,EAAE,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,EAAE,CAAA;AAEzC,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,cAAc,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAA"}

package/dist/uploads/fileVersioning/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fileVersioning/types.ts"],"sourcesContent":["export type StoredFileRole = { sizeKey: string; type: 'size' } | { type: 'default' | 'original' }\n\n/** One stored file. It can be both the original upload and the default file. */\nexport type StoredFile = {\n  key: string\n  roles: StoredFileRole[]\n}\n\nexport type StoredFileList = StoredFile[]\n\nexport type StoredFileReference = {\n  key: string\n  role: StoredFileRole\n}\n\nexport type StoredFileIdentity = Pick<StoredFile, 'key'>\n"],"names":[],"mappings":"AAeA,WAAwD"}

package/dist/uploads/formatFilesize.js

@@ -1,4 +1,4 @@
-export function formatFilesize(bytes, decimals = 0) {
+export function formatFilesize(bytes, decimals = 1) {
     if (bytes === 0) {
         return '0 bytes';
     }

package/dist/uploads/formatFilesize.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/uploads/formatFilesize.ts"],"sourcesContent":["export function formatFilesize(bytes: number, decimals = 0): string {\n  if (bytes === 0) {\n    return '0 bytes'\n  }\n\n  const k = 1024\n  const dm = decimals < 0 ? 0 : decimals\n  const sizes = [' bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']\n\n  const i = Math.floor(Math.log(bytes) / Math.log(k))\n\n  return `${parseFloat((bytes / k ** i).toFixed(dm))}${sizes[i]}`\n}\n"],"names":["formatFilesize","bytes","decimals","k","dm","sizes","i","Math","floor","log","parseFloat","toFixed"],"mappings":"AAAA,OAAO,SAASA,eAAeC,KAAa,EAAEC,WAAW,CAAC;IACxD,IAAID,UAAU,GAAG;QACf,OAAO;IACT;IAEA,MAAME,IAAI;IACV,MAAMC,KAAKF,WAAW,IAAI,IAAIA;IAC9B,MAAMG,QAAQ;QAAC;QAAU;QAAM;QAAM;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;IAExE,MAAMC,IAAIC,KAAKC,KAAK,CAACD,KAAKE,GAAG,CAACR,SAASM,KAAKE,GAAG,CAACN;IAEhD,OAAO,GAAGO,WAAW,AAACT,CAAAA,QAAQE,KAAKG,CAAAA,EAAGK,OAAO,CAACP,OAAOC,KAAK,CAACC,EAAE,EAAE;AACjE"}
+{"version":3,"sources":["../../src/uploads/formatFilesize.ts"],"sourcesContent":["export function formatFilesize(bytes: number, decimals = 1): string {\n  if (bytes === 0) {\n    return '0 bytes'\n  }\n\n  const k = 1024\n  const dm = decimals < 0 ? 0 : decimals\n  const sizes = [' bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']\n\n  const i = Math.floor(Math.log(bytes) / Math.log(k))\n\n  return `${parseFloat((bytes / k ** i).toFixed(dm))}${sizes[i]}`\n}\n"],"names":["formatFilesize","bytes","decimals","k","dm","sizes","i","Math","floor","log","parseFloat","toFixed"],"mappings":"AAAA,OAAO,SAASA,eAAeC,KAAa,EAAEC,WAAW,CAAC;IACxD,IAAID,UAAU,GAAG;QACf,OAAO;IACT;IAEA,MAAME,IAAI;IACV,MAAMC,KAAKF,WAAW,IAAI,IAAIA;IAC9B,MAAMG,QAAQ;QAAC;QAAU;QAAM;QAAM;QAAM;QAAM;QAAM;QAAM;QAAM;KAAK;IAExE,MAAMC,IAAIC,KAAKC,KAAK,CAACD,KAAKE,GAAG,CAACR,SAASM,KAAKE,GAAG,CAACN;IAEhD,OAAO,GAAGO,WAAW,AAACT,CAAAA,QAAQE,KAAKG,CAAAA,EAAGK,OAAO,CAACP,OAAOC,KAAK,CAACC,EAAE,EAAE;AACjE"}

package/dist/uploads/generateFileData.d.ts

@@ -1,12 +1,14 @@
 import type { Collection } from '../collections/config/types.js';
 import type { SanitizedConfig } from '../config/types.js';
 import type { PayloadRequest } from '../types/index.js';
+import type { ExternalUploadSource } from './sanitizeUploadData.js';
 import type { FileToSave } from './types.js';
 type Args<T> = {
     collection: Collection;
     config: SanitizedConfig;
     data: T;
     draft?: boolean;
+    externalUploadSource?: ExternalUploadSource;
     isDuplicating?: boolean;
     operation: 'create' | 'update';
     originalDoc?: T;
@@ -18,6 +20,34 @@ type Result<T> = Promise<{
     data: T;
     files: FileToSave[];
 }>;
-export declare const generateFileData: <T>({ collection: { config: collectionConfig }, data, draft, isDuplicating, operation, originalDoc, overwriteExistingFiles, req, throwOnMissingFile, }: Args<T>) => Result<T>;
+export type TempFileHandling = {
+    sourcePath: string;
+    type: 'copyFromTempFile';
+} | {
+    type: 'skip';
+} | {
+    type: 'useBuffer';
+};
+/**
+ * Decides how to get a file's bytes onto disk when no transformer rewrote it (a transformed
+ * file is already an in-memory buffer, so it always takes the `useBuffer` path). Copies straight
+ * from the temp file when possible, rather than reading a potentially large temp file into memory
+ * just to write it back out - see the `generateFileData` function doc for why.
+ */
+export declare const resolveTempFileHandling: ({ disableLocalStorage, hasProcessedBuffer, tempFilePath, }: {
+    disableLocalStorage: boolean;
+    hasProcessedBuffer: boolean;
+    tempFilePath: string | undefined;
+}) => TempFileHandling;
+/**
+ * Builds the document's file metadata and the list of files to write to disk.
+ *
+ * A large client upload may arrive as a temp file instead of an in-memory buffer (see
+ * getFileFromUploadInstructions.ts), and `file.data` can hold only a partial probe rather than
+ * the full file. To avoid loading such files into memory unnecessarily, no transformer runs
+ * unless the full bytes are available, this skips reading a temp file entirely when local
+ * storage is disabled, and copies it straight to its destination when local storage is enabled.
+ */
+export declare const generateFileData: <T>({ collection: { config: collectionConfig }, data, draft, externalUploadSource, isDuplicating, operation, originalDoc, overwriteExistingFiles, req, throwOnMissingFile, }: Args<T>) => Result<T>;
 export {};
 //# sourceMappingURL=generateFileData.d.ts.map

package/dist/uploads/generateFileData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateFileData.d.ts","sourceRoot":"","sources":["../../src/uploads/generateFileData.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACjE,OAAO,KAAK,EAAY,UAAU,EAAgC,MAAM,YAAY,CAAA;AAcpF,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,KAAK,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAC,CAAA;AA6BF,eAAO,MAAM,gBAAgB,GAAU,CAAC,EAAE,oJAUvC,IAAI,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAmWpB,CAAA"}
+{"version":3,"file":"generateFileData.d.ts","sourceRoot":"","sources":["../../src/uploads/generateFileData.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,gCAAgC,CAAA;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAA;AAEnE,OAAO,KAAK,EAAuB,UAAU,EAAe,MAAM,YAAY,CAAA;AAwB9E,KAAK,IAAI,CAAC,CAAC,IAAI;IACb,UAAU,EAAE,UAAU,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,oBAAoB,CAAC,EAAE,oBAAoB,CAAA;IAC3C,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,SAAS,EAAE,QAAQ,GAAG,QAAQ,CAAA;IAC9B,WAAW,CAAC,EAAE,CAAC,CAAA;IACf,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,GAAG,EAAE,cAAc,CAAA;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,CAAA;AAED,KAAK,MAAM,CAAC,CAAC,IAAI,OAAO,CAAC;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,UAAU,EAAE,CAAA;CACpB,CAAC,CAAA;AA6BF,MAAM,MAAM,gBAAgB,GACxB;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GAChD;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAA;AAEzB;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,+DAIjC;IACD,mBAAmB,EAAE,OAAO,CAAA;IAC5B,kBAAkB,EAAE,OAAO,CAAA;IAC3B,YAAY,EAAE,MAAM,GAAG,SAAS,CAAA;CACjC,KAAG,gBAQH,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,GAAU,CAAC,4KAWrC,IAAI,CAAC,CAAC,CAAC,KAAG,MAAM,CAAC,CAAC,CAsoBpB,CAAA"}