@omujs/omu 0.9.48 → 0.9.49

package/src/api/session/extension.ts

@@ -1,205 +0,0 @@
-import { App, AppJson } from '../../app';
-import { Identifier, IdentifierMap, IdentifierSet, IntoId } from '../../identifier';
-import { PacketType } from '../../network/packet';
-import { Omu } from '../../omu';
-import { Serializer } from '../../serialize';
-import { SessionParam } from '../../token';
-import { EndpointType } from '../endpoint';
-import { Extension, ExtensionType } from '../extension';
-import { SessionObserver } from '../server/extension';
-import { Table, TableType } from '../table';
-
-export const SESSION_EXTENSION_TYPE: ExtensionType<SessionExtension> = new ExtensionType('sessions', (omu: Omu) => new SessionExtension(omu));
-
-export const SESSIONS_READ_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('read');
-const SESSION_TABLE_TYPE = TableType.createJson(SESSION_EXTENSION_TYPE, {
-    name: 'sessions',
-    serializer: App,
-    key: (app) => app.id.key(),
-    permissions: {
-        read: SESSIONS_READ_PERMISSION_ID,
-    },
-});
-const REQUIRE_APPS_PACKET_TYPE = PacketType.createJson<Identifier[]>(SESSION_EXTENSION_TYPE, {
-    name: 'require',
-    serializer: Serializer.of(Identifier).toArray(),
-});
-const SESSION_OBSERVE_PACKET_TYPE = PacketType.createJson<Identifier[]>(SESSION_EXTENSION_TYPE, {
-    name: 'observe',
-    serializer: Serializer.of(Identifier).toArray(),
-});
-const SESSION_CONNECTED_PACKET_TYPE = PacketType.createJson<App>(SESSION_EXTENSION_TYPE, {
-    name: 'session_connected',
-    serializer: App,
-});
-const SESSION_DISCONNECTED_PACKET_TYPE = PacketType.createJson<App>(SESSION_EXTENSION_TYPE, {
-    name: 'session_disconnected',
-    serializer: App,
-});
-
-type RemoteAppRequestPayload = {
-    app: AppJson;
-    permissions: string[];
-};
-
-export type RequestRemoteAppResponse = {
-    type: 'success';
-    token: string;
-    lan_ip: string;
-} | {
-    type: 'error';
-    message: string;
-};
-
-export const REMOTE_APP_REQUEST_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('remote_app', 'request');
-
-const REMOTE_APP_REQUEST_ENDPOINT_TYPE = EndpointType.createJson<RemoteAppRequestPayload, RequestRemoteAppResponse>(SESSION_EXTENSION_TYPE, {
-    name: 'remote_app_request',
-    permissionId: REMOTE_APP_REQUEST_PERMISSION_ID,
-});
-
-export type GenerateTokenResponse = {
-    type: 'success';
-    token: string;
-} | {
-    type: 'error';
-    message: string;
-};
-
-export const GENERATE_TOKEN_PERMISSION_ID: Identifier = SESSION_EXTENSION_TYPE.join('generate_token');
-
-type GenerateTokenPayload = {
-    app: AppJson;
-    permissions: string[];
-};
-
-const GENERATE_TOKEN_ENDPOINT_TYPE = EndpointType.createJson<GenerateTokenPayload, GenerateTokenResponse>(SESSION_EXTENSION_TYPE, {
-    name: 'generate_token',
-    permissionId: GENERATE_TOKEN_PERMISSION_ID,
-});
-
-export class SessionExtension implements Extension {
-    public readonly type: ExtensionType<SessionExtension> = SESSION_EXTENSION_TYPE;
-    public readonly sessions: Table<App>;
-    private readonly sessionObservers = new IdentifierMap<SessionObserver>();
-    private readonly requiredApps = new IdentifierSet();
-
-    constructor(private readonly omu: Omu) {
-        omu.network.registerPacket(
-            REQUIRE_APPS_PACKET_TYPE,
-            SESSION_OBSERVE_PACKET_TYPE,
-            SESSION_CONNECTED_PACKET_TYPE,
-            SESSION_DISCONNECTED_PACKET_TYPE,
-        );
-        omu.network.addPacketHandler(
-            SESSION_CONNECTED_PACKET_TYPE, (app) => this.handleSessionConnect(app),
-        );
-        omu.network.addPacketHandler(
-            SESSION_DISCONNECTED_PACKET_TYPE, (app) => this.handleSessionDisconnect(app),
-        );
-        this.sessions = omu.tables.get(SESSION_TABLE_TYPE);
-        omu.network.addTask(() => this.onTask());
-        omu.onReady(() => this.onReady());
-    }
-
-    public async has(id: IntoId): Promise<boolean> {
-        return await this.sessions.has(Identifier.from(id).key());
-    }
-
-    public observe(appId: IntoId, options?: {
-        onConnect?(app: App): void;
-        onDisconnect?(app: App): void;
-    }): SessionObserver {
-        const id = Identifier.from(appId);
-        if (this.omu.running) {
-            this.omu.send(SESSION_OBSERVE_PACKET_TYPE, [id]);
-        }
-        const observer = this.sessionObservers.get(id) ?? new SessionObserver([], []);
-        if (options?.onConnect) {
-            observer.onConnect(options.onConnect);
-        }
-        if (options?.onDisconnect) {
-            observer.onDisconnect(options.onDisconnect);
-        }
-        this.sessionObservers.set(id, 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: IntoId[]): void {
-        if (this.omu.running) {
-            throw new Error('Cannot require apps after the client has started');
-        }
-        for (const appId of appIds) {
-            this.requiredApps.add(Identifier.from(appId));
-        }
-    }
-
-    private async onTask(): Promise<void> {
-        if (this.requiredApps.size > 0) {
-            this.omu.send(REQUIRE_APPS_PACKET_TYPE, Array.from(this.requiredApps.values()));
-        }
-    }
-
-    private async onReady(): Promise<void> {
-        if (this.sessionObservers.size > 0) {
-            this.omu.send(SESSION_OBSERVE_PACKET_TYPE, Array.from(this.sessionObservers.keys()));
-        }
-    }
-
-    public async requestRemoteApp(options: {
-        app: App;
-        permissions: IntoId[];
-    }): Promise<RequestRemoteAppResponse> {
-        const { app } = options;
-        if (!app.url) {
-            throw new Error('App must have a URL to request it remotely');
-        }
-        if (app.type !== 'remote') {
-            throw new Error('App must be a remote app to request it remotely');
-        }
-        if (!app.metadata) {
-            throw new Error('App must have metadata to request it remotely');
-        }
-        return this.omu.endpoints.call(REMOTE_APP_REQUEST_ENDPOINT_TYPE, {
-            app: App.serialize(options.app),
-            permissions: options.permissions.map(id => Identifier.from(id).key()),
-        });
-    }
-
-    public async generateToken(options: {
-        app: App;
-        permissions?: IntoId[];
-    }): Promise<SessionParam> {
-        const result = await this.omu.endpoints.call(GENERATE_TOKEN_ENDPOINT_TYPE, {
-            app: App.serialize(options.app),
-            permissions: options.permissions?.map(id => Identifier.from(id).key()),
-        });
-        if (result.type === 'error') {
-            throw new Error(result.message);
-        }
-        return {
-            token: result.token,
-            address: this.omu.address,
-        };
-    }
-}

package/src/api/session/index.ts

@@ -1,7 +0,0 @@
-export {
-    GENERATE_TOKEN_PERMISSION_ID, REMOTE_APP_REQUEST_PERMISSION_ID, SESSION_EXTENSION_TYPE,
-    SessionExtension,
-    SESSIONS_READ_PERMISSION_ID,
-    type RequestRemoteAppResponse,
-} from './extension';
-

package/src/api/signal/extension.ts

@@ -1,125 +0,0 @@
-import type { Unlisten } from '../../event';
-import { Identifier, IdentifierMap } from '../../identifier';
-import { PacketType } from '../../network/packet';
-import { Omu } from '../../omu';
-import { JsonType, Serializable } from '../../serialize';
-import { ExtensionType, type Extension } from '../extension.js';
-import { SignalPacket, SignalRegisterPacket } from './packets.js';
-import { SignalType, type Signal } from './signal.js';
-
-export const SIGNAL_EXTENSION_TYPE: ExtensionType<SignalExtension> = new ExtensionType(
-    'signal',
-    (omu: Omu) => new SignalExtension(omu),
-);
-
-const SIGNAL_REGISTER_PACKET = PacketType.createJson<SignalRegisterPacket>(SIGNAL_EXTENSION_TYPE, {
-    name: 'register',
-    serializer: SignalRegisterPacket,
-});
-const SIGNAL_LISTEN_PACKET = PacketType.createJson<Identifier>(SIGNAL_EXTENSION_TYPE, {
-    name: 'listen',
-    serializer: Identifier,
-});
-const SIGNAL_NOTIFY_PACKET = PacketType.createSerialized<SignalPacket>(SIGNAL_EXTENSION_TYPE, {
-    name: 'notify',
-    serializer: SignalPacket,
-});
-
-export class SignalExtension implements Extension {
-    public readonly type: ExtensionType<SignalExtension> = SIGNAL_EXTENSION_TYPE;
-    private readonly signals = new IdentifierMap<SignalType<unknown>>();
-
-    constructor(private readonly omu: Omu) {
-        omu.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.omu, signalType);
-    }
-
-    public json<T, D extends JsonType = JsonType>(name: string, options?: { serializer?: Serializable<T, D> }): Signal<T> {
-        const id = this.omu.app.id.base.join(name);
-        const type = SignalType.createJson<T>(id, {
-            name,
-            serializer: options?.serializer,
-        });
-        return this.createSignal(type);
-    }
-
-    public serialized<T>(name: string, options: { serializer: Serializable<T, Uint8Array> }): Signal<T> {
-        const id = this.omu.app.id.base.join(name);
-        const type = SignalType.createSerialized<T>(id, {
-            name,
-            serializer: options?.serializer,
-        });
-        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 omu: Omu,
-        private readonly type: SignalType<T>,
-    ) {
-        omu.network.addPacketHandler(SIGNAL_NOTIFY_PACKET, (data) => this.handleBroadcast(data));
-        omu.network.addTask(() => this.onTask());
-    }
-
-    public notify(body: T): void {
-        const data = this.type.serializer.serialize(body);
-        this.omu.send(SIGNAL_NOTIFY_PACKET, {
-            id: this.type.id,
-            body: data,
-        });
-        for (const listener of this.listeners) {
-            listener(body);
-        }
-    }
-
-    public listen(handler: (value: T) => void): Unlisten {
-        if (!this.listening) {
-            this.omu.onReady(() => {
-                this.omu.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.omu.app.id)) {
-            return;
-        }
-        this.omu.send(SIGNAL_REGISTER_PACKET, {
-            id: this.type.id,
-            permissions: this.type.permissions,
-        });
-    }
-}

package/src/api/signal/packets.ts

@@ -1,61 +0,0 @@
-import { Identifier } from '../../identifier';
-import { ByteReader, ByteWriter } from '../../serialize';
-
-import { SignalPermissions, SignalPermissionsJSON } 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.writeUint8Array(packet.body);
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): SignalPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const body = reader.readUint8Array();
-        return new SignalPacket(id, body);
-    }
-}
-
-interface SignalRegisterPacketJSON {
-    id: string;
-    permissions: SignalPermissionsJSON;
-}
-
-export class SignalRegisterPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly permissions: SignalPermissions,
-    ) {}
-
-    public static serialize(packet: SignalRegisterPacket): SignalRegisterPacketJSON {
-        const { permissions: perms } = packet;
-        return {
-            id: packet.id.key(),
-            permissions: {
-                all: perms.all ? Identifier.from(perms.all).key() : undefined,
-                listen: perms.listen ? Identifier.from(perms.listen).key() : undefined,
-                send: perms.send ? Identifier.from(perms.send).key() : undefined,
-            },
-        };
-    }
-
-    public static deserialize(data: SignalRegisterPacketJSON): SignalRegisterPacket {
-        const { permissions: perms } = data;
-        return new SignalRegisterPacket(
-            Identifier.fromKey(data.id),
-            {
-                all: perms.all ? Identifier.fromKey(perms.all) : undefined,
-                listen: perms.listen ? Identifier.fromKey(perms.listen) : undefined,
-                send: perms.send ? Identifier.fromKey(perms.send) : undefined,
-            },
-        );
-    }
-}

