@4players/odin-common 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 1.2.0
+
+- Added both typed and untyped rpc connection class
+
+## 1.1.2
+
+- Added missing export
+
+## 1.1.1
+
+- Updated npm ignore patterns
+
 ## 1.1.0
 
 - Added utility functions shared across browser frontend/backend apis

package/lib/cjs/utility/rpc.js

@@ -1,6 +1,16 @@
 "use strict";
+/* eslint-disable no-dupe-class-members */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRpcMessage = exports.parseRpc = exports.msgpackDecode = exports.msgpackEncode = void 0;
+exports.isKnownRpcMessage = exports.parseRpcMessage = exports.parseRpc = exports.TypedRpcConnection = exports.RpcConnection = exports.msgpackDecode = exports.msgpackEncode = void 0;
 const msgpack = require("@msgpack/msgpack");
 const serialization_1 = require("../schema/serialization");
 const result_1 = require("./result");
@@ -12,6 +22,181 @@ function msgpackDecode(buffer) {
     return msgpack.decode(buffer);
 }
 exports.msgpackDecode = msgpackDecode;
+class RpcConnection {
+    get closed() {
+        return this._Close.signal.aborted;
+    }
+    get closeSignal() {
+        return this._Close.signal;
+    }
+    constructor(webSocket) {
+        this.webSocket = webSocket;
+        this._SendQueue = [];
+        this._RecvQueue = [];
+        this._Requests = new Map();
+        this._Close = new AbortController();
+        this._NextId = 1;
+        this.webSocket.addEventListener('open', this._OnWebSocketOpen.bind(this));
+        this.webSocket.addEventListener('close', this.close.bind(this));
+        this.webSocket.addEventListener('message', this._OnWebSocketMessage.bind(this));
+        this.webSocket.binaryType = 'arraybuffer';
+        this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
+            once: true,
+        });
+    }
+    request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed) {
+                return Promise.resolve('closed');
+            }
+            const id = this._NextId;
+            const timeoutId = timeout === undefined
+                ? undefined
+                : setTimeout(() => this._TimeoutRequest(id), timeout);
+            this._Send([0, id, name, properties]);
+            return new Promise((resolve) => {
+                this._Requests.set(id, { resolve, timeoutId });
+                this._NextId += 1;
+            });
+        });
+    }
+    notify(name, properties) {
+        if (this.closed === false) {
+            this._Send([2, name, properties]);
+        }
+    }
+    recv() {
+        if (this.closed === false) {
+            return new Promise((resolve) => this._RecvQueue.push(resolve));
+        }
+        else {
+            return Promise.resolve('closed');
+        }
+    }
+    close() {
+        this._Close.abort();
+    }
+    _TimeoutRequest(requestId) {
+        const request = this._Requests.get(requestId);
+        if (request === undefined)
+            return;
+        this._Requests.delete(requestId);
+        clearTimeout(request.timeoutId);
+        request.resolve('timeout');
+    }
+    _Send(message) {
+        this.webSocket.send(msgpack.encode(message));
+    }
+    _OnWebSocketOpen(ev) {
+        for (const data in this._SendQueue) {
+            this.webSocket.send(data);
+        }
+        this._SendQueue.length = 0;
+    }
+    _OnWebSocketMessage(ev) {
+        const rpc = parseRpc(ev.data);
+        if (rpc.type !== 'Success') {
+            this.webSocket.close();
+            return;
+        }
+        switch (rpc.value[0]) {
+            case 0:
+                this._Send([1, rpc.value[1], 'not supported', undefined]);
+                break;
+            case 1:
+                this._OnResponse(rpc.value[1], rpc.value[2], rpc.value[3]);
+                break;
+            case 2:
+                this._OnEvent(rpc.value[1], rpc.value[2]);
+                break;
+        }
+    }
+    _OnResponse(id, error, result) {
+        const request = this._Requests.get(id);
+        if (request === undefined)
+            return;
+        clearTimeout(request.timeoutId);
+        request.resolve(error === null ? (0, result_1.success)(result) : (0, result_1.failure)(error));
+    }
+    _OnEvent(name, properties) {
+        const receiver = this._RecvQueue.shift();
+        if (receiver !== undefined) {
+            receiver({ name, properties });
+        }
+    }
+    _Cleanup() {
+        for (const request of this._Requests.values()) {
+            clearTimeout(request.timeoutId);
+            request.resolve('closed');
+        }
+        this._Requests.clear();
+        for (const accept of this._RecvQueue) {
+            accept('closed');
+        }
+        this._RecvQueue.length = 0;
+        this._SendQueue.length = 0;
+        this.webSocket.close();
+    }
+}
+exports.RpcConnection = RpcConnection;
+class TypedRpcConnection extends RpcConnection {
+    constructor(webSocket, _Commands, _Events) {
+        super(webSocket);
+        this._Commands = _Commands;
+        this._Events = _Events;
+    }
+    request(name, properties, timeout) {
+        const _super = Object.create(null, {
+            request: { get: () => super.request }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            properties = this._Commands[name].request.parse(properties);
+            const response = yield (timeout !== undefined
+                ? _super.request.call(this, name, properties, timeout)
+                : _super.request.call(this, name, properties));
+            if (response === 'closed' ||
+                response === 'timeout' ||
+                response.type === 'Failure') {
+                return response;
+            }
+            const parsed = this._Commands[name].response.safeParse(response.value);
+            if (parsed.success) {
+                response.value = parsed.data;
+                return response;
+            }
+            else {
+                return (0, result_1.failure)(`response schema failed validation: ${parsed.error}`);
+            }
+        });
+    }
+    notify(name, properties) {
+        properties = this._Commands[name].request.parse(properties);
+        super.notify(name, properties);
+    }
+    recv() {
+        const _super = Object.create(null, {
+            recv: { get: () => super.recv }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const event = yield _super.recv.call(this);
+            if (event === 'closed')
+                return event;
+            const parsed = parseRpcMessage(this._Events, event);
+            if (parsed !== undefined) {
+                return parsed;
+            }
+            if (!isKnownRpcMessage(this._Events, event.name)) {
+                console.warn(`dropping unknown event ${event.name}`);
+            }
+            else {
+                console.error(`schema validation for ${event.name} failed; closing connection`);
+                this.close();
+            }
+            return 'closed';
+        });
+    }
+}
+exports.TypedRpcConnection = TypedRpcConnection;
 function parseRpc(buffer) {
     try {
         return (0, result_1.success)(serialization_1.MessagePackRpcSchema.parse(msgpackDecode(buffer)));
@@ -37,3 +222,4 @@ exports.parseRpcMessage = parseRpcMessage;
 function isKnownRpcMessage(events, name) {
     return name in events;
 }
+exports.isKnownRpcMessage = isKnownRpcMessage;

package/lib/cjs/utility/selector.js

@@ -11,14 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Selector = void 0;
 class Selector {
-    constructor(generators) {
-        this.generators = generators;
-        this.futures = generators.map(Selector.addIndex);
+    constructor(_Generators) {
+        this._Generators = _Generators;
+        this._Futures = _Generators.map(Selector.addIndex);
     }
     next() {
         return __awaiter(this, void 0, void 0, function* () {
-            const [result, index] = yield Promise.race(this.futures);
-            this.futures[index] = Selector.addIndex(this.generators[index], index);
+            const [result, index] = yield Promise.race(this._Futures);
+            this._Futures[index] = Selector.addIndex(this._Generators[index], index);
             return result;
         });
     }

package/lib/cjs/utility/strand.js

@@ -12,8 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Strand = void 0;
 class Strand {
     constructor() {
-        this.tasks = [];
-        this.running = false;
+        this._Tasks = [];
+        this._Running = false;
     }
     enqueue(task) {
         return new Promise((resolve, reject) => {
@@ -26,22 +26,22 @@ class Strand {
                     reject(error);
                 }
             });
-            this.tasks.push(wrapped);
-            if (!this.running) {
+            this._Tasks.push(wrapped);
+            if (!this._Running) {
                 this.execute();
             }
         });
     }
     execute() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.running = true;
+            this._Running = true;
             while (true) {
-                const task = this.tasks.shift();
+                const task = this._Tasks.shift();
                 if (task === undefined)
                     break;
                 yield task();
             }
-            this.running = false;
+            this._Running = false;
         });
     }
 }

