Implement promises library with non-blocking methods

promises/index.js

@@ -0,0 +1,76 @@
+const path = require("path");
+const { Worker } = require("worker_threads");
+
+let workerPromise;
+async function initWorker() {
+    if (workerPromise) return workerPromise;
+    const worker = new Worker(path.join(__dirname, "worker.js"));
+    workerPromise = new Promise((resolve) => {
+        function onReady() {
+            worker.off("message", onReady);
+            let pendingPromises = {};
+            worker.on("message", ({ id, res, err }) => {
+                if (err) pendingPromises[id].reject(err);
+                else pendingPromises[id].resolve(res);
+                delete pendingPromises[id];
+            });
+            const wrappedWorker = {
+                sendMessage: ({ isClass, self, method, args }) => {
+                    const id = Math.random().toString(36).substring(2);
+                    return new Promise((resolve, reject) => {
+                        pendingPromises[id] = { resolve, reject };
+                        worker.postMessage({ id, isClass, self, method, args });
+                    });
+                },
+                terminate: () => worker.terminate(),
+            };
+            resolve(wrappedWorker);
+        }
+        worker.on("message", onReady);
+    });
+
+    return workerPromise;
+}
+
+async function clearResources() {
+    if (workerPromise) {
+        const worker = await workerPromise;
+        workerPromise = null;
+        await worker.terminate();
+    }
+}
+
+function proxify(worker, res) {
+    return new Proxy(res, {
+        get(obj, method) {
+            if (method === "then" || method === "catch" || method === "finally")
+                return obj[method];
+            return (...args) => worker.sendMessage({ self: obj, method, args });
+        },
+    });
+}
+
+function wrapClass(className) {
+    return async (...args) => {
+        const worker = await initWorker();
+        const res = await worker.sendMessage({
+            isClass: true,
+            method: className,
+            args,
+        });
+        return proxify(worker, res);
+    };
+}
+
+function wrapMethod(methodName) {
+    return async (...args) => {
+        const worker = await initWorker();
+        return worker.sendMessage({ method: methodName, args });
+    };
+}
+
+exports.Wallet = wrapClass("Wallet");
+exports.dropOnline = wrapMethod("dropOnline");
+exports.generateKeys = wrapMethod("generateKeys");
+exports.restoreKeys = wrapMethod("restoreKeys");
+exports.clearResources = clearResources;

promises/worker.js

@@ -0,0 +1,39 @@
+const { parentPort } = require("worker_threads");
+const wrapper = require("../wrapper");
+
+const registry = {};
+parentPort.on("message", ({ id, isClass, self, method, args }) => {
+    try {
+        if (self) self = getArgValue(self);
+        else self = wrapper;
+        if (typeof self[method] !== "function") {
+            throw new Error(
+                `${self[method]} is not a function (calling ${method})`,
+            );
+        }
+
+        let res;
+        if (isClass) res = new self[method](...args.map(getArgValue));
+        else res = self[method](...args.map(getArgValue));
+        if (isTransferable(res)) parentPort.postMessage({ id, res });
+        else {
+            registry[id] = res;
+            parentPort.postMessage({ id, res: { _id: id } });
+        }
+    } catch (err) {
+        parentPort.postMessage({ id, err });
+    }
+});
+parentPort.postMessage(null);
+
+function getArgValue(a) {
+    return registry[a?._id] || a;
+}
+function isTransferable(obj) {
+    return !(
+        obj != null &&
+        typeof obj === "object" &&
+        obj.constructor !== Object &&
+        obj.constructor !== Array
+    );
+}