package/src/api/signal/signal.ts

@@ -1,67 +0,0 @@
-import type { Unlisten } from '../../event';
-import { Identifier, IntoId } from '../../identifier';
-import type { Serializable } from '../../serialize';
-import { Serializer } from '../../serialize';
-
-export interface SignalPermissionsJSON {
-    all?: string;
-    listen?: string;
-    send?: string;
-}
-
-export interface SignalPermissions {
-    all?: IntoId | undefined;
-    listen?: IntoId | undefined;
-    send?: IntoId | undefined;
-}
-
-export class SignalType<T> {
-    constructor(
-        public readonly id: Identifier,
-        public readonly serializer: Serializable<T, Uint8Array>,
-        public readonly permissions: SignalPermissions,
-    ) {}
-
-    static createJson<T>(
-        identifier: IntoId,
-        {
-            name,
-            serializer,
-            permissions,
-        }: {
-            name: string;
-            serializer?: Serializable<T, any>;
-            permissions?: SignalPermissions;
-        },
-    ): SignalType<T> {
-        return new SignalType(
-            Identifier.from(identifier).join(name),
-            Serializer.of<T, any>(serializer ?? Serializer.noop()).toJson(),
-            permissions ?? {},
-        );
-    }
-
-    static createSerialized<T>(
-        identifier: IntoId,
-        {
-            name,
-            serializer,
-            permissions,
-        }: {
-            name: string;
-            serializer: Serializable<T, Uint8Array>;
-            permissions?: SignalPermissions;
-        },
-    ): SignalType<T> {
-        return new SignalType(
-            Identifier.from(identifier).join(name),
-            serializer,
-            permissions ?? {},
-        );
-    }
-}
-
-export interface Signal<T> {
-    listen(handler: (value: T) => void): Unlisten;
-    notify(body: T): void;
-}