@kirill.konshin/utils 0.0.14 → 0.0.16

package/src/core/worker.test.ts

@@ -0,0 +1,197 @@
+import { expect, describe, test, vi } from 'vitest';
+import { RespondersBase, WorkerDialog } from './worker';
+import EventEmitter from 'node:events';
+
+// Prepare
+
+//TODO @vitest/web-worker can ve used, coverage is collected, but this gives more direct access to worker internals
+// class WorkerPeer extends EventEmitter implements WorkerLike {
+class WorkerPeer extends EventEmitter {
+    peer: WorkerPeer;
+
+    setPeer(peer: WorkerPeer) {
+        this.peer = peer;
+    }
+
+    postMessage(data: any) {
+        this.peer?.emit('message', { data });
+    }
+
+    addEventListener(event: string, listener: (e: any) => void, options) {
+        this[options['once'] ? 'once' : 'on'](event, listener);
+        options?.signal?.addEventListener('abort', () => this.off(event, listener));
+    }
+
+    removeEventListener(event: string, listener: (e: any) => void) {
+        this.off(event, listener);
+    }
+}
+
+class Responders extends RespondersBase<Responders> {
+    lastContext: any; // for testing purposes
+
+    test = this.create(
+        'test',
+        async (
+            { n, abort = false, buf }: { n: number; abort?: boolean; buf?: ArrayBuffer }, // should have all possible combinations for strong typing
+            ctx,
+        ) => {
+            this.lastContext = ctx;
+
+            const res: number[] = [];
+
+            let aborted = false;
+            let progress = 0;
+
+            ctx.listen(({ abort }) => {
+                if (abort) aborted = true;
+            });
+
+            for (const i of Array(n).keys()) {
+                if (aborted) break;
+                progress = (i + 1) / n;
+                ctx.send({ progress });
+                res.push(i);
+            }
+
+            return { res, progress, aborted };
+        },
+    );
+
+    error = this.create(
+        'error',
+        async (
+            _, // should have all possible combinations for strong typing
+            ctx,
+        ) => {
+            this.lastContext = ctx;
+            throw new Error('Test');
+        },
+    );
+}
+
+const createWorker = () => {
+    const mainWorker = new WorkerPeer();
+    const mainDialog = new WorkerDialog(
+        mainWorker as never as Worker,
+        {} as WorkerDialog<Responders>['responders'],
+        'Main',
+    );
+
+    const worker = new WorkerPeer();
+    const workerDialog = new WorkerDialog(worker as never as Worker, new Responders(), 'Worker');
+
+    mainWorker.setPeer(worker);
+    worker.setPeer(mainWorker);
+
+    return { mainWorker, mainDialog, worker, workerDialog };
+};
+
+// Tests
+
+describe('Worker', async () => {
+    test('simple', async () => {
+        const { mainDialog, workerDialog } = createWorker();
+
+        const l = vi.fn();
+        let mctx;
+
+        const result = await mainDialog.withMessage('test').fetch({ n: 3, buf: new ArrayBuffer() }, (ctx) => {
+            mctx = ctx;
+            ctx.listen(l);
+        });
+
+        expect(l).toBeCalledTimes(4); // 3x progress, last
+        expect(result).toStrictEqual({ res: [0, 1, 2], progress: 1, aborted: false });
+
+        expect(mainDialog.contexts.size).toBe(0);
+        expect(mctx.debugInfo.closed).toBe(true);
+
+        expect(workerDialog.contexts.size).toBe(2);
+        expect(workerDialog.contexts.values().next().value.debugInfo).toStrictEqual({
+            id: '*',
+            parentId: undefined,
+            message: 'test',
+            closed: false,
+            type: 'response',
+            listeners: 1,
+        });
+        expect(workerDialog.responders.lastContext.debugInfo).toStrictEqual({
+            id: '1',
+            parentId: '*',
+            message: 'test',
+            closed: true,
+            type: 'response',
+            listeners: 0,
+        });
+    });
+
+    test('abort', async () => {
+        const { mainDialog } = createWorker();
+
+        const result = await mainDialog.withMessage('test').fetch({ n: 3 }, (ctx) => {
+            ctx.listen(() => {
+                ctx.send({ abort: true });
+            });
+        });
+
+        expect(result).toStrictEqual({ res: [0], progress: 0.3333333333333333, aborted: true });
+    });
+
+    test('faulty listener', async () => {
+        const { mainDialog } = createWorker();
+
+        await mainDialog.withMessage('test').fetch({ n: 3 }, (ctx) => {
+            ctx.listen(() => {
+                throw new Error('Listener');
+            });
+        });
+
+        expect.assertions(0); // nothing happened
+    });
+
+    test('error', async () => {
+        const { mainDialog } = createWorker();
+        await expect(async () => mainDialog.withMessage('error').fetch()).rejects.toThrowError('Test');
+    });
+
+    test('close', async () => {
+        const { mainDialog, workerDialog } = createWorker();
+
+        mainDialog.close();
+        workerDialog.close();
+
+        expect(mainDialog.contexts.size).toBe(0);
+        expect(workerDialog.contexts.size).toBe(0);
+    });
+
+    test('empty message', async () => {
+        expect(() => createWorker().mainDialog.withMessage(undefined as any)).toThrowError(
+            'New context must have message',
+        );
+    });
+
+    test('empty ID', async () => {
+        const { mainDialog } = createWorker();
+        const first = mainDialog.withMessage('test');
+        expect(() => first.withMessage('error', '')).toThrowError('ID is required');
+    });
+
+    test('nesting', async () => {
+        const { mainDialog } = createWorker();
+        const first = mainDialog.withMessage('test');
+        const second = first.withMessage('error', 'x');
+        const third = second.withMessage('error');
+        expect(mainDialog.contexts.size).toBe(3);
+        expect(first.info).toBe('Main:*/1:test[open,request]');
+        first.close();
+        expect(mainDialog.contexts.size).toBe(0);
+        expect(first.debugInfo.closed).toBe(true);
+        expect(second.debugInfo.closed).toBe(true);
+        expect(third.debugInfo.closed).toBe(true);
+        expect(first.info).toBe('Main:*/1:test[closed,request]'); // id bumped from 0
+        expect(second.info).toBe('Main:1/x:error[closed,request]'); // new id
+        expect(third.info).toBe('Main:x/x:error[closed,request]'); // id kept
+        await expect(() => first.fetch({ n: 1 })).rejects.toThrowError(/Context 1 is closed/);
+    });
+});

