payload 4.0.0-internal.fa345ef → 4.0.0-internal.ff27d6e

package/dist/uploads/uploadFileRollback.js

@@ -0,0 +1,269 @@
+import { randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { getFileHandleIdentity, getFileIdentity, hasFileIdentity, hasRenameStableFileIdentity } from './fileIdentity.js';
+import { linkFileWithoutOverwrite } from './linkFileWithoutOverwrite.js';
+export const stageUploadFileRollback = async ({ file, rollbacks })=>{
+    let rollback = rollbacks.get(file.path);
+    if (!rollback) {
+        rollback = await createUploadFileRollback({
+            filePath: file.path
+        });
+        rollbacks.set(file.path, rollback);
+    }
+    const stagedFilePath = path.join(rollback.directoryPath, `upload-${randomUUID()}`);
+    rollback.stagedFilePaths.add(stagedFilePath);
+    return {
+        ...file,
+        path: stagedFilePath
+    };
+};
+export const publishUploadedFile = async ({ file, rollbacks, stagedFile })=>{
+    const rollback = rollbacks.get(file.path);
+    if (!rollback || !rollback.stagedFilePaths.has(stagedFile.path)) {
+        throw new Error('The staged upload does not belong to this operation.');
+    }
+    const precedingPublish = rollback.publishQueue;
+    let releasePublish;
+    rollback.publishQueue = new Promise((resolve)=>{
+        releasePublish = resolve;
+    });
+    await precedingPublish;
+    try {
+        const fileHandle = await fs.open(stagedFile.path, 'r');
+        try {
+            rollback.publicationState = 'indeterminate';
+            const quarantinedDestination = await quarantineUploadDestination({
+                rollback
+            });
+            const hasExpectedDestination = rollback.expectedDestinationFileIdentity !== undefined;
+            const hasMatchingDestination = hasExpectedDestination ? hasRenameStableFileIdentity({
+                actual: quarantinedDestination?.fileIdentity,
+                expected: rollback.expectedDestinationFileIdentity
+            }) : quarantinedDestination === undefined;
+            if (!hasMatchingDestination) {
+                rollback.publicationState = 'failed';
+                if (quarantinedDestination) {
+                    await restoreQuarantinedUploadDestination({
+                        quarantinedDestination,
+                        rollback
+                    });
+                }
+                throw new Error('The upload destination changed before the staged file was published.');
+            }
+            try {
+                await linkFileWithoutOverwrite({
+                    sourceFilePath: stagedFile.path,
+                    targetFilePath: rollback.filePath
+                });
+            } catch (error) {
+                rollback.publicationState = 'failed';
+                if (quarantinedDestination) {
+                    try {
+                        await restoreQuarantinedUploadDestination({
+                            quarantinedDestination,
+                            rollback
+                        });
+                    } catch (restoreError) {
+                        throw new AggregateError([
+                            error,
+                            restoreError
+                        ], 'The staged upload could not be installed or its prior destination restored.');
+                    }
+                }
+                throw error;
+            }
+            rollback.publicationState = 'indeterminate';
+            rollback.uploadedFileIdentity = await getFileHandleIdentity({
+                fileHandle
+            });
+            rollback.expectedDestinationFileIdentity = rollback.uploadedFileIdentity;
+            rollback.publicationState = 'owned';
+        } finally{
+            await fileHandle.close();
+        }
+    } finally{
+        releasePublish();
+    }
+};
+export const cleanupUploadFileRollbacks = async ({ rollbacks })=>{
+    const errors = [];
+    for (const rollback of rollbacks.values()){
+        try {
+            await fs.rm(rollback.directoryPath, {
+                force: true,
+                recursive: true
+            });
+        } catch (error) {
+            errors.push(error);
+        }
+    }
+    rollbacks.clear();
+    throwCollectedErrors({
+        errors
+    });
+};
+export const rollbackUploadFiles = async ({ rollbacks })=>{
+    const errors = [];
+    for (const rollback of [
+        ...rollbacks.values()
+    ].reverse()){
+        try {
+            await rollbackUploadFile({
+                rollback
+            });
+            await fs.rm(rollback.directoryPath, {
+                force: true,
+                recursive: true
+            });
+            rollbacks.delete(rollback.filePath);
+        } catch (error) {
+            errors.push(error);
+        }
+    }
+    throwCollectedErrors({
+        errors
+    });
+};
+const createUploadFileRollback = async ({ filePath })=>{
+    const originalFileIdentity = await getFileIdentity({
+        filePath
+    });
+    if (originalFileIdentity && !originalFileIdentity.isRegularFile) {
+        throw new Error('The upload destination must be a regular file.');
+    }
+    const directoryPath = path.join(path.dirname(filePath), `.payload-upload-rollback-${randomUUID()}`);
+    await fs.mkdir(directoryPath, {
+        mode: 0o700
+    });
+    const rollback = {
+        directoryPath,
+        expectedDestinationFileIdentity: originalFileIdentity,
+        filePath,
+        publicationState: 'not-published',
+        publishQueue: Promise.resolve(),
+        stagedFilePaths: new Set()
+    };
+    if (!originalFileIdentity) {
+        return rollback;
+    }
+    const backupFilePath = path.join(directoryPath, 'backup');
+    try {
+        await fs.copyFile(filePath, backupFilePath, constants.COPYFILE_EXCL);
+        const [currentOriginalFileIdentity, backupFileIdentity] = await Promise.all([
+            getFileIdentity({
+                filePath
+            }),
+            getFileIdentity({
+                filePath: backupFilePath
+            })
+        ]);
+        if (!hasFileIdentity({
+            actual: currentOriginalFileIdentity,
+            expected: originalFileIdentity
+        }) || !backupFileIdentity) {
+            throw new Error('The upload file changed while its rollback backup was being created.');
+        }
+        rollback.backupFileIdentity = backupFileIdentity;
+        rollback.backupFilePath = backupFilePath;
+        return rollback;
+    } catch (error) {
+        await fs.rm(directoryPath, {
+            force: true,
+            recursive: true
+        }).catch(()=>undefined);
+        throw error;
+    }
+};
+const rollbackUploadFile = async ({ rollback })=>{
+    if (rollback.publicationState === 'not-published') {
+        return;
+    }
+    if (rollback.publicationState === 'failed' || rollback.publicationState === 'indeterminate' || !rollback.uploadedFileIdentity) {
+        throw new Error('The published upload could not be identified safely for rollback.');
+    }
+    const quarantinedFilePath = path.join(rollback.directoryPath, `published-${randomUUID()}`);
+    try {
+        await fs.rename(rollback.filePath, quarantinedFilePath);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            await restoreBackupIfPresent({
+                rollback
+            });
+            return;
+        }
+        throw error;
+    }
+    const quarantinedFileIdentity = await getFileIdentity({
+        filePath: quarantinedFilePath
+    });
+    if (!hasRenameStableFileIdentity({
+        actual: quarantinedFileIdentity,
+        expected: rollback.uploadedFileIdentity
+    })) {
+        await linkFileWithoutOverwrite({
+            sourceFilePath: quarantinedFilePath,
+            targetFilePath: rollback.filePath
+        });
+        return;
+    }
+    await restoreBackupIfPresent({
+        rollback
+    });
+};
+const quarantineUploadDestination = async ({ rollback })=>{
+    const quarantinedFilePath = path.join(rollback.directoryPath, `destination-${randomUUID()}`);
+    try {
+        await fs.rename(rollback.filePath, quarantinedFilePath);
+    } catch (error) {
+        if (error.code === 'ENOENT') {
+            return undefined;
+        }
+        throw error;
+    }
+    const fileIdentity = await getFileIdentity({
+        filePath: quarantinedFilePath
+    });
+    if (!fileIdentity) {
+        throw new Error('The upload destination was not present after it was quarantined.');
+    }
+    return {
+        fileIdentity,
+        filePath: quarantinedFilePath
+    };
+};
+const restoreQuarantinedUploadDestination = async ({ quarantinedDestination, rollback })=>{
+    await linkFileWithoutOverwrite({
+        sourceFilePath: quarantinedDestination.filePath,
+        targetFilePath: rollback.filePath
+    });
+};
+const restoreBackupIfPresent = async ({ rollback })=>{
+    if (!rollback.backupFileIdentity || !rollback.backupFilePath) {
+        return;
+    }
+    const currentBackupFileIdentity = await getFileIdentity({
+        filePath: rollback.backupFilePath
+    });
+    if (!hasFileIdentity({
+        actual: currentBackupFileIdentity,
+        expected: rollback.backupFileIdentity
+    })) {
+        throw new Error('The upload rollback backup no longer belongs to this operation.');
+    }
+    await linkFileWithoutOverwrite({
+        sourceFilePath: rollback.backupFilePath,
+        targetFilePath: rollback.filePath
+    });
+};
+const throwCollectedErrors = ({ errors })=>{
+    if (errors.length === 1) {
+        throw errors[0];
+    }
+    if (errors.length > 1) {
+        throw new AggregateError(errors, 'Multiple upload rollback tasks failed.');
+    }
+};
+
+//# sourceMappingURL=uploadFileRollback.js.map

