build(deps-dev): apply updates
[poolifier.git] / src / worker / abstract-worker.ts
index 311a56ad60e00684835e89ef0507d60f0c9d4432..2359758dc72c2a362b60e513890664731fdc7fea 100644 (file)
@@ -1,4 +1,3 @@
-import { AsyncResource } from 'node:async_hooks'
 import type { Worker } from 'node:cluster'
 import type { MessagePort } from 'node:worker_threads'
 import { performance } from 'node:perf_hooks'
@@ -7,26 +6,26 @@ import type {
   Task,
   TaskPerformance,
   WorkerStatistics
-} from '../utility-types'
+} from '../utility-types.js'
 import {
   DEFAULT_TASK_NAME,
   EMPTY_FUNCTION,
   isAsyncFunction,
   isPlainObject
-} from '../utils'
-import { KillBehaviors, type WorkerOptions } from './worker-options'
+} from '../utils.js'
+import { KillBehaviors, type WorkerOptions } from './worker-options.js'
 import type {
   TaskAsyncFunction,
   TaskFunction,
   TaskFunctionOperationResult,
   TaskFunctions,
   TaskSyncFunction
-} from './task-functions'
+} from './task-functions.js'
 import {
   checkTaskFunctionName,
   checkValidTaskFunctionEntry,
   checkValidWorkerOptions
-} from './utils'
+} from './utils.js'
 
 const DEFAULT_MAX_INACTIVE_TIME = 60000
 const DEFAULT_WORKER_OPTIONS: WorkerOptions = {
@@ -56,7 +55,7 @@ export abstract class AbstractWorker<
   MainWorker extends Worker | MessagePort,
   Data = unknown,
   Response = unknown
-> extends AsyncResource {
+> {
   /**
    * Worker id.
    */
@@ -77,29 +76,28 @@ export abstract class AbstractWorker<
    * Handler id of the `activeInterval` worker activity check.
    */
   protected activeInterval?: NodeJS.Timeout
+
   /**
    * Constructs a new poolifier worker.
    *
-   * @param type - The type of async event.
    * @param isMain - Whether this is the main worker or not.
    * @param mainWorker - Reference to main worker.
    * @param taskFunctions - Task function(s) processed by the worker when the pool's `execution` function is invoked. The first function is the default function.
    * @param opts - Options for the worker.
    */
   public constructor (
-    type: string,
     protected readonly isMain: boolean,
     private readonly mainWorker: MainWorker,
     taskFunctions: TaskFunction<Data, Response> | TaskFunctions<Data, Response>,
     protected opts: WorkerOptions = DEFAULT_WORKER_OPTIONS
   ) {
-    super(type)
     if (this.isMain == null) {
       throw new Error('isMain parameter is mandatory')
     }
     this.checkTaskFunctions(taskFunctions)
     this.checkWorkerOptions(this.opts)
     if (!this.isMain) {
+      // Should be once() but Node.js on windows has a bug that prevents it from working
       this.getMainWorker().on('message', this.handleReadyMessage.bind(this))
     }
   }
@@ -279,10 +277,8 @@ export abstract class AbstractWorker<
           'Cannot set the default task function to a non-existing task function'
         )
       }
-      this.taskFunctions.set(
-        DEFAULT_TASK_NAME,
-        this.taskFunctions.get(name) as TaskFunction<Data, Response>
-      )
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.taskFunctions.set(DEFAULT_TASK_NAME, this.taskFunctions.get(name)!)
       this.sendTaskFunctionNamesToMainWorker()
       return { status: true }
     } catch (error) {
@@ -330,19 +326,22 @@ export abstract class AbstractWorker<
     switch (taskFunctionOperation) {
       case 'add':
         response = this.addTaskFunction(
-          taskFunctionName as string,
-          // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
-          new Function(`return ${taskFunction as string}`)() as TaskFunction<
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          taskFunctionName!,
+          // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func, @typescript-eslint/no-non-null-assertion
+          new Function(`return ${taskFunction!}`)() as TaskFunction<
           Data,
           Response
           >
         )
         break
       case 'remove':
-        response = this.removeTaskFunction(taskFunctionName as string)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        response = this.removeTaskFunction(taskFunctionName!)
         break
       case 'default':
-        response = this.setDefaultTaskFunction(taskFunctionName as string)
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        response = this.setDefaultTaskFunction(taskFunctionName!)
         break
       default:
         response = { status: false, error: new Error('Unknown task operation') }
@@ -355,7 +354,8 @@ export abstract class AbstractWorker<
       ...(!response.status &&
         response?.error != null && {
         workerError: {
-          name: taskFunctionName as string,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          name: taskFunctionName!,
           message: this.handleError(response.error as Error | string)
         }
       })
@@ -367,21 +367,17 @@ export abstract class AbstractWorker<
    *
    * @param message - The kill message.
    */
-  protected handleKillMessage (message: MessageValue<Data>): void {
+  protected handleKillMessage (_message: MessageValue<Data>): void {
     this.stopCheckActive()
     if (isAsyncFunction(this.opts.killHandler)) {
       (this.opts.killHandler?.() as Promise<void>)
         .then(() => {
           this.sendToMainWorker({ kill: 'success' })
-          return null
+          return undefined
         })
         .catch(() => {
           this.sendToMainWorker({ kill: 'failure' })
         })
-        .finally(() => {
-          this.emitDestroy()
-        })
-        .catch(EMPTY_FUNCTION)
     } else {
       try {
         // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
@@ -389,8 +385,6 @@ export abstract class AbstractWorker<
         this.sendToMainWorker({ kill: 'success' })
       } catch {
         this.sendToMainWorker({ kill: 'failure' })
-      } finally {
-        this.emitDestroy()
       }
     }
   }
@@ -404,7 +398,7 @@ export abstract class AbstractWorker<
   private checkMessageWorkerId (message: MessageValue<Data>): void {
     if (message.workerId == null) {
       throw new Error('Message worker id is not set')
-    } else if (message.workerId != null && message.workerId !== this.id) {
+    } else if (message.workerId !== this.id) {
       throw new Error(
         `Message worker id ${message.workerId} does not match the worker id ${this.id}`
       )
@@ -490,24 +484,27 @@ export abstract class AbstractWorker<
    *
    * @param task - The task to execute.
    */
-  protected run (task: Task<Data>): void {
+  protected readonly run = (task: Task<Data>): void => {
     const { name, taskId, data } = task
-    const fn = this.taskFunctions.get(name ?? DEFAULT_TASK_NAME)
-    if (fn == null) {
+    const taskFunctionName = name ?? DEFAULT_TASK_NAME
+    if (!this.taskFunctions.has(taskFunctionName)) {
       this.sendToMainWorker({
         workerError: {
-          name: name as string,
-          message: `Task function '${name as string}' not found`,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          name: name!,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          message: `Task function '${name!}' not found`,
           data
         },
         taskId
       })
       return
     }
+    const fn = this.taskFunctions.get(taskFunctionName)
     if (isAsyncFunction(fn)) {
-      this.runInAsyncScope(this.runAsync.bind(this), this, fn, task)
+      this.runAsync(fn as TaskAsyncFunction<Data, Response>, task)
     } else {
-      this.runInAsyncScope(this.runSync.bind(this), this, fn, task)
+      this.runSync(fn as TaskSyncFunction<Data, Response>, task)
     }
   }
 
@@ -517,10 +514,10 @@ export abstract class AbstractWorker<
    * @param fn - Task function that will be executed.
    * @param task - Input data for the task function.
    */
-  protected runSync (
+  protected readonly runSync = (
     fn: TaskSyncFunction<Data, Response>,
     task: Task<Data>
-  ): void {
+  ): void => {
     const { name, taskId, data } = task
     try {
       let taskPerformance = this.beginTaskPerformance(name)
@@ -534,7 +531,8 @@ export abstract class AbstractWorker<
     } catch (error) {
       this.sendToMainWorker({
         workerError: {
-          name: name as string,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          name: name!,
           message: this.handleError(error as Error | string),
           data
         },
@@ -551,10 +549,10 @@ export abstract class AbstractWorker<
    * @param fn - Task function that will be executed.
    * @param task - Input data for the task function.
    */
-  protected runAsync (
+  protected readonly runAsync = (
     fn: TaskAsyncFunction<Data, Response>,
     task: Task<Data>
-  ): void {
+  ): void => {
     const { name, taskId, data } = task
     let taskPerformance = this.beginTaskPerformance(name)
     fn(data)
@@ -570,7 +568,8 @@ export abstract class AbstractWorker<
       .catch(error => {
         this.sendToMainWorker({
           workerError: {
-            name: name as string,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            name: name!,
             message: this.handleError(error as Error | string),
             data
           },