@4players/odin-plugin-web 1.0.0-alpha.9 → 1.0.1

package/lib/plugin/roomConnection.js

@@ -1,303 +0,0 @@
-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 { RpcConnection } from './rpcConnection';
-import { Token } from './token';
-import { Selector, failure, sleep, success, RoomCommandsRpc, } from '@4players/odin-common';
-import * as z from 'zod';
-import { ConnectTimeout, MinTokenLifetime, MinTokenRefreshInterval, } from './config';
-export class RoomConnection {
-    get token() {
-        return this._Token;
-    }
-    get userData() {
-        return this._UserData;
-    }
-    get position() {
-        return this._Position;
-    }
-    get closed() {
-        return this._Close.signal.aborted;
-    }
-    get mainConnection() {
-        return this._MainConnection;
-    }
-    constructor(connectionPool, onEvent, gateway, token, roomId, userData, position) {
-        this.connectionPool = connectionPool;
-        this.onEvent = onEvent;
-        this.gateway = gateway;
-        this.roomId = roomId;
-        this._Close = new AbortController();
-        this._LastTokenRenew = performance.now();
-        this._Closed = new Promise((accept) => this._Close.signal.addEventListener('abort', () => accept('closed'), {
-            once: true,
-        }));
-        this._Token = token;
-        this._UserData = userData;
-        this._Position = position;
-        this._Main().then(({ reason }) => console.debug(`room closed; ${reason}`));
-    }
-    request(name, properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._RoomConnection === undefined) {
-                return failure('currently not connected');
-            }
-            const response = yield this._RoomConnection.request(name, properties);
-            if (response !== 'closed' && response.type === 'Success') {
-                this._HandleRequests(name, properties, response.value);
-            }
-            return response;
-        });
-    }
-    typedRequest(name, properties) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const schema = RoomCommandsRpc[name];
-            const response = yield this.request(name, properties);
-            if (response === 'closed' || response.type === 'Failure')
-                return response;
-            const parsed = schema.response.safeParse(response.value);
-            if (parsed.success)
-                return success(parsed.data);
-            else {
-                return failure(`received invalid response from ${name}; ${parsed.error}`);
-            }
-        });
-    }
-    close() {
-        this._Close.abort();
-    }
-    get renewTokenIn() {
-        const earliest = this._LastTokenRenew - performance.now() + MinTokenRefreshInterval;
-        const latest = this._Token.timeLeft - MinTokenLifetime;
-        return Math.max(earliest, latest);
-    }
-    _Main() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let closeReason = 'unable to establish connection';
-            /// as long as we are asked to continue
-            while (this._Close.signal.aborted === false) {
-                const result = yield this._ConnectToServer();
-                if (result.type === 'Failure') {
-                    closeReason = result.reason;
-                    break;
-                }
-                (_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.close();
-                this._RoomConnection = undefined;
-                this._MainConnection = undefined;
-                // can the token be used to request a better token from a gateway?
-                if (this.gateway !== undefined && this._Token.hasAudience('gateway')) {
-                    this._ChangeStatus('Joining', `requesting new token from ${this.gateway}`);
-                    const newToken = yield contactGateway(this.gateway, this._Token, this._Close.signal);
-                    if (newToken.type === 'Success') {
-                        if (newToken.value !== 'rejected') {
-                            // we got a better token, lets retry.
-                            this._Token = newToken.value;
-                            continue;
-                        }
-                        else {
-                            closeReason = 'invalid or expired token';
-                            break;
-                        }
-                    }
-                }
-                // we failed to get a connection, should we try again?
-                if (this._Token.timeLeft <= 0) {
-                    closeReason = 'unable to use expired token';
-                    break;
-                }
-                // slow retries down
-                yield sleep(1000);
-            }
-            this._ChangeStatus('Closed', this._Close.signal.aborted ? 'user requested' : closeReason);
-            this.close();
-            return failure(closeReason);
-        });
-    }
-    _ConnectToServer() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // for now strip upstream wrappers in the token, because it not supported in web
-            let token = this._Token;
-            while (token.upstream !== undefined) {
-                token = token.upstream;
-            }
-            if (!token.hasAudience('sfu') || token.address === undefined) {
-                return success('continue');
-            }
-            this._ChangeStatus('Joining', `connecting to ${token.address}`);
-            // are we already connected to the server?
-            if (this._MainConnection === undefined ||
-                this._MainConnection.closed ||
-                this._MainConnection.url !== token.address) {
-                // no? release the not fitting connection
-                if (this._MainConnection) {
-                    this.connectionPool.releaseConnection(this._MainConnection);
-                }
-                // connect to the right server
-                const mainConnection = yield this.connectionPool.acquireConnection(token.address, this._Close.signal);
-                if (mainConnection === 'closed')
-                    return failure('connection pool closed'); // connection pool is closed
-                if (mainConnection.type === 'Failure') {
-                    this._ChangeStatus('Joining', `connection failed; ${mainConnection.reason}`);
-                    return success('continue');
-                }
-                this._MainConnection = mainConnection.value;
-            }
-            // join room
-            const result = yield Promise.race([
-                Promise.all([
-                    this._MainConnection.joinRoom(token, this.roomId, this.userData, this.position),
-                ]),
-                sleep(ConnectTimeout, 'timeout'),
-                this._Closed,
-            ]);
-            if (result === 'closed')
-                return failure('room connection closed'); // room connection was closed
-            if (result !== 'timeout') {
-                const [websocket] = result;
-                if (websocket === 'closed')
-                    return success('continue'); // connection was lost, before joinRoom finished
-                if (websocket.type === 'Failure') {
-                    // join was rejected by the server
-                    return failure(`unable to join room; ${websocket.reason}`);
-                }
-                // room connection is open, make it available
-                this._RoomConnection = new RpcConnection(websocket.value);
-                this._ChangeStatus('Joined', `joined room ${this.roomId} on ${websocket.value.url}`);
-                // TODO(sven): handle this
-                // await this._MainConnection.webRtcReady()
-                // process room events
-                yield this._HandleConnection(this._MainConnection, websocket.value);
-            }
-            // try to reconnect
-            return success('continue');
-        });
-    }
-    _ChangeStatus(status, message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const properties = {
-                status,
-                message,
-            };
-            this.onEvent('RoomStatusChanged', properties);
-        });
-    }
-    _HandleConnection(main, webSocket) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._RoomConnection === undefined)
-                return;
-            const selector = new Selector([
-                () => sleep(this.renewTokenIn, 'renewToken'),
-                () => sleep(500, 'tick'),
-                () => __awaiter(this, void 0, void 0, function* () { var _a; return yield ((_a = this._RoomConnection) === null || _a === void 0 ? void 0 : _a.recv()); }),
-                () => this._Closed,
-                () => main.closePromise,
-            ]);
-            while (true) {
-                const value = yield selector.next();
-                switch (value) {
-                    case undefined:
-                    case 'closed':
-                        webSocket.close();
-                        return;
-                    case 'renewToken':
-                        this._RenewToken(main, webSocket);
-                        break;
-                    case 'tick':
-                        break;
-                    default:
-                        this._HandleEvent(value);
-                        break;
-                }
-            }
-        });
-    }
-    _HandleEvent(event) {
-        this.onEvent(event.name, event.properties);
-    }
-    _HandleRequests(name, properties, response) {
-        switch (name) {
-            case 'SetPeerPosition':
-                // eslint-disable-next-line no-case-declarations
-                const setPeerPosition = RoomCommandsRpc.SetPeerPosition.request.safeParse(properties);
-                if (setPeerPosition.success) {
-                    const value = setPeerPosition.data.position;
-                    this._Position = value.length === 2 ? [value[0], value[1], 0] : value;
-                }
-                else {
-                    console.warn('unable to process SetPeerPosition command');
-                }
-                break;
-            case 'UpdatePeer':
-                // eslint-disable-next-line no-case-declarations
-                const updatePeer = RoomCommandsRpc.UpdatePeer.request.safeParse(properties);
-                if (updatePeer.success) {
-                    this._UserData = updatePeer.data.user_data;
-                }
-                else {
-                    console.warn('unable to process UpdatePeer command');
-                }
-                break;
-        }
-    }
-    _RenewToken(main, webSocket) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this._LastTokenRenew = performance.now();
-            if (this.token.timeLeft > MinTokenLifetime)
-                return;
-            const response = yield main.getReconnectToken(webSocket);
-            if (response.type === 'Success') {
-                if (response.value.timeLeft > this._Token.timeLeft) {
-                    this._Token = response.value;
-                }
-            }
-            else {
-                console.warn(`${main.url} rejected reconnect token request; ${response.reason}`);
-            }
-        });
-    }
-}
-function contactGateway(gateway, token, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const response = yield fetch(gateway, {
-                body: '{"jsonrpc":"2.0","id":1,"method":"Connect","params":{}}',
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json',
-                    authorization: `Bearer ${token}`,
-                },
-                signal,
-            });
-            const schema = z.union([
-                z.object({
-                    result: z.object({
-                        token: z.string(),
-                    }),
-                }),
-                z.object({
-                    error: z.object({
-                        message: z.string(),
-                    }),
-                }),
-            ]);
-            const body = schema.parse(yield response.json());
-            if ('result' in body) {
-                return Token.parse(body.result.token);
-            }
-            else {
-                console.error(`gateway rejected token; ${body.error.message}`);
-                return success('rejected');
-            }
-        }
-        catch (error) {
-            return failure(String(error));
-        }
-    });
-}

