@omujs/omu 0.9.10 → 0.9.26

package/src/extension/registry/index.ts

@@ -1,3 +0,0 @@
-export { REGISTRY_EXTENSION_TYPE, RegistryExtension } from './registry-extension.js';
-export { Registry, RegistryType } from './registry.js';
-

package/src/extension/registry/packets.ts

@@ -1,50 +0,0 @@
-import { ByteReader, ByteWriter } from '../../bytebuffer.js';
-import { Identifier } from '../../identifier.js';
-
-import { RegistryPermissions } from './registry.js';
-
-export class RegistryPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly value: Uint8Array | null,
-    ) { }
-
-    public static serialize(packet: RegistryPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeBoolean(packet.value !== null);
-        if (packet.value !== null) {
-            writer.writeByteArray(packet.value);
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): RegistryPacket {
-        const reader = new ByteReader(data);
-        const id = Identifier.fromKey(reader.readString());
-        const existing = reader.readBoolean();
-        const value = existing ? reader.readByteArray() : null;
-        return new RegistryPacket(id, value);
-    }
-}
-
-export class RegistryRegisterPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly permissions: RegistryPermissions,
-    ) { }
-
-    public static serialize(packet: RegistryRegisterPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        packet.permissions.serialize(writer);
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): RegistryRegisterPacket {
-        const reader = new ByteReader(data);
-        const id = Identifier.fromKey(reader.readString());
-        const permissions = RegistryPermissions.deserialize(reader);
-        return new RegistryRegisterPacket(id, permissions);
-    }
-}

package/src/extension/registry/registry.ts

