payload 4.0.0-internal.cd69eef → 4.0.0-internal.d1cc1d3

package/dist/uploads/probeImageSize.spec.js

@@ -0,0 +1,366 @@
+import { readFileSync } from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { describe, expect, it } from 'vitest';
+import { probeImageSize } from './probeImageSize.js';
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+const fixturesDir = path.resolve(dirname, '../../../../test/uploads');
+const readFixture = (name)=>readFileSync(path.join(fixturesDir, name));
+// Packs `{ length, value }` fields into a little-endian, LSB-first bitstream,
+// matching the JPEG XL `SizeHeader` bit layout.
+const packJXLBits = (fields)=>{
+    const bits = [];
+    for (const { length, value } of fields){
+        for(let i = 0; i < length; i++){
+            bits.push(value >> i & 1);
+        }
+    }
+    const bytes = Buffer.alloc(Math.ceil(bits.length / 8));
+    bits.forEach((bit, i)=>{
+        if (bit) {
+            bytes[Math.floor(i / 8)] |= 1 << i % 8;
+        }
+    });
+    return bytes;
+};
+// Encodes a non-small `SizeHeader` dimension: a 2-bit size class selecting
+// how many extra bits follow, then `value - 1` in that many bits.
+const packJXLDimension = (value)=>{
+    const n = value - 1;
+    const sizeClasses = [
+        9,
+        13,
+        18,
+        30
+    ];
+    const classIndex = sizeClasses.findIndex((extraBits)=>n < 2 ** extraBits);
+    return [
+        {
+            length: 2,
+            value: classIndex
+        },
+        {
+            length: sizeClasses[classIndex],
+            value: n
+        }
+    ];
+};
+const encodeJXLCodestream = (width, height)=>{
+    const body = packJXLBits([
+        {
+            length: 1,
+            value: 0
+        },
+        ...packJXLDimension(height),
+        {
+            length: 3,
+            value: 0
+        },
+        ...packJXLDimension(width)
+    ]);
+    return Buffer.concat([
+        Buffer.from([
+            0xff,
+            0x0a
+        ]),
+        body
+    ]);
+};
+const encodeSmallJXLCodestream = (width, height)=>{
+    const body = packJXLBits([
+        {
+            length: 1,
+            value: 1
+        },
+        {
+            length: 5,
+            value: height / 8 - 1
+        },
+        {
+            length: 3,
+            value: 0
+        },
+        {
+            length: 5,
+            value: width / 8 - 1
+        }
+    ]);
+    return Buffer.concat([
+        Buffer.from([
+            0xff,
+            0x0a
+        ]),
+        body
+    ]);
+};
+const jxlBox = (type, payload)=>{
+    const box = Buffer.alloc(8 + payload.length);
+    box.writeUInt32BE(box.length, 0);
+    box.write(type, 4, 'ascii');
+    payload.copy(box, 8);
+    return box;
+};
+// The fixed 12-byte JXL container signature box
+const jxlSignatureBox = Buffer.from([
+    0x00,
+    0x00,
+    0x00,
+    0x0c,
+    0x4a,
+    0x58,
+    0x4c,
+    0x20,
+    0x0d,
+    0x0a,
+    0x87,
+    0x0a
+]);
+const jxlFtypBox = jxlBox('ftyp', Buffer.concat([
+    Buffer.from('jxl '),
+    Buffer.alloc(4),
+    Buffer.from('jxl ')
+]));
+describe('probeImageSize', ()=>{
+    // Expected dimensions verified against the previous `image-size` implementation
+    const cases = [
+        {
+            file: 'test-image.png',
+            height: 800,
+            width: 800
+        },
+        {
+            file: 'small.png',
+            height: 80,
+            width: 320
+        },
+        {
+            file: 'image with spaces.png',
+            height: 1600,
+            width: 1600
+        },
+        {
+            file: 'test-image.jpg',
+            height: 800,
+            width: 800
+        },
+        {
+            file: 'test-image.tiff',
+            height: 100,
+            width: 200
+        },
+        {
+            file: 'image.svg',
+            height: 260,
+            width: 260
+        },
+        {
+            file: 'svgWithXml.svg',
+            height: 1,
+            width: 1
+        },
+        {
+            file: 'corrupt.svg',
+            height: 400,
+            width: 400
+        },
+        {
+            file: 'animated.webp',
+            height: 200,
+            width: 200
+        },
+        {
+            file: 'non-animated.webp',
+            height: 420,
+            width: 900
+        },
+        {
+            file: 'test-image-avif.avif',
+            height: 800,
+            width: 800
+        }
+    ];
+    it.each(cases)('should read dimensions for $file', ({ file, height, width })=>{
+        expect(probeImageSize(readFixture(file))).toEqual({
+            height,
+            width
+        });
+    });
+    it('should return the largest image for a HEIF file embedding a thumbnail', ()=>{
+        // Apple HEIC files place a small thumbnail `ispe` before the full-resolution
+        // primary `ispe` inside `ipco`; the primary (largest) must win.
+        const box = (type, payload)=>{
+            const b = Buffer.alloc(8 + payload.length);
+            b.writeUInt32BE(b.length, 0);
+            b.write(type, 4, 'ascii');
+            payload.copy(b, 8);
+            return b;
+        };
+        const ispe = (width, height)=>{
+            const payload = Buffer.alloc(12) // 4 bytes version/flags + width + height
+            ;
+            payload.writeUInt32BE(width, 4);
+            payload.writeUInt32BE(height, 8);
+            return box('ispe', payload);
+        };
+        const ipco = box('ipco', Buffer.concat([
+            ispe(80, 80),
+            ispe(400, 300)
+        ]));
+        const iprp = box('iprp', ipco);
+        const meta = box('meta', Buffer.concat([
+            Buffer.alloc(4),
+            iprp
+        ]));
+        const ftyp = box('ftyp', Buffer.from('avif    '));
+        const heif = Buffer.concat([
+            ftyp,
+            meta
+        ]);
+        expect(probeImageSize(heif)).toEqual({
+            height: 300,
+            width: 400
+        });
+    });
+    it('should throw on an unsupported file type', ()=>{
+        expect(()=>probeImageSize(Buffer.from('not an image'))).toThrow();
+    });
+    it('should read dimensions for a BMP file', ()=>{
+        const bmp = Buffer.alloc(54);
+        bmp.write('BM', 0, 'ascii');
+        bmp.writeUInt32LE(54, 10); // pixel data offset
+        bmp.writeUInt32LE(40, 14); // BITMAPINFOHEADER size
+        bmp.writeInt32LE(64, 18); // width
+        bmp.writeInt32LE(-48, 22); // height stored negative for a top-down bitmap
+        expect(probeImageSize(bmp)).toEqual({
+            height: 48,
+            width: 64
+        });
+    });
+    it('should read dimensions for an ICO file, picking the largest embedded image', ()=>{
+        const ico = Buffer.alloc(24);
+        ico.writeUInt16LE(1, 2); // type: 1 = icon
+        ico.writeUInt16LE(2, 4); // image count
+        ico[6] = 16; // entry 0: 16x16
+        ico[7] = 16;
+        ico[22] = 32; // entry 1: 32x32
+        ico[23] = 32;
+        expect(probeImageSize(ico)).toEqual({
+            height: 32,
+            width: 32
+        });
+    });
+    it('should read dimensions for a CUR file', ()=>{
+        const cur = Buffer.alloc(22);
+        cur.writeUInt16LE(2, 2); // type: 2 = cursor
+        cur.writeUInt16LE(1, 4); // image count
+        cur[6] = 24;
+        cur[7] = 24;
+        expect(probeImageSize(cur)).toEqual({
+            height: 24,
+            width: 24
+        });
+    });
+    it('should not hang on a malformed HEIF buffer with a zero-size box', ()=>{
+        // Reproduces the CVE-2025-71319 trigger: an ISO-BMFF box whose size field is
+        // zero inside a container would loop forever in the unpatched `image-size`.
+        const makeBox = (type, payload)=>{
+            const box = Buffer.alloc(8 + payload.length);
+            box.writeUInt32BE(box.length, 0);
+            box.write(type, 4, 'ascii');
+            payload.copy(box, 8);
+            return box;
+        };
+        const zeroSizeBox = Buffer.alloc(8);
+        zeroSizeBox.write('ipco', 4, 'ascii'); // size field left as 0
+        const meta = makeBox('meta', Buffer.concat([
+            Buffer.alloc(4),
+            zeroSizeBox
+        ]));
+        const ftyp = makeBox('ftyp', Buffer.from('avif    '));
+        const malformed = Buffer.concat([
+            ftyp,
+            meta
+        ]);
+        expect(()=>probeImageSize(malformed)).toThrow();
+    });
+    it('should read dimensions for a bare JPEG XL codestream', ()=>{
+        expect(probeImageSize(encodeJXLCodestream(1920, 1080))).toEqual({
+            height: 1080,
+            width: 1920
+        });
+    });
+    it('should read dimensions for a small bare JPEG XL codestream', ()=>{
+        expect(probeImageSize(encodeSmallJXLCodestream(64, 48))).toEqual({
+            height: 48,
+            width: 64
+        });
+    });
+    it('should read dimensions for a JPEG XL container with a single jxlc box', ()=>{
+        const jxlc = jxlBox('jxlc', encodeJXLCodestream(640, 480));
+        const container = Buffer.concat([
+            jxlSignatureBox,
+            jxlFtypBox,
+            jxlc
+        ]);
+        expect(probeImageSize(container)).toEqual({
+            height: 480,
+            width: 640
+        });
+    });
+    it('should reassemble a JPEG XL codestream split across jxlp boxes', ()=>{
+        const codestream = encodeJXLCodestream(800, 600);
+        const splitPoint = 3;
+        // Each jxlp payload is prefixed with a 4-byte partial-codestream index
+        const jxlp0 = jxlBox('jxlp', Buffer.concat([
+            Buffer.from([
+                0,
+                0,
+                0,
+                0
+            ]),
+            codestream.subarray(0, splitPoint)
+        ]));
+        const jxlp1 = jxlBox('jxlp', Buffer.concat([
+            Buffer.from([
+                0,
+                0,
+                0,
+                1
+            ]),
+            codestream.subarray(splitPoint)
+        ]));
+        const container = Buffer.concat([
+            jxlSignatureBox,
+            jxlFtypBox,
+            jxlp0,
+            jxlp1
+        ]);
+        expect(probeImageSize(container)).toEqual({
+            height: 600,
+            width: 800
+        });
+    });
+    it('should throw rather than hang on a JPEG XL container with a truncated jxlc box', ()=>{
+        const truncatedJxlc = Buffer.alloc(8);
+        truncatedJxlc.write('jxlc', 4, 'ascii'); // size field left as 0: extends to end of buffer, no payload left
+        const container = Buffer.concat([
+            jxlSignatureBox,
+            jxlFtypBox,
+            truncatedJxlc
+        ]);
+        expect(()=>probeImageSize(container)).toThrow();
+    });
+    it('should not hang on a JPEG XL container with thousands of unrelated boxes', ()=>{
+        const unrelatedBoxes = Buffer.concat(Array.from({
+            length: 5000
+        }, ()=>jxlBox('free', Buffer.alloc(0))));
+        const container = Buffer.concat([
+            jxlSignatureBox,
+            jxlFtypBox,
+            unrelatedBoxes
+        ]);
+        expect(()=>probeImageSize(container)).toThrow();
+    });
+});
+
+//# sourceMappingURL=probeImageSize.spec.js.map

