refactor: refine code examples

Signed-off-by: Jérôme Benoit <jerome.benoit@piment-noir.org>

diff --git a/README.md b/README.md
index affe8bc91ce03bc3ad3f6c71448203026ee40eaa..c0d1e26a7fbf2e06aefa3d98686fb399e26e331c 100644 (file)
--- a/README.md
+++ b/README.md
@@ -116,8 +116,8 @@ const pool = new FixedThreadPool(availableParallelism(), './yourWorker.js', {
   onlineHandler: () => console.info('worker is online')
 })
 
-pool.emitter.on(PoolEvents.ready, () => console.info('Pool is ready'))
-pool.emitter.on(PoolEvents.busy, () => console.info('Pool is busy'))
+pool.emitter?.on(PoolEvents.ready, () => console.info('Pool is ready'))
+pool.emitter?.on(PoolEvents.busy, () => console.info('Pool is busy'))
 
 // or a dynamic worker_threads pool
 const pool = new DynamicThreadPool(Math.floor(availableParallelism() / 2), availableParallelism(), './yourWorker.js', {
@@ -125,9 +125,9 @@ const pool = new DynamicThreadPool(Math.floor(availableParallelism() / 2), avail
   onlineHandler: () => console.info('worker is online')
 })
 
-pool.emitter.on(PoolEvents.full, () => console.info('Pool is full'))
-pool.emitter.on(PoolEvents.ready, () => console.info('Pool is ready'))
-pool.emitter.on(PoolEvents.busy, () => console.info('Pool is busy'))
+pool.emitter?.on(PoolEvents.full, () => console.info('Pool is full'))
+pool.emitter?.on(PoolEvents.ready, () => console.info('Pool is ready'))
+pool.emitter?.on(PoolEvents.busy, () => console.info('Pool is busy'))
 
 // the execute method signature is the same for both implementations,
 // so you can easily switch from one to another

diff --git a/examples/javascript/dynamicExample.js b/examples/javascript/dynamicExample.js
index 33fdec970c6a9de20aa431f353d71c627bb80e71..2783c171774e5d3b77cd16179d4a258d10ef9572 100644 (file)
--- a/examples/javascript/dynamicExample.js
+++ b/examples/javascript/dynamicExample.js
@@ -17,9 +17,9 @@ const pool = new DynamicThreadPool(
 let poolFull = 0
 let poolReady = 0
 let poolBusy = 0
-pool.emitter.on(PoolEvents.full, () => poolFull++)
-pool.emitter.on(PoolEvents.ready, () => poolReady++)
-pool.emitter.on(PoolEvents.busy, () => poolBusy++)
+pool.emitter?.on(PoolEvents.full, () => poolFull++)
+pool.emitter?.on(PoolEvents.ready, () => poolReady++)
+pool.emitter?.on(PoolEvents.busy, () => poolBusy++)
 
 let resolved = 0
 const start = performance.now()
@@ -30,10 +30,13 @@ for (let i = 1; i <= iterations; i++) {
     .then(() => {
       resolved++
       if (resolved === iterations) {
-        console.info(`Time taken is ${performance.now() - start}`)
+        console.info(
+          `Time taken is ${(performance.now() - start).toFixed(2)}ms`
+        )
         console.info(`The pool was full for ${poolFull} times`)
         console.info(`The pool was ready for ${poolReady} times`)
-        return console.info(`The pool was busy for ${poolBusy} times`)
+        console.info(`The pool was busy for ${poolBusy} times`)
+        return pool.destroy()
       }
       return null
     })

diff --git a/examples/javascript/fixedExample.js b/examples/javascript/fixedExample.js
index 66bfc8fc8a32e3186acec24195183be75b49cbbd..8aab9cb7a80544f2a83f2c7f348c6b711776bfba 100644 (file)
--- a/examples/javascript/fixedExample.js
+++ b/examples/javascript/fixedExample.js
@@ -11,8 +11,8 @@ const pool = new FixedThreadPool(availableParallelism(), './yourWorker.js', {
 })
 let poolReady = 0
 let poolBusy = 0
-pool.emitter.on(PoolEvents.ready, () => poolReady++)
-pool.emitter.on(PoolEvents.busy, () => poolBusy++)
+pool.emitter?.on(PoolEvents.ready, () => poolReady++)
+pool.emitter?.on(PoolEvents.busy, () => poolBusy++)
 
 let resolved = 0
 const start = performance.now()
@@ -23,9 +23,12 @@ for (let i = 1; i <= iterations; i++) {
     .then(() => {
       resolved++
       if (resolved === iterations) {
-        console.info(`Time taken is ${performance.now() - start}`)
+        console.info(
+          `Time taken is ${(performance.now() - start).toFixed(2)}ms`
+        )
         console.info(`The pool was ready for ${poolReady} times`)
-        return console.info(`The pool was busy for ${poolBusy} times`)
+        console.info(`The pool was busy for ${poolBusy} times`)
+        return pool.destroy()
       }
       return null
     })

diff --git a/examples/javascript/yourWorker.js b/examples/javascript/yourWorker.js
index cc462f7f97b1cde5a48712494a651fcf90f420fb..073253ea2300d9d7277cec9c77b34a8a8d1a1e40 100644 (file)
--- a/examples/javascript/yourWorker.js
+++ b/examples/javascript/yourWorker.js
@@ -1,9 +1,6 @@
 'use strict'
-const { isMainThread } = require('node:worker_threads')
 const { ThreadWorker } = require('poolifier')
 
-const debug = false
-
 function yourFunction () {
   for (let i = 0; i <= 1000; i++) {
     const o = {
@@ -11,7 +8,6 @@ function yourFunction () {
     }
     JSON.stringify(o)
   }
-  debug === true && console.info(`This is the main thread ${isMainThread}`)
   return { ok: 1 }
 }
 

diff --git a/examples/typescript/http-server-pool/express-cluster/src/worker.ts b/examples/typescript/http-server-pool/express-cluster/src/worker.ts
index 7dd607b5b17cfd703d4dd75ae0c08d5aa6c5dd7b..940503dfad3f241cceaefa3779060bd5f4afa1d8 100644 (file)
--- a/examples/typescript/http-server-pool/express-cluster/src/worker.ts
+++ b/examples/typescript/http-server-pool/express-cluster/src/worker.ts
@@ -4,16 +4,16 @@ import { ClusterWorker } from 'poolifier'
 import express, { type Express, type Request, type Response } from 'express'
 import type { WorkerData, WorkerResponse } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class ExpressWorker extends ClusterWorker<WorkerData, WorkerResponse> {
   private static server: Server
 
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return ExpressWorker.factorial(n - 1) * n
+  }
+
   private static readonly startExpress = (
     workerData?: WorkerData
   ): WorkerResponse => {
@@ -30,7 +30,7 @@ class ExpressWorker extends ClusterWorker<WorkerData, WorkerResponse> {
 
     application.get('/api/factorial/:number', (req: Request, res: Response) => {
       const { number } = req.params
-      res.send({ number: factorial(parseInt(number)) }).end()
+      res.send({ number: ExpressWorker.factorial(parseInt(number)) }).end()
     })
 
     ExpressWorker.server = application.listen(port, () => {

diff --git a/examples/typescript/http-server-pool/express-hybrid/src/request-handler-worker.ts b/examples/typescript/http-server-pool/express-hybrid/src/request-handler-worker.ts
index 40cde50d640e24baea7df6cc256dc8bf491f0c89..8c247819488b5548f3e4fe1adbbaf106286cd3f4 100644 (file)
--- a/examples/typescript/http-server-pool/express-hybrid/src/request-handler-worker.ts
+++ b/examples/typescript/http-server-pool/express-hybrid/src/request-handler-worker.ts
@@ -5,17 +5,17 @@ import {
   type ThreadWorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class RequestHandlerWorker<
   Data extends ThreadWorkerData<DataPayload>,
   Response extends ThreadWorkerResponse<DataPayload>
 > extends ThreadWorker<Data, Response> {
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return RequestHandlerWorker.factorial(n - 1) * n
+  }
+
   public constructor () {
     super({
       echo: (workerData?: Data) => {
@@ -23,7 +23,11 @@ class RequestHandlerWorker<
       },
       factorial: (workerData?: Data) => {
         return {
-          data: { number: factorial(workerData?.data?.number as number) }
+          data: {
+            number: RequestHandlerWorker.factorial(
+              workerData?.data?.number as number
+            )
+          }
         } as unknown as Response
       }
     })

diff --git a/examples/typescript/http-server-pool/express-worker_threads/src/worker.ts b/examples/typescript/http-server-pool/express-worker_threads/src/worker.ts
index 7589aa6b6aaa9b37aa519d24c86bafc96d657b98..3f573647b34cef414a6b62baeb3227aefac29971 100644 (file)
--- a/examples/typescript/http-server-pool/express-worker_threads/src/worker.ts
+++ b/examples/typescript/http-server-pool/express-worker_threads/src/worker.ts
@@ -5,17 +5,17 @@ import {
   type WorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class RequestHandlerWorker<
   Data extends WorkerData<BodyPayload>,
   Response extends WorkerResponse<BodyPayload>
 > extends ThreadWorker<Data, Response> {
+  private static readonly factorial: (n: number) => number = n => {
+    if (n === 0) {
+      return 1
+    }
+    return RequestHandlerWorker.factorial(n - 1) * n
+  }
+
   public constructor () {
     super({
       echo: (workerData?: Data) => {
@@ -23,7 +23,11 @@ class RequestHandlerWorker<
       },
       factorial: (workerData?: Data) => {
         return {
-          body: { number: factorial(workerData?.body?.number as number) }
+          body: {
+            number: RequestHandlerWorker.factorial(
+              workerData?.body?.number as number
+            )
+          }
         } as unknown as Response
       }
     })

diff --git a/examples/typescript/http-server-pool/fastify-cluster/src/worker.ts b/examples/typescript/http-server-pool/fastify-cluster/src/worker.ts
index ee64ee2ec3911257f86e90a48702116676692afa..2f6c8f6dec1fcf405c8ce5bdb78a51c84c7c1915 100644 (file)
--- a/examples/typescript/http-server-pool/fastify-cluster/src/worker.ts
+++ b/examples/typescript/http-server-pool/fastify-cluster/src/worker.ts
@@ -3,16 +3,16 @@ import { ClusterWorker } from 'poolifier'
 import Fastify, { type FastifyInstance } from 'fastify'
 import type { WorkerData, WorkerResponse } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class FastifyWorker extends ClusterWorker<WorkerData, WorkerResponse> {
   private static fastify: FastifyInstance
 
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return FastifyWorker.factorial(n - 1) * n
+  }
+
   private static readonly startFastify = async (
     workerData?: WorkerData
   ): Promise<WorkerResponse> => {
@@ -30,7 +30,7 @@ class FastifyWorker extends ClusterWorker<WorkerData, WorkerResponse> {
       Params: { number: number }
     }>('/api/factorial/:number', request => {
       const { number } = request.params
-      return { number: factorial(number) }
+      return { number: FastifyWorker.factorial(number) }
     })
 
     await FastifyWorker.fastify.listen({ port })

diff --git a/examples/typescript/http-server-pool/fastify-hybrid/src/request-handler-worker.ts b/examples/typescript/http-server-pool/fastify-hybrid/src/request-handler-worker.ts
index 40cde50d640e24baea7df6cc256dc8bf491f0c89..8c247819488b5548f3e4fe1adbbaf106286cd3f4 100644 (file)
--- a/examples/typescript/http-server-pool/fastify-hybrid/src/request-handler-worker.ts
+++ b/examples/typescript/http-server-pool/fastify-hybrid/src/request-handler-worker.ts
@@ -5,17 +5,17 @@ import {
   type ThreadWorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class RequestHandlerWorker<
   Data extends ThreadWorkerData<DataPayload>,
   Response extends ThreadWorkerResponse<DataPayload>
 > extends ThreadWorker<Data, Response> {
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return RequestHandlerWorker.factorial(n - 1) * n
+  }
+
   public constructor () {
     super({
       echo: (workerData?: Data) => {
@@ -23,7 +23,11 @@ class RequestHandlerWorker<
       },
       factorial: (workerData?: Data) => {
         return {
-          data: { number: factorial(workerData?.data?.number as number) }
+          data: {
+            number: RequestHandlerWorker.factorial(
+              workerData?.data?.number as number
+            )
+          }
         } as unknown as Response
       }
     })

diff --git a/examples/typescript/http-server-pool/fastify-worker_threads/src/worker.ts b/examples/typescript/http-server-pool/fastify-worker_threads/src/worker.ts
index 7589aa6b6aaa9b37aa519d24c86bafc96d657b98..3f573647b34cef414a6b62baeb3227aefac29971 100644 (file)
--- a/examples/typescript/http-server-pool/fastify-worker_threads/src/worker.ts
+++ b/examples/typescript/http-server-pool/fastify-worker_threads/src/worker.ts
@@ -5,17 +5,17 @@ import {
   type WorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class RequestHandlerWorker<
   Data extends WorkerData<BodyPayload>,
   Response extends WorkerResponse<BodyPayload>
 > extends ThreadWorker<Data, Response> {
+  private static readonly factorial: (n: number) => number = n => {
+    if (n === 0) {
+      return 1
+    }
+    return RequestHandlerWorker.factorial(n - 1) * n
+  }
+
   public constructor () {
     super({
       echo: (workerData?: Data) => {
@@ -23,7 +23,11 @@ class RequestHandlerWorker<
       },
       factorial: (workerData?: Data) => {
         return {
-          body: { number: factorial(workerData?.body?.number as number) }
+          body: {
+            number: RequestHandlerWorker.factorial(
+              workerData?.body?.number as number
+            )
+          }
         } as unknown as Response
       }
     })

diff --git a/examples/typescript/websocket-server-pool/ws-cluster/src/worker.ts b/examples/typescript/websocket-server-pool/ws-cluster/src/worker.ts
index 5e758eb7d3f845e1d8508bf907bda9fa7fcbcc3d..0e8dc20a95fd8d2f3f161381d07f90a36e60b933 100644 (file)
--- a/examples/typescript/websocket-server-pool/ws-cluster/src/worker.ts
+++ b/examples/typescript/websocket-server-pool/ws-cluster/src/worker.ts
@@ -8,16 +8,16 @@ import {
   type WorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class WebSocketServerWorker extends ClusterWorker<WorkerData, WorkerResponse> {
   private static wss: WebSocketServer
 
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return WebSocketServerWorker.factorial(n - 1) * n
+  }
+
   private static readonly startWebSocketServer = (
     workerData?: WorkerData
   ): WorkerResponse => {
@@ -49,7 +49,9 @@ class WebSocketServerWorker extends ClusterWorker<WorkerData, WorkerResponse> {
             ws.send(
               JSON.stringify({
                 type: MessageType.factorial,
-                data: { number: factorial(data.number as number) }
+                data: {
+                  number: WebSocketServerWorker.factorial(data.number as number)
+                }
               })
             )
             break

diff --git a/examples/typescript/websocket-server-pool/ws-hybrid/src/request-handler-worker.ts b/examples/typescript/websocket-server-pool/ws-hybrid/src/request-handler-worker.ts
index 40cde50d640e24baea7df6cc256dc8bf491f0c89..8c247819488b5548f3e4fe1adbbaf106286cd3f4 100644 (file)
--- a/examples/typescript/websocket-server-pool/ws-hybrid/src/request-handler-worker.ts
+++ b/examples/typescript/websocket-server-pool/ws-hybrid/src/request-handler-worker.ts
@@ -5,17 +5,17 @@ import {
   type ThreadWorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class RequestHandlerWorker<
   Data extends ThreadWorkerData<DataPayload>,
   Response extends ThreadWorkerResponse<DataPayload>
 > extends ThreadWorker<Data, Response> {
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return RequestHandlerWorker.factorial(n - 1) * n
+  }
+
   public constructor () {
     super({
       echo: (workerData?: Data) => {
@@ -23,7 +23,11 @@ class RequestHandlerWorker<
       },
       factorial: (workerData?: Data) => {
         return {
-          data: { number: factorial(workerData?.data?.number as number) }
+          data: {
+            number: RequestHandlerWorker.factorial(
+              workerData?.data?.number as number
+            )
+          }
         } as unknown as Response
       }
     })

diff --git a/examples/typescript/websocket-server-pool/ws-worker_threads/src/worker.ts b/examples/typescript/websocket-server-pool/ws-worker_threads/src/worker.ts
index 92b9d64a7dc0af093e2cad38d08262733c965352..6f9f0914d3fea36b438141217f56c177f8e7c4c2 100644 (file)
--- a/examples/typescript/websocket-server-pool/ws-worker_threads/src/worker.ts
+++ b/examples/typescript/websocket-server-pool/ws-worker_threads/src/worker.ts
@@ -5,17 +5,17 @@ import {
   type WorkerResponse
 } from './types.js'
 
-const factorial: (n: number) => number = n => {
-  if (n === 0) {
-    return 1
-  }
-  return factorial(n - 1) * n
-}
-
 class RequestHandlerWorker<
   Data extends WorkerData<DataPayload>,
   Response extends WorkerResponse<DataPayload>
 > extends ThreadWorker<Data, Response> {
+  private static readonly factorial = (n: number): number => {
+    if (n === 0) {
+      return 1
+    }
+    return RequestHandlerWorker.factorial(n - 1) * n
+  }
+
   public constructor () {
     super({
       echo: (workerData?: Data) => {
@@ -23,7 +23,11 @@ class RequestHandlerWorker<
       },
       factorial: (workerData?: Data) => {
         return {
-          data: { number: factorial(workerData?.data?.number as number) }
+          data: {
+            number: RequestHandlerWorker.factorial(
+              workerData?.data?.number as number
+            )
+          }
         } as unknown as Response
       }
     })