package/lib/esm/utility/rpc.js

@@ -1,3 +1,13 @@
+/* eslint-disable no-dupe-class-members */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import * as msgpack from '@msgpack/msgpack';
 import { MessagePackRpcSchema } from '../schema/serialization';
 import { failure, success } from './result';
@@ -7,6 +17,179 @@ export function msgpackEncode(value) {
 export function msgpackDecode(buffer) {
     return msgpack.decode(buffer);
 }
+export class RpcConnection {
+    get closed() {
+        return this._Close.signal.aborted;
+    }
+    get closeSignal() {
+        return this._Close.signal;
+    }
+    constructor(webSocket) {
+        this.webSocket = webSocket;
+        this._SendQueue = [];
+        this._RecvQueue = [];
+        this._Requests = new Map();
+        this._Close = new AbortController();
+        this._NextId = 1;
+        this.webSocket.addEventListener('open', this._OnWebSocketOpen.bind(this));
+        this.webSocket.addEventListener('close', this.close.bind(this));
+        this.webSocket.addEventListener('message', this._OnWebSocketMessage.bind(this));
+        this.webSocket.binaryType = 'arraybuffer';
+        this._Close.signal.addEventListener('abort', this._Cleanup.bind(this), {
+            once: true,
+        });
+    }
+    request(name, properties, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.closed) {
+                return Promise.resolve('closed');
+            }
+            const id = this._NextId;
+            const timeoutId = timeout === undefined
+                ? undefined
+                : setTimeout(() => this._TimeoutRequest(id), timeout);
+            this._Send([0, id, name, properties]);
+            return new Promise((resolve) => {
+                this._Requests.set(id, { resolve, timeoutId });
+                this._NextId += 1;
+            });
+        });
+    }
+    notify(name, properties) {
+        if (this.closed === false) {
+            this._Send([2, name, properties]);
+        }
+    }
+    recv() {
+        if (this.closed === false) {
+            return new Promise((resolve) => this._RecvQueue.push(resolve));
+        }
+        else {
+            return Promise.resolve('closed');
+        }
+    }
+    close() {
+        this._Close.abort();
+    }
+    _TimeoutRequest(requestId) {
+        const request = this._Requests.get(requestId);
+        if (request === undefined)
+            return;
+        this._Requests.delete(requestId);
+        clearTimeout(request.timeoutId);
+        request.resolve('timeout');
+    }
+    _Send(message) {
+        this.webSocket.send(msgpack.encode(message));
+    }
+    _OnWebSocketOpen(ev) {
+        for (const data in this._SendQueue) {
+            this.webSocket.send(data);
+        }
+        this._SendQueue.length = 0;
+    }
+    _OnWebSocketMessage(ev) {
+        const rpc = parseRpc(ev.data);
+        if (rpc.type !== 'Success') {
+            this.webSocket.close();
+            return;
+        }
+        switch (rpc.value[0]) {
+            case 0:
+                this._Send([1, rpc.value[1], 'not supported', undefined]);
+                break;
+            case 1:
+                this._OnResponse(rpc.value[1], rpc.value[2], rpc.value[3]);
+                break;
+            case 2:
+                this._OnEvent(rpc.value[1], rpc.value[2]);
+                break;
+        }
+    }
+    _OnResponse(id, error, result) {
+        const request = this._Requests.get(id);
+        if (request === undefined)
+            return;
+        clearTimeout(request.timeoutId);
+        request.resolve(error === null ? success(result) : failure(error));
+    }
+    _OnEvent(name, properties) {
+        const receiver = this._RecvQueue.shift();
+        if (receiver !== undefined) {
+            receiver({ name, properties });
+        }
+    }
+    _Cleanup() {
+        for (const request of this._Requests.values()) {
+            clearTimeout(request.timeoutId);
+            request.resolve('closed');
+        }
+        this._Requests.clear();
+        for (const accept of this._RecvQueue) {
+            accept('closed');
+        }
+        this._RecvQueue.length = 0;
+        this._SendQueue.length = 0;
+        this.webSocket.close();
+    }
+}
+export class TypedRpcConnection extends RpcConnection {
+    constructor(webSocket, _Commands, _Events) {
+        super(webSocket);
+        this._Commands = _Commands;
+        this._Events = _Events;
+    }
+    request(name, properties, timeout) {
+        const _super = Object.create(null, {
+            request: { get: () => super.request }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            properties = this._Commands[name].request.parse(properties);
+            const response = yield (timeout !== undefined
+                ? _super.request.call(this, name, properties, timeout)
+                : _super.request.call(this, name, properties));
+            if (response === 'closed' ||
+                response === 'timeout' ||
+                response.type === 'Failure') {
+                return response;
+            }
+            const parsed = this._Commands[name].response.safeParse(response.value);
+            if (parsed.success) {
+                response.value = parsed.data;
+                return response;
+            }
+            else {
+                return failure(`response schema failed validation: ${parsed.error}`);
+            }
+        });
+    }
+    notify(name, properties) {
+        properties = this._Commands[name].request.parse(properties);
+        super.notify(name, properties);
+    }
+    recv() {
+        const _super = Object.create(null, {
+            recv: { get: () => super.recv }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const event = yield _super.recv.call(this);
+            if (event === 'closed')
+                return event;
+            const parsed = parseRpcMessage(this._Events, event);
+            if (parsed !== undefined) {
+                return parsed;
+            }
+            if (!isKnownRpcMessage(this._Events, event.name)) {
+                console.warn(`dropping unknown event ${event.name}`);
+            }
+            else {
+                console.error(`schema validation for ${event.name} failed; closing connection`);
+                this.close();
+            }
+            return 'closed';
+        });
+    }
+}
 export function parseRpc(buffer) {
     try {
         return success(MessagePackRpcSchema.parse(msgpackDecode(buffer)));
@@ -27,6 +210,6 @@ export function parseRpcMessage(events, rpc) {
         properties: parsed.data,
     };
 }
-function isKnownRpcMessage(events, name) {
+export function isKnownRpcMessage(events, name) {
     return name in events;
 }

package/lib/esm/utility/selector.js

@@ -8,14 +8,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 export class Selector {
-    constructor(generators) {
-        this.generators = generators;
-        this.futures = generators.map(Selector.addIndex);
+    constructor(_Generators) {
+        this._Generators = _Generators;
+        this._Futures = _Generators.map(Selector.addIndex);
     }
     next() {
         return __awaiter(this, void 0, void 0, function* () {
-            const [result, index] = yield Promise.race(this.futures);
-            this.futures[index] = Selector.addIndex(this.generators[index], index);
+            const [result, index] = yield Promise.race(this._Futures);
+            this._Futures[index] = Selector.addIndex(this._Generators[index], index);
             return result;
         });
     }

package/lib/esm/utility/strand.js

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 export class Strand {
     constructor() {
-        this.tasks = [];
-        this.running = false;
+        this._Tasks = [];
+        this._Running = false;
     }
     enqueue(task) {
         return new Promise((resolve, reject) => {
@@ -23,22 +23,22 @@ export class Strand {
                     reject(error);
                 }
             });
-            this.tasks.push(wrapped);
-            if (!this.running) {
+            this._Tasks.push(wrapped);
+            if (!this._Running) {
                 this.execute();
             }
         });
     }
     execute() {
         return __awaiter(this, void 0, void 0, function* () {
-            this.running = true;
+            this._Running = true;
             while (true) {
-                const task = this.tasks.shift();
+                const task = this._Tasks.shift();
                 if (task === undefined)
                     break;
                 yield task();
             }
-            this.running = false;
+            this._Running = false;
         });
     }
 }