package/dist/uploads/probeImageSize.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/probeImageSize.spec.ts"],"sourcesContent":["import { readFileSync } from 'fs'\nimport path from 'path'\nimport { fileURLToPath } from 'url'\nimport { describe, expect, it } from 'vitest'\n\nimport { probeImageSize } from './probeImageSize.js'\n\nconst dirname = path.dirname(fileURLToPath(import.meta.url))\nconst fixturesDir = path.resolve(dirname, '../../../../test/uploads')\n\nconst readFixture = (name: string) => readFileSync(path.join(fixturesDir, name))\n\n// Packs `{ length, value }` fields into a little-endian, LSB-first bitstream,\n// matching the JPEG XL `SizeHeader` bit layout.\nconst packJXLBits = (fields: Array<{ length: number; value: number }>): Buffer => {\n  const bits: number[] = []\n  for (const { length, value } of fields) {\n    for (let i = 0; i < length; i++) {\n      bits.push((value >> i) & 1)\n    }\n  }\n\n  const bytes = Buffer.alloc(Math.ceil(bits.length / 8))\n  bits.forEach((bit, i) => {\n    if (bit) {\n      bytes[Math.floor(i / 8)]! |= 1 << i % 8\n    }\n  })\n\n  return bytes\n}\n\n// Encodes a non-small `SizeHeader` dimension: a 2-bit size class selecting\n// how many extra bits follow, then `value - 1` in that many bits.\nconst packJXLDimension = (value: number): Array<{ length: number; value: number }> => {\n  const n = value - 1\n  const sizeClasses = [9, 13, 18, 30]\n  const classIndex = sizeClasses.findIndex((extraBits) => n < 2 ** extraBits)\n\n  return [\n    { length: 2, value: classIndex },\n    { length: sizeClasses[classIndex]!, value: n },\n  ]\n}\n\nconst encodeJXLCodestream = (width: number, height: number): Buffer => {\n  const body = packJXLBits([\n    { length: 1, value: 0 }, // isSmallImage = false\n    ...packJXLDimension(height),\n    { length: 3, value: 0 }, // widthMode = 0 (explicit dimension)\n    ...packJXLDimension(width),\n  ])\n\n  return Buffer.concat([Buffer.from([0xff, 0x0a]), body])\n}\n\nconst encodeSmallJXLCodestream = (width: number, height: number): Buffer => {\n  const body = packJXLBits([\n    { length: 1, value: 1 }, // isSmallImage = true\n    { length: 5, value: height / 8 - 1 },\n    { length: 3, value: 0 }, // widthMode = 0 (explicit dimension)\n    { length: 5, value: width / 8 - 1 },\n  ])\n\n  return Buffer.concat([Buffer.from([0xff, 0x0a]), body])\n}\n\nconst jxlBox = (type: string, payload: Buffer): Buffer => {\n  const box = Buffer.alloc(8 + payload.length)\n  box.writeUInt32BE(box.length, 0)\n  box.write(type, 4, 'ascii')\n  payload.copy(box, 8)\n  return box\n}\n\n// The fixed 12-byte JXL container signature box\nconst jxlSignatureBox = Buffer.from([\n  0x00, 0x00, 0x00, 0x0c, 0x4a, 0x58, 0x4c, 0x20, 0x0d, 0x0a, 0x87, 0x0a,\n])\nconst jxlFtypBox = jxlBox(\n  'ftyp',\n  Buffer.concat([Buffer.from('jxl '), Buffer.alloc(4), Buffer.from('jxl ')]),\n)\n\ndescribe('probeImageSize', () => {\n  // Expected dimensions verified against the previous `image-size` implementation\n  const cases: Array<{ file: string; height: number; width: number }> = [\n    { file: 'test-image.png', height: 800, width: 800 },\n    { file: 'small.png', height: 80, width: 320 },\n    { file: 'image with spaces.png', height: 1600, width: 1600 },\n    { file: 'test-image.jpg', height: 800, width: 800 },\n    { file: 'test-image.tiff', height: 100, width: 200 },\n    { file: 'image.svg', height: 260, width: 260 },\n    { file: 'svgWithXml.svg', height: 1, width: 1 },\n    { file: 'corrupt.svg', height: 400, width: 400 },\n    { file: 'animated.webp', height: 200, width: 200 },\n    { file: 'non-animated.webp', height: 420, width: 900 },\n    { file: 'test-image-avif.avif', height: 800, width: 800 },\n  ]\n\n  it.each(cases)('should read dimensions for $file', ({ file, height, width }) => {\n    expect(probeImageSize(readFixture(file))).toEqual({ height, width })\n  })\n\n  it('should return the largest image for a HEIF file embedding a thumbnail', () => {\n    // Apple HEIC files place a small thumbnail `ispe` before the full-resolution\n    // primary `ispe` inside `ipco`; the primary (largest) must win.\n    const box = (type: string, payload: Buffer) => {\n      const b = Buffer.alloc(8 + payload.length)\n      b.writeUInt32BE(b.length, 0)\n      b.write(type, 4, 'ascii')\n      payload.copy(b, 8)\n      return b\n    }\n    const ispe = (width: number, height: number) => {\n      const payload = Buffer.alloc(12) // 4 bytes version/flags + width + height\n      payload.writeUInt32BE(width, 4)\n      payload.writeUInt32BE(height, 8)\n      return box('ispe', payload)\n    }\n    const ipco = box('ipco', Buffer.concat([ispe(80, 80), ispe(400, 300)]))\n    const iprp = box('iprp', ipco)\n    const meta = box('meta', Buffer.concat([Buffer.alloc(4), iprp]))\n    const ftyp = box('ftyp', Buffer.from('avif    '))\n    const heif = Buffer.concat([ftyp, meta])\n\n    expect(probeImageSize(heif)).toEqual({ height: 300, width: 400 })\n  })\n\n  it('should throw on an unsupported file type', () => {\n    expect(() => probeImageSize(Buffer.from('not an image'))).toThrow()\n  })\n\n  it('should read dimensions for a BMP file', () => {\n    const bmp = Buffer.alloc(54)\n    bmp.write('BM', 0, 'ascii')\n    bmp.writeUInt32LE(54, 10) // pixel data offset\n    bmp.writeUInt32LE(40, 14) // BITMAPINFOHEADER size\n    bmp.writeInt32LE(64, 18) // width\n    bmp.writeInt32LE(-48, 22) // height stored negative for a top-down bitmap\n\n    expect(probeImageSize(bmp)).toEqual({ height: 48, width: 64 })\n  })\n\n  it('should read dimensions for an ICO file, picking the largest embedded image', () => {\n    const ico = Buffer.alloc(24)\n    ico.writeUInt16LE(1, 2) // type: 1 = icon\n    ico.writeUInt16LE(2, 4) // image count\n    ico[6] = 16 // entry 0: 16x16\n    ico[7] = 16\n    ico[22] = 32 // entry 1: 32x32\n    ico[23] = 32\n\n    expect(probeImageSize(ico)).toEqual({ height: 32, width: 32 })\n  })\n\n  it('should read dimensions for a CUR file', () => {\n    const cur = Buffer.alloc(22)\n    cur.writeUInt16LE(2, 2) // type: 2 = cursor\n    cur.writeUInt16LE(1, 4) // image count\n    cur[6] = 24\n    cur[7] = 24\n\n    expect(probeImageSize(cur)).toEqual({ height: 24, width: 24 })\n  })\n\n  it('should not hang on a malformed HEIF buffer with a zero-size box', () => {\n    // Reproduces the CVE-2025-71319 trigger: an ISO-BMFF box whose size field is\n    // zero inside a container would loop forever in the unpatched `image-size`.\n    const makeBox = (type: string, payload: Buffer) => {\n      const box = Buffer.alloc(8 + payload.length)\n      box.writeUInt32BE(box.length, 0)\n      box.write(type, 4, 'ascii')\n      payload.copy(box, 8)\n      return box\n    }\n    const zeroSizeBox = Buffer.alloc(8)\n    zeroSizeBox.write('ipco', 4, 'ascii') // size field left as 0\n    const meta = makeBox('meta', Buffer.concat([Buffer.alloc(4), zeroSizeBox]))\n    const ftyp = makeBox('ftyp', Buffer.from('avif    '))\n    const malformed = Buffer.concat([ftyp, meta])\n\n    expect(() => probeImageSize(malformed)).toThrow()\n  })\n\n  it('should read dimensions for a bare JPEG XL codestream', () => {\n    expect(probeImageSize(encodeJXLCodestream(1920, 1080))).toEqual({ height: 1080, width: 1920 })\n  })\n\n  it('should read dimensions for a small bare JPEG XL codestream', () => {\n    expect(probeImageSize(encodeSmallJXLCodestream(64, 48))).toEqual({ height: 48, width: 64 })\n  })\n\n  it('should read dimensions for a JPEG XL container with a single jxlc box', () => {\n    const jxlc = jxlBox('jxlc', encodeJXLCodestream(640, 480))\n    const container = Buffer.concat([jxlSignatureBox, jxlFtypBox, jxlc])\n\n    expect(probeImageSize(container)).toEqual({ height: 480, width: 640 })\n  })\n\n  it('should reassemble a JPEG XL codestream split across jxlp boxes', () => {\n    const codestream = encodeJXLCodestream(800, 600)\n    const splitPoint = 3\n    // Each jxlp payload is prefixed with a 4-byte partial-codestream index\n    const jxlp0 = jxlBox(\n      'jxlp',\n      Buffer.concat([Buffer.from([0, 0, 0, 0]), codestream.subarray(0, splitPoint)]),\n    )\n    const jxlp1 = jxlBox(\n      'jxlp',\n      Buffer.concat([Buffer.from([0, 0, 0, 1]), codestream.subarray(splitPoint)]),\n    )\n    const container = Buffer.concat([jxlSignatureBox, jxlFtypBox, jxlp0, jxlp1])\n\n    expect(probeImageSize(container)).toEqual({ height: 600, width: 800 })\n  })\n\n  it('should throw rather than hang on a JPEG XL container with a truncated jxlc box', () => {\n    const truncatedJxlc = Buffer.alloc(8)\n    truncatedJxlc.write('jxlc', 4, 'ascii') // size field left as 0: extends to end of buffer, no payload left\n    const container = Buffer.concat([jxlSignatureBox, jxlFtypBox, truncatedJxlc])\n\n    expect(() => probeImageSize(container)).toThrow()\n  })\n\n  it('should not hang on a JPEG XL container with thousands of unrelated boxes', () => {\n    const unrelatedBoxes = Buffer.concat(\n      Array.from({ length: 5000 }, () => jxlBox('free', Buffer.alloc(0))),\n    )\n    const container = Buffer.concat([jxlSignatureBox, jxlFtypBox, unrelatedBoxes])\n\n    expect(() => probeImageSize(container)).toThrow()\n  })\n})\n"],"names":["readFileSync","path","fileURLToPath","describe","expect","it","probeImageSize","dirname","url","fixturesDir","resolve","readFixture","name","join","packJXLBits","fields","bits","length","value","i","push","bytes","Buffer","alloc","Math","ceil","forEach","bit","floor","packJXLDimension","n","sizeClasses","classIndex","findIndex","extraBits","encodeJXLCodestream","width","height","body","concat","from","encodeSmallJXLCodestream","jxlBox","type","payload","box","writeUInt32BE","write","copy","jxlSignatureBox","jxlFtypBox","cases","file","each","toEqual","b","ispe","ipco","iprp","meta","ftyp","heif","toThrow","bmp","writeUInt32LE","writeInt32LE","ico","writeUInt16LE","cur","makeBox","zeroSizeBox","malformed","jxlc","container","codestream","splitPoint","jxlp0","subarray","jxlp1","truncatedJxlc","unrelatedBoxes","Array"],"mappings":"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"}

