node-thread-decorator 1.0.0

package/README.md

@@ -0,0 +1,69 @@
+# Node Thread Decorator
+
+[![node version][node-image]][node-url]
+
+[node-image]: https://img.shields.io/badge/node.js-%3E=_18.0-green.svg?style=flat-square
+[node-url]: http://nodejs.org/download/
+
+### Install
+
+```
+$ npm i -S node-thread-decorator
+```
+
+### Usage
+
+- Import
+
+```ts
+import { RunInNewThread } from "node-thread-decorator";
+```
+
+```ts
+import { Controller, Get } from '@nestjs/common';
+
+import { RunInNewThread } from 'node-thread-decorator';
+import { IHealthAdapter } from './adapter';
+
+@Controller()
+export class HealthController {
+  /**
+   * Blocks the main thread for a specified duration in milliseconds.
+   * This function runs in a new process due to the decorator `@RunInNewProcess`.
+   *
+   * @param {number} milliseconds - The time to block the thread in milliseconds.
+   */
+  @RunInNewThread()
+  blockMainThread(milliseconds: number) {
+    const start = Date.now();
+    while (Date.now() - start < milliseconds) {
+      // Looping until time has passed
+    }
+    console.log("Finished new process", process.pid);
+  }
+
+  /**
+   * Endpoint that returns health information of the service.
+   * It will block the main thread for 10 seconds to simulate a heavy operation.
+   *
+   * @returns {Promise<string>} - A promise that resolves when the health check is completed.
+   */
+  @Get(['/health', '/'])
+  async getHealth(): Promise<string> {
+    console.log("Started process", process.pid);
+    this.blockMainThread(10000); // Simulating blocking the thread for 10 seconds
+    console.log("Health check completed");
+    return "APP UP!"
+  }
+}
+
+---
+
+The following is a list of all the people that have contributed Node Thread Decorator. Thanks for your contributions!
+
+[<img alt="mikemajesty" src="https://avatars1.githubusercontent.com/u/11630212?s=460&v=4&s=117" width="117">](https://github.com/mikemajesty)
+
+## License
+
+It is available under the MIT license.
+[License](https://opensource.org/licenses/mit-license.php)

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "node-thread-decorator",
+  "version": "1.0.0",
+  "description": "node thread decorator",
+  "main": "dist/thread.decorator.js",
+  "types": "dist/thread.decorator.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "colorette": "^2.0.20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.7"
+  }
+}

package/src/thread.decorator.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Module providing decorators for execution in separate threads.
+ */
+declare module 'node-thread' {
+  /**
+   * Executes the decorated method in a separate thread.
+   *
+   * @param timeout - Maximum time in milliseconds for the thread execution. If not provided, there is no timeout.
+   * @returns A method decorator that executes the method in a separate thread.
+   */
+  export function RunInNewThread(timeout?: number): MethodDecorator;
+}

package/src/thread.decorator.ts

@@ -0,0 +1,67 @@
+import { red } from 'colorette';
+import { Worker } from 'worker_threads';
+
+export function RunInNewThread(timeout?: number) {
+  return function (target: object, key: string, descriptor: PropertyDescriptor): PropertyDescriptor {
+    const originalMethod = descriptor.value;
+
+    // Modifying the descriptor to replace the original method with one that runs in a worker thread
+    descriptor.value = function (...args: unknown[]) {
+      // Convert the method code to string to send to the worker
+      const fnCode = originalMethod.toString();
+
+      // Create a new Worker instance to run the method in a separate thread
+      const worker = new Worker(`${__dirname}/thread.js`);
+
+      let timeoutId: NodeJS.Timeout | null = null;
+
+      // Send the method code and arguments to the worker
+      worker.postMessage([fnCode, args]);
+
+      // Set a timeout if specified
+      if (timeout) {
+        timeoutId = setTimeout(() => {
+          const className = target.constructor.name;
+          const methodName = key;
+          const error = new Error('worker execution timed out.');
+          Object.assign(error, { context: `${className}/${methodName}` });
+
+          console.error(error);
+          worker.terminate(); // Terminate the worker if it times out
+        }, timeout);
+      }
+
+      // Handle messages received from the worker (either success or error)
+      worker.on('message', (value: { error: Error; success: unknown }) => {
+        if (timeoutId) clearTimeout(timeoutId); // Clear the timeout if the worker finishes early
+        if (value.error) {
+          return Promise.reject(value.error); // Reject if there's an error
+        }
+
+        if (value.success) {
+          return Promise.resolve(value.success); // Resolve with the worker's result
+        }
+      });
+
+      // Handle errors emitted by the worker thread
+      worker.on('error', (err: Error) => {
+        if (timeoutId) clearTimeout(timeoutId); // Clear timeout on error
+        if (err.name === 'ReferenceError') {
+          console.error(red('worker error '), err);
+          return;
+        }
+        console.error(red('worker error '), err?.message ?? err);
+      });
+
+      // Handle worker exit (whether successful or with an error code)
+      worker.on('exit', (code: number) => {
+        if (timeoutId) clearTimeout(timeoutId); // Clear timeout on worker exit
+        if (code !== 0) {
+          console.error(red(`worker stopped with exit code ${code}`)); // Log if the worker exits with a non-zero code
+        }
+      });
+    };
+
+    return descriptor;
+  };
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "es2017",
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "noImplicitAny": true,
+    "strictBindCallApply": false,
+    "forceConsistentCasingInFileNames": false,
+    "noFallthroughCasesInSwitch": false,
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  }
+}