payload 4.0.0-internal.4cbdd50 → 4.0.0-internal.4e1f822

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/safeFetch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safeFetch.d.ts","sourceRoot":"","sources":["../../src/uploads/safeFetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EAAS,KAAK,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAErC,CAAA;AAsDD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,GAAU,GAAG,MAAM,UAAU,CAAC,OAAO,WAAW,CAAC,KAAG,OAAO,CAAC,QAAQ,CA4CzF,CAAA"}
+{"version":3,"file":"safeFetch.d.ts","sourceRoot":"","sources":["../../src/uploads/safeFetch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAA;AAE5B,OAAO,EAAS,KAAK,IAAI,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEpD;;GAEG;AACH,eAAO,MAAM,yBAAyB;;CAErC,CAAA;AAsDD;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,YAAmB,UAAU,CAAC,OAAO,WAAW,CAAC,KAAG,OAAO,CAAC,QAAQ,CA4CzF,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"saveBufferToFile.d.ts","sourceRoot":"","sources":["../../src/uploads/saveBufferToFile.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAU,QAAQ,MAAM,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,IAAI,CAUrF,CAAA"}
+{"version":3,"file":"saveBufferToFile.d.ts","sourceRoot":"","sources":["../../src/uploads/saveBufferToFile.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,WAAkB,MAAM,YAAY,MAAM,KAAG,OAAO,CAAC,IAAI,CAUrF,CAAA"}

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