package/lib/plugin/rpcConnection.d.ts

@@ -1,48 +0,0 @@
-import * as z from 'zod';
-import { Result, RpcMessage } from '@4players/odin-common';
-export declare function connect(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
-export declare function connectOnce(url: URL, signal: AbortSignal): Promise<Result<WebSocket>>;
-export declare class RpcConnection {
-    readonly webSocket: WebSocket;
-    private readonly _SendQueue;
-    private readonly _RecvQueue;
-    private readonly _Requests;
-    private readonly _Close;
-    private _NextId;
-    get closed(): boolean;
-    get closeSignal(): AbortSignal;
-    constructor(webSocket: WebSocket);
-    request(name: string, properties: unknown): Promise<Result<unknown> | 'closed'>;
-    request(name: string, properties: unknown, timeout: number): Promise<Result<unknown> | 'closed' | 'timeout'>;
-    notify(name: string, properties: unknown): void;
-    recv(): Promise<RpcMessage | 'closed'>;
-    close(): void;
-    private _TimeoutRequest;
-    private _Send;
-    private _OnWebSocketOpen;
-    private _OnWebSocketMessage;
-    private _OnResponse;
-    private _OnEvent;
-    private _Cleanup;
-}
-export type Commands = Record<string, {
-    request: z.ZodTypeAny;
-    response: z.ZodTypeAny;
-}>;
-export type Events = Record<string, z.ZodTypeAny>;
-export interface TypedRpcMessage<Name extends string, Properties> extends RpcMessage {
-    name: Name;
-    properties: Properties;
-}
-export type RealizedEvents<E extends Events> = {
-    [Name in Extract<keyof E, string>]: TypedRpcMessage<Name, z.infer<E[Name]>>;
-}[Extract<keyof E, string>];
-export declare class TypedRpcConnection<C extends Commands, E extends Events> extends RpcConnection {
-    readonly _Commands: C;
-    readonly _Events: E;
-    constructor(webSocket: WebSocket, _Commands: C, _Events: E);
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): Promise<Result<z.infer<C[Name]['response']>> | 'closed'>;
-    request<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>, timeout: number): Promise<Result<z.infer<C[Name]['response']>> | 'closed' | 'timeout'>;
-    notify<Name extends Extract<keyof C, string>>(name: Name, properties: z.infer<C[Name]['request']>): void;
-    recv(): Promise<RealizedEvents<E> | 'closed'>;
-}