package/src/core/worker.ts

@@ -1,36 +1,6 @@
-export function isTransferable(obj: any): boolean {
-    return transferrable.some((t) => obj instanceof t) ? obj : null;
-}
-
-function getTransferrable(data: any = {}): Transferable[] {
-    if (!data) return [];
-    return Object.values<any>(data)
-        .reduce((r, v) => {
-            return Array.isArray(v) ? [...r, ...v.map(isTransferable)] : [...r, isTransferable(v)];
-        }, [])
-        .filter(Boolean);
-}
+import { getTransferrable } from './workerUtils';
 
-// @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects
-const transferrable =
-    typeof window !== 'undefined'
-        ? [
-              ArrayBuffer,
-              MessagePort,
-              ReadableStream,
-              WritableStream,
-              TransformStream,
-              // WebTransportReceiveStream, // ReferenceError: WebTransportReceiveStream is not defined
-              // WebTransportSendStream, // ReferenceError: WebTransportReceiveStream is not defined
-              // AudioData, // TS2304: Cannot find name AudioData
-              ImageBitmap,
-              VideoFrame,
-              OffscreenCanvas,
-              RTCDataChannel,
-              MediaSourceHandle,
-              // MIDIAccess, // ReferenceError: MIDIAccess is not defined
-          ].filter(Boolean)
-        : [];
+// Types
 
 type WebWorker = Worker | (Window & typeof globalThis) | (WorkerGlobalScope & typeof globalThis);
 
@@ -44,6 +14,7 @@ export type Ctx<R, K extends keyof R> = {
     id: string;
     parentId?: string;
     message: K;
+    done: boolean;
 };
 
 type Data<R, M extends keyof R> = MethodReturn<R, M> | MethodArg<R, M> | Error;
@@ -56,35 +27,37 @@ type Listener<R, M extends keyof R, D extends Data<R, M> = Data<R, M>, S extends
     event: Event<R, M>,
 ) => void | Promise<void>;
 
-const ALL = '*';
+// Constants
 
-let id = 0;
+const ALL = '*';
 
-function getID() {
-    return (++id).toString();
-}
+const RESPONDER = Symbol('responder');
 
 function checkClosed(obj: any, label: string = 'external') {
-    if (obj?.closed) throw new Error(`Context is closed ${this.info} (${label})`, { cause: obj });
+    if (obj?.closed) throw new Error(`Context ${obj.id} is closed (${label})`, { cause: obj });
 }
 
 function checkMessage(obj: any, message: any) {
     if (!message) throw new Error('New context must have message', { cause: obj });
 }
 
