@omujs/omu 0.9.48 → 0.9.50

package/src/network/network.ts

@@ -1,322 +0,0 @@
-import type { Address } from '../address.js';
-import {
-    AnotherConnection, AppRemoved, DisconnectReason, InternalError,
-    InvalidOrigin,
-    InvalidPacket,
-    InvalidToken,
-    InvalidVersion,
-    PermissionDenied,
-    ServerRestart,
-} from '../errors.js';
-import { EventEmitter } from '../event';
-import { IdentifierMap } from '../identifier';
-import { Omu } from '../omu.js';
-import type { SessioTokenProvider } from '../token.js';
-import { VERSION } from '../version.js';
-
-import type { Connection, Transport } from './connection.js';
-import { PacketMapper } from './connection.js';
-import { AES, Decryptor, ENCRYPTION_AVAILABLE, EncryptionResponse, Encryptor } from './encryption.js';
-import { ConnectPacket, DisconnectType, PACKET_TYPES } from './packet/packet-types.js';
-import type { Packet, PacketType } from './packet/packet.js';
-
-type PacketHandler<T> = {
-    readonly type: PacketType<T>;
-    event: EventEmitter<[T]>;
-};
-
-type StatusType<T> = {
-    type: T;
-};
-
-export type NetworkStatus = StatusType<'connecting'> | StatusType<'connected'> | StatusType<'ready'> | {
-    type: 'disconnected';
-    attempt?: number;
-    reason?: DisconnectReason;
-} | {
-    type: 'reconnecting';
-    attempt: number;
-    timeout: number;
-    date: Date;
-    cancel: () => void;
-};
-
-export class Network {
-    public status: NetworkStatus = { type: 'disconnected' };
-    public readonly event: { connected: EventEmitter<[]>; disconnected: EventEmitter<[DisconnectReason | undefined]>; packet: EventEmitter<[Packet<unknown>]>; status: EventEmitter<[NetworkStatus]> } = {
-        connected: new EventEmitter(),
-        disconnected: new EventEmitter(),
-        packet: new EventEmitter(),
-        status: new EventEmitter(),
-    };
-    private readonly tasks: Array<() => Promise<void> | void> = [];
-    private readonly packetMapper = new PacketMapper();
-    private readonly packetHandlers = new IdentifierMap<PacketHandler<unknown>>();
-    private listenTask: Promise<void> | undefined = undefined;
-    public reason: DisconnectReason | undefined = undefined;
-    private attempt = 0;
-
-    constructor(
-        private readonly omu: Omu,
-        public address: Address,
-        private readonly tokenProvider: SessioTokenProvider,
-        private transport: Transport,
-        private connection?: Connection | undefined,
-        private aes?: AES | undefined,
-    ) {
-        this.registerPacket(
-            PACKET_TYPES.SERVER_META,
-            PACKET_TYPES.CONNECT,
-            PACKET_TYPES.DISCONNECT,
-            PACKET_TYPES.TOKEN,
-            PACKET_TYPES.READY,
-            PACKET_TYPES.ENCRYPTED_PACKET,
-        );
-        this.addPacketHandler(PACKET_TYPES.DISCONNECT, async (reason) => {
-            if (reason.type === DisconnectType.SHUTDOWN
-                || reason.type === DisconnectType.CLOSE) {
-                this.setStatus({ type: 'disconnected' });
-                return;
-            }
-            const ERROR_MAP = {
-                [DisconnectType.ANOTHER_CONNECTION]: AnotherConnection,
-                [DisconnectType.PERMISSION_DENIED]: PermissionDenied,
-                [DisconnectType.APP_REMOVED]: AppRemoved,
-                [DisconnectType.INVALID_TOKEN]: InvalidToken,
-                [DisconnectType.INVALID_ORIGIN]: InvalidOrigin,
-                [DisconnectType.INVALID_VERSION]: InvalidVersion,
-                [DisconnectType.INTERNAL_ERROR]: InternalError,
-                [DisconnectType.INVALID_PACKET]: InvalidPacket,
-                [DisconnectType.INVALID_PACKET_TYPE]: InvalidPacket,
-                [DisconnectType.INVALID_PACKET_DATA]: InvalidPacket,
-                [DisconnectType.SERVER_RESTART]: ServerRestart,
-                [DisconnectType.CLOSE]: undefined,
-                [DisconnectType.SHUTDOWN]: undefined,
-            };
-            const error = ERROR_MAP[reason.type];
-            if (error) {
-                this.reason = new error(reason.message ?? '');
-            }
-        });
-        this.addPacketHandler(PACKET_TYPES.READY, () => {
-            if (this.status.type === 'ready') {
-                throw new Error('Received READY packet when already ready');
-            }
-            this.setStatus({ type: 'ready' });
-            this.attempt = 0;
-        });
-    }
-
-    public setConnection(connection: Connection): void {
-        if (this.status.type !== 'disconnected') {
-            throw new Error('Cannot change connection while connected');
-        }
-        this.connection = connection;
-    }
-
-    public registerPacket(...packetTypes: PacketType<unknown>[]): void {
-        this.packetMapper.register(...packetTypes);
-        for (const type of packetTypes) {
-            this.packetHandlers.set(type.id, {
-                type,
-                event: new EventEmitter(),
-            });
-        }
-    }
-
-    public addPacketHandler<T>(type: PacketType<T>, handler: (packet: T) => void): void {
-        const listeners = this.packetHandlers.get(type.id) as PacketHandler<unknown> | undefined;
-        if (!listeners) {
-            throw new Error(`Packet type ${type.id.key()} not registered`);
-        }
-        listeners.event.listen(handler as (packet: unknown) => void);
-    }
-
-    private async scheduleReconnect(attempt: number): Promise<boolean> {
-        const timeout = Math.min(30000, 2000 * (Math.pow(1.5, attempt) - 1) + 2000);
-        const date = new Date();
-        let cancelled = false;
-        const status: Extract<NetworkStatus, { type: 'reconnecting' }> = {
-            type: 'reconnecting',
-            attempt,
-            timeout,
-            date,
-            cancel: () => {cancelled = true;},
-        };
-        await this.setStatus(status);
-        if (cancelled) {
-            return false;
-        }
-        const remaining = status.timeout - (new Date().getTime() - date.getTime());
-        await new Promise((resolve) => setTimeout(resolve, remaining));
-        return true;
-    }
-
-    public async connect(reconnect = true): Promise<void> {
-        if (!this.isState('disconnected')) {
-            throw new Error(`Cannot connect while ${this.status.type}`);
-        }
-        if (this.listenTask) {
-            throw new Error('Cannot connect while already connecting');
-        }
-
-        this.attempt = 0;
-        while (this.omu.running) {
-            this.attempt++;
-            try {
-                this.aes = undefined;
-                this.connection = await this.transport.connect();
-                await this.setStatus({ type: 'connecting' });
-                const metaReceived = await this.connection.receive(this.packetMapper);
-                if (!metaReceived) {
-                    throw new Error('Connection closed before receiving server meta');
-                }
-                if (!PACKET_TYPES.SERVER_META.match(metaReceived)) {
-                    throw new Error('First packet received was not server meta');
-                }
-                const { data: meta } = metaReceived;
-                this.address.hash = meta.hash;
-                let token = await this.tokenProvider.get(this.address, this.omu.app);
-                if (!token) {
-                    throw new InvalidToken(`No token available for app ${this.omu.app.id.key()} at ${this.address.host}:${this.address.port}:${this.address.hash}`);
-                }
-                let encryptionResp: EncryptionResponse | undefined = undefined;
-                if (this.omu.app.type === 'remote' && ENCRYPTION_AVAILABLE && meta.encryption) {
-                    const decryptor = await Decryptor.new();
-                    const encryptor = await Encryptor.new(meta.encryption.rsa);
-                    if (token) {
-                        token = await encryptor.encryptString(token);
-                    }
-                    this.aes = await AES.new();
-                    encryptionResp = {
-                        kind: 'v1',
-                        rsa: await decryptor.toRequest(),
-                        aes: await this.aes.serialize(encryptor),
-                    };
-                }
-                this.connection.send({
-                    type: PACKET_TYPES.CONNECT,
-                    data: new ConnectPacket({
-                        app: this.omu.app,
-                        protocol: { version: VERSION },
-                        encryption: encryptionResp,
-                        token,
-                    }),
-                }, this.packetMapper);
-                this.listenTask = this.listen();
-                await this.setStatus({ type: 'connected' });
-                await this.event.connected.emit();
-                this.dispatchTasks().then(() => {
-                    this.send({
-                        type: PACKET_TYPES.READY,
-                        data: null,
-                    });
-                });
-                await this.listenTask;
-            } catch (error) {
-                if (error instanceof DisconnectReason) {
-                    this.reason = error;
-                }
-                if (!reconnect) {
-                    throw error;
-                }
-            } finally {
-                this.event.disconnected.emit(this.reason);
-                if (this.status.type !== 'disconnected' && this.status.type !== 'reconnecting') {
-                    this.setStatus({ type: 'disconnected', attempt: this.attempt, reason: this.reason });
-                }
-                this.connection?.close();
-                this.connection = undefined;
-                this.listenTask = undefined;
-            }
-            if (this.reason && ![
-                DisconnectType.SHUTDOWN,
-                DisconnectType.SERVER_RESTART,
-            ].includes(this.reason.type)) {
-                break;
-            }
-            this.reason = undefined;
-            if (!reconnect) {
-                break;
-            }
-            const shouldReconnect = await this.scheduleReconnect(this.attempt);
-            if (!shouldReconnect) {
-                break;
-            }
-        }
-        await this.setStatus({ type: 'disconnected', reason: this.reason });
-        this.connection?.close();
-        this.connection = undefined;
-    }
-
-    private isState(state: NetworkStatus['type']): boolean {
-        return this.status.type === state;
-    }
-
-    public async send(packet: Packet): Promise<void> {
-        if (!this.connection) {
-            throw new Error('No connection established');
-        }
-        if (this.aes) {
-            const serialized = this.packetMapper.serialize(packet);
-            packet = await this.aes.encrypt(serialized);
-        }
-        this.connection.send(packet, this.packetMapper);
-    }
-
-    private async listen(): Promise<void> {
-        while (this.connection) {
-            const packet = await this.connection.receive(this.packetMapper);
-            if (!packet) {
-                break;
-            }
-            await this.dispatchPacket(packet);
-        }
-    }
-
-    private async dispatchPacket(packet: Packet): Promise<void> {
-        if (PACKET_TYPES.ENCRYPTED_PACKET.match(packet)) {
-            if (!this.aes) {
-                throw new Error('Received encrypted packet before encryption was established');
-            }
-            const decrypted = await this.aes.decrypt(packet);
-            packet = this.packetMapper.deserialize(decrypted);
-        }
-        await this.event.packet.emit(packet);
-        const packetHandler = this.packetHandlers.get(packet.type.id);
-        if (!packetHandler) {
-            return;
-        }
-        await packetHandler.event.emit(packet.data);
-    }
-
-    public addTask(task: () => Promise<void> | void): void {
-        if (this.omu.running) {
-            throw new Error('Cannot add task after client is ready');
-        }
-        this.tasks.push(task);
-    }
-
-    public removeTask(task: () => Promise<void> | void): void {
-        this.tasks.splice(this.tasks.indexOf(task), 1);
-    }
-
-    private async dispatchTasks(): Promise<void> {
-        for (const task of this.tasks) {
-            await task();
-        }
-    }
-
-    private async setStatus(status: NetworkStatus): Promise<void> {
-        if (this.status === status) {
-            throw new Error(`Cannot set status to ${status} when already ${status}`);
-        }
-        this.status = status;
-        await this.event.status.emit(status);
-    }
-
-    public close(): void {
-        this.setStatus({ type: 'disconnected' });
-        this.attempt = 0;
-    }
-}

