feat: make piscina entrypoint easier for typescript

Author: danielpza

docs/docs/getting-started/typescript.mdx

@@ -112,3 +112,32 @@ const piscina = new Piscina({
 })();
 ```
 
+## Using generics
+
+You can use generics to the types for the worker function:
+
+```typescript title='worker.ts'
+
+interface Inputs {
+  a: number;
+  b: number;
+}
+
+export default function addNumbers({ a, b }: Inputs): number {
+  return a + b;
+}
+```
+
+```typescript title='main.ts'
+
+import Piscina from 'piscina';
+
+const piscina = new Piscina<typeof import("./worker.ts").default>({
+  filename: new URL("./worker.ts", import.meta.url).href,
+});
+
+(async () => {
+  const result = await piscina.run({ a: 2, b: 3 });
+  console.log('Result:', result);
+})();
+```

package-lock.json

@@ -51,6 +51,7 @@
     "c8": "^10.1.2",
     "concat-stream": "^2.0.0",
     "eslint": "^9.16.0",
+    "expect-type": "^1.2.1",
     "gen-esm-wrapper": "^1.1.1",
     "neostandard": "^0.12.0",
     "tap": "^16.3.7",

package.json

@@ -720,7 +720,7 @@ class ThreadPool {
   }
 }
 
-export default class Piscina<T = any, R = any> extends EventEmitterAsyncResource {
+export default class Piscina<F extends (payload: any) => any = (payload: any) => any> extends EventEmitterAsyncResource {
   #pool : ThreadPool;
   #histogram: PiscinaHistogram | null = null;
 
@@ -793,7 +793,7 @@ export default class Piscina<T = any, R = any> extends EventEmitterAsyncResource
     this.#pool = new ThreadPool(this, options);
   }
 
-  run (task : T, options : RunOptions = kDefaultRunOptions): Promise<R> {
+  run (task : Parameters<F>[0], options : RunOptions = kDefaultRunOptions): Promise<ReturnType<F>> {
     if (options === null || typeof options !== 'object') {
       return Promise.reject(
         new TypeError('options must be an object'));

src/index.ts

@@ -0,0 +1,3 @@
+export default function add({ a, b }: { a: number; b: number }): number {
+	return a + b;
+}

test/fixtures/worker-type.ts

@@ -0,0 +1,26 @@
+import { resolve } from "node:path";
+import { expectTypeOf } from "expect-type";
+
+import { test } from "tap";
+
+import Piscina from "../dist";
+
+test("types can be inferred from function", async (t) => {
+	const pool = new Piscina<typeof import("./fixtures/worker-type.js").default>({
+		filename: resolve(__dirname, "fixtures/worker-type.js"),
+		concurrentTasksPerWorker: 1,
+	});
+
+	expectTypeOf(pool.run).parameter(0).toEqualTypeOf<{ a: number; b: number }>();
+	expectTypeOf(pool.run).returns.toEqualTypeOf<Promise<number>>();
+});
+
+test("types can be manually specified", async (t) => {
+	const pool = new Piscina<(payload: { a: number; b: number }) => number>({
+		filename: resolve(__dirname, "fixtures/worker-type.js"),
+		concurrentTasksPerWorker: 1,
+	});
+
+	expectTypeOf(pool.run).parameter(0).toEqualTypeOf<{ a: number; b: number }>();
+	expectTypeOf(pool.run).returns.toEqualTypeOf<Promise<number>>();
+});