package/dist/uploads/uploadFileRollback.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/uploadFileRollback.ts"],"sourcesContent":["import { randomUUID } from 'node:crypto'\nimport { constants } from 'node:fs'\nimport fs from 'node:fs/promises'\nimport path from 'node:path'\n\nimport type { FileIdentity } from './fileIdentity.js'\nimport type { FileToSave } from './types.js'\n\nimport {\n  getFileHandleIdentity,\n  getFileIdentity,\n  hasFileIdentity,\n  hasRenameStableFileIdentity,\n} from './fileIdentity.js'\nimport { linkFileWithoutOverwrite } from './linkFileWithoutOverwrite.js'\n\ntype UploadFileRollback = {\n  backupFileIdentity?: FileIdentity\n  backupFilePath?: string\n  directoryPath: string\n  expectedDestinationFileIdentity?: FileIdentity\n  filePath: string\n  publicationState: 'failed' | 'indeterminate' | 'not-published' | 'owned'\n  publishQueue: Promise<void>\n  stagedFilePaths: Set<string>\n  uploadedFileIdentity?: FileIdentity\n}\n\nexport type UploadFileRollbacks = Map<string, UploadFileRollback>\n\nexport const stageUploadFileRollback = async ({\n  file,\n  rollbacks,\n}: {\n  file: FileToSave\n  rollbacks: UploadFileRollbacks\n}): Promise<FileToSave> => {\n  let rollback = rollbacks.get(file.path)\n\n  if (!rollback) {\n    rollback = await createUploadFileRollback({ filePath: file.path })\n    rollbacks.set(file.path, rollback)\n  }\n\n  const stagedFilePath = path.join(rollback.directoryPath, `upload-${randomUUID()}`)\n\n  rollback.stagedFilePaths.add(stagedFilePath)\n\n  return { ...file, path: stagedFilePath }\n}\n\nexport const publishUploadedFile = async ({\n  file,\n  rollbacks,\n  stagedFile,\n}: {\n  file: FileToSave\n  rollbacks: UploadFileRollbacks\n  stagedFile: FileToSave\n}): Promise<void> => {\n  const rollback = rollbacks.get(file.path)\n\n  if (!rollback || !rollback.stagedFilePaths.has(stagedFile.path)) {\n    throw new Error('The staged upload does not belong to this operation.')\n  }\n\n  const precedingPublish = rollback.publishQueue\n  let releasePublish!: () => void\n\n  rollback.publishQueue = new Promise<void>((resolve) => {\n    releasePublish = resolve\n  })\n\n  await precedingPublish\n\n  try {\n    const fileHandle = await fs.open(stagedFile.path, 'r')\n\n    try {\n      rollback.publicationState = 'indeterminate'\n      const quarantinedDestination = await quarantineUploadDestination({ rollback })\n      const hasExpectedDestination = rollback.expectedDestinationFileIdentity !== undefined\n      const hasMatchingDestination = hasExpectedDestination\n        ? hasRenameStableFileIdentity({\n            actual: quarantinedDestination?.fileIdentity,\n            expected: rollback.expectedDestinationFileIdentity!,\n          })\n        : quarantinedDestination === undefined\n\n      if (!hasMatchingDestination) {\n        rollback.publicationState = 'failed'\n\n        if (quarantinedDestination) {\n          await restoreQuarantinedUploadDestination({ quarantinedDestination, rollback })\n        }\n\n        throw new Error('The upload destination changed before the staged file was published.')\n      }\n\n      try {\n        await linkFileWithoutOverwrite({\n          sourceFilePath: stagedFile.path,\n          targetFilePath: rollback.filePath,\n        })\n      } catch (error) {\n        rollback.publicationState = 'failed'\n\n        if (quarantinedDestination) {\n          try {\n            await restoreQuarantinedUploadDestination({ quarantinedDestination, rollback })\n          } catch (restoreError) {\n            throw new AggregateError(\n              [error, restoreError],\n              'The staged upload could not be installed or its prior destination restored.',\n            )\n          }\n        }\n\n        throw error\n      }\n\n      rollback.publicationState = 'indeterminate'\n      rollback.uploadedFileIdentity = await getFileHandleIdentity({ fileHandle })\n      rollback.expectedDestinationFileIdentity = rollback.uploadedFileIdentity\n      rollback.publicationState = 'owned'\n    } finally {\n      await fileHandle.close()\n    }\n  } finally {\n    releasePublish()\n  }\n}\n\nexport const cleanupUploadFileRollbacks = async ({\n  rollbacks,\n}: {\n  rollbacks: UploadFileRollbacks\n}): Promise<void> => {\n  const errors: unknown[] = []\n\n  for (const rollback of rollbacks.values()) {\n    try {\n      await fs.rm(rollback.directoryPath, { force: true, recursive: true })\n    } catch (error) {\n      errors.push(error)\n    }\n  }\n\n  rollbacks.clear()\n  throwCollectedErrors({ errors })\n}\n\nexport const rollbackUploadFiles = async ({\n  rollbacks,\n}: {\n  rollbacks: UploadFileRollbacks\n}): Promise<void> => {\n  const errors: unknown[] = []\n\n  for (const rollback of [...rollbacks.values()].reverse()) {\n    try {\n      await rollbackUploadFile({ rollback })\n      await fs.rm(rollback.directoryPath, { force: true, recursive: true })\n      rollbacks.delete(rollback.filePath)\n    } catch (error) {\n      errors.push(error)\n    }\n  }\n\n  throwCollectedErrors({ errors })\n}\n\nconst createUploadFileRollback = async ({\n  filePath,\n}: {\n  filePath: string\n}): Promise<UploadFileRollback> => {\n  const originalFileIdentity = await getFileIdentity({ filePath })\n\n  if (originalFileIdentity && !originalFileIdentity.isRegularFile) {\n    throw new Error('The upload destination must be a regular file.')\n  }\n\n  const directoryPath = path.join(\n    path.dirname(filePath),\n    `.payload-upload-rollback-${randomUUID()}`,\n  )\n\n  await fs.mkdir(directoryPath, { mode: 0o700 })\n  const rollback: UploadFileRollback = {\n    directoryPath,\n    expectedDestinationFileIdentity: originalFileIdentity,\n    filePath,\n    publicationState: 'not-published',\n    publishQueue: Promise.resolve(),\n    stagedFilePaths: new Set(),\n  }\n\n  if (!originalFileIdentity) {\n    return rollback\n  }\n\n  const backupFilePath = path.join(directoryPath, 'backup')\n\n  try {\n    await fs.copyFile(filePath, backupFilePath, constants.COPYFILE_EXCL)\n\n    const [currentOriginalFileIdentity, backupFileIdentity] = await Promise.all([\n      getFileIdentity({ filePath }),\n      getFileIdentity({ filePath: backupFilePath }),\n    ])\n\n    if (\n      !hasFileIdentity({ actual: currentOriginalFileIdentity, expected: originalFileIdentity }) ||\n      !backupFileIdentity\n    ) {\n      throw new Error('The upload file changed while its rollback backup was being created.')\n    }\n\n    rollback.backupFileIdentity = backupFileIdentity\n    rollback.backupFilePath = backupFilePath\n    return rollback\n  } catch (error) {\n    await fs.rm(directoryPath, { force: true, recursive: true }).catch(() => undefined)\n    throw error\n  }\n}\n\nconst rollbackUploadFile = async ({\n  rollback,\n}: {\n  rollback: UploadFileRollback\n}): Promise<void> => {\n  if (rollback.publicationState === 'not-published') {\n    return\n  }\n\n  if (\n    rollback.publicationState === 'failed' ||\n    rollback.publicationState === 'indeterminate' ||\n    !rollback.uploadedFileIdentity\n  ) {\n    throw new Error('The published upload could not be identified safely for rollback.')\n  }\n\n  const quarantinedFilePath = path.join(rollback.directoryPath, `published-${randomUUID()}`)\n\n  try {\n    await fs.rename(rollback.filePath, quarantinedFilePath)\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n      await restoreBackupIfPresent({ rollback })\n      return\n    }\n\n    throw error\n  }\n\n  const quarantinedFileIdentity = await getFileIdentity({ filePath: quarantinedFilePath })\n\n  if (\n    !hasRenameStableFileIdentity({\n      actual: quarantinedFileIdentity,\n      expected: rollback.uploadedFileIdentity,\n    })\n  ) {\n    await linkFileWithoutOverwrite({\n      sourceFilePath: quarantinedFilePath,\n      targetFilePath: rollback.filePath,\n    })\n    return\n  }\n\n  await restoreBackupIfPresent({ rollback })\n}\n\nconst quarantineUploadDestination = async ({\n  rollback,\n}: {\n  rollback: UploadFileRollback\n}): Promise<{ fileIdentity: FileIdentity; filePath: string } | undefined> => {\n  const quarantinedFilePath = path.join(rollback.directoryPath, `destination-${randomUUID()}`)\n\n  try {\n    await fs.rename(rollback.filePath, quarantinedFilePath)\n  } catch (error) {\n    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {\n      return undefined\n    }\n\n    throw error\n  }\n\n  const fileIdentity = await getFileIdentity({ filePath: quarantinedFilePath })\n\n  if (!fileIdentity) {\n    throw new Error('The upload destination was not present after it was quarantined.')\n  }\n\n  return { fileIdentity, filePath: quarantinedFilePath }\n}\n\nconst restoreQuarantinedUploadDestination = async ({\n  quarantinedDestination,\n  rollback,\n}: {\n  quarantinedDestination: { fileIdentity: FileIdentity; filePath: string }\n  rollback: UploadFileRollback\n}): Promise<void> => {\n  await linkFileWithoutOverwrite({\n    sourceFilePath: quarantinedDestination.filePath,\n    targetFilePath: rollback.filePath,\n  })\n}\n\nconst restoreBackupIfPresent = async ({\n  rollback,\n}: {\n  rollback: UploadFileRollback\n}): Promise<void> => {\n  if (!rollback.backupFileIdentity || !rollback.backupFilePath) {\n    return\n  }\n\n  const currentBackupFileIdentity = await getFileIdentity({ filePath: rollback.backupFilePath })\n\n  if (\n    !hasFileIdentity({\n      actual: currentBackupFileIdentity,\n      expected: rollback.backupFileIdentity,\n    })\n  ) {\n    throw new Error('The upload rollback backup no longer belongs to this operation.')\n  }\n\n  await linkFileWithoutOverwrite({\n    sourceFilePath: rollback.backupFilePath,\n    targetFilePath: rollback.filePath,\n  })\n}\n\nconst throwCollectedErrors = ({ errors }: { errors: unknown[] }): void => {\n  if (errors.length === 1) {\n    throw errors[0]\n  }\n\n  if (errors.length > 1) {\n    throw new AggregateError(errors, 'Multiple upload rollback tasks failed.')\n  }\n}\n"],"names":["randomUUID","constants","fs","path","getFileHandleIdentity","getFileIdentity","hasFileIdentity","hasRenameStableFileIdentity","linkFileWithoutOverwrite","stageUploadFileRollback","file","rollbacks","rollback","get","createUploadFileRollback","filePath","set","stagedFilePath","join","directoryPath","stagedFilePaths","add","publishUploadedFile","stagedFile","has","Error","precedingPublish","publishQueue","releasePublish","Promise","resolve","fileHandle","open","publicationState","quarantinedDestination","quarantineUploadDestination","hasExpectedDestination","expectedDestinationFileIdentity","undefined","hasMatchingDestination","actual","fileIdentity","expected","restoreQuarantinedUploadDestination","sourceFilePath","targetFilePath","error","restoreError","AggregateError","uploadedFileIdentity","close","cleanupUploadFileRollbacks","errors","values","rm","force","recursive","push","clear","throwCollectedErrors","rollbackUploadFiles","reverse","rollbackUploadFile","delete","originalFileIdentity","isRegularFile","dirname","mkdir","mode","Set","backupFilePath","copyFile","COPYFILE_EXCL","currentOriginalFileIdentity","backupFileIdentity","all","catch","quarantinedFilePath","rename","code","restoreBackupIfPresent","quarantinedFileIdentity","currentBackupFileIdentity","length"],"mappings":"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"}