package/src/network/packet/packet-types.ts

@@ -1,164 +0,0 @@
-import type { AppJson } from '../../app.js';
-import { App } from '../../app.js';
-import { Identifier } from '../../identifier';
-import { Serializer } from '../../serialize/serializer.js';
-import { PacketType } from './packet.js';
-
-const IDENTIFIER = new Identifier('core', 'packet');
-
-type ProtocolInfo = {
-    version: string;
-};
-
-type RSANumbers = {
-    e: string;
-    n: string;
-};
-
-type EncryptionRequest = {
-    kind: 'v1';
-    rsa: RSANumbers;
-};
-
-type EncryptionResponse = {
-    kind: 'v1';
-    rsa: RSANumbers;
-    aes: string;
-};
-
-export type ServerMeta = {
-    protocol: ProtocolInfo;
-    encryption: EncryptionRequest | null;
-    hash: string | undefined;
-};
-
-type ConnectPacketJson = {
-    protocol: ProtocolInfo;
-    app: AppJson;
-    token: string;
-    encryption: EncryptionResponse | null;
-};
-
-export class ConnectPacket {
-    public readonly protocol: ProtocolInfo;
-    public readonly app: App;
-    public readonly token: string;
-    public readonly encryption: EncryptionResponse | null;
-
-    constructor(options: {
-        protocol: ProtocolInfo;
-        app: App;
-        token: string;
-        encryption?: EncryptionResponse | null;
-    }) {
-        this.protocol = options.protocol;
-        this.app = options.app;
-        this.token = options.token;
-        this.encryption = options.encryption ?? null;
-    }
-
-    public static deserialize(data: ConnectPacketJson): ConnectPacket {
-        return new ConnectPacket({
-            protocol: data.protocol,
-            app: App.deserialize(data.app),
-            encryption: data.encryption,
-            token: data.token,
-        });
-    }
-
-    public static serialize(data: ConnectPacket): ConnectPacketJson {
-        return {
-            protocol: data.protocol,
-            app: App.serialize(data.app),
-            encryption: data.encryption,
-            token: data.token,
-        };
-    }
-}
-
-export enum DisconnectType {
-    INVALID_TOKEN = 'invalid_token',
-    INVALID_ORIGIN = 'invalid_origin',
-    INVALID_VERSION = 'invalid_version',
-    INVALID_PACKET_TYPE = 'invalid_packet_type',
-    INVALID_PACKET_DATA = 'invalid_packet_data',
-    INVALID_PACKET = 'invalid_packet',
-    INTERNAL_ERROR = 'internal_error',
-    ANOTHER_CONNECTION = 'another_connection',
-    PERMISSION_DENIED = 'permission_denied',
-    APP_REMOVED = 'app_removed',
-    SERVER_RESTART = 'server_restart',
-    SHUTDOWN = 'shutdown',
-    CLOSE = 'close',
-}
-
-type DisconnectPacketJson = {
-    type: DisconnectType;
-    message: string | null;
-};
-
-export class DisconnectPacket {
-    public readonly type: DisconnectType;
-    public readonly message: string | null;
-
-    constructor(options: {
-        type: DisconnectType;
-        message?: string | null;
-    }) {
-        this.type = options.type;
-        this.message = options.message ?? null;
-    }
-
-    public static serialize(data: DisconnectPacket): DisconnectPacketJson {
-        return data.toJson();
-    }
-
-    public static deserialize(data: DisconnectPacketJson): DisconnectPacket {
-        return DisconnectPacket.fromJson(data);
-    }
-
-    static fromJson(data: DisconnectPacketJson): DisconnectPacket {
-        return new DisconnectPacket({
-            type: data.type,
-            message: data.message,
-        });
-    }
-
-    toJson(): DisconnectPacketJson {
-        return {
-            type: this.type,
-            message: this.message,
-        };
-    }
-}
-
-export const PACKET_TYPES: {
-    SERVER_META: PacketType<ServerMeta>;
-    CONNECT: PacketType<ConnectPacket>;
-    DISCONNECT: PacketType<DisconnectPacket>;
-    TOKEN: PacketType<string>;
-    READY: PacketType<undefined>;
-    ENCRYPTED_PACKET: PacketType<Uint8Array>;
-} = {
-    SERVER_META: PacketType.createJson<ServerMeta>(IDENTIFIER, {
-        name: 'server_meta',
-    }),
-    CONNECT: PacketType.createJson<ConnectPacket>(IDENTIFIER, {
-        name: 'connect',
-        serializer: ConnectPacket,
-    }),
-    DISCONNECT: PacketType.createJson<DisconnectPacket>(IDENTIFIER, {
-        name: 'disconnect',
-        serializer: DisconnectPacket,
-    }),
-    TOKEN: PacketType.createJson<string>(IDENTIFIER, {
-        name: 'token',
-    }),
-    READY: PacketType.createJson<undefined>(IDENTIFIER, {
-        name: 'ready',
-    }),
-    ENCRYPTED_PACKET: PacketType.createSerialized<Uint8Array>(IDENTIFIER, {
-        name: 'e',
-        serializer: Serializer.noop(),
-    }),
-};

