payload 4.0.0-internal.cd69eef → 4.0.0-internal.ce66a41

package/dist/uploads/endpoints/{getFileFromURL.js → pasteURL.js}

@@ -2,14 +2,14 @@ import { executeAccess } from '../../auth/executeAccess.js';
 import { APIError } from '../../errors/APIError.js';
 import { Forbidden } from '../../errors/Forbidden.js';
 import { getRequestCollectionWithID } from '../../utilities/getRequestEntity.js';
-import { isURLAllowed } from '../../utilities/isURLAllowed.js';
 import { sanitizeFilename } from '../../utilities/sanitizeFilename.js';
-import { safeFetch } from '../safeFetch.js';
+import { fetchWithRedirects } from '../fetchWithRedirects.js';
+import { validateUploadURL } from '../validateUploadURL.js';
 // If doc id is provided, it means we are updating the doc
 // /:collectionSlug/paste-url/:doc-id?src=:fileUrl
 // If doc id is not provided, it means we are creating a new doc
 // /:collectionSlug/paste-url?src=:fileUrl
-export const getFileFromURLHandler = async (req)=>{
+export const pasteURLHandler = async (req)=>{
     const { id, collection } = getRequestCollectionWithID(req, {
         optionalID: true
     });
@@ -17,12 +17,10 @@ export const getFileFromURLHandler = async (req)=>{
         throw new Forbidden(req.t);
     }
     const config = collection?.config;
-    if (!config.upload?.pasteURL) {
-        throw new APIError('Pasting from URL is not enabled for this collection.', 400);
-    }
     if (id) {
         // updating doc
         const accessResult = await executeAccess({
+            slug: config.slug,
             req
         }, config.access.update);
         if (!accessResult) {
@@ -31,6 +29,7 @@ export const getFileFromURLHandler = async (req)=>{
     } else {
         // creating doc
         const accessResult = await executeAccess({
+            slug: config.slug,
             req
         }, config.access?.create);
         if (!accessResult) {
@@ -45,57 +44,22 @@ export const getFileFromURLHandler = async (req)=>{
     if (!src || typeof src !== 'string') {
         throw new APIError('A valid URL string is required.', 400);
     }
-    const hasAllowList = typeof config.upload.pasteURL === 'object' && Array.isArray(config.upload.pasteURL.allowList);
-    let fileURL;
-    try {
-        fileURL = new URL(src).href;
-    } catch  {
-        throw new APIError('A valid URL string is required.', 400);
-    }
-    if (hasAllowList && !isURLAllowed(fileURL, config.upload.pasteURL.allowList)) {
-        throw new APIError('The provided URL is not allowed.', 400);
-    }
-    let redirectCount = 0;
-    const maxRedirects = 3;
-    let response;
-    while(true){
-        if (hasAllowList && isURLAllowed(fileURL, config.upload.pasteURL.allowList)) {
-            // Allow-listed URLs bypass SSRF filtering (e.g. internal/localhost CDNs)
-            response = await fetch(fileURL, {
-                headers: {
-                    'Accept-Encoding': 'identity'
-                },
-                redirect: 'manual',
-                signal: AbortSignal.timeout(30_000)
-            });
-        } else {
-            response = await safeFetch(fileURL, {
-                headers: {
-                    'Accept-Encoding': 'identity'
-                },
-                signal: AbortSignal.timeout(30_000)
-            });
-        }
-        if (response.status >= 300 && response.status < 400) {
-            redirectCount++;
-            if (redirectCount > maxRedirects) {
-                throw new APIError('Too many redirects.', 403);
-            }
-            const location = response.headers.get('location');
-            if (location) {
-                fileURL = new URL(location, fileURL).href;
-                if (hasAllowList && !isURLAllowed(fileURL, config.upload.pasteURL.allowList)) {
-                    throw new APIError('The provided URL is not allowed.', 400);
-                }
-                continue;
-            }
-        }
-        break;
-    }
+    const url = validateUploadURL({
+        uploadConfig: config.upload,
+        url: src
+    });
+    const { response, url: resolvedURL } = await fetchWithRedirects({
+        allowList: config.upload.pasteURL ? config.upload.pasteURL.allowList : undefined,
+        headers: {
+            'Accept-Encoding': 'identity'
+        },
+        timeout: 30_000,
+        url: url.href
+    });
     if (!response.ok) {
         throw new APIError('Failed to fetch the file from the provided URL.', response.status);
     }
-    const rawFileName = decodeURIComponent(new URL(fileURL).pathname.split('/').pop() || '');
+    const rawFileName = decodeURIComponent(new URL(resolvedURL).pathname.split('/').pop() || '');
     const safeFileName = sanitizeFilename(rawFileName);
     const encodedFileName = encodeURIComponent(safeFileName).replace(/['()]/g, (c)=>`%${c.charCodeAt(0).toString(16).toUpperCase()}`);
     // Strip quotes, backslashes, and control chars from the ASCII fallback
@@ -113,4 +77,4 @@ export const getFileFromURLHandler = async (req)=>{
     });
 };
 
-//# sourceMappingURL=getFileFromURL.js.map
+//# sourceMappingURL=pasteURL.js.map

package/dist/uploads/endpoints/pasteURL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/endpoints/pasteURL.ts"],"sourcesContent":["import type { PayloadHandler } from '../../config/types.js'\n\nimport { executeAccess } from '../../auth/executeAccess.js'\nimport { APIError } from '../../errors/APIError.js'\nimport { Forbidden } from '../../errors/Forbidden.js'\nimport { getRequestCollectionWithID } from '../../utilities/getRequestEntity.js'\nimport { sanitizeFilename } from '../../utilities/sanitizeFilename.js'\nimport { fetchWithRedirects } from '../fetchWithRedirects.js'\nimport { validateUploadURL } from '../validateUploadURL.js'\n\n// If doc id is provided, it means we are updating the doc\n// /:collectionSlug/paste-url/:doc-id?src=:fileUrl\n\n// If doc id is not provided, it means we are creating a new doc\n// /:collectionSlug/paste-url?src=:fileUrl\n\nexport const pasteURLHandler: PayloadHandler = async (req) => {\n  const { id, collection } = getRequestCollectionWithID(req, { optionalID: true })\n\n  if (!req.user) {\n    throw new Forbidden(req.t)\n  }\n\n  const config = collection?.config\n\n  if (id) {\n    // updating doc\n    const accessResult = await executeAccess({ slug: config.slug, req }, config.access.update)\n    if (!accessResult) {\n      throw new Forbidden(req.t)\n    }\n  } else {\n    // creating doc\n    const accessResult = await executeAccess({ slug: config.slug, req }, config.access?.create)\n    if (!accessResult) {\n      throw new Forbidden(req.t)\n    }\n  }\n\n  if (!req.url) {\n    throw new APIError('Request URL is missing.', 400)\n  }\n\n  const { searchParams } = new URL(req.url)\n  const src = searchParams.get('src')\n\n  if (!src || typeof src !== 'string') {\n    throw new APIError('A valid URL string is required.', 400)\n  }\n\n  const url = validateUploadURL({ uploadConfig: config.upload, url: src })\n\n  const { response, url: resolvedURL } = await fetchWithRedirects({\n    allowList: config.upload.pasteURL ? config.upload.pasteURL.allowList : undefined,\n    headers: { 'Accept-Encoding': 'identity' },\n    timeout: 30_000,\n    url: url.href,\n  })\n\n  if (!response.ok) {\n    throw new APIError('Failed to fetch the file from the provided URL.', response.status)\n  }\n\n  const rawFileName = decodeURIComponent(new URL(resolvedURL).pathname.split('/').pop() || '')\n  const safeFileName = sanitizeFilename(rawFileName)\n  const encodedFileName = encodeURIComponent(safeFileName).replace(\n    /['()]/g,\n    (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,\n  )\n  // Strip quotes, backslashes, and control chars from the ASCII fallback\n  const asciiFileName = safeFileName.replace(/[\"\\\\\\r\\n]/g, '_')\n\n  const headers: Record<string, string> = {\n    'Content-Disposition': `attachment; filename=\"${asciiFileName}\"; filename*=UTF-8''${encodedFileName}`,\n    'Content-Type': response.headers.get('content-type') || 'application/octet-stream',\n  }\n\n  const contentLength = response.headers.get('content-length')\n  if (contentLength) {\n    headers['Content-Length'] = contentLength\n  }\n\n  return new Response(response.body, { headers })\n}\n"],"names":["executeAccess","APIError","Forbidden","getRequestCollectionWithID","sanitizeFilename","fetchWithRedirects","validateUploadURL","pasteURLHandler","req","id","collection","optionalID","user","t","config","accessResult","slug","access","update","create","url","searchParams","URL","src","get","uploadConfig","upload","response","resolvedURL","allowList","pasteURL","undefined","headers","timeout","href","ok","status","rawFileName","decodeURIComponent","pathname","split","pop","safeFileName","encodedFileName","encodeURIComponent","replace","c","charCodeAt","toString","toUpperCase","asciiFileName","contentLength","Response","body"],"mappings":"AAEA,SAASA,aAAa,QAAQ,8BAA6B;AAC3D,SAASC,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,SAAS,QAAQ,4BAA2B;AACrD,SAASC,0BAA0B,QAAQ,sCAAqC;AAChF,SAASC,gBAAgB,QAAQ,sCAAqC;AACtE,SAASC,kBAAkB,QAAQ,2BAA0B;AAC7D,SAASC,iBAAiB,QAAQ,0BAAyB;AAE3D,0DAA0D;AAC1D,kDAAkD;AAElD,gEAAgE;AAChE,0CAA0C;AAE1C,OAAO,MAAMC,kBAAkC,OAAOC;IACpD,MAAM,EAAEC,EAAE,EAAEC,UAAU,EAAE,GAAGP,2BAA2BK,KAAK;QAAEG,YAAY;IAAK;IAE9E,IAAI,CAACH,IAAII,IAAI,EAAE;QACb,MAAM,IAAIV,UAAUM,IAAIK,CAAC;IAC3B;IAEA,MAAMC,SAASJ,YAAYI;IAE3B,IAAIL,IAAI;QACN,eAAe;QACf,MAAMM,eAAe,MAAMf,cAAc;YAAEgB,MAAMF,OAAOE,IAAI;YAAER;QAAI,GAAGM,OAAOG,MAAM,CAACC,MAAM;QACzF,IAAI,CAACH,cAAc;YACjB,MAAM,IAAIb,UAAUM,IAAIK,CAAC;QAC3B;IACF,OAAO;QACL,eAAe;QACf,MAAME,eAAe,MAAMf,cAAc;YAAEgB,MAAMF,OAAOE,IAAI;YAAER;QAAI,GAAGM,OAAOG,MAAM,EAAEE;QACpF,IAAI,CAACJ,cAAc;YACjB,MAAM,IAAIb,UAAUM,IAAIK,CAAC;QAC3B;IACF;IAEA,IAAI,CAACL,IAAIY,GAAG,EAAE;QACZ,MAAM,IAAInB,SAAS,2BAA2B;IAChD;IAEA,MAAM,EAAEoB,YAAY,EAAE,GAAG,IAAIC,IAAId,IAAIY,GAAG;IACxC,MAAMG,MAAMF,aAAaG,GAAG,CAAC;IAE7B,IAAI,CAACD,OAAO,OAAOA,QAAQ,UAAU;QACnC,MAAM,IAAItB,SAAS,mCAAmC;IACxD;IAEA,MAAMmB,MAAMd,kBAAkB;QAAEmB,cAAcX,OAAOY,MAAM;QAAEN,KAAKG;IAAI;IAEtE,MAAM,EAAEI,QAAQ,EAAEP,KAAKQ,WAAW,EAAE,GAAG,MAAMvB,mBAAmB;QAC9DwB,WAAWf,OAAOY,MAAM,CAACI,QAAQ,GAAGhB,OAAOY,MAAM,CAACI,QAAQ,CAACD,SAAS,GAAGE;QACvEC,SAAS;YAAE,mBAAmB;QAAW;QACzCC,SAAS;QACTb,KAAKA,IAAIc,IAAI;IACf;IAEA,IAAI,CAACP,SAASQ,EAAE,EAAE;QAChB,MAAM,IAAIlC,SAAS,mDAAmD0B,SAASS,MAAM;IACvF;IAEA,MAAMC,cAAcC,mBAAmB,IAAIhB,IAAIM,aAAaW,QAAQ,CAACC,KAAK,CAAC,KAAKC,GAAG,MAAM;IACzF,MAAMC,eAAetC,iBAAiBiC;IACtC,MAAMM,kBAAkBC,mBAAmBF,cAAcG,OAAO,CAC9D,UACA,CAACC,IAAM,CAAC,CAAC,EAAEA,EAAEC,UAAU,CAAC,GAAGC,QAAQ,CAAC,IAAIC,WAAW,IAAI;IAEzD,uEAAuE;IACvE,MAAMC,gBAAgBR,aAAaG,OAAO,CAAC,cAAc;IAEzD,MAAMb,UAAkC;QACtC,uBAAuB,CAAC,sBAAsB,EAAEkB,cAAc,oBAAoB,EAAEP,iBAAiB;QACrG,gBAAgBhB,SAASK,OAAO,CAACR,GAAG,CAAC,mBAAmB;IAC1D;IAEA,MAAM2B,gBAAgBxB,SAASK,OAAO,CAACR,GAAG,CAAC;IAC3C,IAAI2B,eAAe;QACjBnB,OAAO,CAAC,iBAAiB,GAAGmB;IAC9B;IAEA,OAAO,IAAIC,SAASzB,SAAS0B,IAAI,EAAE;QAAErB;IAAQ;AAC/C,EAAC"}

package/dist/uploads/endpoints/uploadInstructions.d.ts

@@ -1,3 +1,15 @@
 import type { Endpoint } from '../../config/types.js';
+import type { PayloadRequest } from '../../types/index.js';
+import type { UploadInstructions, UploadInstructionsRequest } from '../types.js';
+export declare const getUploadInstructions: ({ overrideAccess, req, ...upload }: {
+    overrideAccess?: boolean;
+    req: PayloadRequest;
+} & UploadInstructionsRequest) => Promise<UploadInstructions>;
 export declare const uploadInstructionsEndpoint: Endpoint;
+/**
+ * Stores or removes temporary files when no adapter-specific upload instructions are available.
+ * PUT keeps the file until it is used in a document request.
+ * DELETE removes a file the client no longer needs.
+ */
+export declare const stagedUploadEndpoints: Endpoint[];
 //# sourceMappingURL=uploadInstructions.d.ts.map

package/dist/uploads/endpoints/uploadInstructions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadInstructions.d.ts","sourceRoot":"","sources":["../../../src/uploads/endpoints/uploadInstructions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAOrD,eAAO,MAAM,0BAA0B,EAAE,QAkDxC,CAAA"}
+{"version":3,"file":"uploadInstructions.d.ts","sourceRoot":"","sources":["../../../src/uploads/endpoints/uploadInstructions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAC1D,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AA+BhF,eAAO,MAAM,qBAAqB,uCAI/B;IACD,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,GAAG,EAAE,cAAc,CAAA;CACpB,GAAG,yBAAyB,KAAG,OAAO,CAAC,kBAAkB,CA0CzD,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,QAwBxC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,EAAE,QAAQ,EAW3C,CAAA"}

package/dist/uploads/endpoints/uploadInstructions.js

@@ -1,38 +1,87 @@
-import { APIError, Forbidden } from '../../errors/index.js';
+import { APIError } from '../../errors/index.js';
+import { assertClientUploadAccess } from '../assertClientUploadAccess.js';
+import { checkFileMetadataRestrictions } from '../checkFileRestrictions.js';
+import { uploadRequiresServerValidation } from '../getFileTypeIdentity.js';
+import { deleteStagedFile, generateStagedUploadInstructions, uploadStagedFile } from '../stagedUpload.js';
 const bytesToMB = (bytes)=>bytes / 1024 / 1024;
+const isUploadInstructionsRequest = (upload)=>typeof upload === 'object' && upload !== null && 'collectionSlug' in upload && typeof upload.collectionSlug === 'string' && (!('docPrefix' in upload) || upload.docPrefix === undefined || typeof upload.docPrefix === 'string') && 'filename' in upload && typeof upload.filename === 'string' && 'filesize' in upload && typeof upload.filesize === 'number' && Number.isSafeInteger(upload.filesize) && upload.filesize >= 0 && 'mimeType' in upload && typeof upload.mimeType === 'string';
+export const getUploadInstructions = async ({ overrideAccess = false, req, ...upload })=>{
+    const collection = req.payload.collections[upload.collectionSlug];
+    const uploadConfig = collection?.config?.upload;
+    if (!overrideAccess) {
+        await assertClientUploadAccess({
+            collectionSlug: upload.collectionSlug,
+            req
+        });
+    }
+    if (!uploadConfig) {
+        throw new APIError(`Upload collection ${upload.collectionSlug} was not found`, 400);
+    }
+    const filesizeLimit = req.payload.config.upload.limits?.fileSize;
+    if (filesizeLimit && upload.filesize > filesizeLimit) {
+        throw new APIError(`Exceeded file size limit. Limit: ${bytesToMB(filesizeLimit).toFixed(2)}MB, got: ${bytesToMB(upload.filesize).toFixed(2)}MB`, 400);
+    }
+    const uploadInstructions = uploadConfig.uploadInstructions;
+    const requiresServerValidation = uploadRequiresServerValidation({
+        allowRestrictedFileTypes: uploadConfig.allowRestrictedFileTypes,
+        filename: upload.filename,
+        mimeType: upload.mimeType
+    });
+    await checkFileMetadataRestrictions({
+        collection: collection.config,
+        filename: upload.filename,
+        filesize: upload.filesize,
+        mimeType: upload.mimeType,
+        req
+    });
+    if (uploadInstructions && requiresServerValidation) {
+        throw new APIError('SVG and XML files must be uploaded with the document through Payload.', 400);
+    }
+    return uploadInstructions ? uploadInstructions.generate({
+        ...upload,
+        overrideAccess,
+        req
+    }) : generateStagedUploadInstructions({
+        ...upload,
+        req
+    });
+};
 export const uploadInstructionsEndpoint = {
     handler: async (req)=>{
         if (!req.json) {
             throw new APIError('Content-Type expected to be application/json', 400);
         }
         const upload = await req.json();
-        if (!upload || typeof upload.collectionSlug !== 'string' || upload.docPrefix !== undefined && typeof upload.docPrefix !== 'string' || typeof upload.filename !== 'string' || typeof upload.filesize !== 'number' || !Number.isSafeInteger(upload.filesize) || upload.filesize < 0 || typeof upload.mimeType !== 'string') {
+        if (!isUploadInstructionsRequest(upload)) {
             throw new APIError('Invalid upload instructions request', 400);
         }
-        const uploadRequest = upload;
-        const collection = req.payload.collections[uploadRequest.collectionSlug];
-        const uploadInstructions = collection?.config?.upload.uploadInstructions;
-        if (!collection || !uploadInstructions) {
-            throw new APIError(`Upload instructions are not configured for ${uploadRequest.collectionSlug}`, 400);
-        }
-        const { access, generate } = uploadInstructions;
-        if (access ? !await access({
-            collectionSlug: uploadRequest.collectionSlug,
-            req
-        }) : !req.user) {
-            throw new Forbidden(req.t);
-        }
-        const filesizeLimit = req.payload.config.upload.limits?.fileSize;
-        if (filesizeLimit && uploadRequest.filesize > filesizeLimit) {
-            throw new APIError(`Exceeded file size limit. Limit: ${bytesToMB(filesizeLimit).toFixed(2)}MB, got: ${bytesToMB(uploadRequest.filesize).toFixed(2)}MB`, 400);
-        }
-        return Response.json(await generate({
-            ...uploadRequest,
+        return Response.json(await getUploadInstructions({
+            collectionSlug: upload.collectionSlug,
+            docPrefix: upload.docPrefix,
+            filename: upload.filename,
+            filesize: upload.filesize,
+            mimeType: upload.mimeType,
             req
         }));
     },
     method: 'post',
     path: '/upload-instructions'
 };
+/**
+ * Stores or removes temporary files when no adapter-specific upload instructions are available.
+ * PUT keeps the file until it is used in a document request.
+ * DELETE removes a file the client no longer needs.
+ */ export const stagedUploadEndpoints = [
+    {
+        handler: uploadStagedFile,
+        method: 'put',
+        path: '/upload-instructions/:uploadId'
+    },
+    {
+        handler: deleteStagedFile,
+        method: 'delete',
+        path: '/upload-instructions/:uploadId'
+    }
+];
 
 //# sourceMappingURL=uploadInstructions.js.map

package/dist/uploads/endpoints/uploadInstructions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/endpoints/uploadInstructions.ts"],"sourcesContent":["import type { Endpoint } from '../../config/types.js'\nimport type { UploadInstructionsRequest } from '../types.js'\n\nimport { APIError, Forbidden } from '../../errors/index.js'\n\nconst bytesToMB = (bytes: number) => bytes / 1024 / 1024\n\nexport const uploadInstructionsEndpoint: Endpoint = {\n  handler: async (req) => {\n    if (!req.json) {\n      throw new APIError('Content-Type expected to be application/json', 400)\n    }\n\n    const upload = (await req.json()) as null | Partial<UploadInstructionsRequest>\n    if (\n      !upload ||\n      typeof upload.collectionSlug !== 'string' ||\n      (upload.docPrefix !== undefined && typeof upload.docPrefix !== 'string') ||\n      typeof upload.filename !== 'string' ||\n      typeof upload.filesize !== 'number' ||\n      !Number.isSafeInteger(upload.filesize) ||\n      upload.filesize < 0 ||\n      typeof upload.mimeType !== 'string'\n    ) {\n      throw new APIError('Invalid upload instructions request', 400)\n    }\n\n    const uploadRequest = upload as UploadInstructionsRequest\n    const collection = req.payload.collections[uploadRequest.collectionSlug]\n    const uploadInstructions = collection?.config?.upload.uploadInstructions\n\n    if (!collection || !uploadInstructions) {\n      throw new APIError(\n        `Upload instructions are not configured for ${uploadRequest.collectionSlug}`,\n        400,\n      )\n    }\n\n    const { access, generate } = uploadInstructions\n    if (\n      access ? !(await access({ collectionSlug: uploadRequest.collectionSlug, req })) : !req.user\n    ) {\n      throw new Forbidden(req.t)\n    }\n\n    const filesizeLimit = req.payload.config.upload.limits?.fileSize\n    if (filesizeLimit && uploadRequest.filesize > filesizeLimit) {\n      throw new APIError(\n        `Exceeded file size limit. Limit: ${bytesToMB(filesizeLimit).toFixed(2)}MB, got: ${bytesToMB(uploadRequest.filesize).toFixed(2)}MB`,\n        400,\n      )\n    }\n\n    return Response.json(await generate({ ...uploadRequest, req }))\n  },\n  method: 'post',\n  path: '/upload-instructions',\n}\n"],"names":["APIError","Forbidden","bytesToMB","bytes","uploadInstructionsEndpoint","handler","req","json","upload","collectionSlug","docPrefix","undefined","filename","filesize","Number","isSafeInteger","mimeType","uploadRequest","collection","payload","collections","uploadInstructions","config","access","generate","user","t","filesizeLimit","limits","fileSize","toFixed","Response","method","path"],"mappings":"AAGA,SAASA,QAAQ,EAAEC,SAAS,QAAQ,wBAAuB;AAE3D,MAAMC,YAAY,CAACC,QAAkBA,QAAQ,OAAO;AAEpD,OAAO,MAAMC,6BAAuC;IAClDC,SAAS,OAAOC;QACd,IAAI,CAACA,IAAIC,IAAI,EAAE;YACb,MAAM,IAAIP,SAAS,gDAAgD;QACrE;QAEA,MAAMQ,SAAU,MAAMF,IAAIC,IAAI;QAC9B,IACE,CAACC,UACD,OAAOA,OAAOC,cAAc,KAAK,YAChCD,OAAOE,SAAS,KAAKC,aAAa,OAAOH,OAAOE,SAAS,KAAK,YAC/D,OAAOF,OAAOI,QAAQ,KAAK,YAC3B,OAAOJ,OAAOK,QAAQ,KAAK,YAC3B,CAACC,OAAOC,aAAa,CAACP,OAAOK,QAAQ,KACrCL,OAAOK,QAAQ,GAAG,KAClB,OAAOL,OAAOQ,QAAQ,KAAK,UAC3B;YACA,MAAM,IAAIhB,SAAS,uCAAuC;QAC5D;QAEA,MAAMiB,gBAAgBT;QACtB,MAAMU,aAAaZ,IAAIa,OAAO,CAACC,WAAW,CAACH,cAAcR,cAAc,CAAC;QACxE,MAAMY,qBAAqBH,YAAYI,QAAQd,OAAOa;QAEtD,IAAI,CAACH,cAAc,CAACG,oBAAoB;YACtC,MAAM,IAAIrB,SACR,CAAC,2CAA2C,EAAEiB,cAAcR,cAAc,EAAE,EAC5E;QAEJ;QAEA,MAAM,EAAEc,MAAM,EAAEC,QAAQ,EAAE,GAAGH;QAC7B,IACEE,SAAS,CAAE,MAAMA,OAAO;YAAEd,gBAAgBQ,cAAcR,cAAc;YAAEH;QAAI,KAAM,CAACA,IAAImB,IAAI,EAC3F;YACA,MAAM,IAAIxB,UAAUK,IAAIoB,CAAC;QAC3B;QAEA,MAAMC,gBAAgBrB,IAAIa,OAAO,CAACG,MAAM,CAACd,MAAM,CAACoB,MAAM,EAAEC;QACxD,IAAIF,iBAAiBV,cAAcJ,QAAQ,GAAGc,eAAe;YAC3D,MAAM,IAAI3B,SACR,CAAC,iCAAiC,EAAEE,UAAUyB,eAAeG,OAAO,CAAC,GAAG,SAAS,EAAE5B,UAAUe,cAAcJ,QAAQ,EAAEiB,OAAO,CAAC,GAAG,EAAE,CAAC,EACnI;QAEJ;QAEA,OAAOC,SAASxB,IAAI,CAAC,MAAMiB,SAAS;YAAE,GAAGP,aAAa;YAAEX;QAAI;IAC9D;IACA0B,QAAQ;IACRC,MAAM;AACR,EAAC"}
+{"version":3,"sources":["../../../src/uploads/endpoints/uploadInstructions.ts"],"sourcesContent":["import type { Endpoint } from '../../config/types.js'\nimport type { PayloadRequest } from '../../types/index.js'\nimport type { UploadInstructions, UploadInstructionsRequest } from '../types.js'\n\nimport { APIError } from '../../errors/index.js'\nimport { assertClientUploadAccess } from '../assertClientUploadAccess.js'\nimport { checkFileMetadataRestrictions } from '../checkFileRestrictions.js'\nimport { uploadRequiresServerValidation } from '../getFileTypeIdentity.js'\nimport {\n  deleteStagedFile,\n  generateStagedUploadInstructions,\n  uploadStagedFile,\n} from '../stagedUpload.js'\n\nconst bytesToMB = (bytes: number) => bytes / 1024 / 1024\n\nconst isUploadInstructionsRequest = (upload: unknown): upload is UploadInstructionsRequest =>\n  typeof upload === 'object' &&\n  upload !== null &&\n  'collectionSlug' in upload &&\n  typeof upload.collectionSlug === 'string' &&\n  (!('docPrefix' in upload) ||\n    upload.docPrefix === undefined ||\n    typeof upload.docPrefix === 'string') &&\n  'filename' in upload &&\n  typeof upload.filename === 'string' &&\n  'filesize' in upload &&\n  typeof upload.filesize === 'number' &&\n  Number.isSafeInteger(upload.filesize) &&\n  upload.filesize >= 0 &&\n  'mimeType' in upload &&\n  typeof upload.mimeType === 'string'\n\nexport const getUploadInstructions = async ({\n  overrideAccess = false,\n  req,\n  ...upload\n}: {\n  overrideAccess?: boolean\n  req: PayloadRequest\n} & UploadInstructionsRequest): Promise<UploadInstructions> => {\n  const collection = req.payload.collections[upload.collectionSlug]\n  const uploadConfig = collection?.config?.upload\n\n  if (!overrideAccess) {\n    await assertClientUploadAccess({ collectionSlug: upload.collectionSlug, req })\n  }\n\n  if (!uploadConfig) {\n    throw new APIError(`Upload collection ${upload.collectionSlug} was not found`, 400)\n  }\n\n  const filesizeLimit = req.payload.config.upload.limits?.fileSize\n  if (filesizeLimit && upload.filesize > filesizeLimit) {\n    throw new APIError(\n      `Exceeded file size limit. Limit: ${bytesToMB(filesizeLimit).toFixed(2)}MB, got: ${bytesToMB(upload.filesize).toFixed(2)}MB`,\n      400,\n    )\n  }\n\n  const uploadInstructions = uploadConfig.uploadInstructions\n  const requiresServerValidation = uploadRequiresServerValidation({\n    allowRestrictedFileTypes: uploadConfig.allowRestrictedFileTypes,\n    filename: upload.filename,\n    mimeType: upload.mimeType,\n  })\n\n  await checkFileMetadataRestrictions({\n    collection: collection.config,\n    filename: upload.filename,\n    filesize: upload.filesize,\n    mimeType: upload.mimeType,\n    req,\n  })\n\n  if (uploadInstructions && requiresServerValidation) {\n    throw new APIError('SVG and XML files must be uploaded with the document through Payload.', 400)\n  }\n\n  return uploadInstructions\n    ? uploadInstructions.generate({ ...upload, overrideAccess, req })\n    : generateStagedUploadInstructions({ ...upload, req })\n}\n\nexport const uploadInstructionsEndpoint: Endpoint = {\n  handler: async (req) => {\n    if (!req.json) {\n      throw new APIError('Content-Type expected to be application/json', 400)\n    }\n\n    const upload: unknown = await req.json()\n    if (!isUploadInstructionsRequest(upload)) {\n      throw new APIError('Invalid upload instructions request', 400)\n    }\n\n    return Response.json(\n      await getUploadInstructions({\n        collectionSlug: upload.collectionSlug,\n        docPrefix: upload.docPrefix,\n        filename: upload.filename,\n        filesize: upload.filesize,\n        mimeType: upload.mimeType,\n        req,\n      }),\n    )\n  },\n  method: 'post',\n  path: '/upload-instructions',\n}\n\n/**\n * Stores or removes temporary files when no adapter-specific upload instructions are available.\n * PUT keeps the file until it is used in a document request.\n * DELETE removes a file the client no longer needs.\n */\nexport const stagedUploadEndpoints: Endpoint[] = [\n  {\n    handler: uploadStagedFile,\n    method: 'put',\n    path: '/upload-instructions/:uploadId',\n  },\n  {\n    handler: deleteStagedFile,\n    method: 'delete',\n    path: '/upload-instructions/:uploadId',\n  },\n]\n"],"names":["APIError","assertClientUploadAccess","checkFileMetadataRestrictions","uploadRequiresServerValidation","deleteStagedFile","generateStagedUploadInstructions","uploadStagedFile","bytesToMB","bytes","isUploadInstructionsRequest","upload","collectionSlug","docPrefix","undefined","filename","filesize","Number","isSafeInteger","mimeType","getUploadInstructions","overrideAccess","req","collection","payload","collections","uploadConfig","config","filesizeLimit","limits","fileSize","toFixed","uploadInstructions","requiresServerValidation","allowRestrictedFileTypes","generate","uploadInstructionsEndpoint","handler","json","Response","method","path","stagedUploadEndpoints"],"mappings":"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"}

package/dist/uploads/fetchAPI-multipart/handlers.d.ts

@@ -1,8 +1,8 @@
 import type { FetchAPIFileUploadOptions } from '../../config/types.js';
 type Handler = (options: FetchAPIFileUploadOptions, fieldname: string, filename: string) => {
-    cleanup: () => void;
+    cleanup: () => Promise<void> | void;
     complete: () => Buffer;
-    dataHandler: (data: Buffer) => void;
+    dataHandler: (data: Buffer) => Promise<void> | void;
     getFilePath: () => string;
     getFileSize: () => number;
     getHash: () => string;

package/dist/uploads/fetchAPI-multipart/handlers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/handlers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAItE,KAAK,OAAO,GAAG,CACb,OAAO,EAAE,yBAAyB,EAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,KACb;IACH,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,QAAQ,EAAE,MAAM,MAAM,CAAA;IACtB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,OAAO,EAAE,MAAM,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,OAuD7B,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,OAgCxB,CAAA"}
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/handlers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAItE,KAAK,OAAO,GAAG,CACb,OAAO,EAAE,yBAAyB,EAClC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,KACb;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACnC,QAAQ,EAAE,MAAM,MAAM,CAAA;IACtB,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACnD,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,WAAW,EAAE,MAAM,MAAM,CAAA;IACzB,OAAO,EAAE,MAAM,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CACxC,CAAA;AAED,eAAO,MAAM,eAAe,EAAE,OA6D7B,CAAA;AAED,eAAO,MAAM,UAAU,EAAE,OAmCxB,CAAA"}

package/dist/uploads/fetchAPI-multipart/handlers.js

@@ -15,6 +15,7 @@ export const tempFileHandler = (options, fieldname, filename)=>{
     const writeStream = fs.createWriteStream(tempFilePath);
     const writePromise = new Promise((resolve, reject)=>{
         writeStream.on('finish', ()=>resolve(true));
+        writeStream.on('close', ()=>resolve(false));
         writeStream.on('error', (err)=>{
             debugLog(options, `Error write temp file: ${err}`);
             reject(err);
@@ -23,9 +24,15 @@ export const tempFileHandler = (options, fieldname, filename)=>{
     return {
         cleanup: ()=>{
             completed = true;
-            debugLog(options, `Cleaning up temporary file ${tempFilePath}...`);
-            writeStream.end();
-            deleteFile(tempFilePath, (err)=>err ? debugLog(options, `Cleaning up temporary file ${tempFilePath} failed: ${err}`) : debugLog(options, `Cleaning up temporary file ${tempFilePath} done.`));
+            return new Promise((resolve)=>{
+                const remove = ()=>deleteFile(tempFilePath, ()=>resolve());
+                if (writeStream.closed) {
+                    remove();
+                } else {
+                    writeStream.once('close', remove);
+                    writeStream.destroy();
+                }
+            });
         },
         complete: ()=>{
             completed = true;
@@ -41,10 +48,13 @@ export const tempFileHandler = (options, fieldname, filename)=>{
                 debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
                 return;
             }
-            writeStream.write(data);
+            const ready = writeStream.write(data);
             hash.update(data);
             fileSize += data.length;
             debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+            if (!ready) {
+                return new Promise((resolve)=>writeStream.once('drain', resolve));
+            }
         },
         getFilePath: ()=>tempFilePath,
         getFileSize: ()=>fileSize,
@@ -61,11 +71,14 @@ export const memHandler = (options, fieldname, filename)=>{
     return {
         cleanup: ()=>{
             completed = true;
+            buffers.length = 0;
         },
         complete: ()=>{
             debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
             completed = true;
-            return getBuffer();
+            const buffer = getBuffer();
+            buffers.length = 0;
+            return buffer;
         },
         dataHandler: (data)=>{
             if (completed === true) {

package/dist/uploads/fetchAPI-multipart/handlers.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/handlers.ts"],"sourcesContent":["import crypto from 'crypto'\nimport fs, { WriteStream } from 'fs'\nimport path from 'path'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\n\nimport { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js'\n\ntype Handler = (\n  options: FetchAPIFileUploadOptions,\n  fieldname: string,\n  filename: string,\n) => {\n  cleanup: () => void\n  complete: () => Buffer\n  dataHandler: (data: Buffer) => void\n  getFilePath: () => string\n  getFileSize: () => number\n  getHash: () => string\n  getWritePromise: () => Promise<boolean>\n}\n\nexport const tempFileHandler: Handler = (options, fieldname, filename) => {\n  const tempFilePath = path.resolve(options.tempFileDir!, getTempFilename())\n  checkAndMakeDir({ createParentPath: true }, tempFilePath)\n\n  debugLog(options, `Temporary file path is ${tempFilePath}`)\n\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  debugLog(options, `Opening write stream for ${fieldname}->${filename}...`)\n  const writeStream = fs.createWriteStream(tempFilePath)\n  const writePromise = new Promise<boolean>((resolve, reject) => {\n    writeStream.on('finish', () => resolve(true))\n    writeStream.on('error', (err) => {\n      debugLog(options, `Error write temp file: ${err}`)\n      reject(err)\n    })\n  })\n\n  return {\n    cleanup: () => {\n      completed = true\n      debugLog(options, `Cleaning up temporary file ${tempFilePath}...`)\n      writeStream.end()\n      deleteFile(tempFilePath, (err) =>\n        err\n          ? debugLog(options, `Cleaning up temporary file ${tempFilePath} failed: ${err}`)\n          : debugLog(options, `Cleaning up temporary file ${tempFilePath} done.`),\n      )\n    },\n    complete: () => {\n      completed = true\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      if (writeStream instanceof WriteStream) {\n        writeStream.end()\n      }\n      // Return empty buff since data was uploaded into a temp file.\n      return Buffer.concat([])\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      writeStream.write(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => tempFilePath,\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => writePromise,\n  }\n}\n\nexport const memHandler: Handler = (options, fieldname, filename) => {\n  const buffers: Buffer[] = []\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  const getBuffer = () => Buffer.concat(buffers, fileSize)\n\n  return {\n    cleanup: () => {\n      completed = true\n    },\n    complete: () => {\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      completed = true\n      return getBuffer()\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      buffers.push(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => '',\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => Promise.resolve(true),\n  }\n}\n"],"names":["crypto","fs","WriteStream","path","checkAndMakeDir","debugLog","deleteFile","getTempFilename","tempFileHandler","options","fieldname","filename","tempFilePath","resolve","tempFileDir","createParentPath","hash","createHash","fileSize","completed","writeStream","createWriteStream","writePromise","Promise","reject","on","err","cleanup","end","complete","Buffer","concat","dataHandler","data","write","update","length","getFilePath","getFileSize","getHash","digest","getWritePromise","memHandler","buffers","getBuffer","push"],"mappings":"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"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/handlers.ts"],"sourcesContent":["import crypto from 'crypto'\nimport fs, { WriteStream } from 'fs'\nimport path from 'path'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\n\nimport { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js'\n\ntype Handler = (\n  options: FetchAPIFileUploadOptions,\n  fieldname: string,\n  filename: string,\n) => {\n  cleanup: () => Promise<void> | void\n  complete: () => Buffer\n  dataHandler: (data: Buffer) => Promise<void> | void\n  getFilePath: () => string\n  getFileSize: () => number\n  getHash: () => string\n  getWritePromise: () => Promise<boolean>\n}\n\nexport const tempFileHandler: Handler = (options, fieldname, filename) => {\n  const tempFilePath = path.resolve(options.tempFileDir!, getTempFilename())\n  checkAndMakeDir({ createParentPath: true }, tempFilePath)\n\n  debugLog(options, `Temporary file path is ${tempFilePath}`)\n\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  debugLog(options, `Opening write stream for ${fieldname}->${filename}...`)\n  const writeStream = fs.createWriteStream(tempFilePath)\n  const writePromise = new Promise<boolean>((resolve, reject) => {\n    writeStream.on('finish', () => resolve(true))\n    writeStream.on('close', () => resolve(false))\n    writeStream.on('error', (err) => {\n      debugLog(options, `Error write temp file: ${err}`)\n      reject(err)\n    })\n  })\n\n  return {\n    cleanup: () => {\n      completed = true\n      return new Promise<void>((resolve) => {\n        const remove = () => deleteFile(tempFilePath, () => resolve())\n        if (writeStream.closed) {\n          remove()\n        } else {\n          writeStream.once('close', remove)\n          writeStream.destroy()\n        }\n      })\n    },\n    complete: () => {\n      completed = true\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      if (writeStream instanceof WriteStream) {\n        writeStream.end()\n      }\n      // Return empty buff since data was uploaded into a temp file.\n      return Buffer.concat([])\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      const ready = writeStream.write(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n      if (!ready) {\n        return new Promise<void>((resolve) => writeStream.once('drain', resolve))\n      }\n    },\n    getFilePath: () => tempFilePath,\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => writePromise,\n  }\n}\n\nexport const memHandler: Handler = (options, fieldname, filename) => {\n  const buffers: Buffer[] = []\n  const hash = crypto.createHash('md5')\n  let fileSize = 0\n  let completed = false\n\n  const getBuffer = () => Buffer.concat(buffers, fileSize)\n\n  return {\n    cleanup: () => {\n      completed = true\n      buffers.length = 0\n    },\n    complete: () => {\n      debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`)\n      completed = true\n      const buffer = getBuffer()\n      buffers.length = 0\n      return buffer\n    },\n    dataHandler: (data) => {\n      if (completed === true) {\n        debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`)\n        return\n      }\n      buffers.push(data)\n      hash.update(data)\n      fileSize += data.length\n      debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`)\n    },\n    getFilePath: () => '',\n    getFileSize: () => fileSize,\n    getHash: () => hash.digest('hex'),\n    getWritePromise: () => Promise.resolve(true),\n  }\n}\n"],"names":["crypto","fs","WriteStream","path","checkAndMakeDir","debugLog","deleteFile","getTempFilename","tempFileHandler","options","fieldname","filename","tempFilePath","resolve","tempFileDir","createParentPath","hash","createHash","fileSize","completed","writeStream","createWriteStream","writePromise","Promise","reject","on","err","cleanup","remove","closed","once","destroy","complete","end","Buffer","concat","dataHandler","data","ready","write","update","length","getFilePath","getFileSize","getHash","digest","getWritePromise","memHandler","buffers","getBuffer","buffer","push"],"mappings":"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"}

package/dist/uploads/fetchAPI-multipart/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAqBnD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,EAAE,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;CACtD,CAAA;AAED,KAAK,kBAAkB,GAAG,CAAC,IAAI,EAAE;IAC/B,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAEzC,eAAO,MAAM,wBAAwB,EAAE,kBAiBtC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AAEtE,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAyBnD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACpB,QAAQ,EAAE,MAAM,CAAA;IAChB,EAAE,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACpE,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,8BAA8B,GAAG;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,0BAA0B,GAAG;IACvC,KAAK,CAAC,EAAE,QAAQ,CAAA;IAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;CACtD,CAAA;AAED,KAAK,kBAAkB,GAAG,CAAC,IAAI,EAAE;IAC/B,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAEzC,eAAO,MAAM,wBAAwB,EAAE,kBA2CtC,CAAA"}

package/dist/uploads/fetchAPI-multipart/index.js

@@ -2,14 +2,22 @@ import { APIError } from '../../errors/APIError.js';
 import { isEligibleRequest } from './isEligibleRequest.js';
 import { processMultipart } from './processMultipart.js';
 import { debugLog } from './utilities.js';
+const DEFAULT_REQUEST_SIZE_LIMIT = 50 * 1024 * 1024;
 const DEFAULT_UPLOAD_OPTIONS = {
-    abortOnLimit: false,
+    abortOnLimit: true,
     createParentPath: false,
     debug: false,
     defParamCharset: 'utf8',
     limitHandler: false,
+    limits: {
+        fields: 20,
+        fieldSize: 1024 * 1024,
+        files: 3,
+        fileSize: 20 * 1024 * 1024
+    },
     parseNested: false,
     preserveExtension: false,
+    requestSizeLimit: DEFAULT_REQUEST_SIZE_LIMIT,
     responseOnLimit: 'File size limit has been reached',
     safeFileNames: false,
     tempFileDir: 'tmp',
@@ -18,10 +26,24 @@ const DEFAULT_UPLOAD_OPTIONS = {
     useTempFiles: false
 };
 export const processMultipartFormdata = async ({ options: incomingOptions, request })=>{
+    const requestSizeLimit = incomingOptions?.requestSizeLimit === undefined ? DEFAULT_REQUEST_SIZE_LIMIT : incomingOptions.requestSizeLimit;
+    if (requestSizeLimit !== Infinity && (!Number.isSafeInteger(requestSizeLimit) || requestSizeLimit < 0)) {
+        throw new TypeError('requestSizeLimit must be Infinity or a non-negative safe integer representing bytes');
+    }
     const options = {
         ...DEFAULT_UPLOAD_OPTIONS,
-        ...incomingOptions
+        ...incomingOptions,
+        abortOnLimit: incomingOptions?.abortOnLimit ?? DEFAULT_UPLOAD_OPTIONS.abortOnLimit,
+        limits: {
+            ...DEFAULT_UPLOAD_OPTIONS.limits
+        },
+        requestSizeLimit
     };
+    for (const [key, value] of Object.entries(incomingOptions?.limits || {})){
+        if (value !== undefined) {
+            options.limits[key] = value;
+        }
+    }
     if (!isEligibleRequest(request)) {
         debugLog(options, 'Request is not eligible for file upload!');
         return {

package/dist/uploads/fetchAPI-multipart/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/index.ts"],"sourcesContent":["import path from 'path'\n\nimport type { FetchAPIFileUploadOptions } from '../../config/types.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_UPLOAD_OPTIONS: FetchAPIFileUploadOptions = {\n  abortOnLimit: false,\n  createParentPath: false,\n  debug: false,\n  defParamCharset: 'utf8',\n  limitHandler: false,\n  parseNested: false,\n  preserveExtension: false,\n  responseOnLimit: 'File size limit has been reached',\n  safeFileNames: false,\n  tempFileDir: 'tmp', // Relative path is created inside current workdir.\n  uploadTimeout: 60000,\n  uriDecodeFileNames: false,\n  useTempFiles: false,\n}\n\nexport type FileShape = {\n  data: Buffer\n  encoding: string\n  md5: Buffer | string\n  mimetype: string\n  mv: (filePath: string, callback: () => void) => Promise<void> | void\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\n\ntype FetchAPIFileUploadResponseFile = {\n  data: Buffer\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath?: string\n}\n\nexport type FetchAPIFileUploadResponse = {\n  error?: APIError\n  fields: Record<string, string>\n  files: Record<string, FetchAPIFileUploadResponseFile>\n}\n\ntype FetchAPIFileUpload = (args: {\n  options?: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\n\nexport const processMultipartFormdata: FetchAPIFileUpload = async ({\n  options: incomingOptions,\n  request,\n}) => {\n  const options: FetchAPIFileUploadOptions = { ...DEFAULT_UPLOAD_OPTIONS, ...incomingOptions }\n\n  if (!isEligibleRequest(request)) {\n    debugLog(options, 'Request is not eligible for file upload!')\n\n    return {\n      error: new APIError('Request is not eligible for file upload', 500),\n      fields: undefined!,\n      files: undefined!,\n    }\n  } else {\n    return processMultipart({ options, request })\n  }\n}\n"],"names":["APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_UPLOAD_OPTIONS","abortOnLimit","createParentPath","debug","defParamCharset","limitHandler","parseNested","preserveExtension","responseOnLimit","safeFileNames","tempFileDir","uploadTimeout","uriDecodeFileNames","useTempFiles","processMultipartFormdata","options","incomingOptions","request","error","fields","undefined","files"],"mappings":"AAIA,SAASA,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,MAAMC,yBAAoD;IACxDC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,iBAAiB;IACjBC,cAAc;IACdC,aAAa;IACbC,mBAAmB;IACnBC,iBAAiB;IACjBC,eAAe;IACfC,aAAa;IACbC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAiCA,OAAO,MAAMC,2BAA+C,OAAO,EACjEC,SAASC,eAAe,EACxBC,OAAO,EACR;IACC,MAAMF,UAAqC;QAAE,GAAGf,sBAAsB;QAAE,GAAGgB,eAAe;IAAC;IAE3F,IAAI,CAACnB,kBAAkBoB,UAAU;QAC/BlB,SAASgB,SAAS;QAElB,OAAO;YACLG,OAAO,IAAItB,SAAS,2CAA2C;YAC/DuB,QAAQC;YACRC,OAAOD;QACT;IACF,OAAO;QACL,OAAOtB,iBAAiB;YAAEiB;YAASE;QAAQ;IAC7C;AACF,EAAC"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/index.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from '../../config/types.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { isEligibleRequest } from './isEligibleRequest.js'\nimport { processMultipart } from './processMultipart.js'\nimport { debugLog } from './utilities.js'\n\nconst DEFAULT_REQUEST_SIZE_LIMIT = 50 * 1024 * 1024\n\nconst DEFAULT_UPLOAD_OPTIONS: FetchAPIFileUploadOptions = {\n  abortOnLimit: true,\n  createParentPath: false,\n  debug: false,\n  defParamCharset: 'utf8',\n  limitHandler: false,\n  limits: { fields: 20, fieldSize: 1024 * 1024, files: 3, fileSize: 20 * 1024 * 1024 },\n  parseNested: false,\n  preserveExtension: false,\n  requestSizeLimit: DEFAULT_REQUEST_SIZE_LIMIT,\n  responseOnLimit: 'File size limit has been reached',\n  safeFileNames: false,\n  tempFileDir: 'tmp', // Relative path is created inside current workdir.\n  uploadTimeout: 60000,\n  uriDecodeFileNames: false,\n  useTempFiles: false,\n}\n\nexport type FileShape = {\n  data: Buffer\n  encoding: string\n  md5: Buffer | string\n  mimetype: string\n  mv: (filePath: string, callback: () => void) => Promise<void> | void\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\n\ntype FetchAPIFileUploadResponseFile = {\n  data: Buffer\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath?: string\n}\n\nexport type FetchAPIFileUploadResponse = {\n  error?: APIError\n  fields: Record<string, string>\n  files: Record<string, FetchAPIFileUploadResponseFile>\n}\n\ntype FetchAPIFileUpload = (args: {\n  options?: FetchAPIFileUploadOptions\n  request: Request\n}) => Promise<FetchAPIFileUploadResponse>\n\nexport const processMultipartFormdata: FetchAPIFileUpload = async ({\n  options: incomingOptions,\n  request,\n}) => {\n  const requestSizeLimit =\n    incomingOptions?.requestSizeLimit === undefined\n      ? DEFAULT_REQUEST_SIZE_LIMIT\n      : incomingOptions.requestSizeLimit\n\n  if (\n    requestSizeLimit !== Infinity &&\n    (!Number.isSafeInteger(requestSizeLimit) || requestSizeLimit < 0)\n  ) {\n    throw new TypeError(\n      'requestSizeLimit must be Infinity or a non-negative safe integer representing bytes',\n    )\n  }\n\n  const options: FetchAPIFileUploadOptions = {\n    ...DEFAULT_UPLOAD_OPTIONS,\n    ...incomingOptions,\n    abortOnLimit: incomingOptions?.abortOnLimit ?? DEFAULT_UPLOAD_OPTIONS.abortOnLimit,\n    limits: { ...DEFAULT_UPLOAD_OPTIONS.limits },\n    requestSizeLimit,\n  }\n\n  for (const [key, value] of Object.entries(incomingOptions?.limits || {})) {\n    if (value !== undefined) {\n      options.limits![key as keyof NonNullable<FetchAPIFileUploadOptions['limits']>] = value\n    }\n  }\n\n  if (!isEligibleRequest(request)) {\n    debugLog(options, 'Request is not eligible for file upload!')\n\n    return {\n      error: new APIError('Request is not eligible for file upload', 500),\n      fields: undefined!,\n      files: undefined!,\n    }\n  } else {\n    return processMultipart({ options, request })\n  }\n}\n"],"names":["APIError","isEligibleRequest","processMultipart","debugLog","DEFAULT_REQUEST_SIZE_LIMIT","DEFAULT_UPLOAD_OPTIONS","abortOnLimit","createParentPath","debug","defParamCharset","limitHandler","limits","fields","fieldSize","files","fileSize","parseNested","preserveExtension","requestSizeLimit","responseOnLimit","safeFileNames","tempFileDir","uploadTimeout","uriDecodeFileNames","useTempFiles","processMultipartFormdata","options","incomingOptions","request","undefined","Infinity","Number","isSafeInteger","TypeError","key","value","Object","entries","error"],"mappings":"AAEA,SAASA,QAAQ,QAAQ,2BAA0B;AACnD,SAASC,iBAAiB,QAAQ,yBAAwB;AAC1D,SAASC,gBAAgB,QAAQ,wBAAuB;AACxD,SAASC,QAAQ,QAAQ,iBAAgB;AAEzC,MAAMC,6BAA6B,KAAK,OAAO;AAE/C,MAAMC,yBAAoD;IACxDC,cAAc;IACdC,kBAAkB;IAClBC,OAAO;IACPC,iBAAiB;IACjBC,cAAc;IACdC,QAAQ;QAAEC,QAAQ;QAAIC,WAAW,OAAO;QAAMC,OAAO;QAAGC,UAAU,KAAK,OAAO;IAAK;IACnFC,aAAa;IACbC,mBAAmB;IACnBC,kBAAkBd;IAClBe,iBAAiB;IACjBC,eAAe;IACfC,aAAa;IACbC,eAAe;IACfC,oBAAoB;IACpBC,cAAc;AAChB;AAiCA,OAAO,MAAMC,2BAA+C,OAAO,EACjEC,SAASC,eAAe,EACxBC,OAAO,EACR;IACC,MAAMV,mBACJS,iBAAiBT,qBAAqBW,YAClCzB,6BACAuB,gBAAgBT,gBAAgB;IAEtC,IACEA,qBAAqBY,YACpB,CAAA,CAACC,OAAOC,aAAa,CAACd,qBAAqBA,mBAAmB,CAAA,GAC/D;QACA,MAAM,IAAIe,UACR;IAEJ;IAEA,MAAMP,UAAqC;QACzC,GAAGrB,sBAAsB;QACzB,GAAGsB,eAAe;QAClBrB,cAAcqB,iBAAiBrB,gBAAgBD,uBAAuBC,YAAY;QAClFK,QAAQ;YAAE,GAAGN,uBAAuBM,MAAM;QAAC;QAC3CO;IACF;IAEA,KAAK,MAAM,CAACgB,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACV,iBAAiBhB,UAAU,CAAC,GAAI;QACxE,IAAIwB,UAAUN,WAAW;YACvBH,QAAQf,MAAM,AAAC,CAACuB,IAA8D,GAAGC;QACnF;IACF;IAEA,IAAI,CAAClC,kBAAkB2B,UAAU;QAC/BzB,SAASuB,SAAS;QAElB,OAAO;YACLY,OAAO,IAAItC,SAAS,2CAA2C;YAC/DY,QAAQiB;YACRf,OAAOe;QACT;IACF,OAAO;QACL,OAAO3B,iBAAiB;YAAEwB;YAASE;QAAQ;IAC7C;AACF,EAAC"}

package/dist/uploads/fetchAPI-multipart/isEligibleRequest.js

@@ -1,5 +1,4 @@
-// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/no-obscure-range
-const ACCEPTABLE_CONTENT_TYPE = /multipart\/['"()+-_]+(?:; ?['"()+-_]*)+$/i;
+const ACCEPTABLE_CONTENT_TYPE = /multipart\/[\w'"()+,./:<=>?@[\\\]^-]+(?:; ?[\w'"()+,./:<=>?@[\\\]^-]*)+$/i;
 const UNACCEPTABLE_METHODS = new Set([
     'CONNECT',
     'DELETE',

package/dist/uploads/fetchAPI-multipart/isEligibleRequest.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/no-obscure-range\nconst ACCEPTABLE_CONTENT_TYPE = /multipart\\/['\"()+-_]+(?:; ?['\"()+-_]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'TRACE'])\n\nconst hasBody = (req: Request): boolean => {\n  const contentLength = req.headers.get('content-length')\n\n  return Boolean(\n    req.body || req.headers.get('transfer-encoding') || (contentLength && contentLength !== '0'),\n  )\n}\n\nconst hasAcceptableMethod = (req: Request): boolean => !UNACCEPTABLE_METHODS.has(req.method)\n\nconst hasAcceptableContentType = (req: Request): boolean => {\n  const contType = req.headers.get('content-type')\n  return contType!.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType!)\n}\n\nexport const isEligibleRequest = (req: Request): boolean => {\n  try {\n    return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req)\n  } catch (ignore) {\n    return false\n  }\n}\n"],"names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","contentLength","headers","get","Boolean","body","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","ignore"],"mappings":"AAAA,wFAAwF;AACxF,MAAMA,0BAA0B;AAChC,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAW;IAAU;IAAO;IAAQ;IAAW;CAAQ;AAE7F,MAAMC,UAAU,CAACC;IACf,MAAMC,gBAAgBD,IAAIE,OAAO,CAACC,GAAG,CAAC;IAEtC,OAAOC,QACLJ,IAAIK,IAAI,IAAIL,IAAIE,OAAO,CAACC,GAAG,CAAC,wBAAyBF,iBAAiBA,kBAAkB;AAE5F;AAEA,MAAMK,sBAAsB,CAACN,MAA0B,CAACH,qBAAqBU,GAAG,CAACP,IAAIQ,MAAM;AAE3F,MAAMC,2BAA2B,CAACT;IAChC,MAAMU,WAAWV,IAAIE,OAAO,CAACC,GAAG,CAAC;IACjC,OAAOO,SAAUC,QAAQ,CAAC,gBAAgBf,wBAAwBgB,IAAI,CAACF;AACzE;AAEA,OAAO,MAAMG,oBAAoB,CAACb;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQM,oBAAoBN,QAAQS,yBAAyBT;IAC9E,EAAE,OAAOc,QAAQ;QACf,OAAO;IACT;AACF,EAAC"}
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/isEligibleRequest.ts"],"sourcesContent":["const ACCEPTABLE_CONTENT_TYPE =\n  /multipart\\/[\\w'\"()+,./:<=>?@[\\\\\\]^-]+(?:; ?[\\w'\"()+,./:<=>?@[\\\\\\]^-]*)+$/i\nconst UNACCEPTABLE_METHODS = new Set(['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'TRACE'])\n\nconst hasBody = (req: Request): boolean => {\n  const contentLength = req.headers.get('content-length')\n\n  return Boolean(\n    req.body || req.headers.get('transfer-encoding') || (contentLength && contentLength !== '0'),\n  )\n}\n\nconst hasAcceptableMethod = (req: Request): boolean => !UNACCEPTABLE_METHODS.has(req.method)\n\nconst hasAcceptableContentType = (req: Request): boolean => {\n  const contType = req.headers.get('content-type')\n  return contType!.includes('boundary=') && ACCEPTABLE_CONTENT_TYPE.test(contType!)\n}\n\nexport const isEligibleRequest = (req: Request): boolean => {\n  try {\n    return hasBody(req) && hasAcceptableMethod(req) && hasAcceptableContentType(req)\n  } catch (ignore) {\n    return false\n  }\n}\n"],"names":["ACCEPTABLE_CONTENT_TYPE","UNACCEPTABLE_METHODS","Set","hasBody","req","contentLength","headers","get","Boolean","body","hasAcceptableMethod","has","method","hasAcceptableContentType","contType","includes","test","isEligibleRequest","ignore"],"mappings":"AAAA,MAAMA,0BACJ;AACF,MAAMC,uBAAuB,IAAIC,IAAI;IAAC;IAAW;IAAU;IAAO;IAAQ;IAAW;CAAQ;AAE7F,MAAMC,UAAU,CAACC;IACf,MAAMC,gBAAgBD,IAAIE,OAAO,CAACC,GAAG,CAAC;IAEtC,OAAOC,QACLJ,IAAIK,IAAI,IAAIL,IAAIE,OAAO,CAACC,GAAG,CAAC,wBAAyBF,iBAAiBA,kBAAkB;AAE5F;AAEA,MAAMK,sBAAsB,CAACN,MAA0B,CAACH,qBAAqBU,GAAG,CAACP,IAAIQ,MAAM;AAE3F,MAAMC,2BAA2B,CAACT;IAChC,MAAMU,WAAWV,IAAIE,OAAO,CAACC,GAAG,CAAC;IACjC,OAAOO,SAAUC,QAAQ,CAAC,gBAAgBf,wBAAwBgB,IAAI,CAACF;AACzE;AAEA,OAAO,MAAMG,oBAAoB,CAACb;IAChC,IAAI;QACF,OAAOD,QAAQC,QAAQM,oBAAoBN,QAAQS,yBAAyBT;IAC9E,EAAE,OAAOc,QAAQ;QACf,OAAO;IACT;AACF,EAAC"}

package/dist/uploads/fetchAPI-multipart/processMultipart.d.ts

@@ -1,11 +1,5 @@
 import type { FetchAPIFileUploadOptions } from '../../config/types.js';
 import type { FetchAPIFileUploadResponse } from './index.js';
-declare const waitFlushProperty: unique symbol;
-declare global {
-    interface Request {
-        [waitFlushProperty]?: Promise<any>[];
-    }
-}
 type ProcessMultipart = (args: {
     options: FetchAPIFileUploadOptions;
     request: Request;

package/dist/uploads/fetchAPI-multipart/processMultipart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAS5D,QAAA,MAAM,iBAAiB,eAAuC,CAAA;AAE9D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,OAAO;QACf,CAAC,iBAAiB,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAA;KACrC;CACF;AAED,KAAK,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,yBAAyB,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AACzC,eAAO,MAAM,gBAAgB,EAAE,gBA6N9B,CAAA"}
+{"version":3,"file":"processMultipart.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/processMultipart.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAA;AAS5D,KAAK,gBAAgB,GAAG,CAAC,IAAI,EAAE;IAC7B,OAAO,EAAE,yBAAyB,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;CACjB,KAAK,OAAO,CAAC,0BAA0B,CAAC,CAAA;AAEzC,eAAO,MAAM,gBAAgB,EAAE,gBAgM9B,CAAA"}