package/dist/uploads/uploadFiles.d.ts

@@ -1,5 +1,8 @@
 import type { Payload } from '../index.js';
 import type { PayloadRequest } from '../types/index.js';
 import type { FileToSave } from './types.js';
-export declare const uploadFiles: (payload: Payload, files: FileToSave[], req: PayloadRequest) => Promise<void>;
+import type { UploadFileRollbacks } from './uploadFileRollback.js';
+export declare const uploadFiles: (payload: Payload, files: FileToSave[], req: PayloadRequest, { uploadFileRollbacks, }?: {
+    uploadFileRollbacks?: UploadFileRollbacks;
+}) => Promise<void>;
 //# sourceMappingURL=uploadFiles.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"uploadFiles.d.ts","sourceRoot":"","sources":["../../src/uploads/uploadFiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAK5C,eAAO,MAAM,WAAW,GACtB,SAAS,OAAO,EAChB,OAAO,UAAU,EAAE,EACnB,KAAK,cAAc,KAClB,OAAO,CAAC,IAAI,CAWd,CAAA"}
+{"version":3,"file":"uploadFiles.d.ts","sourceRoot":"","sources":["../../src/uploads/uploadFiles.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAOlE,eAAO,MAAM,WAAW,YACb,OAAO,SACT,UAAU,EAAE,OACd,cAAc,6BAGhB;IACD,mBAAmB,CAAC,EAAE,mBAAmB,CAAA;CAC1C,KACA,OAAO,CAAC,IAAI,CAwCd,CAAA"}

package/dist/uploads/uploadFiles.js

@@ -1,10 +1,41 @@
+import fs from 'fs/promises';
 import { FileUploadError } from '../errors/index.js';
+import { assertNoValidationWrite } from '../utilities/assertNoValidationWrite.js';
 import { saveBufferToFile } from './saveBufferToFile.js';
-export const uploadFiles = async (payload, files, req)=>{
+import { publishUploadedFile, stageUploadFileRollback } from './uploadFileRollback.js';
+export const uploadFiles = async (payload, files, req, { uploadFileRollbacks } = {})=>{
+    assertNoValidationWrite(req);
     try {
-        await Promise.all(files.map(async ({ buffer, path })=>{
-            await saveBufferToFile(buffer, path);
+        const filesToUpload = [];
+        for (const file of files){
+            filesToUpload.push({
+                file,
+                stagedFile: uploadFileRollbacks ? await stageUploadFileRollback({
+                    file,
+                    rollbacks: uploadFileRollbacks
+                }) : file
+            });
+        }
+        const uploadResults = await Promise.allSettled(filesToUpload.map(async ({ stagedFile })=>{
+            if ('sourcePath' in stagedFile) {
+                await fs.copyFile(stagedFile.sourcePath, stagedFile.path);
+            } else {
+                await saveBufferToFile(stagedFile.buffer, stagedFile.path);
+            }
         }));
+        const failedUpload = uploadResults.find((result)=>result.status === 'rejected');
+        if (failedUpload) {
+            throw failedUpload.reason;
+        }
+        if (uploadFileRollbacks) {
+            for (const { file, stagedFile } of filesToUpload){
+                await publishUploadedFile({
+                    file,
+                    rollbacks: uploadFileRollbacks,
+                    stagedFile
+                });
+            }
+        }
     } catch (err) {
         payload.logger.error(err);
         throw new FileUploadError(req.t);

package/dist/uploads/uploadFiles.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/uploads/uploadFiles.ts"],"sourcesContent":["import type { Payload } from '../index.js'\nimport type { PayloadRequest } from '../types/index.js'\nimport type { FileToSave } from './types.js'\n\nimport { FileUploadError } from '../errors/index.js'\nimport { saveBufferToFile } from './saveBufferToFile.js'\n\nexport const uploadFiles = async (\n  payload: Payload,\n  files: FileToSave[],\n  req: PayloadRequest,\n): Promise<void> => {\n  try {\n    await Promise.all(\n      files.map(async ({ buffer, path }) => {\n        await saveBufferToFile(buffer, path)\n      }),\n    )\n  } catch (err) {\n    payload.logger.error(err)\n    throw new FileUploadError(req.t)\n  }\n}\n"],"names":["FileUploadError","saveBufferToFile","uploadFiles","payload","files","req","Promise","all","map","buffer","path","err","logger","error","t"],"mappings":"AAIA,SAASA,eAAe,QAAQ,qBAAoB;AACpD,SAASC,gBAAgB,QAAQ,wBAAuB;AAExD,OAAO,MAAMC,cAAc,OACzBC,SACAC,OACAC;IAEA,IAAI;QACF,MAAMC,QAAQC,GAAG,CACfH,MAAMI,GAAG,CAAC,OAAO,EAAEC,MAAM,EAAEC,IAAI,EAAE;YAC/B,MAAMT,iBAAiBQ,QAAQC;QACjC;IAEJ,EAAE,OAAOC,KAAK;QACZR,QAAQS,MAAM,CAACC,KAAK,CAACF;QACrB,MAAM,IAAIX,gBAAgBK,IAAIS,CAAC;IACjC;AACF,EAAC"}
+{"version":3,"sources":["../../src/uploads/uploadFiles.ts"],"sourcesContent":["import fs from 'fs/promises'\n\nimport type { Payload } from '../index.js'\nimport type { PayloadRequest } from '../types/index.js'\nimport type { FileToSave } from './types.js'\nimport type { UploadFileRollbacks } from './uploadFileRollback.js'\n\nimport { FileUploadError } from '../errors/index.js'\nimport { assertNoValidationWrite } from '../utilities/assertNoValidationWrite.js'\nimport { saveBufferToFile } from './saveBufferToFile.js'\nimport { publishUploadedFile, stageUploadFileRollback } from './uploadFileRollback.js'\n\nexport const uploadFiles = async (\n  payload: Payload,\n  files: FileToSave[],\n  req: PayloadRequest,\n  {\n    uploadFileRollbacks,\n  }: {\n    uploadFileRollbacks?: UploadFileRollbacks\n  } = {},\n): Promise<void> => {\n  assertNoValidationWrite(req)\n\n  try {\n    const filesToUpload: Array<{ file: FileToSave; stagedFile: FileToSave }> = []\n\n    for (const file of files) {\n      filesToUpload.push({\n        file,\n        stagedFile: uploadFileRollbacks\n          ? await stageUploadFileRollback({ file, rollbacks: uploadFileRollbacks })\n          : file,\n      })\n    }\n\n    const uploadResults = await Promise.allSettled(\n      filesToUpload.map(async ({ stagedFile }) => {\n        if ('sourcePath' in stagedFile) {\n          await fs.copyFile(stagedFile.sourcePath, stagedFile.path)\n        } else {\n          await saveBufferToFile(stagedFile.buffer, stagedFile.path)\n        }\n      }),\n    )\n\n    const failedUpload = uploadResults.find((result) => result.status === 'rejected')\n\n    if (failedUpload) {\n      throw failedUpload.reason\n    }\n\n    if (uploadFileRollbacks) {\n      for (const { file, stagedFile } of filesToUpload) {\n        await publishUploadedFile({ file, rollbacks: uploadFileRollbacks, stagedFile })\n      }\n    }\n  } catch (err) {\n    payload.logger.error(err)\n    throw new FileUploadError(req.t)\n  }\n}\n"],"names":["fs","FileUploadError","assertNoValidationWrite","saveBufferToFile","publishUploadedFile","stageUploadFileRollback","uploadFiles","payload","files","req","uploadFileRollbacks","filesToUpload","file","push","stagedFile","rollbacks","uploadResults","Promise","allSettled","map","copyFile","sourcePath","path","buffer","failedUpload","find","result","status","reason","err","logger","error","t"],"mappings":"AAAA,OAAOA,QAAQ,cAAa;AAO5B,SAASC,eAAe,QAAQ,qBAAoB;AACpD,SAASC,uBAAuB,QAAQ,0CAAyC;AACjF,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,mBAAmB,EAAEC,uBAAuB,QAAQ,0BAAyB;AAEtF,OAAO,MAAMC,cAAc,OACzBC,SACAC,OACAC,KACA,EACEC,mBAAmB,EAGpB,GAAG,CAAC,CAAC;IAENR,wBAAwBO;IAExB,IAAI;QACF,MAAME,gBAAqE,EAAE;QAE7E,KAAK,MAAMC,QAAQJ,MAAO;YACxBG,cAAcE,IAAI,CAAC;gBACjBD;gBACAE,YAAYJ,sBACR,MAAML,wBAAwB;oBAAEO;oBAAMG,WAAWL;gBAAoB,KACrEE;YACN;QACF;QAEA,MAAMI,gBAAgB,MAAMC,QAAQC,UAAU,CAC5CP,cAAcQ,GAAG,CAAC,OAAO,EAAEL,UAAU,EAAE;YACrC,IAAI,gBAAgBA,YAAY;gBAC9B,MAAMd,GAAGoB,QAAQ,CAACN,WAAWO,UAAU,EAAEP,WAAWQ,IAAI;YAC1D,OAAO;gBACL,MAAMnB,iBAAiBW,WAAWS,MAAM,EAAET,WAAWQ,IAAI;YAC3D;QACF;QAGF,MAAME,eAAeR,cAAcS,IAAI,CAAC,CAACC,SAAWA,OAAOC,MAAM,KAAK;QAEtE,IAAIH,cAAc;YAChB,MAAMA,aAAaI,MAAM;QAC3B;QAEA,IAAIlB,qBAAqB;YACvB,KAAK,MAAM,EAAEE,IAAI,EAAEE,UAAU,EAAE,IAAIH,cAAe;gBAChD,MAAMP,oBAAoB;oBAAEQ;oBAAMG,WAAWL;oBAAqBI;gBAAW;YAC/E;QACF;IACF,EAAE,OAAOe,KAAK;QACZtB,QAAQuB,MAAM,CAACC,KAAK,CAACF;QACrB,MAAM,IAAI5B,gBAAgBQ,IAAIuB,CAAC;IACjC;AACF,EAAC"}

package/dist/uploads/validateISOBaseMediaFile.d.ts

@@ -0,0 +1,4 @@
+export declare const isISOBaseMediaMimeType: (mimeType: string) => boolean;
+export declare const validateISOBaseMediaBuffer: (buffer: Buffer) => Promise<boolean>;
+export declare const validateISOBaseMediaFile: (filePath: string) => Promise<boolean>;
+//# sourceMappingURL=validateISOBaseMediaFile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validateISOBaseMediaFile.d.ts","sourceRoot":"","sources":["../../src/uploads/validateISOBaseMediaFile.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,sBAAsB,aAAc,MAAM,KAAG,OACjB,CAAA;AA8DzC,eAAO,MAAM,0BAA0B,WAAkB,MAAM,KAAG,OAAO,CAAC,OAAO,CAG9E,CAAA;AAEH,eAAO,MAAM,wBAAwB,aAAoB,MAAM,KAAG,OAAO,CAAC,OAAO,CAiBhF,CAAA"}

package/dist/uploads/validateISOBaseMediaFile.js

@@ -0,0 +1,91 @@
+import fs from 'fs/promises';
+const MAX_BOX_COUNT = 10_000;
+const QUICKTIME_FIRST_BOX_TYPES = new Set([
+    'free',
+    'mdat',
+    'moov',
+    'wide'
+]);
+const ISO_BASE_MEDIA_MIME_TYPES = new Set([
+    'audio/mp4',
+    'audio/x-m4a',
+    'image/avif',
+    'image/heic',
+    'image/heic-sequence',
+    'image/heif',
+    'image/heif-sequence',
+    'image/x-canon-cr3',
+    'video/3gpp',
+    'video/3gpp2',
+    'video/mp4',
+    'video/quicktime',
+    'video/x-m4v'
+]);
+export const isISOBaseMediaMimeType = (mimeType)=>ISO_BASE_MEDIA_MIME_TYPES.has(mimeType);
+const validateBoxStructure = async (size, readAt)=>{
+    if (!Number.isSafeInteger(size) || size < 24) {
+        return false;
+    }
+    let boxCount = 0;
+    let position = 0;
+    while(position < size){
+        if (++boxCount > MAX_BOX_COUNT || size - position < 8) {
+            return false;
+        }
+        const header = await readAt(position, Math.min(16, size - position));
+        if (header.length < 8) {
+            return false;
+        }
+        const boxType = header.toString('latin1', 4, 8);
+        const size32 = header.readUInt32BE(0);
+        let boxSize;
+        let headerSize = 8;
+        if (size32 === 0) {
+            boxSize = size - position;
+        } else if (size32 === 1) {
+            if (header.length < 16) {
+                return false;
+            }
+            const size64 = header.readBigUInt64BE(8);
+            if (size64 > BigInt(Number.MAX_SAFE_INTEGER)) {
+                return false;
+            }
+            boxSize = Number(size64);
+            headerSize = 16;
+        } else {
+            boxSize = size32;
+        }
+        if (boxSize < headerSize || boxSize > size - position) {
+            return false;
+        }
+        if (position === 0 && boxType === 'ftyp') {
+            const payloadSize = boxSize - headerSize;
+            if (size32 === 0 || payloadSize < 8 || (payloadSize - 8) % 4 !== 0 || boxSize === size) {
+                return false;
+            }
+        } else if (position === 0 && !QUICKTIME_FIRST_BOX_TYPES.has(boxType)) {
+            return false;
+        }
+        position += boxSize;
+    }
+    return position === size;
+};
+export const validateISOBaseMediaBuffer = async (buffer)=>validateBoxStructure(buffer.length, (position, length)=>Promise.resolve(buffer.subarray(position, position + length)));
+export const validateISOBaseMediaFile = async (filePath)=>{
+    let fileHandle;
+    try {
+        fileHandle = await fs.open(filePath, 'r');
+        const { size } = await fileHandle.stat();
+        return await validateBoxStructure(size, async (position, length)=>{
+            const buffer = Buffer.allocUnsafe(length);
+            const { bytesRead } = await fileHandle.read(buffer, 0, length, position);
+            return buffer.subarray(0, bytesRead);
+        });
+    } catch  {
+        return false;
+    } finally{
+        await fileHandle?.close();
+    }
+};
+
+//# sourceMappingURL=validateISOBaseMediaFile.js.map

package/dist/uploads/validateISOBaseMediaFile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/validateISOBaseMediaFile.ts"],"sourcesContent":["import fs from 'fs/promises'\n\nconst MAX_BOX_COUNT = 10_000\nconst QUICKTIME_FIRST_BOX_TYPES = new Set(['free', 'mdat', 'moov', 'wide'])\n\nconst ISO_BASE_MEDIA_MIME_TYPES = new Set([\n  'audio/mp4',\n  'audio/x-m4a',\n  'image/avif',\n  'image/heic',\n  'image/heic-sequence',\n  'image/heif',\n  'image/heif-sequence',\n  'image/x-canon-cr3',\n  'video/3gpp',\n  'video/3gpp2',\n  'video/mp4',\n  'video/quicktime',\n  'video/x-m4v',\n])\n\ntype ReadAt = (position: number, length: number) => Promise<Buffer>\n\nexport const isISOBaseMediaMimeType = (mimeType: string): boolean =>\n  ISO_BASE_MEDIA_MIME_TYPES.has(mimeType)\n\nconst validateBoxStructure = async (size: number, readAt: ReadAt): Promise<boolean> => {\n  if (!Number.isSafeInteger(size) || size < 24) {\n    return false\n  }\n\n  let boxCount = 0\n  let position = 0\n\n  while (position < size) {\n    if (++boxCount > MAX_BOX_COUNT || size - position < 8) {\n      return false\n    }\n\n    const header = await readAt(position, Math.min(16, size - position))\n    if (header.length < 8) {\n      return false\n    }\n\n    const boxType = header.toString('latin1', 4, 8)\n    const size32 = header.readUInt32BE(0)\n    let boxSize: number\n    let headerSize = 8\n\n    if (size32 === 0) {\n      boxSize = size - position\n    } else if (size32 === 1) {\n      if (header.length < 16) {\n        return false\n      }\n\n      const size64 = header.readBigUInt64BE(8)\n      if (size64 > BigInt(Number.MAX_SAFE_INTEGER)) {\n        return false\n      }\n\n      boxSize = Number(size64)\n      headerSize = 16\n    } else {\n      boxSize = size32\n    }\n\n    if (boxSize < headerSize || boxSize > size - position) {\n      return false\n    }\n\n    if (position === 0 && boxType === 'ftyp') {\n      const payloadSize = boxSize - headerSize\n      if (size32 === 0 || payloadSize < 8 || (payloadSize - 8) % 4 !== 0 || boxSize === size) {\n        return false\n      }\n    } else if (position === 0 && !QUICKTIME_FIRST_BOX_TYPES.has(boxType)) {\n      return false\n    }\n\n    position += boxSize\n  }\n\n  return position === size\n}\n\nexport const validateISOBaseMediaBuffer = async (buffer: Buffer): Promise<boolean> =>\n  validateBoxStructure(buffer.length, (position, length) =>\n    Promise.resolve(buffer.subarray(position, position + length)),\n  )\n\nexport const validateISOBaseMediaFile = async (filePath: string): Promise<boolean> => {\n  let fileHandle: Awaited<ReturnType<typeof fs.open>> | undefined\n\n  try {\n    fileHandle = await fs.open(filePath, 'r')\n    const { size } = await fileHandle.stat()\n\n    return await validateBoxStructure(size, async (position, length) => {\n      const buffer = Buffer.allocUnsafe(length)\n      const { bytesRead } = await fileHandle!.read(buffer, 0, length, position)\n      return buffer.subarray(0, bytesRead)\n    })\n  } catch {\n    return false\n  } finally {\n    await fileHandle?.close()\n  }\n}\n"],"names":["fs","MAX_BOX_COUNT","QUICKTIME_FIRST_BOX_TYPES","Set","ISO_BASE_MEDIA_MIME_TYPES","isISOBaseMediaMimeType","mimeType","has","validateBoxStructure","size","readAt","Number","isSafeInteger","boxCount","position","header","Math","min","length","boxType","toString","size32","readUInt32BE","boxSize","headerSize","size64","readBigUInt64BE","BigInt","MAX_SAFE_INTEGER","payloadSize","validateISOBaseMediaBuffer","buffer","Promise","resolve","subarray","validateISOBaseMediaFile","filePath","fileHandle","open","stat","Buffer","allocUnsafe","bytesRead","read","close"],"mappings":"AAAA,OAAOA,QAAQ,cAAa;AAE5B,MAAMC,gBAAgB;AACtB,MAAMC,4BAA4B,IAAIC,IAAI;IAAC;IAAQ;IAAQ;IAAQ;CAAO;AAE1E,MAAMC,4BAA4B,IAAID,IAAI;IACxC;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAID,OAAO,MAAME,yBAAyB,CAACC,WACrCF,0BAA0BG,GAAG,CAACD,UAAS;AAEzC,MAAME,uBAAuB,OAAOC,MAAcC;IAChD,IAAI,CAACC,OAAOC,aAAa,CAACH,SAASA,OAAO,IAAI;QAC5C,OAAO;IACT;IAEA,IAAII,WAAW;IACf,IAAIC,WAAW;IAEf,MAAOA,WAAWL,KAAM;QACtB,IAAI,EAAEI,WAAWZ,iBAAiBQ,OAAOK,WAAW,GAAG;YACrD,OAAO;QACT;QAEA,MAAMC,SAAS,MAAML,OAAOI,UAAUE,KAAKC,GAAG,CAAC,IAAIR,OAAOK;QAC1D,IAAIC,OAAOG,MAAM,GAAG,GAAG;YACrB,OAAO;QACT;QAEA,MAAMC,UAAUJ,OAAOK,QAAQ,CAAC,UAAU,GAAG;QAC7C,MAAMC,SAASN,OAAOO,YAAY,CAAC;QACnC,IAAIC;QACJ,IAAIC,aAAa;QAEjB,IAAIH,WAAW,GAAG;YAChBE,UAAUd,OAAOK;QACnB,OAAO,IAAIO,WAAW,GAAG;YACvB,IAAIN,OAAOG,MAAM,GAAG,IAAI;gBACtB,OAAO;YACT;YAEA,MAAMO,SAASV,OAAOW,eAAe,CAAC;YACtC,IAAID,SAASE,OAAOhB,OAAOiB,gBAAgB,GAAG;gBAC5C,OAAO;YACT;YAEAL,UAAUZ,OAAOc;YACjBD,aAAa;QACf,OAAO;YACLD,UAAUF;QACZ;QAEA,IAAIE,UAAUC,cAAcD,UAAUd,OAAOK,UAAU;YACrD,OAAO;QACT;QAEA,IAAIA,aAAa,KAAKK,YAAY,QAAQ;YACxC,MAAMU,cAAcN,UAAUC;YAC9B,IAAIH,WAAW,KAAKQ,cAAc,KAAK,AAACA,CAAAA,cAAc,CAAA,IAAK,MAAM,KAAKN,YAAYd,MAAM;gBACtF,OAAO;YACT;QACF,OAAO,IAAIK,aAAa,KAAK,CAACZ,0BAA0BK,GAAG,CAACY,UAAU;YACpE,OAAO;QACT;QAEAL,YAAYS;IACd;IAEA,OAAOT,aAAaL;AACtB;AAEA,OAAO,MAAMqB,6BAA6B,OAAOC,SAC/CvB,qBAAqBuB,OAAOb,MAAM,EAAE,CAACJ,UAAUI,SAC7Cc,QAAQC,OAAO,CAACF,OAAOG,QAAQ,CAACpB,UAAUA,WAAWI,UACtD;AAEH,OAAO,MAAMiB,2BAA2B,OAAOC;IAC7C,IAAIC;IAEJ,IAAI;QACFA,aAAa,MAAMrC,GAAGsC,IAAI,CAACF,UAAU;QACrC,MAAM,EAAE3B,IAAI,EAAE,GAAG,MAAM4B,WAAWE,IAAI;QAEtC,OAAO,MAAM/B,qBAAqBC,MAAM,OAAOK,UAAUI;YACvD,MAAMa,SAASS,OAAOC,WAAW,CAACvB;YAClC,MAAM,EAAEwB,SAAS,EAAE,GAAG,MAAML,WAAYM,IAAI,CAACZ,QAAQ,GAAGb,QAAQJ;YAChE,OAAOiB,OAAOG,QAAQ,CAAC,GAAGQ;QAC5B;IACF,EAAE,OAAM;QACN,OAAO;IACT,SAAU;QACR,MAAML,YAAYO;IACpB;AACF,EAAC"}

package/dist/uploads/validateSvg.d.ts

@@ -1,6 +1,12 @@
-/**
- * Validate SVG content for security vulnerabilities
- * Detects and blocks malicious patterns commonly used in SVG-based attacks
- */
+export type SvgInspection = {
+    isSafe: boolean;
+    isSvg: boolean;
+    isValid: boolean;
+};
+export declare function inspectSvg(buffer: Buffer): SvgInspection;
+export declare function inspectSvgFile(filePath: string, options?: {
+    highWaterMark?: number;
+}): Promise<SvgInspection>;
+/** Validate SVG content by parsing its XML structure and rejecting active content. */
 export declare function validateSvg(buffer: Buffer): boolean;
 //# sourceMappingURL=validateSvg.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validateSvg.d.ts","sourceRoot":"","sources":["../../src/uploads/validateSvg.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAqDnD"}
+{"version":3,"file":"validateSvg.d.ts","sourceRoot":"","sources":["../../src/uploads/validateSvg.ts"],"names":[],"mappings":"AAuEA,MAAM,MAAM,aAAa,GAAG;IAC1B,MAAM,EAAE,OAAO,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;CACjB,CAAA;AAmMD,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,CAiBxD;AAED,wBAAsB,cAAc,CAClC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,GACnC,OAAO,CAAC,aAAa,CAAC,CAiCxB;AAED,sFAAsF;AACtF,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnD"}