@omujs/omu 0.1.22

package/src/extension/registry/registry-extension.ts

@@ -0,0 +1,154 @@
+import type { Client } from '../../client.js';
+import type { Unlisten } from '../../event-emitter.js';
+import { EventEmitter } from '../../event-emitter.js';
+import { Identifier, IdentifierMap } from '../../identifier.js';
+import { PacketType } from '../../network/packet/index.js';
+import { Serializer } from '../../serializer.js';
+import { EndpointType } from '../endpoint/endpoint.js';
+import { ExtensionType, type Extension } from '../extension.js';
+
+import { RegistryPacket, RegistryRegisterPacket } from './packets.js';
+import { RegistryType, type Registry } from './registry.js';
+
+export class RegistryExtension implements Extension {
+    private readonly registries = new IdentifierMap<Registry<unknown>>();
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(
+            REGISTRY_REGISTER_PACKET,
+            REGISTRY_UPDATE_PACKET,
+            REGISTRY_LISTEN_PACKET,
+        );
+    }
+
+    private createRegistry<T>(registryType: RegistryType<T>): Registry<T> {
+        this.client.permissions.require(REGISTRY_PERMISSION_ID);
+        if (this.registries.has(registryType.id)) {
+            throw new Error(`Registry with identifier '${registryType.id}' already exists`);
+        }
+        return new RegistryImpl(this.client, registryType);
+    }
+
+    public get<T>(registryType: RegistryType<T>): Registry<T> {
+        const identifier = registryType.id;
+        let registry = this.registries.get(identifier);
+        if (registry === undefined) {
+            registry = this.createRegistry(registryType);
+            this.registries.set(identifier, registry);
+        }
+        return registry as Registry<T>;
+    }
+
+    public create<T>(name: string, defaultValue: T): Registry<T> {
+        const identifier = this.client.app.id.join(name);
+        if (this.registries.has(identifier)) {
+            throw new Error(`Registry with name '${name}' already exists`);
+        }
+        const tableType = RegistryType.createJson(identifier, {
+            name,
+            defaultValue,
+        });
+        return this.createRegistry(tableType);
+    }
+}
+
+class RegistryImpl<T> implements Registry<T> {
+    private readonly eventEmitter: EventEmitter<(value: T) => void> = new EventEmitter();
+    private listening = false;
+    public value: T;
+
+    constructor(
+        private readonly client: Client,
+        public readonly type: RegistryType<T>,
+    ) {
+        this.value = type.defaultValue;
+        client.network.addPacketHandler(REGISTRY_UPDATE_PACKET, (packet) =>
+            this.handleUpdate(packet),
+        );
+        client.network.addTask(() => this.onTask());
+    }
+
+    public async get(): Promise<T> {
+        const result = await this.client.endpoints.call(REGISTRY_GET_ENDPOINT, this.type.id);
+        if (result.value === null) {
+            return this.type.defaultValue;
+        }
+        return this.type.serializer.deserialize(result.value);
+    }
+
+    public async set(value: T): Promise<void> {
+        this.client.send(REGISTRY_UPDATE_PACKET, {
+            id: this.type.id,
+            value: this.type.serializer.serialize(value),
+        });
+    }
+
+    public async update(fn: (value: T) => T): Promise<void> {
+        const value = await this.get();
+        const newValue = await fn(value);
+        await this.set(newValue);
+    }
+
+    public listen(handler: (value: T) => void): Unlisten {
+        if (!this.listening) {
+            this.client.whenReady(() => {
+                this.client.send(REGISTRY_LISTEN_PACKET, this.type.id);
+            });
+            this.listening = true;
+        }
+        return this.eventEmitter.listen(handler);
+    }
+
+    private handleUpdate(data: RegistryPacket): void {
+        if (!data.id.isEqual(this.type.id)) {
+            return;
+        }
+        if (data.value !== null) {
+            this.value = this.type.serializer.deserialize(data.value);
+        }
+        this.eventEmitter.emit(this.value);
+    }
+
+    private onTask(): void {
+        if (!this.type.id.isSubpathOf(this.client.app.id)) {
+            return;
+        }
+        this.client.send(REGISTRY_REGISTER_PACKET, {
+            id: this.type.id,
+            permissions: this.type.permissions,
+        });
+    }
+}
+
+export const REGISTRY_EXTENSION_TYPE = new ExtensionType(
+    'registry',
+    (client: Client) => new RegistryExtension(client),
+);
+export const REGISTRY_PERMISSION_ID = REGISTRY_EXTENSION_TYPE.join('permission');
+const REGISTRY_REGISTER_PACKET = PacketType.createSerialized<RegistryRegisterPacket>(
+    REGISTRY_EXTENSION_TYPE,
+    {
+        name: 'register',
+        serializer: RegistryRegisterPacket,
+    },
+);
+const REGISTRY_UPDATE_PACKET = PacketType.createSerialized<RegistryPacket>(
+    REGISTRY_EXTENSION_TYPE,
+    {
+        name: 'update',
+        serializer: RegistryPacket,
+    },
+);
+const REGISTRY_LISTEN_PACKET = PacketType.createJson<Identifier>(REGISTRY_EXTENSION_TYPE, {
+    name: 'listen',
+    serializer: Serializer.model(Identifier),
+});
+const REGISTRY_GET_ENDPOINT = EndpointType.createSerialized<Identifier, RegistryPacket>(
+    REGISTRY_EXTENSION_TYPE,
+    {
+        name: 'get',
+        requestSerializer: Serializer.model(Identifier).toJson(),
+        responseSerializer: RegistryPacket,
+        permissionId: REGISTRY_PERMISSION_ID,
+    },
+);