package/dist/uploads/stagedUpload.d.ts

@@ -0,0 +1,27 @@
+import type { PayloadHandler } from '../config/types.js';
+import type { PayloadRequest } from '../types/index.js';
+import type { File, UploadInstructions, UploadInstructionsRequest } from './types.js';
+/**
+ * Creates a signed, one-hour URL where the client can send the file bytes. The returned file value
+ * is later passed to a document create or update request.
+ */
+export declare const generateStagedUploadInstructions: ({ collectionSlug, docPrefix, filename, filesize, mimeType, req, }: {
+    req: PayloadRequest;
+} & UploadInstructionsRequest) => Promise<UploadInstructions>;
+/**
+ * Saves the bytes sent to a signed upload URL. The file is written as a partial file first and only
+ * becomes available when its size exactly matches the size in the upload ID.
+ */
+export declare const uploadStagedFile: PayloadHandler;
+/** Removes a temporary upload that the client no longer needs. */
+export declare const deleteStagedFile: PayloadHandler;
+/**
+ * Loads a completed staged file for a document request. Only the same user and collection can use
+ * it, and the temporary file is deleted after it is read.
+ */
+export declare const getStagedFile: ({ collectionSlug, req, uploadReference, }: {
+    collectionSlug: string;
+    req: PayloadRequest;
+    uploadReference: unknown;
+}) => Promise<File>;
+//# sourceMappingURL=stagedUpload.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stagedUpload.d.ts","sourceRoot":"","sources":["../../src/uploads/stagedUpload.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACvD,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAOrF;;;GAGG;AACH,eAAO,MAAM,gCAAgC,sEAO1C;IAAE,GAAG,EAAE,cAAc,CAAA;CAAE,GAAG,yBAAyB,KAAG,OAAO,CAAC,kBAAkB,CAsClF,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,cA0D9B,CAAA;AAED,kEAAkE;AAClE,eAAO,MAAM,gBAAgB,EAAE,cAO9B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,8CAIvB;IACD,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,EAAE,cAAc,CAAA;IACnB,eAAe,EAAE,OAAO,CAAA;CACzB,KAAG,OAAO,CAAC,IAAI,CAyCf,CAAA"}

