fix: formatting, tests are buggy as hell

Signed-off-by: tunnckoCore <[email protected]>

Author: tunnckoCore

eslint.config.js

@@ -3,7 +3,7 @@ import xaxa from 'eslint-config-xaxa';
 export default xaxa({
   ignores: [
     '**/super-headers.js',
-    '**/packages/formidable-v3/**',
+    // '**/packages/formidable-v3/**',
     '**/*.cjs',
     'async-gens-with-queues-slow.ts',
   ],
@@ -19,4 +19,27 @@ export default xaxa({
       variables: true,
     }],
   },
+}, {
+  files: ['**/*.test.js', '**/*.test.ts'],
+  languageOptions: {
+    globals: {
+      // jest
+      afterAll: 'readonly',
+      afterEach: 'readonly',
+      beforeAll: 'readonly',
+      beforeEach: 'readonly',
+      // mocha
+      context: 'readonly',
+      describe: 'readonly',
+      expect: 'readonly',
+      it: 'readonly',
+
+      suite: 'readonly',
+      test: 'readonly',
+    },
+  },
+  name: 'test-files',
+  rules: {
+    // 'no-undef': 'off',
+  },
 });

packages/formidable-v3/src/Formidable.js

@@ -9,85 +9,93 @@ import os from 'node:os';
 import path from 'node:path';
 import { StringDecoder } from 'node:string_decoder';
 import once from 'once';
+
 import FormidableError, * as errors from './FormidableError.js';
-import PersistentFile from './PersistentFile.js';
-import VolatileFile from './VolatileFile.js';
 import DummyParser from './parsers/Dummy.js';
 import MultipartParser from './parsers/Multipart.js';
-import { json, multipart, octetstream, querystring } from './plugins/index.js';
+import PersistentFile from './PersistentFile.js';
+import {
+  json,
+  multipart,
+  octetstream,
+  querystring,
+} from './plugins/index.js';
+import VolatileFile from './VolatileFile.js';
 
-const CUID2_FINGERPRINT = `${process.env.NODE_ENV}-${os.platform()}-${os.hostname()}`
-const createId = cuid2init({ length: 25, fingerprint: CUID2_FINGERPRINT.toLowerCase() });
+const CUID2_FINGERPRINT = `${process.env.NODE_ENV}-${os.platform()}-${os.hostname()}`;
+const createId = cuid2init({ fingerprint: CUID2_FINGERPRINT.toLowerCase(), length: 25 });
 
 const DEFAULT_OPTIONS = {
-  maxFields: 1000,
-  maxFieldsSize: 20 * 1024 * 1024,
-  maxFiles: Infinity,
-  maxFileSize: 200 * 1024 * 1024,
-  maxTotalFileSize: undefined,
-  minFileSize: 1,
   allowEmptyFiles: false,
   createDirsFromUploads: false,
-  keepExtensions: false,
-  encoding: 'utf-8',
-  hashAlgorithm: false,
-  uploadDir: os.tmpdir(),
+  defaultInvalidName: 'invalid-name',
   enabledPlugins: [octetstream, querystring, multipart, json],
+  encoding: 'utf-8',
+  filename: undefined,
   fileWriteStreamHandler: null,
-  defaultInvalidName: 'invalid-name',
   filter(_part) {
     return true;
   },
-  filename: undefined,
+  hashAlgorithm: false,
+  keepExtensions: false,
+  maxFields: 1000,
+  maxFieldsSize: 20 * 1024 * 1024,
+  maxFiles: Infinity,
+  maxFileSize: 200 * 1024 * 1024,
+  maxTotalFileSize: undefined,
+  minFileSize: 1,
+  uploadDir: os.tmpdir(),
 };
 
 function hasOwnProp(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj, key);
+  return Object.hasOwn(obj, key);
 }
 