package/src/network/packet/packet.ts

@@ -1,55 +0,0 @@
-import type { Identifier } from '../../identifier';
-import { JsonType, type Serializable, Serializer } from '../../serialize';
-
-export type PacketData = {
-    readonly type: string;
-    readonly data: Uint8Array;
-};
-
-export type Packet<T = unknown> = {
-    readonly type: PacketType<T>;
-    readonly data: T;
-};
-
-export class PacketType<T> {
-    constructor(
-        public readonly id: Identifier,
-        public readonly serializer: Serializable<T, Uint8Array>,
-    ) { }
-
-    public new(data: T): Packet<T> {
-        return {
-            type: this,
-            data,
-        };
-    }
-    public match(packet: Packet): packet is Packet<T> {
-        return packet.type === this;
-    }
-
-    static createJson<T, D extends JsonType = JsonType>(identifier: Identifier, {
-        name,
-        serializer,
-    }: {
-        name: string;
-        serializer?: Serializable<T, D>;
-    }): PacketType<T> {
-        return new PacketType<T>(
-            identifier.join(name),
-            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),
-        );
-    }
-
-    static createSerialized<T>(identifier: Identifier, {
-        name,
-        serializer,
-    }: {
-        name: string;
-        serializer: Serializable<T, Uint8Array>;
-    }): PacketType<T> {
-        return new PacketType(
-            identifier.join(name),
-            serializer,
-        );
-    }
-}