@@ -1,98 +0,0 @@
-import type { ByteReader, ByteWriter } from '../../bytebuffer.js';
-import { Flags } from '../../bytebuffer.js';
-import type { Unlisten } from '../../event-emitter.js';
-import { Identifier } from '../../identifier.js';
-import type { Serializable } from '../../serializer.js';
-import { Serializer } from '../../serializer.js';
-
-export class RegistryPermissions {
-    constructor(
-        public readonly all?: Identifier,
-        public readonly read?: Identifier,
-        public readonly write?: Identifier,
-    ) { }
-
-    public serialize(writer: ByteWriter): void {
-        const flags = new Flags({length: 3});
-        flags.set(0, this.all !== undefined);
-        flags.set(1, this.read !== undefined);
-        flags.set(2, this.write !== undefined);
-        writer.writeFlags(flags);
-        if (this.all !== undefined) {
-            writer.writeString(this.all.key());
-        }
-        if (this.read !== undefined) {
-            writer.writeString(this.read.key());
-        }
-        if (this.write !== undefined) {
-            writer.writeString(this.write.key());
-        }
-    }
-
-    public static deserialize(reader: ByteReader): RegistryPermissions {
-        const flags = reader.readFlags(3);
-        const all = flags.has(0) ? Identifier.fromKey(reader.readString()) : undefined;
-        const read = flags.has(1) ? Identifier.fromKey(reader.readString()) : undefined;
-        const write = flags.has(2) ? Identifier.fromKey(reader.readString()) : undefined;
-        return new RegistryPermissions(
-            all,
-            read,
-            write,
-        );
-    }
-}
-
-export class RegistryType<T> {
-    constructor(
-        public readonly id: Identifier,
-        public readonly defaultValue: T,
-        public readonly serializer: Serializable<T, Uint8Array>,
-        public readonly permissions: RegistryPermissions,
-    ) { }
-
-    public static createJson<T>(identifier: Identifier, {
-        name,
-        defaultValue,
-        permissions,
-    }: {
-        name: string;
-        defaultValue: T;
-        permissions?: RegistryPermissions;
-    }): RegistryType<T> {
-        return new RegistryType(
-            identifier.join(name),
-            defaultValue,
-            Serializer.json(),
-            permissions ?? new RegistryPermissions(),
-        );
-    }
-
-    public static createSerialized<T>(identifier: Identifier, {
-        name,
-        defaultValue,
-        serializer,
-        permissions,
-    }: {
-        name: string;
-        defaultValue: T;
-        serializer: Serializable<T, Uint8Array>;
-        permissions?: RegistryPermissions;
-    }): RegistryType<T> {
-        return new RegistryType(
-            identifier.join(name),
-            defaultValue,
-            serializer,
-            permissions ?? new RegistryPermissions(),
-        );
-    }
-}
-
-export interface Registry<T> {
-    readonly type: RegistryType<T>;
-    readonly value: T;
-    get(): Promise<T>;
-    set(value: T): Promise<void>;
-    update(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
-    modify(fn: (value: T) => PromiseLike<T> | T): Promise<T>;
-    listen(fn: (value: T) => void): Unlisten;
-}

package/src/extension/server/index.ts

@@ -1,6 +0,0 @@
-export {
-    SERVER_APPS_READ_PERMISSION_ID,
-    SERVER_EXTENSION_TYPE,
-    SERVER_SHUTDOWN_PERMISSION_ID,
-    ServerExtension,
-} from './server-extension.js';

package/src/extension/server/server-extension.ts

@@ -1,180 +0,0 @@
-import { App } from '../../app.js';
-import type { Client } from '../../client.js';
-import { Identifier, IdentifierMap, IdentifierSet } from '../../identifier.js';
-import { PacketType } from '../../network/packet/packet.js';
-import { Serializer } from '../../serializer.js';
-import { EndpointType } from '../endpoint/endpoint.js';
-import type { Extension } from '../extension.js';
-import { ExtensionType } from '../extension.js';
-import { Registry, RegistryPermissions, RegistryType } from '../registry/registry.js';
-import type { Table } from '../table/index.js';
-import { TABLE_EXTENSION_TYPE } from '../table/table-extension.js';
-import { TableType } from '../table/table.js';
-
-export const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension> = new ExtensionType(
-    'server',
-    (client: Client) => new ServerExtension(client),
-    () => [TABLE_EXTENSION_TYPE],
-);
-
-export const SERVER_APPS_READ_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('apps', 'read');
-const APP_TABLE_TYPE = TableType.createModel(SERVER_EXTENSION_TYPE, {
-    name: 'apps',
-    model: App,
-    permissions: {
-        read: SERVER_APPS_READ_PERMISSION_ID,
-    },
-});
-
-export const SERVER_SESSIONS_READ_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('sessions', 'read');
-const SESSION_TABLE_TYPE = TableType.createModel(SERVER_EXTENSION_TYPE, {
-    name: 'sessions',
-    model: App,
-    permissions: {
-        read: SERVER_APPS_READ_PERMISSION_ID,
-    },
-});
-export const SERVER_SHUTDOWN_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('shutdown');
-const SHUTDOWN_ENDPOINT_TYPE = EndpointType.createJson<boolean, boolean>(SERVER_EXTENSION_TYPE, {
-    name: 'shutdown',
-    permissionId: SERVER_SHUTDOWN_PERMISSION_ID,
-});
-const REQUIRE_APPS_PACKET_TYPE = PacketType.createJson<Identifier[]>(SERVER_EXTENSION_TYPE, {
-    name: 'require_apps',
-    serializer: Serializer.model(Identifier).toArray(),
-});
-export const TRUSTED_ORIGINS_GET_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('trusted_origins', 'get');
-export const TRUSTED_ORIGINS_SET_PERMISSION_ID = SERVER_EXTENSION_TYPE.join('trusted_origins', 'set');
-const TRUSTED_ORIGINS_REGISTRY_TYPE = RegistryType.createJson<string[]>(SERVER_EXTENSION_TYPE, {
-    name: 'trusted_origins',
-    defaultValue: [],
-    permissions: new RegistryPermissions(
-        TRUSTED_ORIGINS_GET_PERMISSION_ID,
-        TRUSTED_ORIGINS_SET_PERMISSION_ID,
-    ),
-});
-const SESSION_OBSERVE_PACKET_TYPE = PacketType.createJson<Identifier[]>(SERVER_EXTENSION_TYPE, {
-    name: 'session_observe',
-    serializer: Serializer.model(Identifier).toArray(),
-});
-const SESSION_CONNECT_PACKET_TYPE = PacketType.createJson<App>(SERVER_EXTENSION_TYPE, {
-    name: 'session_connect',
-    serializer: Serializer.model(App),
-});
-const SESSION_DISCONNECT_PACKET_TYPE = PacketType.createJson<App>(SERVER_EXTENSION_TYPE, {
-    name: 'session_disconnect',
-    serializer: Serializer.model(App),
-});
-
-export class ServerExtension implements Extension {
-    public readonly type = SERVER_EXTENSION_TYPE;
-    public readonly apps: Table<App>;
-    public readonly sessions: Table<App>;
-    public readonly trustedOrigins: Registry<string[]>;
-    private readonly sessionObservers = new IdentifierMap<SessionObserver>();
-    private readonly requiredApps = new IdentifierSet();
-
-    constructor(private readonly client: Client) {
-        client.network.registerPacket(
-            REQUIRE_APPS_PACKET_TYPE,
-            SESSION_OBSERVE_PACKET_TYPE,
-            SESSION_CONNECT_PACKET_TYPE,
-            SESSION_DISCONNECT_PACKET_TYPE,
-        );
-        client.network.addPacketHandler(
-            SESSION_CONNECT_PACKET_TYPE, (app) => this.handleSessionConnect(app)
-        )
-        client.network.addPacketHandler(
-            SESSION_DISCONNECT_PACKET_TYPE, (app) => this.handleSessionDisconnect(app)
-        )
-        this.apps = client.tables.get(APP_TABLE_TYPE);
-        this.sessions = client.tables.get(SESSION_TABLE_TYPE);
-        this.trustedOrigins = client.registries.get(TRUSTED_ORIGINS_REGISTRY_TYPE);
-        client.network.addTask(() => this.onTask());
-        client.onReady(() => this.onReady());
-    }
-
-    private async onTask(): Promise<void> {
-        if (this.requiredApps.size > 0) {
-            this.client.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
-        }
-    }
-
-    private async onReady(): Promise<void> {
-        if (this.sessionObservers.size > 0) {
-            this.client.send(SESSION_OBSERVE_PACKET_TYPE, Array.from(this.sessionObservers.keys()));
-        }
-    }
-
-    public async shutdown(restart?: boolean): Promise<boolean> {
-        this.client.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);
-        await new Promise<void>((resolve) => {
-            const unlisten = this.client.network.event.disconnected.listen(() => {
-                resolve();
-                unlisten();
-            });
-        });
-        return true;
-    }
-
-    public observeSession(appId: Identifier, {
-        onConnect,
-        onDisconnect
-    }: {
-        onConnect(app: App): void;
-        onDisconnect(app: App): void;
-    }): SessionObserver {
-        if (this.client.running) {
-            throw new Error('Cannot observe sessions after the client has started');
-        }
-        const observer = this.sessionObservers.get(appId) ?? new SessionObserver([], []);
-        observer.onConnect(onConnect);
-        observer.onDisconnect(onDisconnect);
-        this.sessionObservers.set(appId, observer);
-        return observer;
-    }
-
-    private async handleSessionConnect(app: App): Promise<void> {
-        const observer = this.sessionObservers.get(app.id);
-        if (!observer) {
-            return;
-        }
-        for (const callback of observer.onConnectCallbacks) {
-            await callback(app);
-        }
-    }
-
-    private async handleSessionDisconnect(app: App): Promise<void> {
-        const observer = this.sessionObservers.get(app.id);
-        if (!observer) {
-            return;
-        }
-        for (const callback of observer.onDisconnectCallbacks) {
-            await callback(app);
-        }
-    }
-
-    public require(...appIds: Identifier[]): void {
-        if (this.client.running) {
-            throw new Error('Cannot require apps after the client has started');
-        }
-        for (const appId of appIds) {
-            this.requiredApps.add(appId);
-        }
-    }
-}
-
-export class SessionObserver {
-    constructor(
-        public readonly onConnectCallbacks: Array<(app: App) => Promise<void> | void>,
-        public readonly onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>,
-    ) { }
-
-    public onConnect(callback: (app: App) => Promise<void> | void): void {
-        this.onConnectCallbacks.push(callback);
-    }
-
-    public onDisconnect(callback: (app: App) => Promise<void> | void): void {
-        this.onDisconnectCallbacks.push(callback);
-    }
-}