-
-const decorateForceSequential = function (promiseCreator) {
+function decorateForceSequential(promiseCreator) {
   /* forces a function that returns a promise to be sequential
   useful for fs  for example */
   let lastPromise = Promise.resolve();
+
   return async function (...x) {
-      const promiseWeAreWaitingFor = lastPromise;
-      let currentPromise;
-      let callback;
-      // we need to change lastPromise before await anything,
-      // otherwise 2 calls might wait the same thing
-      lastPromise = new Promise(function (resolve) {
-          callback = resolve;
-      });
-      await promiseWeAreWaitingFor;
-      currentPromise = promiseCreator(...x);
-      currentPromise.then(callback).catch(callback);
-      return currentPromise;
+    const promiseWeAreWaitingFor = lastPromise;
+    let currentPromise;
+    let callback;
+    // we need to change lastPromise before await anything,
+    // otherwise 2 calls might wait the same thing
+    lastPromise = new Promise((resolve) => {
+      callback = resolve;
+    });
+    await promiseWeAreWaitingFor;
+    currentPromise = promiseCreator(...x);
+    currentPromise.then(callback).catch(callback);
+    return currentPromise;
   };
-};
+}
 
-const createNecessaryDirectoriesAsync = decorateForceSequential(function (filePath) {
+const createNecessaryDirectoriesAsync = decorateForceSequential((filePath) => {
   const directoryname = path.dirname(filePath);
+
   return fsPromises.mkdir(directoryname, { recursive: true });
 });
 
-const invalidExtensionChar = (c) => {
+function invalidExtensionChar(c) {
   const code = c.charCodeAt(0);
+
   return !(
-    code === 46 || // .
-    (code >= 48 && code <= 57) ||
-    (code >= 65 && code <= 90) ||
-    (code >= 97 && code <= 122)
+    code === 46 // .
+    || (code >= 48 && code <= 57)
+    || (code >= 65 && code <= 90)
+    || (code >= 97 && code <= 122)
   );
-};
+}
 
 class IncomingForm extends EventEmitter {
   constructor(options = {}) {
     super();
 
     this.options = { ...DEFAULT_OPTIONS, ...options };
     if (!this.options.maxTotalFileSize) {
-      this.options.maxTotalFileSize = this.options.maxFileSize
+      this.options.maxTotalFileSize = this.options.maxFileSize;
     }
 
     const dir = path.resolve(
@@ -150,7 +158,7 @@ class IncomingForm extends EventEmitter {
     return this;
   }
 
-  pause () {
+  pause() {
     try {
       this.req.pause();
     } catch (err) {
@@ -164,7 +172,7 @@ class IncomingForm extends EventEmitter {
     return true;
   }
 
-  resume () {
+  resume() {
     try {
       this.req.resume();
     } catch (err) {
@@ -198,7 +206,7 @@ class IncomingForm extends EventEmitter {
         } else {
           resolveRef([fields, files]);
         }
-      }
+      };
     }
     const callback = once(dezalgo(cb));
     this.fields = {};
@@ -256,6 +264,7 @@ class IncomingForm extends EventEmitter {
           this._parser.end();
         }
       });
+
     if (promise) {
       return promise;
     }
@@ -365,10 +374,10 @@ class IncomingForm extends EventEmitter {
     const newFilename = this._getNewName(part);
     const filepath = this._joinDirectoryName(newFilename);
     const file = await this._newFile({
-      newFilename,
       filepath,
-      originalFilename: part.originalFilename,
       mimetype: part.mimetype,
+      newFilename,
+      originalFilename: part.originalFilename,
     });
     file.on('error', (err) => {
       this._error(err);
@@ -459,7 +468,6 @@ class IncomingForm extends EventEmitter {
       return;
     }
 
-
     new DummyParser(this, this.options);
 
     const results = [];
@@ -517,21 +525,26 @@ class IncomingForm extends EventEmitter {
     return new MultipartParser(this.options);
   }
 
-  async _newFile({ filepath, originalFilename, mimetype, newFilename }) {
+  async _newFile({
+    filepath,
+    mimetype,
+    newFilename,
+    originalFilename,
+  }) {
     if (this.options.fileWriteStreamHandler) {
       return new VolatileFile({
-        newFilename,
-        filepath,
-        originalFilename,
-        mimetype,
         createFileWriteStream: this.options.fileWriteStreamHandler,
+        filepath,
         hashAlgorithm: this.options.hashAlgorithm,
+        mimetype,
+        newFilename,
+        originalFilename,
       });
     }
     if (this.options.createDirsFromUploads) {
       try {
         await createNecessaryDirectoriesAsync(filepath);
-      } catch (errorCreatingDir) {
+      } catch (err) {
         this._error(new FormidableError(
           `cannot create directory`,
           errors.cannotCreateDir,
@@ -540,27 +553,26 @@ class IncomingForm extends EventEmitter {
       }
     }
     return new PersistentFile({
-      newFilename,
       filepath,
-      originalFilename,
-      mimetype,
       hashAlgorithm: this.options.hashAlgorithm,
+      mimetype,
+      newFilename,
+      originalFilename,
     });
   }
 
   _getFileName(headerValue) {
     // matches either a quoted-string or a token (RFC 2616 section 19.5.1)
     const m = headerValue.match(
-      /\bfilename=("(.*?)"|([^()<>{}[\]@,;:"?=\s/\t]+))($|;\s)/i,
+      /\bfilename=("(.*?)"|([^()<>{}[\]@,;:"?=\s/]+))($|;\s)/i,
     );
-    if (!m) return null;
+    if (!m) 
+return null;
 
     const match = m[2] || m[3] || '';
     let originalFilename = match.substr(match.lastIndexOf('\\') + 1);
     originalFilename = originalFilename.replace(/%22/g, '"');
-    originalFilename = originalFilename.replace(/&#([\d]{4});/g, (_, code) =>
-      String.fromCharCode(code),
-    );
+    originalFilename = originalFilename.replace(/&#(\d{4});/g, (_, code) => String.fromCharCode(code));
 
     return originalFilename;
   }
@@ -579,7 +591,7 @@ class IncomingForm extends EventEmitter {
     let rawExtname = path.extname(basename);
 
     if (firstDot !== lastDot) {
-      rawExtname =  basename.slice(firstDot);
+      rawExtname = basename.slice(firstDot);
     }
 
     let filtered;
@@ -626,8 +638,9 @@ class IncomingForm extends EventEmitter {
         const name = createId();
 
         if (part && this.options.keepExtensions) {
-          const originalFilename =
-            typeof part === 'string' ? part : part.originalFilename;
+          const originalFilename
+            = typeof part === 'string' ? part : part.originalFilename;
+
           return `${name}${this._getExtension(originalFilename)}`;
         }
 

packages/formidable-v3/src/FormidableError.js

@@ -1,51 +1,29 @@
-const missingPlugin = 1000;
-const pluginFunction = 1001;
-const aborted = 1002;
-const noParser = 1003;
-const uninitializedParser = 1004;
-const filenameNotString = 1005;
-const maxFieldsSizeExceeded = 1006;
-const maxFieldsExceeded = 1007;
-const smallerThanMinFileSize = 1008;
-const biggerThanTotalMaxFileSize = 1009;
-const noEmptyFiles = 1010;
-const missingContentType = 1011;
-const malformedMultipart = 1012;
-const missingMultipartBoundary = 1013;
-const unknownTransferEncoding = 1014;
-const maxFilesExceeded = 1015;
-const biggerThanMaxFileSize = 1016;
-const pluginFailed = 1017;
-const cannotCreateDir = 1018;
+export const missingPlugin = 1000;
+export const pluginFunction = 1001;
+export const aborted = 1002;
+export const noParser = 1003;
+export const uninitializedParser = 1004;
+export const filenameNotString = 1005;
+export const maxFieldsSizeExceeded = 1006;
+export const maxFieldsExceeded = 1007;
+export const smallerThanMinFileSize = 1008;
+export const biggerThanTotalMaxFileSize = 1009;
+export const noEmptyFiles = 1010;
+export const missingContentType = 1011;
+export const malformedMultipart = 1012;
+export const missingMultipartBoundary = 1013;
+export const unknownTransferEncoding = 1014;
+export const maxFilesExceeded = 1015;
+export const biggerThanMaxFileSize = 1016;
+export const pluginFailed = 1017;
+export const cannotCreateDir = 1018;
 
-const FormidableError = class extends Error {
+export const FormidableError = class extends Error {
   constructor(message, internalCode, httpCode = 500) {
     super(message);
     this.code = internalCode;
     this.httpCode = httpCode;
   }
 };
 
-export {
-  missingPlugin,
-  pluginFunction,
-  aborted,
-  noParser,
-  uninitializedParser,
-  filenameNotString,
-  maxFieldsSizeExceeded,
-  maxFieldsExceeded,
-  maxFilesExceeded,
-  smallerThanMinFileSize,
-  biggerThanMaxFileSize,
-  noEmptyFiles,
-  missingContentType,
-  malformedMultipart,
-  missingMultipartBoundary,
-  unknownTransferEncoding,
-  biggerThanTotalMaxFileSize,
-  pluginFailed,
-  cannotCreateDir,
-};
-
 export default FormidableError;