package/dist/uploads/stagedUpload.js

@@ -0,0 +1,197 @@
+import { jwtVerify } from 'jose';
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { jwtSign } from '../auth/jwt.js';
+import { APIError, Forbidden } from '../errors/index.js';
+import { formatAdminURL } from '../utilities/formatAdminURL.js';
+import { checkFileRestrictions } from './checkFileRestrictions.js';
+/**
+ * Creates a signed, one-hour URL where the client can send the file bytes. The returned file value
+ * is later passed to a document create or update request.
+ */ export const generateStagedUploadInstructions = async ({ collectionSlug, docPrefix, filename, filesize, mimeType, req })=>{
+    await removeExpiredUploads(req, collectionSlug);
+    const { token: uploadId } = await jwtSign({
+        fieldsToSign: {
+            id: randomUUID(),
+            collectionSlug,
+            docPrefix,
+            filename,
+            filesize,
+            mimeType,
+            user: getUser(req)
+        },
+        secret: req.payload.secret,
+        tokenExpiration
+    });
+    return {
+        type: 'http',
+        file: {
+            filename,
+            mimeType,
+            size: filesize,
+            uploadReference: {
+                uploadId
+            }
+        },
+        request: {
+            headers: {
+                'Content-Length': String(filesize),
+                'Content-Type': mimeType
+            },
+            method: 'PUT',
+            url: formatAdminURL({
+                apiRoute: req.payload.config.routes.api,
+                path: `/upload-instructions/${uploadId}`,
+                serverURL: req.payload.config.serverURL
+            })
+        }
+    };
+};
+/**
+ * Saves the bytes sent to a signed upload URL. The file is written as a partial file first and only
+ * becomes available when its size exactly matches the size in the upload ID.
+ */ export const uploadStagedFile = async (req)=>{
+    const upload = await verifyUploadID(req, req.routeParams?.uploadId);
+    const directory = await getUploadDirectory(req, upload.collectionSlug);
+    const uploadPath = path.join(directory, upload.id);
+    const temporaryPath = `${uploadPath}.${randomUUID()}.part`;
+    const file = await fs.open(temporaryPath, 'wx');
+    let uploadedSize = 0;
+    try {
+        try {
+            const reader = req.body?.getReader();
+            while(reader){
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                uploadedSize += value.byteLength;
+                if (uploadedSize > upload.filesize) {
+                    throw new APIError('Uploaded file is larger than expected.', 400);
+                }
+                let offset = 0;
+                while(offset < value.byteLength){
+                    const { bytesWritten } = await file.write(value, offset);
+                    offset += bytesWritten;
+                }
+            }
+            if (uploadedSize !== upload.filesize) {
+                throw new APIError('Uploaded file size does not match the expected size.', 400);
+            }
+        } finally{
+            await file.close();
+        }
+        const collection = req.payload.collections[upload.collectionSlug].config;
+        await checkFileRestrictions({
+            collection,
+            file: {
+                name: upload.filename,
+                data: Buffer.alloc(0),
+                mimetype: upload.mimeType,
+                size: upload.filesize,
+                tempFilePath: temporaryPath
+            },
+            req
+        });
+        await fs.rename(temporaryPath, uploadPath);
+    } catch (error) {
+        await fs.rm(temporaryPath, {
+            force: true
+        });
+        throw error;
+    }
+    return new Response(null, {
+        status: 204
+    });
+};
+/** Removes a temporary upload that the client no longer needs. */ export const deleteStagedFile = async (req)=>{
+    const upload = await verifyUploadID(req, req.routeParams?.uploadId);
+    const directory = await getUploadDirectory(req, upload.collectionSlug);
+    await fs.rm(path.join(directory, upload.id), {
+        force: true
+    });
+    return new Response(null, {
+        status: 204
+    });
+};
+/**
+ * Loads a completed staged file for a document request. Only the same user and collection can use
+ * it, and the temporary file is deleted after it is read.
+ */ export const getStagedFile = async ({ collectionSlug, req, uploadReference })=>{
+    if (!uploadReference || typeof uploadReference !== 'object' || Array.isArray(uploadReference) || !('uploadId' in uploadReference) || typeof uploadReference.uploadId !== 'string') {
+        throw new APIError('Invalid staged upload.', 400);
+    }
+    const { uploadId } = uploadReference;
+    const upload = await verifyUploadID(req, uploadId);
+    if (upload.collectionSlug !== collectionSlug || upload.user !== getUser(req)) {
+        throw new Forbidden(req.t);
+    }
+    const directory = await getUploadDirectory(req, upload.collectionSlug);
+    const tempFilePath = path.join(directory, upload.id);
+    let data;
+    try {
+        data = await fs.readFile(tempFilePath);
+    } catch  {
+        throw new APIError('Staged upload was not found.', 400);
+    }
+    if (data.length !== upload.filesize) {
+        await fs.rm(tempFilePath, {
+            force: true
+        });
+        throw new APIError('Staged upload is incomplete.', 400);
+    }
+    await fs.rm(tempFilePath, {
+        force: true
+    });
+    return {
+        name: upload.filename,
+        data,
+        mimetype: upload.mimeType,
+        size: data.length
+    };
+};
+/**
+ * Staged uploads hold a file temporarily until a document create or update uses it. The signed
+ * upload ID remembers which file and user the upload belongs to.
+ */ const tokenExpiration = 60 * 60;
+const getUser = (req)=>req.user ? `${req.user.collection}:${String(req.user.id)}` : null;
+/** Returns the hidden folder where temporary uploads for this collection are stored. */ const getUploadDirectory = async (req, collectionSlug)=>{
+    const upload = req.payload.collections[collectionSlug]?.config.upload;
+    const directory = path.resolve(upload && !upload.disableLocalStorage ? upload.staticDir || collectionSlug : req.payload.config.upload.tempFileDir || os.tmpdir(), '.payload-staged-uploads');
+    await fs.mkdir(directory, {
+        recursive: true
+    });
+    return directory;
+};
+/** Removes temporary files older than the one-hour upload window. */ const removeExpiredUploads = async (req, collectionSlug)=>{
+    const directory = await getUploadDirectory(req, collectionSlug);
+    const expiresBefore = Date.now() - tokenExpiration * 1000;
+    for (const filename of (await fs.readdir(directory))){
+        const filePath = path.join(directory, filename);
+        const stats = await fs.stat(filePath).catch(()=>null);
+        if (stats && stats.mtimeMs < expiresBefore) {
+            await fs.rm(filePath, {
+                force: true
+            });
+        }
+    }
+};
+/** Verifies that an upload ID was signed by Payload, has not expired, and contains valid details. */ const verifyUploadID = async (req, uploadID)=>{
+    try {
+        if (typeof uploadID !== 'string') {
+            throw new Error();
+        }
+        const secret = new TextEncoder().encode(req.payload.secret);
+        const { payload } = await jwtVerify(uploadID, secret);
+        if (typeof payload.id !== 'string' || !/^[\da-f-]{36}$/i.test(payload.id) || typeof payload.collectionSlug !== 'string' || typeof payload.filename !== 'string' || !Number.isSafeInteger(payload.filesize) || payload.filesize < 0 || typeof payload.mimeType !== 'string' || payload.user !== null && typeof payload.user !== 'string') {
+            throw new Error();
+        }
+        return payload;
+    } catch  {
+        throw new APIError('Invalid or expired staged upload.', 400);
+    }
+};
+
+//# sourceMappingURL=stagedUpload.js.map