package/src/extension/signal/index.ts

@@ -1,3 +0,0 @@
-export { SIGNAL_EXTENSION_TYPE, SignalExtension } from './signal-extension.js';
-export { Signal, SignalType } from './signal.js';
-

package/src/extension/signal/packets.ts

@@ -1,46 +0,0 @@
-import { ByteReader, ByteWriter } from '../../bytebuffer.js';
-import { Identifier } from '../../identifier.js';
-
-import { SignalPermissions } from './signal.js';
-
-export class SignalPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly body: Uint8Array,
-    ) { }
-
-    public static serialize(packet: SignalPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeByteArray(packet.body);
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): SignalPacket {
-        const reader = new ByteReader(data);
-        const id = Identifier.fromKey(reader.readString());
-        const body = reader.readByteArray();
-        return new SignalPacket(id, body);
-    }
-}
-
-export class SignalRegisterPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly permissions: SignalPermissions,
-    ) { }
-
-    public static serialize(packet: SignalRegisterPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        packet.permissions.serialize(writer);
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): SignalRegisterPacket {
-        const reader = new ByteReader(data);
-        const id = Identifier.fromKey(reader.readString());
-        const permissions = SignalPermissions.deserialize(reader);
-        return new SignalRegisterPacket(id, permissions);
-    }
-}

