@depup/payload 3.79.1-depup.0

package/dist/uploads/endpoints/getFile.js

@@ -0,0 +1,144 @@
+import { fileTypeFromFile } from 'file-type';
+import fsPromises from 'fs/promises';
+import { status as httpStatus } from 'http-status';
+import path from 'path';
+import { APIError } from '../../errors/APIError.js';
+import { checkFileAccess } from '../../uploads/checkFileAccess.js';
+import { streamFile } from '../../uploads/fetchAPI-stream-file/index.js';
+import { getFileTypeFallback } from '../../uploads/getFileTypeFallback.js';
+import { parseRangeHeader } from '../../uploads/parseRangeHeader.js';
+import { getRequestCollection } from '../../utilities/getRequestEntity.js';
+import { headersWithCors } from '../../utilities/headersWithCors.js';
+export const getFileHandler = async (req)=>{
+    const collection = getRequestCollection(req);
+    const filename = req.routeParams?.filename;
+    if (!collection.config.upload) {
+        throw new APIError(`This collection is not an upload collection: ${collection.config.slug}`, httpStatus.BAD_REQUEST);
+    }
+    const accessResult = await checkFileAccess({
+        collection,
+        filename,
+        req
+    });
+    if (accessResult instanceof Response) {
+        return accessResult;
+    }
+    if (collection.config.upload.handlers?.length) {
+        let customResponse = null;
+        const headers = new Headers();
+        for (const handler of collection.config.upload.handlers){
+            customResponse = await handler(req, {
+                doc: accessResult,
+                headers,
+                params: {
+                    collection: collection.config.slug,
+                    filename
+                }
+            });
+            if (customResponse && customResponse instanceof Response) {
+                break;
+            }
+        }
+        if (customResponse instanceof Response) {
+            return customResponse;
+        }
+    }
+    // Local filesystem fallback — cloud storage handlers return a Response above
+    // and have their own filename validation via sanitizeFilename.
+    const fileDir = collection.config.upload?.staticDir || collection.config.slug;
+    const resolvedDir = path.resolve(fileDir);
+    const filePath = path.resolve(resolvedDir, filename);
+    if (!filePath.startsWith(resolvedDir + path.sep)) {
+        throw new APIError('Invalid filename.', httpStatus.BAD_REQUEST);
+    }
+    let stats;
+    try {
+        stats = await fsPromises.stat(filePath);
+    } catch (err) {
+        if (err.code === 'ENOENT') {
+            req.payload.logger.error(`File ${filename} for collection ${collection.config.slug} is missing on the disk. Expected path: ${filePath}`);
+            // Omit going to the routeError handler by returning response instead of
+            // throwing an error to cut down log noise. The response still matches what you get with APIError to not leak details to the user.
+            return Response.json({
+                errors: [
+                    {
+                        message: 'Something went wrong.'
+                    }
+                ]
+            }, {
+                headers: headersWithCors({
+                    headers: new Headers(),
+                    req
+                }),
+                status: 500
+            });
+        }
+        throw err;
+    }
+    const fileTypeResult = await fileTypeFromFile(filePath) || getFileTypeFallback(filePath);
+    let mimeType = fileTypeResult.mime;
+    if (filePath.endsWith('.svg') && fileTypeResult.mime === 'application/xml') {
+        mimeType = 'image/svg+xml';
+    }
+    // Parse Range header for byte range requests
+    const rangeHeader = req.headers.get('range');
+    const rangeResult = parseRangeHeader({
+        fileSize: stats.size,
+        rangeHeader
+    });
+    if (rangeResult.type === 'invalid') {
+        let headers = new Headers();
+        headers.set('Content-Range', `bytes */${stats.size}`);
+        headers = collection.config.upload?.modifyResponseHeaders ? collection.config.upload.modifyResponseHeaders({
+            headers
+        }) || headers : headers;
+        return new Response(null, {
+            headers: headersWithCors({
+                headers,
+                req
+            }),
+            status: httpStatus.REQUESTED_RANGE_NOT_SATISFIABLE
+        });
+    }
+    let headers = new Headers();
+    headers.set('Content-Type', mimeType);
+    headers.set('Accept-Ranges', 'bytes');
+    if (mimeType === 'image/svg+xml') {
+        headers.set('Content-Security-Policy', "script-src 'none'");
+    }
+    let data;
+    let status;
+    const isPartial = rangeResult.type === 'partial';
+    const range = rangeResult.range;
+    if (isPartial && range) {
+        const contentLength = range.end - range.start + 1;
+        headers.set('Content-Length', String(contentLength));
+        headers.set('Content-Range', `bytes ${range.start}-${range.end}/${stats.size}`);
+        data = streamFile({
+            filePath,
+            options: {
+                end: range.end,
+                start: range.start
+            }
+        });
+        status = httpStatus.PARTIAL_CONTENT;
+    } else {
+        headers.set('Content-Length', String(stats.size));
+        data = streamFile({
+            filePath
+        });
+        status = httpStatus.OK;
+    }
+    headers = collection.config.upload?.modifyResponseHeaders ? collection.config.upload.modifyResponseHeaders({
+        headers
+    }) || headers : headers;
+    return new Response(data, {
+        headers: headersWithCors({
+            headers,
+            req
+        }),
+        status
+    });
+};
+
+//# sourceMappingURL=getFile.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/endpoints/getFile.ts"],"sourcesContent":["import type { Stats } from 'fs'\n\nimport { fileTypeFromFile } from 'file-type'\nimport fsPromises from 'fs/promises'\nimport { status as httpStatus } from 'http-status'\nimport path from 'path'\n\nimport type { PayloadHandler } from '../../config/types.js'\n\nimport { APIError } from '../../errors/APIError.js'\nimport { checkFileAccess } from '../../uploads/checkFileAccess.js'\nimport { streamFile } from '../../uploads/fetchAPI-stream-file/index.js'\nimport { getFileTypeFallback } from '../../uploads/getFileTypeFallback.js'\nimport { parseRangeHeader } from '../../uploads/parseRangeHeader.js'\nimport { getRequestCollection } from '../../utilities/getRequestEntity.js'\nimport { headersWithCors } from '../../utilities/headersWithCors.js'\n\nexport const getFileHandler: PayloadHandler = async (req) => {\n  const collection = getRequestCollection(req)\n\n  const filename = req.routeParams?.filename as string\n\n  if (!collection.config.upload) {\n    throw new APIError(\n      `This collection is not an upload collection: ${collection.config.slug}`,\n      httpStatus.BAD_REQUEST,\n    )\n  }\n\n  const accessResult = (await checkFileAccess({\n    collection,\n    filename,\n    req,\n  }))!\n\n  if (accessResult instanceof Response) {\n    return accessResult\n  }\n\n  if (collection.config.upload.handlers?.length) {\n    let customResponse: null | Response | void = null\n    const headers = new Headers()\n\n    for (const handler of collection.config.upload.handlers) {\n      customResponse = await handler(req, {\n        doc: accessResult,\n        headers,\n        params: {\n          collection: collection.config.slug,\n          filename,\n        },\n      })\n      if (customResponse && customResponse instanceof Response) {\n        break\n      }\n    }\n\n    if (customResponse instanceof Response) {\n      return customResponse\n    }\n  }\n\n  // Local filesystem fallback — cloud storage handlers return a Response above\n  // and have their own filename validation via sanitizeFilename.\n  const fileDir = collection.config.upload?.staticDir || collection.config.slug\n  const resolvedDir = path.resolve(fileDir)\n  const filePath = path.resolve(resolvedDir, filename)\n\n  if (!filePath.startsWith(resolvedDir + path.sep)) {\n    throw new APIError('Invalid filename.', httpStatus.BAD_REQUEST)\n  }\n\n  let stats: Stats\n\n  try {\n    stats = await fsPromises.stat(filePath)\n  } catch (err) {\n    if ((err as { code?: string }).code === 'ENOENT') {\n      req.payload.logger.error(\n        `File ${filename} for collection ${collection.config.slug} is missing on the disk. Expected path: ${filePath}`,\n      )\n\n      // Omit going to the routeError handler by returning response instead of\n      // throwing an error to cut down log noise. The response still matches what you get with APIError to not leak details to the user.\n      return Response.json(\n        {\n          errors: [\n            {\n              message: 'Something went wrong.',\n            },\n          ],\n        },\n        {\n          headers: headersWithCors({\n            headers: new Headers(),\n            req,\n          }),\n          status: 500,\n        },\n      )\n    }\n\n    throw err\n  }\n\n  const fileTypeResult = (await fileTypeFromFile(filePath)) || getFileTypeFallback(filePath)\n  let mimeType = fileTypeResult.mime\n\n  if (filePath.endsWith('.svg') && fileTypeResult.mime === 'application/xml') {\n    mimeType = 'image/svg+xml'\n  }\n\n  // Parse Range header for byte range requests\n  const rangeHeader = req.headers.get('range')\n  const rangeResult = parseRangeHeader({\n    fileSize: stats.size,\n    rangeHeader,\n  })\n\n  if (rangeResult.type === 'invalid') {\n    let headers = new Headers()\n    headers.set('Content-Range', `bytes */${stats.size}`)\n    headers = collection.config.upload?.modifyResponseHeaders\n      ? collection.config.upload.modifyResponseHeaders({ headers }) || headers\n      : headers\n\n    return new Response(null, {\n      headers: headersWithCors({\n        headers,\n        req,\n      }),\n      status: httpStatus.REQUESTED_RANGE_NOT_SATISFIABLE,\n    })\n  }\n\n  let headers = new Headers()\n  headers.set('Content-Type', mimeType)\n  headers.set('Accept-Ranges', 'bytes')\n\n  if (mimeType === 'image/svg+xml') {\n    headers.set('Content-Security-Policy', \"script-src 'none'\")\n  }\n\n  let data: ReadableStream\n  let status: number\n  const isPartial = rangeResult.type === 'partial'\n  const range = rangeResult.range\n\n  if (isPartial && range) {\n    const contentLength = range.end - range.start + 1\n    headers.set('Content-Length', String(contentLength))\n    headers.set('Content-Range', `bytes ${range.start}-${range.end}/${stats.size}`)\n    data = streamFile({ filePath, options: { end: range.end, start: range.start } })\n    status = httpStatus.PARTIAL_CONTENT\n  } else {\n    headers.set('Content-Length', String(stats.size))\n    data = streamFile({ filePath })\n    status = httpStatus.OK\n  }\n\n  headers = collection.config.upload?.modifyResponseHeaders\n    ? collection.config.upload.modifyResponseHeaders({ headers }) || headers\n    : headers\n\n  return new Response(data, {\n    headers: headersWithCors({\n      headers,\n      req,\n    }),\n    status,\n  })\n}\n"],"names":["fileTypeFromFile","fsPromises","status","httpStatus","path","APIError","checkFileAccess","streamFile","getFileTypeFallback","parseRangeHeader","getRequestCollection","headersWithCors","getFileHandler","req","collection","filename","routeParams","config","upload","slug","BAD_REQUEST","accessResult","Response","handlers","length","customResponse","headers","Headers","handler","doc","params","fileDir","staticDir","resolvedDir","resolve","filePath","startsWith","sep","stats","stat","err","code","payload","logger","error","json","errors","message","fileTypeResult","mimeType","mime","endsWith","rangeHeader","get","rangeResult","fileSize","size","type","set","modifyResponseHeaders","REQUESTED_RANGE_NOT_SATISFIABLE","data","isPartial","range","contentLength","end","start","String","options","PARTIAL_CONTENT","OK"],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+import type { PayloadHandler } from '../../config/types.js';
+export declare const getFileFromURLHandler: PayloadHandler;
+//# sourceMappingURL=getFileFromURL.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getFileFromURL.d.ts","sourceRoot":"","sources":["../../../src/uploads/endpoints/getFileFromURL.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAgB3D,eAAO,MAAM,qBAAqB,EAAE,cA+GnC,CAAA"}