package/lib/plugin/rpcConnection.js

@@ -1,234 +0,0 @@
-/* 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 { failure, success, isKnownRpcMessage, parseRpc, parseRpcMessage, abortableSleep, } from '@4players/odin-common';
-import { ConnectInterval } from './config';
-export function connect(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        console.debug(`connecting to ${url}`);
-        const start = performance.now();
-        let connection = failure('no connection was attempted');
-        for (let failures = 0; failures < ConnectInterval.length && signal.aborted === false; failures++) {
-            const nextReconnectAt = start + whenToConnect(failures);
-            if ((yield abortableSleep(nextReconnectAt - performance.now(), signal)) ===
-                'aborted') {
-                return failure('aborted');
-            }
-            connection = yield connectOnce(url, signal);
-            if (connection.type === 'Success') {
-                return connection;
-            }
-        }
-        return connection;
-    });
-}
-export function connectOnce(url, signal) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let webSocket;
-        try {
-            webSocket = new WebSocket(url);
-        }
-        catch (reason) {
-            return failure(`unable to create websocket; ${reason}`);
-        }
-        const abort = new AbortController();
-        const onOpen = new Promise((accept) => webSocket.addEventListener('open', () => accept(success(webSocket)), {
-            signal: abort.signal,
-        }));
-        const onClose = new Promise((accept) => webSocket.addEventListener('close', (event) => accept(failure(event.reason)), { signal: abort.signal }));
-        const onAbort = new Promise((accept) => signal.addEventListener('abort', () => accept(failure('aborted')), {
-            signal: abort.signal,
-        }));
-        const result = yield Promise.race([onOpen, onClose, onAbort]);
-        abort.abort();
-        return result;
-    });
-}
-function whenToConnect(failures) {
-    const past_connects = ConnectInterval.slice(0, failures).reduce((a, b) => a + b, 0);
-    const interval = ConnectInterval[failures] * Math.random();
-    return past_connects + interval;
-}
-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((accept) => {
-                this._Requests.set(id, { accept, timeoutId });
-                this._NextId += 1;
-            });
-        });
-    }
-    notify(name, properties) {
-        if (this.closed === false) {
-            this._Send([2, name, properties]);
-        }
-    }
-    recv() {
-        if (this.closed === false) {
-            return new Promise((accept) => this._RecvQueue.push(accept));
-        }
-        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.accept('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.accept(error === null ? success(result) : failure(error));
-    }
-    _OnEvent(name, properties) {
-        console.log('event', name, properties);
-        const receiver = this._RecvQueue.shift();
-        if (receiver !== undefined) {
-            receiver({ name, properties });
-        }
-    }
-    _Cleanup() {
-        console.log(`cleanup ${this.webSocket.url}`);
-        for (const request of this._Requests.values()) {
-            clearTimeout(request.timeoutId);
-            request.accept('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';
-        });
-    }
-}

package/lib/plugin/token.d.ts

@@ -1,17 +0,0 @@
-import * as z from 'zod';
-import { TokenAudienceSchema, TokenClaimsSchema, Result } from '@4players/odin-common';
-export type TokenClaims = z.infer<typeof TokenClaimsSchema>;
-export declare class Token {
-    readonly text: string;
-    readonly claims: TokenClaims;
-    static parse(token: string): Result<Token>;
-    private readonly _Address;
-    private readonly _Upstream;
-    protected constructor(text: string, claims: TokenClaims);
-    get timeLeft(): number;
-    get address(): URL | undefined;
-    get upstream(): Token | undefined;
-    get defaultRoomId(): string | undefined;
-    hasAudience(audience: z.infer<typeof TokenAudienceSchema>): boolean;
-    toString(): string;
-}

package/lib/plugin/token.js

@@ -1,78 +0,0 @@
-import { TokenClaimsSchema, failure, fromBase64Url, success, } from '@4players/odin-common';
-export class Token {
-    static parse(token) {
-        const segments = token.split('.');
-        if (segments.length !== 3)
-            return failure('expected three segments');
-        const body = fromBase64Url(segments[1]);
-        if (body.type === 'Failure') {
-            return failure(`invalid token; ${body.reason}`);
-        }
-        let json;
-        try {
-            json = JSON.parse(body.value);
-        }
-        catch (reason) {
-            return failure(`invalid token; ${reason}`);
-        }
-        const parsed = TokenClaimsSchema.safeParse(json);
-        if (parsed.success === false) {
-            return failure(`invalid token; ${parsed.error}`);
-        }
-        return success(new Token(token, parsed.data));
-    }
-    constructor(text, claims) {
-        this.text = text;
-        this.claims = claims;
-        const address = claims.adr;
-        if (address !== undefined) {
-            try {
-                this._Address = new URL(`wss://${address}`);
-            }
-            catch (error) {
-                console.error(`address in token(${address}) can not be parsed; ${error}`);
-            }
-        }
-        if (claims.ups !== undefined) {
-            const upstream = Token.parse(claims.ups);
-            if (upstream.type === 'Success') {
-                this._Upstream = upstream.value;
-            }
-            else {
-                console.error(`upstream in token can not be parsed; ${upstream.reason}`);
-            }
-        }
-    }
-    get timeLeft() {
-        if (this.claims.exp === undefined)
-            return Infinity;
-        return this.claims.exp * 1000 - Date.now();
-    }
-    get address() {
-        return this._Address;
-    }
-    get upstream() {
-        return this._Upstream;
-    }
-    get defaultRoomId() {
-        if (Array.isArray(this.claims.rid)) {
-            return this.claims.rid.length === 1 ? this.claims.rid[0] : undefined;
-        }
-        else {
-            return this.claims.rid;
-        }
-    }
-    hasAudience(audience) {
-        if (this.claims.aud === undefined)
-            return true;
-        if (Array.isArray(this.claims.aud)) {
-            return this.claims.aud.includes(audience);
-        }
-        else {
-            return this.claims.aud === audience;
-        }
-    }
-    toString() {
-        return this.text;
-    }
-}