+// Classes
+
 export class WorkerDialog<R extends RespondersBase<any>> {
     readonly contexts = new Set<Context<R, keyof R>>();
     protected closed = false;
+    protected currentId = 0; // IDs are intentionally not global
 
     constructor(
         public worker: WebWorker,
         public responders: R,
         public name: string,
+        public debug: number = 0, // 0 - none, 1 - general messages, 2 - sub/unsub, 3 - transport TODO Object?
     ) {
         if (!this.worker) return; // Next.js SSR
 
         for (const message in this.responders) {
-            if (['constructor', 'create'].includes(message)) continue;
+            if (!this.responders?.[message]?.[RESPONDER]) continue;
 
             // root context with id=all
             const rootContext = new ResponseContext<R, typeof message>(this, message, ALL);
@@ -94,33 +67,40 @@ export class WorkerDialog<R extends RespondersBase<any>> {
                 // create sub context with ID
                 const responseContext = context.withMessage(message, event.data.ctx.id);
 
-                console.log('Root Listener', rootContext.info, {
-                    rootContext: context,
-                    data,
-                    responseContext,
-                    event,
-                    responder: this.responders[message],
-                });
+                /* v8 ignore start */
+                if (this.debug)
+                    console.log('Root Listener', rootContext.info, {
+                        rootContext: context,
+                        data,
+                        responseContext,
+                        event,
+                        responder: this.responders[message],
+                    });
+                /* v8 ignore stop */
 
                 try {
-                    responseContext.send(await (this.responders[message] as any)(data, responseContext));
+                    responseContext.send(await (this.responders[message] as any)(data, responseContext), true);
                     responseContext.close('root.listener');
                 } catch (e) {
-                    console.error(`Error in responder ${responseContext.info}`, { e });
-                    responseContext.send(e);
+                    /* v8 ignore next */
+                    if (this.debug) console.error(`Error in responder ${responseContext.info}`, { e });
+                    responseContext.send(e, true);
                 }
-            });
+            }, true);
         }
     }
 
+    getID() {
+        return (++this.currentId).toString();
+    }
+
     close() {
         for (const context of this.contexts) context.close('root');
         this.contexts.clear();
-        this.worker.onmessage = null;
     }
 
     withMessage<M extends keyof R>(message: M) {
-        return new RequestContext<R, M>(this, message, getID());
+        return new RequestContext<R, M>(this, message, this.getID()); // always new context
     }
 }
 
@@ -129,6 +109,7 @@ export class RespondersBase<R> {
         message: M,
         responder: F,
     ): F {
+        responder[RESPONDER] = true;
         return responder as any;
     }
 }
