Apply dependencies update

[poolifier.git] / src / worker / abstract-worker.ts

diff --git a/src/worker/abstract-worker.ts b/src/worker/abstract-worker.ts
index b49ede8b0802f1baf39230b087f9b6b99050e8e3..ab56a5e9bb2f8c16c8b774eb2bdd6789de882ee5 100644 (file)
--- a/src/worker/abstract-worker.ts
+++ b/src/worker/abstract-worker.ts
@@ -6,11 +6,11 @@ import { EMPTY_FUNCTION } from '../utils'
 import type { KillBehavior, WorkerOptions } from './worker-options'
 import { KillBehaviors } from './worker-options'
 
-const DEFAULT_MAX_INACTIVE_TIME = 1000 * 60
+const DEFAULT_MAX_INACTIVE_TIME = 60000
 const DEFAULT_KILL_BEHAVIOR: KillBehavior = KillBehaviors.SOFT
 
 /**
- * Base class containing some shared logic for all poolifier workers.
+ * Base class that implements some shared logic for all poolifier workers.
  *
  * @template MainWorker Type of main worker.
  * @template Data Type of data this worker receives from pool's execution. This can only be serializable data.
@@ -84,7 +84,7 @@ export abstract class AbstractWorker<
   ): void {
     if (value.data !== undefined && value.id !== undefined) {
       // Here you will receive messages
-      if (this.opts.async) {
+      if (this.opts.async === true) {
         this.runInAsyncScope(this.runAsync.bind(this), this, fn, value)
       } else {
         this.runInAsyncScope(this.run.bind(this), this, fn, value)
@@ -95,28 +95,26 @@ export abstract class AbstractWorker<
       this.mainWorker = value.parent
     } else if (value.kill !== undefined) {
       // Here is time to kill this worker, just clearing the interval
-      if (this.aliveInterval) clearInterval(this.aliveInterval)
+      if (this.aliveInterval != null) clearInterval(this.aliveInterval)
       this.emitDestroy()
     }
   }
 
-  private checkWorkerOptions (opts: WorkerOptions) {
+  private checkWorkerOptions (opts: WorkerOptions): void {
     this.opts.killBehavior = opts.killBehavior ?? DEFAULT_KILL_BEHAVIOR
     this.opts.maxInactiveTime =
       opts.maxInactiveTime ?? DEFAULT_MAX_INACTIVE_TIME
-    /**
-     * Whether the worker is working asynchronously or not.
-     */
-    this.opts.async = !!opts.async
+    this.opts.async = opts.async ?? false
   }
 
   /**
-   * Check if the `fn` parameter is passed to the constructor.
+   * Checks if the `fn` parameter is passed to the constructor.
    *
    * @param fn The function that should be defined.
    */
   private checkFunctionInput (fn: (data: Data) => Response): void {
-    if (!fn) throw new Error('fn parameter is mandatory')
+    if (fn == null) throw new Error('fn parameter is mandatory')
+    if (typeof fn !== 'function') { throw new TypeError('fn parameter is not a function') }
   }
 
   /**
@@ -125,21 +123,21 @@ export abstract class AbstractWorker<
    * @returns Reference to the main worker.
    */
   protected getMainWorker (): MainWorker {
-    if (!this.mainWorker) {
+    if (this.mainWorker == null) {
       throw new Error('Main worker was not set')
     }
     return this.mainWorker
   }
 
   /**
-   * Send a message to the main worker.
+   * Sends a message to the main worker.
    *
    * @param message The response message.
    */
   protected abstract sendToMainWorker (message: MessageValue<Response>): void
 
   /**
-   * Check to see if the worker should be terminated, because its living too long.
+   * Checks if the worker should be terminated, because its living too long.
    */
   protected checkAlive (): void {
     if (
@@ -151,7 +149,7 @@ export abstract class AbstractWorker<
   }
 
   /**
-   * Handle an error and convert it to a string so it can be sent back to the main worker.
+   * Handles an error and convert it to a string so it can be sent back to the main worker.
    *
    * @param e The error raised by the worker.
    * @returns Message of the error.
@@ -161,7 +159,7 @@ export abstract class AbstractWorker<
   }
 
   /**
-   * Run the given function synchronously.
+   * Runs the given function synchronously.
    *
    * @param fn Function that will be executed.
    * @param value Input data for the given function.
@@ -171,8 +169,10 @@ export abstract class AbstractWorker<
     value: MessageValue<Data>
   ): void {
     try {
+      const startTaskTimestamp = Date.now()
       const res = fn(value.data)
-      this.sendToMainWorker({ data: res, id: value.id })
+      const taskRunTime = Date.now() - startTaskTimestamp
+      this.sendToMainWorker({ data: res, id: value.id, taskRunTime })
     } catch (e) {
       const err = this.handleError(e as Error)
       this.sendToMainWorker({ error: err, id: value.id })
@@ -182,7 +182,7 @@ export abstract class AbstractWorker<
   }
 
   /**
-   * Run the given function asynchronously.
+   * Runs the given function asynchronously.
    *
    * @param fn Function that will be executed.
    * @param value Input data for the given function.
@@ -191,9 +191,11 @@ export abstract class AbstractWorker<
     fn: (data?: Data) => Promise<Response>,
     value: MessageValue<Data>
   ): void {
+    const startTaskTimestamp = Date.now()
     fn(value.data)
       .then(res => {
-        this.sendToMainWorker({ data: res, id: value.id })
+        const taskRunTime = Date.now() - startTaskTimestamp
+        this.sendToMainWorker({ data: res, id: value.id, taskRunTime })
         return null
       })
       .catch(e => {