package/src/extension/signal/signal.ts

@@ -1,89 +0,0 @@
-import type { ByteReader, ByteWriter } from '../../bytebuffer.js';
-import { Flags } from '../../bytebuffer.js';
-import type { Unlisten } from '../../event-emitter.js';
-import { Identifier } from '../../identifier.js';
-import type { Serializable } from '../../serializer.js';
-import { Serializer } from '../../serializer.js';
-
-export class SignalPermissions {
-    constructor(
-        public readonly all?: Identifier,
-        public readonly listen?: Identifier,
-        public readonly send?: Identifier,
-    ) {}
-
-    public serialize(writer: ByteWriter): void {
-        const flags = new Flags({length: 3});
-        flags.set(0, this.all !== undefined);
-        flags.set(1, this.listen !== undefined);
-        flags.set(2, this.send !== undefined);
-        writer.writeFlags(flags);
-        if (this.all !== undefined) {
-            writer.writeString(this.all.key());
-        }
-        if (this.listen !== undefined) {
-            writer.writeString(this.listen.key());
-        }
-        if (this.send !== undefined) {
-            writer.writeString(this.send.key());
-        }
-    }
-
-    public static deserialize(reader: ByteReader): SignalPermissions {
-        const flags = reader.readFlags(3);
-        const all = flags.ifSet(0, () => Identifier.fromKey(reader.readString()));
-        const listen = flags.ifSet(1, () => Identifier.fromKey(reader.readString()));
-        const send = flags.ifSet(2, () => Identifier.fromKey(reader.readString()));
-        return new SignalPermissions(all, listen, send);
-    }
-}
-export class SignalType<T> {
-    constructor(
-        public readonly id: Identifier,
-        public readonly serializer: Serializable<T, Uint8Array>,
-        public readonly permissions: SignalPermissions,
-    ) {}
-
-    static createJson<T>(
-        identifier: Identifier,
-        {
-            name,
-            serializer,
-            permissions,
-        }: {
-            name: string;
-            serializer?: Serializable<T, any>;
-            permissions?: SignalPermissions;
-        },
-    ): SignalType<T> {
-        return new SignalType(
-            identifier.join(name),
-            Serializer.of<T, any>(serializer ?? Serializer.noop()).toJson(),
-            permissions ?? new SignalPermissions(),
-        );
-    }
-
-    static createSerialized<T>(
-        identifier: Identifier,
-        {
-            name,
-            serializer,
-            permissions,
-        }: {
-            name: string;
-            serializer: Serializable<T, Uint8Array>;
-            permissions?: SignalPermissions;
-        },
-    ): SignalType<T> {
-        return new SignalType(
-            identifier.join(name),
-            serializer,
-            permissions ?? new SignalPermissions(),
-        );
-    }
-}
-
-export interface Signal<T> {
-    listen(handler: (value: T) => void): Unlisten;
-    notify(body: T): void;
-}

package/src/extension/table/index.ts

@@ -1,3 +0,0 @@
-export { TABLE_EXTENSION_TYPE, TABLE_PERMISSION_ID, TableExtension } from './table-extension.js';
-export { Table, TableConfig, TableType } from './table.js';
-

package/src/interface.ts

@@ -1,8 +0,0 @@
-
-export interface Keyable {
-    key(): string;
-}
-
-export interface Timestamped {
-    createdAt: Date;
-}

package/src/model.ts

@@ -1,4 +0,0 @@
-export interface Model<T> {
-    toJson(): T;
-    toString(): string;
-}

package/src/network/websocket-connection.ts

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