package/src/extension/registry/registry.ts

@@ -0,0 +1,97 @@
+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(0, 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) => T): Promise<void>;
+    listen(fn: (value: T) => void): Unlisten;
+}

package/src/extension/server/index.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,63 @@
+import { App } from '../../app.js';
+import type { Client } from '../../client.js';
+import { Identifier, 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 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_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 class ServerExtension implements Extension {
+    public readonly apps: Table<App>;
+    private requiredApps = new IdentifierSet();
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(REQUIRE_APPS_PACKET_TYPE);
+        this.apps = client.tables.get(APP_TABLE_TYPE);
+        client.network.addTask(() => this.onTask());
+    }
+
+    private async onTask(): Promise<void> {
+        this.client.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
+    }
+
+    public async shutdown(restart?: boolean): Promise<boolean> {
+        return await this.client.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);
+    }
+
+    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);
+        }
+    }
+}

package/src/extension/signal/index.ts

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

package/src/extension/signal/packets.ts

@@ -0,0 +1,46 @@
+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-extension.ts

@@ -0,0 +1,114 @@
+import type { Client } from '../../client.js';
+import type { Unlisten } from '../../event-emitter.js';
+import { Identifier, IdentifierMap } from '../../identifier.js';
+import { PacketType } from '../../network/packet/index.js';
+import { Serializer } from '../../serializer.js';
+import { ExtensionType, type Extension } from '../extension.js';
+
+import { SignalPacket, SignalRegisterPacket } from './packets.js';
+import type { Signal } from './signal.js';
+import { SignalType } from './signal.js';
+
+export const SIGNAL_EXTENSION_TYPE = new ExtensionType(
+    'signal',
+    (client: Client) => new SignalExtension(client),
+);
+
+const SIGNAL_REGISTER_PACKET = PacketType.createSerialized<SignalRegisterPacket>(
+    SIGNAL_EXTENSION_TYPE,
+    {
+        name: 'register',
+        serializer: SignalRegisterPacket,
+    },
+);
+const SIGNAL_LISTEN_PACKET = PacketType.createJson<Identifier>(SIGNAL_EXTENSION_TYPE, {
+    name: 'listen',
+    serializer: Serializer.model(Identifier),
+});
+const SIGNAL_NOTIFY_PACKET = PacketType.createSerialized<SignalPacket>(SIGNAL_EXTENSION_TYPE, {
+    name: 'notify',
+    serializer: SignalPacket,
+});
+
+export class SignalExtension implements Extension {
+    private readonly signals = new IdentifierMap<SignalType<unknown>>();
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(
+            SIGNAL_REGISTER_PACKET,
+            SIGNAL_LISTEN_PACKET,
+            SIGNAL_NOTIFY_PACKET,
+        );
+    }
+
+    private createSignal<T>(signalType: SignalType<T>): Signal<T> {
+        if (this.signals.has(signalType.id)) {
+            throw new Error(`Signal for key ${signalType.id} already created`);
+        }
+        return new SignalImpl(this.client, signalType);
+    }
+
+    public create<T>(name: string): Signal<T> {
+        const id = this.client.app.id.join(name);
+        const type = SignalType.createJson<T>(id, { name });
+        return this.createSignal(type);
+    }
+
+    public get<T>(signalType: SignalType<T>): Signal<T> {
+        return this.createSignal(signalType);
+    }
+}
+
+class SignalImpl<T> implements Signal<T> {
+    private readonly listeners: ((value: T) => void)[] = [];
+    private listening = false;
+
+    constructor(
+        private readonly client: Client,
+        private readonly type: SignalType<T>,
+    ) {
+        client.network.addPacketHandler(SIGNAL_NOTIFY_PACKET, (data) => this.handleBroadcast(data));
+        client.network.addTask(() => this.onTask());
+    }
+
+    public notify(body: T): void {
+        const data = this.type.serializer.serialize(body);
+        this.client.send(SIGNAL_NOTIFY_PACKET, {
+            id: this.type.id,
+            body: data,
+        });
+    }
+
+    public listen(handler: (value: T) => void): Unlisten {
+        if (!this.listening) {
+            this.client.whenReady(() => {
+                this.client.send(SIGNAL_LISTEN_PACKET, this.type.id);
+            });
+            this.listening = true;
+        }
+        this.listeners.push(handler);
+        return () => {
+            this.listeners.splice(this.listeners.indexOf(handler), 1);
+        };
+    }
+
+    private handleBroadcast(data: SignalPacket): void {
+        if (!data.id.isEqual(this.type.id)) {
+            return;
+        }
+        const body = this.type.serializer.deserialize(data.body);
+        for (const listener of this.listeners) {
+            listener(body);
+        }
+    }
+
+    private onTask(): void {
+        if (!this.type.id.isSubpathOf(this.client.app.id)) {
+            return;
+        }
+        this.client.send(SIGNAL_REGISTER_PACKET, {
+            id: this.type.id,
+            permissions: this.type.permissions,
+        });
+    }
+}

package/src/extension/signal/signal.ts

@@ -0,0 +1,85 @@
+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(0, 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,
+        permissions,
+    }: {
+        name: string
+        permissions?: SignalPermissions
+    }): SignalType<T> {
+        return new SignalType(
+            identifier.join(name),
+            Serializer.json(),
+            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

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