Communication between main thread and sync worker

[psrpinto]

This PR defines the protocol of communication between main thread and workers. The idea is to provide primitives that can be used by all workers, not just the sync worker. In the future, other workers could be adapted to leverage these primitives, e.g. the service worker and the olm worker, or new workers that might be implemented.

There are two types of communication:

1. Asking a worker to run a command: implemented in the form of a Request/Response. Upon receiving a Request, the worker will do whatever it needs to do, and then return a Response. The requester is free to ignore the response, but the worker will always send one.
2. Receiving events from a worker: worker publishes Events to a BroadcastChannel, and main thread can listen to said events.

Primitives

The primitives introduced here are:

1. Worker side:
   • BaseWorker: generic code that applies to all workers.
   • SharedWorker: leverages BaseWorker to implement a SharedWorker.
   • In the future, when the need arises, a DedicatedWorker could be implemented as well.
2. Main thread side:
   • WorkerProxy: allows running code in a worker as if it would be running in the main thread. Sends a Request to the worker, and optionally waits for Response and returns result.
   • EventBus: allows subscribing to specific event types (more on types below).

Types

The API of each worker is specified by defining types for its Requests, Responses and Events. For example, the sync worker would define these types:

export interface StartSyncRequest extends Request {
    type: "StartSync";
    data: {
        sessionId: string,
    }
}

export interface StartSyncResponse extends Response {
    request: StartSyncRequest;
    data: {}
}

export interface SyncStatusChanged extends Event {
    type: "StatusChanged";
    data: {
        newValue: string,
    }
}

Example usage

Worker side:

export class SyncWorker extends SharedWorker {
    constuctor() {
        super();
        this.setHandler("StartSync", this.startSync.bind(this));
    }

    async startSync(request: StartSyncRequest, response: StartSyncResponse): Promise<StartSyncResponse> {
        // Do something.
        return response;
    }
}

Main thread side:

const worker = new SharedWorker("worker.js");
const workerProxy = new WorkerProxy(worker);

const request: StartSyncRequest = {
    id: "1234",
    type: "StartSync",
    data: {
        sessionId: "abc123",
    }
};

const response = await workerProxy.sendAndWaitForResponse(request) as StartSyncResponse;
console.log(response);

[ashfame]

🚀