package/dist/uploads/endpoints/getFileFromURL.js

@@ -0,0 +1,112 @@
+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';
+// 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)=>{
+    const { id, collection } = getRequestCollectionWithID(req, {
+        optionalID: true
+    });
+    if (!req.user) {
+        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({
+            req
+        }, config.access.update);
+        if (!accessResult) {
+            throw new Forbidden(req.t);
+        }
+    } else {
+        // creating doc
+        const accessResult = await executeAccess({
+            req
+        }, config.access?.create);
+        if (!accessResult) {
+            throw new Forbidden(req.t);
+        }
+    }
+    if (!req.url) {
+        throw new APIError('Request URL is missing.', 400);
+    }
+    const { searchParams } = new URL(req.url);
+    const src = searchParams.get('src');
+    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;
+    }
+    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 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
+    const asciiFileName = safeFileName.replace(/["\\\r\n]/g, '_');
+    return new Response(response.body, {
+        headers: {
+            'Content-Disposition': `attachment; filename="${asciiFileName}"; filename*=UTF-8''${encodedFileName}`,
+            'Content-Length': response.headers.get('content-length') || '',
+            'Content-Type': response.headers.get('content-type') || 'application/octet-stream'
+        }
+    });
+};
+
+//# sourceMappingURL=getFileFromURL.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/endpoints/getFileFromURL.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 { isURLAllowed } from '../../utilities/isURLAllowed.js'\nimport { sanitizeFilename } from '../../utilities/sanitizeFilename.js'\nimport { safeFetch } from '../safeFetch.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 getFileFromURLHandler: 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 (!config.upload?.pasteURL) {\n    throw new APIError('Pasting from URL is not enabled for this collection.', 400)\n  }\n\n  if (id) {\n    // updating doc\n    const accessResult = await executeAccess({ req }, config.access.update)\n    if (!accessResult) {\n      throw new Forbidden(req.t)\n    }\n  } else {\n    // creating doc\n    const accessResult = await executeAccess({ 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 hasAllowList =\n    typeof config.upload.pasteURL === 'object' && Array.isArray(config.upload.pasteURL.allowList)\n\n  let fileURL: string\n  try {\n    fileURL = new URL(src).href\n  } catch {\n    throw new APIError('A valid URL string is required.', 400)\n  }\n\n  if (hasAllowList && !isURLAllowed(fileURL, config.upload.pasteURL.allowList)) {\n    throw new APIError('The provided URL is not allowed.', 400)\n  }\n\n  let redirectCount = 0\n  const maxRedirects = 3\n  let response!: Response\n\n  while (true) {\n    if (hasAllowList && isURLAllowed(fileURL, config.upload.pasteURL.allowList)) {\n      // Allow-listed URLs bypass SSRF filtering (e.g. internal/localhost CDNs)\n      response = await fetch(fileURL, {\n        headers: { 'Accept-Encoding': 'identity' },\n        redirect: 'manual',\n        signal: AbortSignal.timeout(30_000),\n      })\n    } else {\n      response = await safeFetch(fileURL, {\n        headers: {\n          'Accept-Encoding': 'identity',\n        },\n        signal: AbortSignal.timeout(30_000),\n      })\n    }\n\n    if (response.status >= 300 && response.status < 400) {\n      redirectCount++\n      if (redirectCount > maxRedirects) {\n        throw new APIError('Too many redirects.', 403)\n      }\n      const location = response.headers.get('location')\n      if (location) {\n        fileURL = new URL(location, fileURL).href\n        if (hasAllowList && !isURLAllowed(fileURL, config.upload.pasteURL.allowList)) {\n          throw new APIError('The provided URL is not allowed.', 400)\n        }\n        continue\n      }\n    }\n\n    break\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(fileURL).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  return new Response(response.body, {\n    headers: {\n      'Content-Disposition': `attachment; filename=\"${asciiFileName}\"; filename*=UTF-8''${encodedFileName}`,\n      'Content-Length': response.headers.get('content-length') || '',\n      'Content-Type': response.headers.get('content-type') || 'application/octet-stream',\n    },\n  })\n}\n"],"names":["executeAccess","APIError","Forbidden","getRequestCollectionWithID","isURLAllowed","sanitizeFilename","safeFetch","getFileFromURLHandler","req","id","collection","optionalID","user","t","config","upload","pasteURL","accessResult","access","update","create","url","searchParams","URL","src","get","hasAllowList","Array","isArray","allowList","fileURL","href","redirectCount","maxRedirects","response","fetch","headers","redirect","signal","AbortSignal","timeout","status","location","ok","rawFileName","decodeURIComponent","pathname","split","pop","safeFileName","encodedFileName","encodeURIComponent","replace","c","charCodeAt","toString","toUpperCase","asciiFileName","Response","body"],"mappings":"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"}

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

@@ -0,0 +1,3 @@
+import type { Endpoint } from '../../config/types.js';
+export declare const uploadCollectionEndpoints: Endpoint[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/uploads/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAA;AAMrD,eAAO,MAAM,yBAAyB,EAAE,QAAQ,EAW9C,CAAA"}

package/dist/uploads/endpoints/index.js

@@ -0,0 +1,17 @@
+import { wrapInternalEndpoints } from '../../utilities/wrapInternalEndpoints.js';
+import { getFileHandler } from './getFile.js';
+import { getFileFromURLHandler } from './getFileFromURL.js';
+export const uploadCollectionEndpoints = wrapInternalEndpoints([
+    {
+        handler: getFileFromURLHandler,
+        method: 'get',
+        path: '/paste-url/:id?'
+    },
+    {
+        handler: getFileHandler,
+        method: 'get',
+        path: '/file/:filename'
+    }
+]);
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/endpoints/index.ts"],"sourcesContent":["import type { Endpoint } from '../../config/types.js'\n\nimport { wrapInternalEndpoints } from '../../utilities/wrapInternalEndpoints.js'\nimport { getFileHandler } from './getFile.js'\nimport { getFileFromURLHandler } from './getFileFromURL.js'\n\nexport const uploadCollectionEndpoints: Endpoint[] = wrapInternalEndpoints([\n  {\n    handler: getFileFromURLHandler,\n    method: 'get',\n    path: '/paste-url/:id?',\n  },\n  {\n    handler: getFileHandler,\n    method: 'get',\n    path: '/file/:filename',\n  },\n])\n"],"names":["wrapInternalEndpoints","getFileHandler","getFileFromURLHandler","uploadCollectionEndpoints","handler","method","path"],"mappings":"AAEA,SAASA,qBAAqB,QAAQ,2CAA0C;AAChF,SAASC,cAAc,QAAQ,eAAc;AAC7C,SAASC,qBAAqB,QAAQ,sBAAqB;AAE3D,OAAO,MAAMC,4BAAwCH,sBAAsB;IACzE;QACEI,SAASF;QACTG,QAAQ;QACRC,MAAM;IACR;IACA;QACEF,SAASH;QACTI,QAAQ;QACRC,MAAM;IACR;CACD,EAAC"}

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

@@ -0,0 +1,16 @@
+import type { FetchAPIFileUploadOptions } from '../../config/types.js';
+import type { FileShape } from './index.js';
+type FileFactoryOptions = {
+    buffer: Buffer;
+    encoding: string;
+    hash: Buffer | string;
+    mimetype: string;
+    name: string;
+    size: number;
+    tempFilePath: string;
+    truncated: boolean;
+};
+type FileFactory = (options: FileFactoryOptions, fileUploadOptions: FetchAPIFileUploadOptions) => FileShape;
+export declare const fileFactory: FileFactory;
+export {};
+//# sourceMappingURL=fileFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fileFactory.d.ts","sourceRoot":"","sources":["../../../src/uploads/fetchAPI-multipart/fileFactory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAoC3C,KAAK,kBAAkB,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AACD,KAAK,WAAW,GAAG,CACjB,OAAO,EAAE,kBAAkB,EAC3B,iBAAiB,EAAE,yBAAyB,KACzC,SAAS,CAAA;AACd,eAAO,MAAM,WAAW,EAAE,WA4BzB,CAAA"}

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

@@ -0,0 +1,44 @@
+import { checkAndMakeDir, debugLog, isFunc, moveFile, promiseCallback, saveBufferToFile } from './utilities.js';
+/**
+ * Returns Local function that moves the file to a different location on the filesystem
+ * which takes two function arguments to make it compatible w/ Promise or Callback APIs
+ */ const moveFromTemp = (filePath, options, fileUploadOptions)=>(resolve, reject)=>{
+        debugLog(fileUploadOptions, `Moving temporary file ${options.tempFilePath} to ${filePath}`);
+        moveFile(options.tempFilePath, filePath, promiseCallback(resolve, reject));
+    };
+/**
+ * Returns Local function that moves the file from buffer to a different location on the filesystem
+ * which takes two function arguments to make it compatible w/ Promise or Callback APIs
+ */ const moveFromBuffer = (filePath, options, fileUploadOptions)=>(resolve, reject)=>{
+        debugLog(fileUploadOptions, `Moving uploaded buffer to ${filePath}`);
+        // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve
+        saveBufferToFile(options.buffer, filePath, promiseCallback(resolve, reject));
+    };
+export const fileFactory = (options, fileUploadOptions)=>{
+    // see: https://github.com/richardgirges/express-fileupload/issues/14
+    // firefox uploads empty file in case of cache miss when f5ing page.
+    // resulting in unexpected behavior. if there is no file data, the file is invalid.
+    // if (!fileUploadOptions.useTempFiles && !options.buffer.length) return;
+    // Create and return file object.
+    return {
+        name: options.name,
+        data: options.buffer,
+        encoding: options.encoding,
+        md5: options.hash,
+        mimetype: options.mimetype,
+        mv: (filePath, callback)=>{
+            // Define a proper move function.
+            const moveFunc = fileUploadOptions.useTempFiles ? moveFromTemp(filePath, options, fileUploadOptions) : moveFromBuffer(filePath, options, fileUploadOptions);
+            // Create a folder for a file.
+            checkAndMakeDir(fileUploadOptions, filePath);
+            // If callback is passed in, use the callback API, otherwise return a promise.
+            const defaultReject = ()=>undefined;
+            return isFunc(callback) ? moveFunc(callback, defaultReject) : new Promise(moveFunc);
+        },
+        size: options.size,
+        tempFilePath: options.tempFilePath,
+        truncated: options.truncated
+    };
+};
+
+//# sourceMappingURL=fileFactory.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/uploads/fetchAPI-multipart/fileFactory.ts"],"sourcesContent":["import type { FetchAPIFileUploadOptions } from '../../config/types.js'\nimport type { FileShape } from './index.js'\n\nimport {\n  checkAndMakeDir,\n  debugLog,\n  isFunc,\n  moveFile,\n  promiseCallback,\n  saveBufferToFile,\n} from './utilities.js'\n\ntype MoveFile = (\n  filePath: string,\n  options: FileFactoryOptions,\n  fileUploadOptions: FetchAPIFileUploadOptions,\n) => (resolve: () => void, reject: () => void) => void\n\n/**\n * Returns Local function that moves the file to a different location on the filesystem\n * which takes two function arguments to make it compatible w/ Promise or Callback APIs\n */\nconst moveFromTemp: MoveFile = (filePath, options, fileUploadOptions) => (resolve, reject) => {\n  debugLog(fileUploadOptions, `Moving temporary file ${options.tempFilePath} to ${filePath}`)\n  moveFile(options.tempFilePath, filePath, promiseCallback(resolve, reject))\n}\n\n/**\n * Returns Local function that moves the file from buffer to a different location on the filesystem\n * which takes two function arguments to make it compatible w/ Promise or Callback APIs\n */\nconst moveFromBuffer: MoveFile = (filePath, options, fileUploadOptions) => (resolve, reject) => {\n  debugLog(fileUploadOptions, `Moving uploaded buffer to ${filePath}`)\n  // @ts-expect-error - vestiges of when tsconfig was not strict. Feel free to improve\n  saveBufferToFile(options.buffer, filePath, promiseCallback(resolve, reject))\n}\n\ntype FileFactoryOptions = {\n  buffer: Buffer\n  encoding: string\n  hash: Buffer | string\n  mimetype: string\n  name: string\n  size: number\n  tempFilePath: string\n  truncated: boolean\n}\ntype FileFactory = (\n  options: FileFactoryOptions,\n  fileUploadOptions: FetchAPIFileUploadOptions,\n) => FileShape\nexport const fileFactory: FileFactory = (options, fileUploadOptions) => {\n  // see: https://github.com/richardgirges/express-fileupload/issues/14\n  // firefox uploads empty file in case of cache miss when f5ing page.\n  // resulting in unexpected behavior. if there is no file data, the file is invalid.\n  // if (!fileUploadOptions.useTempFiles && !options.buffer.length) return;\n\n  // Create and return file object.\n  return {\n    name: options.name,\n    data: options.buffer,\n    encoding: options.encoding,\n    md5: options.hash,\n    mimetype: options.mimetype,\n    mv: (filePath: string, callback) => {\n      // Define a proper move function.\n      const moveFunc = fileUploadOptions.useTempFiles\n        ? moveFromTemp(filePath, options, fileUploadOptions)\n        : moveFromBuffer(filePath, options, fileUploadOptions)\n      // Create a folder for a file.\n      checkAndMakeDir(fileUploadOptions, filePath)\n      // If callback is passed in, use the callback API, otherwise return a promise.\n      const defaultReject = () => undefined\n      return isFunc(callback) ? moveFunc(callback, defaultReject) : new Promise(moveFunc)\n    },\n    size: options.size,\n    tempFilePath: options.tempFilePath,\n    truncated: options.truncated,\n  }\n}\n"],"names":["checkAndMakeDir","debugLog","isFunc","moveFile","promiseCallback","saveBufferToFile","moveFromTemp","filePath","options","fileUploadOptions","resolve","reject","tempFilePath","moveFromBuffer","buffer","fileFactory","name","data","encoding","md5","hash","mimetype","mv","callback","moveFunc","useTempFiles","defaultReject","undefined","Promise","size","truncated"],"mappings":"AAGA,SACEA,eAAe,EACfC,QAAQ,EACRC,MAAM,EACNC,QAAQ,EACRC,eAAe,EACfC,gBAAgB,QACX,iBAAgB;AAQvB;;;CAGC,GACD,MAAMC,eAAyB,CAACC,UAAUC,SAASC,oBAAsB,CAACC,SAASC;QACjFV,SAASQ,mBAAmB,CAAC,sBAAsB,EAAED,QAAQI,YAAY,CAAC,IAAI,EAAEL,UAAU;QAC1FJ,SAASK,QAAQI,YAAY,EAAEL,UAAUH,gBAAgBM,SAASC;IACpE;AAEA;;;CAGC,GACD,MAAME,iBAA2B,CAACN,UAAUC,SAASC,oBAAsB,CAACC,SAASC;QACnFV,SAASQ,mBAAmB,CAAC,0BAA0B,EAAEF,UAAU;QACnE,oFAAoF;QACpFF,iBAAiBG,QAAQM,MAAM,EAAEP,UAAUH,gBAAgBM,SAASC;IACtE;AAgBA,OAAO,MAAMI,cAA2B,CAACP,SAASC;IAChD,qEAAqE;IACrE,oEAAoE;IACpE,mFAAmF;IACnF,yEAAyE;IAEzE,iCAAiC;IACjC,OAAO;QACLO,MAAMR,QAAQQ,IAAI;QAClBC,MAAMT,QAAQM,MAAM;QACpBI,UAAUV,QAAQU,QAAQ;QAC1BC,KAAKX,QAAQY,IAAI;QACjBC,UAAUb,QAAQa,QAAQ;QAC1BC,IAAI,CAACf,UAAkBgB;YACrB,iCAAiC;YACjC,MAAMC,WAAWf,kBAAkBgB,YAAY,GAC3CnB,aAAaC,UAAUC,SAASC,qBAChCI,eAAeN,UAAUC,SAASC;YACtC,8BAA8B;YAC9BT,gBAAgBS,mBAAmBF;YACnC,8EAA8E;YAC9E,MAAMmB,gBAAgB,IAAMC;YAC5B,OAAOzB,OAAOqB,YAAYC,SAASD,UAAUG,iBAAiB,IAAIE,QAAQJ;QAC5E;QACAK,MAAMrB,QAAQqB,IAAI;QAClBjB,cAAcJ,QAAQI,YAAY;QAClCkB,WAAWtB,QAAQsB,SAAS;IAC9B;AACF,EAAC"}

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

@@ -0,0 +1,14 @@
+import type { FetchAPIFileUploadOptions } from '../../config/types.js';
+type Handler = (options: FetchAPIFileUploadOptions, fieldname: string, filename: string) => {
+    cleanup: () => void;
+    complete: () => Buffer;
+    dataHandler: (data: Buffer) => void;
+    getFilePath: () => string;
+    getFileSize: () => number;
+    getHash: () => string;
+    getWritePromise: () => Promise<boolean>;
+};
+export declare const tempFileHandler: Handler;
+export declare const memHandler: Handler;
+export {};
+//# sourceMappingURL=handlers.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,87 @@
+import crypto from 'crypto';
+import fs, { WriteStream } from 'fs';
+import path from 'path';
+import { checkAndMakeDir, debugLog, deleteFile, getTempFilename } from './utilities.js';
+export const tempFileHandler = (options, fieldname, filename)=>{
+    const tempFilePath = path.resolve(options.tempFileDir, getTempFilename());
+    checkAndMakeDir({
+        createParentPath: true
+    }, tempFilePath);
+    debugLog(options, `Temporary file path is ${tempFilePath}`);
+    const hash = crypto.createHash('md5');
+    let fileSize = 0;
+    let completed = false;
+    debugLog(options, `Opening write stream for ${fieldname}->${filename}...`);
+    const writeStream = fs.createWriteStream(tempFilePath);
+    const writePromise = new Promise((resolve, reject)=>{
+        writeStream.on('finish', ()=>resolve(true));
+        writeStream.on('error', (err)=>{
+            debugLog(options, `Error write temp file: ${err}`);
+            reject(err);
+        });
+    });
+    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.`));
+        },
+        complete: ()=>{
+            completed = true;
+            debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
+            if (writeStream instanceof WriteStream) {
+                writeStream.end();
+            }
+            // Return empty buff since data was uploaded into a temp file.
+            return Buffer.concat([]);
+        },
+        dataHandler: (data)=>{
+            if (completed === true) {
+                debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
+                return;
+            }
+            writeStream.write(data);
+            hash.update(data);
+            fileSize += data.length;
+            debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+        },
+        getFilePath: ()=>tempFilePath,
+        getFileSize: ()=>fileSize,
+        getHash: ()=>hash.digest('hex'),
+        getWritePromise: ()=>writePromise
+    };
+};
+export const memHandler = (options, fieldname, filename)=>{
+    const buffers = [];
+    const hash = crypto.createHash('md5');
+    let fileSize = 0;
+    let completed = false;
+    const getBuffer = ()=>Buffer.concat(buffers, fileSize);
+    return {
+        cleanup: ()=>{
+            completed = true;
+        },
+        complete: ()=>{
+            debugLog(options, `Upload ${fieldname}->${filename} completed, bytes:${fileSize}.`);
+            completed = true;
+            return getBuffer();
+        },
+        dataHandler: (data)=>{
+            if (completed === true) {
+                debugLog(options, `Error: got ${fieldname}->${filename} data chunk for completed upload!`);
+                return;
+            }
+            buffers.push(data);
+            hash.update(data);
+            fileSize += data.length;
+            debugLog(options, `Uploading ${fieldname}->${filename}, bytes:${fileSize}...`);
+        },
+        getFilePath: ()=>'',
+        getFileSize: ()=>fileSize,
+        getHash: ()=>hash.digest('hex'),
+        getWritePromise: ()=>Promise.resolve(true)
+    };
+};
+
+//# sourceMappingURL=handlers.js.map

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

@@ -0,0 +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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"}

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

@@ -0,0 +1,32 @@
+import type { FetchAPIFileUploadOptions } from '../../config/types.js';
+import { APIError } from '../../errors/APIError.js';
+export type FileShape = {
+    data: Buffer;
+    encoding: string;
+    md5: Buffer | string;
+    mimetype: string;
+    mv: (filePath: string, callback: () => void) => Promise<void> | void;
+    name: string;
+    size: number;
+    tempFilePath: string;
+    truncated: boolean;
+};
+type FetchAPIFileUploadResponseFile = {
+    data: Buffer;
+    mimetype: string;
+    name: string;
+    size: number;
+    tempFilePath?: string;
+};
+export type FetchAPIFileUploadResponse = {
+    error?: APIError;
+    fields: Record<string, string>;
+    files: Record<string, FetchAPIFileUploadResponseFile>;
+};
+type FetchAPIFileUpload = (args: {
+    options?: FetchAPIFileUploadOptions;
+    request: Request;
+}) => Promise<FetchAPIFileUploadResponse>;
+export declare const processMultipartFormdata: FetchAPIFileUpload;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,40 @@
+import { APIError } from '../../errors/APIError.js';
+import { isEligibleRequest } from './isEligibleRequest.js';
+import { processMultipart } from './processMultipart.js';
+import { debugLog } from './utilities.js';
+const DEFAULT_UPLOAD_OPTIONS = {
+    abortOnLimit: false,
+    createParentPath: false,
+    debug: false,
+    defParamCharset: 'utf8',
+    limitHandler: false,
+    parseNested: false,
+    preserveExtension: false,
+    responseOnLimit: 'File size limit has been reached',
+    safeFileNames: false,
+    tempFileDir: 'tmp',
+    uploadTimeout: 60000,
+    uriDecodeFileNames: false,
+    useTempFiles: false
+};
+export const processMultipartFormdata = async ({ options: incomingOptions, request })=>{
+    const options = {
+        ...DEFAULT_UPLOAD_OPTIONS,
+        ...incomingOptions
+    };
+    if (!isEligibleRequest(request)) {
+        debugLog(options, 'Request is not eligible for file upload!');
+        return {
+            error: new APIError('Request is not eligible for file upload', 500),
+            fields: undefined,
+            files: undefined
+        };
+    } else {
+        return processMultipart({
+            options,
+            request
+        });
+    }
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,2 @@
+export declare const isEligibleRequest: (req: Request) => boolean;
+//# sourceMappingURL=isEligibleRequest.d.ts.map