package/dist/uploads/stagedUpload.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/uploads/stagedUpload.ts"],"sourcesContent":["import { jwtVerify } from 'jose'\nimport { randomUUID } from 'node:crypto'\nimport fs from 'node:fs/promises'\nimport os from 'node:os'\nimport path from 'node:path'\n\nimport type { PayloadHandler } from '../config/types.js'\nimport type { PayloadRequest } from '../types/index.js'\nimport type { File, UploadInstructions, UploadInstructionsRequest } from './types.js'\n\nimport { jwtSign } from '../auth/jwt.js'\nimport { APIError, Forbidden } from '../errors/index.js'\nimport { formatAdminURL } from '../utilities/formatAdminURL.js'\nimport { checkFileRestrictions } from './checkFileRestrictions.js'\n\n/**\n * Creates a signed, one-hour URL where the client can send the file bytes. The returned file value\n * is later passed to a document create or update request.\n */\nexport const generateStagedUploadInstructions = async ({\n  collectionSlug,\n  docPrefix,\n  filename,\n  filesize,\n  mimeType,\n  req,\n}: { req: PayloadRequest } & UploadInstructionsRequest): Promise<UploadInstructions> => {\n  await removeExpiredUploads(req, collectionSlug)\n\n  const { token: uploadId } = await jwtSign({\n    fieldsToSign: {\n      id: randomUUID(),\n      collectionSlug,\n      docPrefix,\n      filename,\n      filesize,\n      mimeType,\n      user: getUser(req),\n    },\n    secret: req.payload.secret,\n    tokenExpiration,\n  })\n\n  return {\n    type: 'http',\n    file: {\n      filename,\n      mimeType,\n      size: filesize,\n      uploadReference: { uploadId },\n    },\n    request: {\n      headers: {\n        'Content-Length': String(filesize),\n        'Content-Type': mimeType,\n      },\n      method: 'PUT',\n      url: formatAdminURL({\n        apiRoute: req.payload.config.routes.api,\n        path: `/upload-instructions/${uploadId}`,\n        serverURL: req.payload.config.serverURL,\n      }),\n    },\n  }\n}\n\n/**\n * Saves the bytes sent to a signed upload URL. The file is written as a partial file first and only\n * becomes available when its size exactly matches the size in the upload ID.\n */\nexport const uploadStagedFile: PayloadHandler = async (req) => {\n  const upload = await verifyUploadID(req, req.routeParams?.uploadId)\n  const directory = await getUploadDirectory(req, upload.collectionSlug)\n  const uploadPath = path.join(directory, upload.id)\n  const temporaryPath = `${uploadPath}.${randomUUID()}.part`\n  const file = await fs.open(temporaryPath, 'wx')\n  let uploadedSize = 0\n\n  try {\n    try {\n      const reader = req.body?.getReader()\n\n      while (reader) {\n        const { done, value } = await reader.read()\n\n        if (done) {\n          break\n        }\n\n        uploadedSize += value.byteLength\n        if (uploadedSize > upload.filesize) {\n          throw new APIError('Uploaded file is larger than expected.', 400)\n        }\n\n        let offset = 0\n        while (offset < value.byteLength) {\n          const { bytesWritten } = await file.write(value, offset)\n          offset += bytesWritten\n        }\n      }\n\n      if (uploadedSize !== upload.filesize) {\n        throw new APIError('Uploaded file size does not match the expected size.', 400)\n      }\n    } finally {\n      await file.close()\n    }\n\n    const collection = req.payload.collections[upload.collectionSlug]!.config\n    await checkFileRestrictions({\n      collection,\n      file: {\n        name: upload.filename,\n        data: Buffer.alloc(0),\n        mimetype: upload.mimeType,\n        size: upload.filesize,\n        tempFilePath: temporaryPath,\n      },\n      req,\n    })\n\n    await fs.rename(temporaryPath, uploadPath)\n  } catch (error) {\n    await fs.rm(temporaryPath, { force: true })\n    throw error\n  }\n\n  return new Response(null, { status: 204 })\n}\n\n/** Removes a temporary upload that the client no longer needs. */\nexport const deleteStagedFile: PayloadHandler = async (req) => {\n  const upload = await verifyUploadID(req, req.routeParams?.uploadId)\n  const directory = await getUploadDirectory(req, upload.collectionSlug)\n\n  await fs.rm(path.join(directory, upload.id), { force: true })\n\n  return new Response(null, { status: 204 })\n}\n\n/**\n * Loads a completed staged file for a document request. Only the same user and collection can use\n * it, and the temporary file is deleted after it is read.\n */\nexport const getStagedFile = async ({\n  collectionSlug,\n  req,\n  uploadReference,\n}: {\n  collectionSlug: string\n  req: PayloadRequest\n  uploadReference: unknown\n}): Promise<File> => {\n  if (\n    !uploadReference ||\n    typeof uploadReference !== 'object' ||\n    Array.isArray(uploadReference) ||\n    !('uploadId' in uploadReference) ||\n    typeof uploadReference.uploadId !== 'string'\n  ) {\n    throw new APIError('Invalid staged upload.', 400)\n  }\n\n  const { uploadId } = uploadReference\n  const upload = await verifyUploadID(req, uploadId)\n\n  if (upload.collectionSlug !== collectionSlug || upload.user !== getUser(req)) {\n    throw new Forbidden(req.t)\n  }\n\n  const directory = await getUploadDirectory(req, upload.collectionSlug)\n  const tempFilePath = path.join(directory, upload.id)\n  let data: Buffer\n\n  try {\n    data = await fs.readFile(tempFilePath)\n  } catch {\n    throw new APIError('Staged upload was not found.', 400)\n  }\n\n  if (data.length !== upload.filesize) {\n    await fs.rm(tempFilePath, { force: true })\n    throw new APIError('Staged upload is incomplete.', 400)\n  }\n\n  await fs.rm(tempFilePath, { force: true })\n\n  return {\n    name: upload.filename,\n    data,\n    mimetype: upload.mimeType,\n    size: data.length,\n  }\n}\n\n/**\n * Staged uploads hold a file temporarily until a document create or update uses it. The signed\n * upload ID remembers which file and user the upload belongs to.\n */\nconst tokenExpiration = 60 * 60\n\n/** The file details stored inside the signed upload ID. */\ntype StagedUploadToken = {\n  id: string\n  user: null | string\n} & UploadInstructionsRequest\n\nconst getUser = (req: PayloadRequest) =>\n  req.user ? `${req.user.collection}:${String(req.user.id)}` : null\n\n/** Returns the hidden folder where temporary uploads for this collection are stored. */\nconst getUploadDirectory = async (req: PayloadRequest, collectionSlug: string) => {\n  const upload = req.payload.collections[collectionSlug]?.config.upload\n  const directory = path.resolve(\n    upload && !upload.disableLocalStorage\n      ? upload.staticDir || collectionSlug\n      : req.payload.config.upload.tempFileDir || os.tmpdir(),\n    '.payload-staged-uploads',\n  )\n\n  await fs.mkdir(directory, { recursive: true })\n\n  return directory\n}\n\n/** Removes temporary files older than the one-hour upload window. */\nconst removeExpiredUploads = async (req: PayloadRequest, collectionSlug: string) => {\n  const directory = await getUploadDirectory(req, collectionSlug)\n  const expiresBefore = Date.now() - tokenExpiration * 1000\n\n  for (const filename of await fs.readdir(directory)) {\n    const filePath = path.join(directory, filename)\n    const stats = await fs.stat(filePath).catch(() => null)\n\n    if (stats && stats.mtimeMs < expiresBefore) {\n      await fs.rm(filePath, { force: true })\n    }\n  }\n}\n\n/** Verifies that an upload ID was signed by Payload, has not expired, and contains valid details. */\nconst verifyUploadID = async (\n  req: PayloadRequest,\n  uploadID: unknown,\n): Promise<StagedUploadToken> => {\n  try {\n    if (typeof uploadID !== 'string') {\n      throw new Error()\n    }\n\n    const secret = new TextEncoder().encode(req.payload.secret)\n    const { payload } = await jwtVerify<StagedUploadToken>(uploadID, secret)\n\n    if (\n      typeof payload.id !== 'string' ||\n      !/^[\\da-f-]{36}$/i.test(payload.id) ||\n      typeof payload.collectionSlug !== 'string' ||\n      typeof payload.filename !== 'string' ||\n      !Number.isSafeInteger(payload.filesize) ||\n      payload.filesize < 0 ||\n      typeof payload.mimeType !== 'string' ||\n      (payload.user !== null && typeof payload.user !== 'string')\n    ) {\n      throw new Error()\n    }\n\n    return payload as StagedUploadToken\n  } catch {\n    throw new APIError('Invalid or expired staged upload.', 400)\n  }\n}\n"],"names":["jwtVerify","randomUUID","fs","os","path","jwtSign","APIError","Forbidden","formatAdminURL","checkFileRestrictions","generateStagedUploadInstructions","collectionSlug","docPrefix","filename","filesize","mimeType","req","removeExpiredUploads","token","uploadId","fieldsToSign","id","user","getUser","secret","payload","tokenExpiration","type","file","size","uploadReference","request","headers","String","method","url","apiRoute","config","routes","api","serverURL","uploadStagedFile","upload","verifyUploadID","routeParams","directory","getUploadDirectory","uploadPath","join","temporaryPath","open","uploadedSize","reader","body","getReader","done","value","read","byteLength","offset","bytesWritten","write","close","collection","collections","name","data","Buffer","alloc","mimetype","tempFilePath","rename","error","rm","force","Response","status","deleteStagedFile","getStagedFile","Array","isArray","t","readFile","length","resolve","disableLocalStorage","staticDir","tempFileDir","tmpdir","mkdir","recursive","expiresBefore","Date","now","readdir","filePath","stats","stat","catch","mtimeMs","uploadID","Error","TextEncoder","encode","test","Number","isSafeInteger"],"mappings":"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"}