package/src/network/websocket-transport.ts

@@ -1,123 +0,0 @@
-import type { Address } from '../address.js';
-import type { Serializable } from '../serialize';
-import { ByteReader, ByteWriter } from '../serialize';
-
-import type { Connection, Transport } from './connection.js';
-import type { Packet, PacketData } from './packet/packet.js';
-
-export class WebsocketTransport implements Transport {
-    constructor(
-        private readonly address: Address,
-    ) { }
-
-    private get wsEndpoint(): string {
-        const protocol = this.address.secure ? 'wss' : 'ws';
-        const { host, port } = this.address;
-        return `${protocol}://${host}:${port}/ws`;
-    }
-
-    public connect(): Promise<Connection> {
-        const socket = new WebSocket(this.wsEndpoint);
-        return WebsocketConnection.fromSocket(socket);
-    }
-}
-
-export class WebsocketConnection implements Connection {
-    private readonly packetQueue: Array<PacketData> = [];
-    private receiveWaiter: (() => void) | null = null;
-    private readingPromise: Promise<void> | null = null;
-    private beingClosed: boolean = false;
-
-    constructor(
-        private socket: WebSocket,
-    ) { }
-
-    public static fromSocket(socket: WebSocket): Promise<WebsocketConnection> {
-        const connection = new WebsocketConnection(socket);
-        return new Promise((resolve, reject) => {
-            socket.onerror = reject;
-            socket.onclose = () => {
-                connection.beingClosed = true;
-                if (connection.receiveWaiter) {
-                    connection.receiveWaiter();
-                    connection.receiveWaiter = null;
-                }
-            };
-            socket.onmessage = (event): void => {
-                connection.readingPromise = connection.onMessage(event).finally(() => {
-                    connection.readingPromise = null;
-                });
-            };
-            socket.onopen = (): void => {
-                resolve(connection);
-            };
-        });
-    }
-
-    private async onMessage(event: MessageEvent<string | Blob>): Promise<void> {
-        if (typeof event.data === 'string') {
-            throw new Error('Received string data');
-        }
-        const reader = await ByteReader.fromBlob(event.data);
-        const data = {
-            type: reader.readString(),
-            data: reader.readUint8Array(),
-        };
-        this.packetQueue.push(data);
-        reader.finish();
-        if (this.receiveWaiter) {
-            this.receiveWaiter();
-        }
-    }
-
-    public async receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null> {
-        if (this.receiveWaiter) {
-            throw new Error('Already receiving');
-        }
-        while (this.packetQueue.length === 0 && !this.beingClosed) {
-            await new Promise<void>((resolve) => {
-                this.receiveWaiter = resolve;
-            });
-            this.receiveWaiter = null;
-        }
-        if (this.packetQueue.length === 0 && this.beingClosed) {
-            return null;
-        }
-        const packetData = this.packetQueue.shift()!;
-        return serializer.deserialize(packetData);
-    }
-
-    get closed(): boolean {
-        if (this.readingPromise) {
-            return false;
-        }
-        if (this.packetQueue.length > 0) {
-            return false;
-        }
-        if (this.receiveWaiter) {
-            return false;
-        }
-        if (this.socket.readyState !== WebSocket.CLOSED && this.socket.readyState !== WebSocket.CLOSING) {
-            return false;
-        }
-        return true;
-    }
-
-    close(): void {
-        if (this.socket) {
-            this.socket.close();
-        }
-        if (this.receiveWaiter) {
-            this.receiveWaiter();
-            this.receiveWaiter = null;
-        }
-    }
-
-    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void {
-        const packetData = serializer.serialize(packet);
-        const writer = new ByteWriter();
-        writer.writeString(packetData.type);
-        writer.writeUint8Array(packetData.data);
-        this.socket.send(writer.finish());
-    }
-}