@@ -144,17 +125,19 @@ abstract class Context<R, M extends keyof R> {
         public id: string | undefined,
         public parent: Context<R, keyof R> | undefined | null = null,
     ) {
-        checkClosed(this.dialog, 'newContext');
-        checkClosed(this.parent, 'newContext');
+        checkClosed(dialog, 'newContext');
+        checkClosed(parent, 'newContext');
         checkMessage(this, message);
-        this.id = parent?.id === ALL ? getID() : id ? id : this.parent?.id;
+        this.id = id ?? parent?.id;
         if (!this.id) throw new Error('ID is required', { cause: this });
+        this.dialog.contexts.add(this);
     }
 
     abstract withMessage<M2 extends keyof R>(message: M2, id?: string): Context<R, M2>;
 
     close(reason: string = 'external') {
-        // console.log('Closing', this.id, reason, this);
+        /* v8 ignore next */
+        if (this.dialog.debug >= 2) console.log('Closing', this.info, reason, this);
 
         this.dialog.contexts.delete(this);
 
@@ -171,33 +154,44 @@ abstract class Context<R, M extends keyof R> {
     }
 
     get info() {
-        return this.dialog.name + '.' + this.parent?.id + '.' + this.id + '.' + this.message.toString();
+        return `${this.dialog.name}:${this.parent?.id ?? ALL}/${this.id}:${this.message.toString()}[${this.closed ? 'closed' : 'open'},${this.type}]`;
     }
 
-    protected postMessage(data?: Data<R, M>) {
+    get debugInfo() {
+        return {
+            id: this.id,
+            parentId: this.parent?.id,
+            message: this.message,
+            closed: this.closed,
+            type: this.type,
+            listeners: this.unsub.size,
+        };
+    }
+
+    abstract type: 'request' | 'response' | string;
+
+    protected postMessage(data?: Data<R, M>, done = false) {
         checkClosed(this, 'postMessage');
 
         const transfer = getTransferrable(data);
 
-        // console.log('postMessage', this.id, this, { mergedCtx, data, transfer });
+        const ctx = {
+            done,
+            id: this.id,
+            parentId: this.parent?.id,
+            message: this.message,
+        };
 
-        this.dialog.worker.postMessage(
-            {
-                data,
-                ctx: {
-                    id: this.id,
-                    parentId: this.parent?.id,
-                    message: this.message,
-                },
-            },
-            transfer,
-        );
+        /* v8 ignore next */
+        if (this.dialog.debug >= 3) console.log('postMessage', this.info, { ctx, data, transfer }, this);
+
+        this.dialog.worker.postMessage({ data, ctx }, transfer);
 
         return data;
     }
 
-    send(data?: Data<R, M>) {
-        return this.postMessage(data);
+    send(data?: Data<R, M>, done = false) {
+        return this.postMessage(data, done);
     }
 
     /**
@@ -216,33 +210,44 @@ abstract class Context<R, M extends keyof R> {
      * un(); // closes
      * ```
      */
-    listen(callback: Listener<R, M>): () => void {
+    listen(callback: Listener<R, M>, done = false): () => void {
         checkClosed(this, 'listen');
 
-        let workerListener: any;
+        const controller = new AbortController();
 
         this.dialog.worker.addEventListener(
             'message',
-            (workerListener = async (event: Event<R, M>) => {
+            async (event: Event<R, M>) => {
                 try {
                     const {
                         data: { ctx, data },
                     } = event;
 
-                    if (!ctx || (this.id !== ALL && this.id !== ctx.id) || this.message !== ctx.message) return; // unknown message from devtools etc., or different context
+                    if (
+                        !ctx ||
+                        (this.id !== ALL && this.id !== ctx.id) ||
+                        this.message !== ctx.message ||
+                        (done && !ctx.done)
+                    )
+                        return; // unknown message from devtools etc., or different context
 
-                    console.log('Shared listener event', this.info, this, event);
+                    /* v8 ignore next */
+                    if (this.dialog.debug) console.log('Listener event', this.info, event, this);
 
                     await callback(data, this, event); // Requests can come here, but they're typed in responders
                 } catch (e) {
-                    console.error(`Error in listener ${this.info}`, this, { event, e });
+                    /* v8 ignore next */
+                    if (this.dialog.debug) console.error(`Error in listener ${this.info}`, this, { event, e });
+                    //TODO Respond with error?
                 }
-            }),
+            },
+            { signal: controller.signal },
         );
 
         const unsub = () => {
-            // console.log('Stop listening', this.id, this);
-            this.dialog.worker.removeEventListener('message', workerListener);
+            /* v8 ignore next */
+            if (this.dialog.debug >= 2) console.log('Stop listening', this.info, this);
+            controller.abort();
             this.unsub.delete(unsub);
         };
 
@@ -253,16 +258,18 @@ abstract class Context<R, M extends keyof R> {
 }
 
 class RequestContext<R, M extends keyof R> extends Context<R, M> {
+    type = 'request';
+
     withMessage<M2 extends keyof R>(message: M2, id?: string): RequestContext<R, M2> {
         return new RequestContext<R, M2>(this.dialog, message, id, this);
     }
 
-    send(data?: MethodArg<R, M>): MethodArg<R, M> {
-        return super.send(data) as any;
+    send(data?: MethodArg<R, M>, done = false): MethodArg<R, M> {
+        return super.send(data, done) as any;
     }
 
-    listen(callback: Listener<R, M, MethodReturn<R, M>, RequestContext<R, M>>): () => void {
-        return super.listen(callback);
+    listen(callback: Listener<R, M, MethodReturn<R, M>, RequestContext<R, M>>, done = false): () => void {
+        return super.listen(callback, done);
     }
 
     /**
@@ -280,13 +287,16 @@ class RequestContext<R, M extends keyof R> extends Context<R, M> {
         data?: MethodArg<R, M>,
         callback?: (context: RequestContext<R, M>) => void,
     ): Promise<MethodReturn<R, M>> {
+        checkClosed(this, 'fetch');
+
         const res = await Promise.all([
             callback?.(this),
             this.expect(), // will be closed in expect -> listener -> unsub
-            this.send(data),
+            this.send(data, true),
         ]);
 
-        // console.log('Fetch', this.id, this.contexts, this.ownContexts);
+        /* v8 ignore next */
+        if (this.dialog.debug >= 2) console.log('Fetch', this.info, this);
 
         this.close('fetch');
 
@@ -302,26 +312,29 @@ class RequestContext<R, M extends keyof R> extends Context<R, M> {
                 try {
                     if ((data as any) instanceof Error) throw data;
                     responseListener();
-                    // console.log('Expect', this.id, this, eventData);
+                    /* v8 ignore next */
+                    if (this.dialog.debug >= 3) console.log('Expect', this.info, data, this);
                     resolve(data as any);
                 } catch (e) {
                     reject(e);
                 }
-            });
+            }, true);
         });
     }
 }
 
 class ResponseContext<R, M extends keyof R> extends Context<R, M> {
+    type = 'response';
+
     withMessage<M2 extends keyof R>(message: M2, id?: string): ResponseContext<R, M2> {
         return new ResponseContext<R, M2>(this.dialog, message, id, this);
     }
 
-    listen(callback: Listener<R, M, MethodArg<R, M>, ResponseContext<R, M>>): () => void {
-        return super.listen(callback);
+    listen(callback: Listener<R, M, MethodArg<R, M>, ResponseContext<R, M>>, done = false): () => void {
+        return super.listen(callback, done);
     }
 
-    send(data?: MethodReturn<R, M>): MethodReturn<R, M> {
-        return super.send(data) as any;
+    send(data?: MethodReturn<R, M>, done = false): MethodReturn<R, M> {
+        return super.send(data, done) as any;
     }
 }

package/src/core/workerUtils.ts

@@ -0,0 +1,32 @@
+const g = globalThis;
+
+// @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Transferable_objects
+const transferrable = [
+    g.ArrayBuffer,
+    g.MessagePort,
+    g.ReadableStream,
+    g.WritableStream,
+    g.TransformStream,
+    // WebTransportReceiveStream, // ReferenceError: WebTransportReceiveStream is not defined
+    // WebTransportSendStream, // ReferenceError: WebTransportReceiveStream is not defined
+    // AudioData, // TS2304: Cannot find name AudioData
+    g.ImageBitmap,
+    g.VideoFrame,
+    g.OffscreenCanvas,
+    g.RTCDataChannel,
+    g.MediaSourceHandle,
+    // MIDIAccess, // ReferenceError: MIDIAccess is not defined
+].filter(Boolean);
+
+export function isTransferable(obj: any): boolean {
+    return transferrable.some((t) => obj instanceof t) ? obj : null;
+}
+
+export function getTransferrable(data: any = {}): Transferable[] {
+    if (!data) return [];
+    return Object.values<any>(data)
+        .reduce((r, v) => {
+            return Array.isArray(v) ? [...r, ...v.map(isTransferable)] : [...r, isTransferable(v)];
+        }, [])
+        .filter(Boolean);
+}

package/src/core/wrpc.fixture.ts

@@ -0,0 +1,72 @@
+import { wrpc } from './wrpc';
+
+export const responder = wrpc().createResponder(self, {
+    // note it's not async, and works properly
+    test: function* ({ buf, signal }: { signal?: AbortSignal; buf?: ArrayBuffer } = {}) {
+        yield { progress: 0 };
+        yield { progress: 0.5 };
+        yield { progress: 1, aborted: !!signal?.aborted };
+        return 'foo';
+    },
+    // note it's not async, and works properly
+    returnYield: function* () {
+        yield 1;
+        yield 2;
+        return yield 3;
+    },
+    bidirectional: function* (prefix = 1): Generator<string, string, number> {
+        let i = 0;
+        while (i < 3) {
+            prefix = (yield prefix + '.' + i) || prefix;
+            i++;
+        }
+        return 'done';
+    },
+    // eslint-disable-next-line require-yield
+    error: async function* () {
+        throw new Error('Test');
+    },
+    promise: async function () {
+        return { test: 'test' };
+    },
+    promiseError: async function () {
+        throw new Error('Test');
+    },
+    setTimeout: async ({ timeout = 1000 }: { timeout?: number } = {}) =>
+        new Promise((resolve) => setTimeout(resolve, timeout)),
+
+    setInterval: async function* ({ timeout = 1000 }: { timeout?: number } = {}) {
+        while (true) {
+            yield await this.setTimeout(timeout);
+        }
+    },
+});
+
+// self.onmessage = (e) => {
+//     console.log('MSG', e);
+//     if (e.data.msg === 'info') {
+//         self.postMessage({
+//             responder: 'test', // responder.toString(),
+//         });
+//     }
+// };
+
+// self.onmessage = (e) => {
+//     console.log('MSG', e);
+//     self.postMessage(`${e.data} world`);
+// };
+
+self.addEventListener('message', (e) => {
+    if (e.data.msg === 'info') {
+        self.postMessage({
+            msg: e.data.msg,
+            responder: 'test', // responder.toString(),
+        });
+    }
+    if (e.data.msg === 'stop') {
+        responder.stop();
+        self.postMessage({
+            msg: e.data.msg,
+        });
+    }
+});