feat: promisify utility now preserves typing info

src/bin/polykey-agent.ts

@@ -37,7 +37,7 @@ const logger = new Logger('polykey', undefined, [new StreamHandler()]);
  */
 async function main(_argv = process.argv): Promise<number> {
   const exitHandlers = new binUtils.ExitHandlers();
-  const processSend = promisify<void>(process.send!.bind(process));
+  const processSend = promisify(process.send!.bind(process));
   const { p: messageInP, resolveP: resolveMessageInP } =
     promise<AgentChildProcessInput>();
   process.once('message', (data: AgentChildProcessInput) => {

src/types.ts

@@ -13,6 +13,14 @@ type POJO = { [key: string]: any };
 type Opaque<K, T> = T & { readonly [brand]: K };
 declare const brand: unique symbol;
 
+/**
+ * Generic callback
+ */
+type Callback<P extends Array<any> = [], R = any, E extends Error = Error> = {
+  (e: E, ...params: Partial<P>): R;
+  (e?: null | undefined, ...params: P): R;
+};
+
 /**
  * Non-empty array
  */
@@ -81,6 +89,7 @@ type FileHandle = fs.promises.FileHandle;
 export type {
   POJO,
   Opaque,
+  Callback,
   NonEmptyArray,
   AbstractConstructorParameters,
   Initial,

src/utils/utils.ts

@@ -1,4 +1,4 @@
-import type { FileSystem, Timer } from '../types';
+import type { FileSystem, Timer, Callback } from '../types';
 import os from 'os';
 import process from 'process';
 import path from 'path';
@@ -138,18 +138,34 @@ async function poll<T, E = any>(
 
 /**
  * Convert callback-style to promise-style
+ * If this is applied to overloaded function
+ * it will only choose one of the function signatures to use
  */
-function promisify<T>(f): (...args: any[]) => Promise<T> {
-  return function <T>(...args): Promise<T> {
+function promisify<
+  T extends Array<unknown>,
+  P extends Array<unknown>,
+  R extends T extends [] ? void : T extends [unknown] ? T[0] : T,
+>(
+  f: (...args: [...params: P, callback: Callback<T>]) => unknown,
+): (...params: P) => Promise<R> {
+  // Uses a regular function so that `this` can be bound
+  return function (...params: P): Promise<R> {
     return new Promise((resolve, reject) => {
       const callback = (error, ...values) => {
         if (error != null) {
           return reject(error);
         }
-        return resolve(values.length === 1 ? values[0] : values);
+        if (values.length === 0) {
+          (resolve as () => void)();
+        } else if (values.length === 1) {
+          resolve(values[0] as R);
+        } else {
+          resolve(values as R);
+        }
+        return;
       };
-      args.push(callback);
-      f.apply(this, args);
+      params.push(callback);
+      f.apply(this, params);
     });
   };
 }