@meshagent/meshagent 0.3.1 → 0.4.1

package/dist/esm/room-client.d.ts

@@ -0,0 +1,46 @@
+import { Protocol } from "./protocol";
+import { LocalParticipant } from "./participant";
+import { SyncClient } from "./sync-client";
+import { DeveloperClient } from "./developer-client";
+import { StorageClient } from "./storage-client";
+import { MessagingClient } from "./messaging-client";
+import { QueuesClient } from "./queues-client";
+import { DatabaseClient } from "./database-client";
+import { AgentsClient } from "./agent-client";
+import { RoomEvent } from "./room-event";
+import { Response } from "./response";
+interface RequestHeader {
+    [key: string]: any;
+}
+export declare class RoomClient {
+    protocol: Protocol;
+    readonly sync: SyncClient;
+    readonly storage: StorageClient;
+    readonly developer: DeveloperClient;
+    readonly messaging: MessagingClient;
+    readonly queues: QueuesClient;
+    readonly database: DatabaseClient;
+    readonly agents: AgentsClient;
+    private _pendingRequests;
+    private _ready;
+    private _localParticipant;
+    private _eventsController;
+    constructor({ protocol }: {
+        protocol: Protocol;
+    });
+    get localParticipant(): LocalParticipant | null;
+    get ready(): Promise<boolean>;
+    start({ onDone, onError }?: {
+        onDone?: () => void;
+        onError?: (error: Error) => void;
+    }): Promise<void>;
+    dispose(): void;
+    sendRequest(type: string, request: RequestHeader, data?: Uint8Array): Promise<Response>;
+    private _handleResponse;
+    private _handleRoomReady;
+    private _onParticipantInit;
+    private _handleParticipant;
+    emit(event: RoomEvent): void;
+    listen(): AsyncIterable<RoomEvent>;
+}
+export {};

package/dist/esm/room-client.js

@@ -0,0 +1,106 @@
+import { Completer } from "./completer";
+import { packMessage, unpackMessage } from "./utils";
+import { LocalParticipant } from "./participant";
+import { StreamController } from "./stream-controller";
+import { SyncClient } from "./sync-client";
+import { DeveloperClient } from "./developer-client";
+import { StorageClient } from "./storage-client";
+import { MessagingClient } from "./messaging-client";
+import { QueuesClient } from "./queues-client";
+import { DatabaseClient } from "./database-client";
+import { AgentsClient } from "./agent-client";
+import { ErrorResponse, unpackResponse } from "./response";
+export class RoomClient {
+    constructor({ protocol }) {
+        this._pendingRequests = new Map();
+        this._ready = new Completer();
+        this._localParticipant = null;
+        this._eventsController = new StreamController();
+        this.protocol = protocol;
+        protocol.addHandler("room_ready", this._handleRoomReady.bind(this));
+        protocol.addHandler("connected", this._handleParticipant.bind(this));
+        protocol.addHandler("__response__", this._handleResponse.bind(this));
+        this.sync = new SyncClient({ room: this });
+        this.storage = new StorageClient({ room: this });
+        this.developer = new DeveloperClient({ room: this });
+        this.messaging = new MessagingClient({ room: this });
+        this.queues = new QueuesClient({ room: this });
+        this.database = new DatabaseClient({ room: this });
+        this.agents = new AgentsClient({ room: this });
+    }
+    get localParticipant() {
+        return this._localParticipant;
+    }
+    get ready() {
+        return this._ready.fut;
+    }
+    async start({ onDone, onError } = {}) {
+        this.sync.start({ onDone, onError });
+        await this.ready;
+    }
+    dispose() {
+        for (const prKey of this._pendingRequests.keys()) {
+            const pr = this._pendingRequests.get(prKey);
+            pr?.reject(new Error("Disposed"));
+            this._pendingRequests.delete(prKey);
+        }
+        this.sync.dispose();
+        this.protocol.dispose();
+        this._localParticipant = null;
+    }
+    async sendRequest(type, request, data) {
+        const requestId = this.protocol.getNextMessageId();
+        const pr = new Completer();
+        this._pendingRequests.set(requestId, pr);
+        const message = packMessage(request, data);
+        await this.protocol.send(type, message, requestId);
+        return await pr.fut;
+    }
+    async _handleResponse(protocol, messageId, type, data) {
+        if (!data) {
+            console.error("No data in response");
+            return;
+        }
+        const response = unpackResponse(data);
+        console.log("GOT RESPONSE", response);
+        if (!response) {
+            console.error("No response");
+            return;
+        }
+        if (this._pendingRequests.has(messageId)) {
+            const pr = this._pendingRequests.get(messageId);
+            this._pendingRequests.delete(messageId);
+            if (response instanceof ErrorResponse) {
+                pr.reject(new Error(response.text));
+            }
+            else {
+                pr.resolve(response);
+            }
+        }
+        else {
+            console.warn(`Received a response for a request that is not pending ${messageId}`);
+        }
+    }
+    async _handleRoomReady(protocol, messageId, type, data) {
+        const [message, _] = unpackMessage(data);
+        this._ready.complete(message["room_name"]);
+    }
+    _onParticipantInit(participantId, attributes) {
+        this._localParticipant = new LocalParticipant(this, participantId);
+        for (const k in attributes) {
+            this._localParticipant.setAttribute(k, attributes[k]);
+        }
+    }
+    async _handleParticipant(protocol, messageId, type, data) {
+        const [message, _] = unpackMessage(data);
+        switch (message["type"]) {
+            case "init": this._onParticipantInit(message["participantId"], message["attributes"]);
+        }
+    }
+    emit(event) {
+        this._eventsController.add(event);
+    }
+    listen() {
+        return this._eventsController.stream;
+    }
+}

package/dist/esm/room-event.d.ts

@@ -0,0 +1,60 @@
+export declare abstract class RoomEvent {
+    abstract get name(): string;
+    abstract get description(): string;
+}
+export declare class RoomMessage {
+    fromParticipantId: string;
+    type: string;
+    message: Record<string, any>;
+    local: boolean;
+    attachment?: Uint8Array;
+    constructor({ fromParticipantId, type, message, local, attachment }: {
+        fromParticipantId: string;
+        type: string;
+        message: Record<string, any>;
+        local?: boolean;
+        attachment?: Uint8Array;
+    });
+}
+export declare class RoomMessageEvent extends RoomEvent {
+    message: RoomMessage;
+    constructor({ message }: {
+        message: RoomMessage;
+    });
+    get name(): string;
+    get description(): string;
+}
+export declare class FileCreatedEvent extends RoomEvent {
+    path: string;
+    constructor({ path }: {
+        path: string;
+    });
+    get name(): string;
+    get description(): string;
+}
+export declare class FileDeletedEvent extends RoomEvent {
+    path: string;
+    constructor({ path }: {
+        path: string;
+    });
+    get name(): string;
+    get description(): string;
+}
+export declare class FileUpdatedEvent extends RoomEvent {
+    path: string;
+    constructor({ path }: {
+        path: string;
+    });
+    get name(): string;
+    get description(): string;
+}
+export declare class RoomLogEvent extends RoomEvent {
+    type: string;
+    data: Record<string, any>;
+    constructor({ type, data }: {
+        type: string;
+        data: Record<string, any>;
+    });
+    get name(): string;
+    get description(): string;
+}

package/dist/esm/room-event.js

@@ -0,0 +1,72 @@
+export class RoomEvent {
+}
+export class RoomMessage {
+    constructor({ fromParticipantId, type, message, local = false, attachment }) {
+        this.fromParticipantId = fromParticipantId;
+        this.type = type;
+        this.message = message;
+        this.local = local;
+        this.attachment = attachment;
+    }
+}
+export class RoomMessageEvent extends RoomEvent {
+    constructor({ message }) {
+        super();
+        this.message = message;
+    }
+    get name() {
+        return this.message.type;
+    }
+    get description() {
+        return `a message was received ${JSON.stringify(this.message.message)}`;
+    }
+}
+export class FileCreatedEvent extends RoomEvent {
+    constructor({ path }) {
+        super();
+        this.path = path;
+    }
+    get name() {
+        return "file created";
+    }
+    get description() {
+        return `a file was created at the path ${this.path}`;
+    }
+}
+export class FileDeletedEvent extends RoomEvent {
+    constructor({ path }) {
+        super();
+        this.path = path;
+    }
+    get name() {
+        return "file deleted";
+    }
+    get description() {
+        return `a file was deleted at the path ${this.path}`;
+    }
+}
+export class FileUpdatedEvent extends RoomEvent {
+    constructor({ path }) {
+        super();
+        this.path = path;
+    }
+    get name() {
+        return "file updated";
+    }
+    get description() {
+        return `a file was updated at the path ${this.path}`;
+    }
+}
+export class RoomLogEvent extends RoomEvent {
+    constructor({ type, data }) {
+        super();
+        this.type = type;
+        this.data = data;
+    }
+    get name() {
+        return this.type;
+    }
+    get description() {
+        return JSON.stringify(this.data);
+    }
+}

package/dist/esm/room-server-client.d.ts

@@ -0,0 +1,19 @@
+import { RuntimeDocument } from "./document";
+import { MeshSchema } from "./schema";
+export type Uint8List = Uint8Array;
+export declare class RoomServerException extends Error {
+    constructor(message: string);
+}
+export declare class MeshDocument extends RuntimeDocument {
+    private _synchronized;
+    constructor({ schema, sendChangesToBackend }: {
+        schema: MeshSchema;
+        sendChangesToBackend?: (base64: string) => void;
+    });
+    onSendUpdateToBackend: (base64: string) => void;
+    onSendUpdateToClient: (base64: string) => void;
+    get synchronized(): Promise<boolean>;
+    get isSynchronized(): boolean;
+    setSynchronizedComplete(): void;
+    dispose(): void;
+}

package/dist/esm/room-server-client.js

@@ -0,0 +1,45 @@
+import { v4 as uuidv4 } from "uuid";
+import { RuntimeDocument } from "./document";
+import { Completer } from "./completer";
+import { registerDocument, unregisterDocument, applyChanges, } from "./runtime";
+export class RoomServerException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RoomServerException";
+    }
+}
+export class MeshDocument extends RuntimeDocument {
+    constructor({ schema, sendChangesToBackend }) {
+        super({
+            id: uuidv4(),
+            schema,
+            sendChanges: (base64) => applyChanges(base64),
+            sendChangesToBackend,
+        });
+        this._synchronized = new Completer();
+        this.onSendUpdateToBackend = (base64) => {
+            const parsed = JSON.parse(base64);
+            if (this.sendChangesToBackend) {
+                this.sendChangesToBackend(parsed.data);
+            }
+        };
+        this.onSendUpdateToClient = (base64) => {
+            const parsed = JSON.parse(base64);
+            this.receiveChanges(parsed.data);
+        };
+        registerDocument(this.id, null, false, this.onSendUpdateToBackend, this.onSendUpdateToClient);
+    }
+    get synchronized() {
+        return this._synchronized.fut;
+    }
+    get isSynchronized() {
+        return this._synchronized.completed;
+    }
+    setSynchronizedComplete() {
+        this._synchronized.complete(true);
+    }
+    dispose() {
+        super.dispose();
+        unregisterDocument(this.id);
+    }
+}

package/dist/esm/runtime.d.ts

@@ -0,0 +1,6 @@
+export { applyBackendChanges, applyChanges, registerDocument, unregisterDocument, } from './entrypoint.js';
+export type SendUpdateFn = (msg: string) => void;
+export interface UpdatePayload {
+    documentID: string;
+    changes: any;
+}

package/dist/esm/runtime.js

@@ -0,0 +1 @@
+export { applyBackendChanges, applyChanges, registerDocument, unregisterDocument, } from './entrypoint.js';

package/dist/esm/schema.d.ts

@@ -0,0 +1,83 @@
+export declare class MeshSchemaValidationException extends Error {
+    constructor(message: string);
+}
+export declare enum SimpleValue {
+    number = "number",
+    string = "string",
+    nullValue = "null",
+    boolean = "boolean"
+}
+export declare namespace SimpleValue {
+    function fromString(val: string): SimpleValue | null;
+}
+export declare abstract class ElementProperty {
+    readonly name: string;
+    readonly description?: string;
+    constructor({ name, description }: {
+        name: string;
+        description?: string;
+    });
+    abstract validate(schema: MeshSchema): void;
+    abstract toJson(): Record<string, any>;
+}
+export declare class ValueProperty extends ElementProperty {
+    readonly type: SimpleValue;
+    readonly enumValues?: any[];
+    constructor({ name, description, type, enumValues }: {
+        name: string;
+        description?: string;
+        type: SimpleValue;
+        enumValues?: any[];
+    });
+    validate(_: MeshSchema): void;
+    toJson(): Record<string, any>;
+}
+export declare class ChildProperty extends ElementProperty {
+    private readonly _childTagNames;
+    readonly ordered: boolean;
+    constructor({ name, description, childTagNames, ordered }: {
+        name: string;
+        description?: string;
+        childTagNames: string[];
+        ordered?: boolean;
+    });
+    validate(schema: MeshSchema): void;
+    isTagAllowed(tagName: string): boolean;
+    get childTagNames(): string[];
+    toJson(): Record<string, any>;
+}
+export declare class ElementType {
+    private readonly _tagName;
+    private readonly _properties;
+    private readonly _description?;
+    private readonly _propertyLookup;
+    private _childPropertyName?;
+    constructor(params: {
+        tagName: string;
+        description?: string;
+        properties: ElementProperty[];
+    });
+    static fromJson(json: Record<string, any>): ElementType;
+    toJson(): Record<string, any>;
+    validate(schema: MeshSchema): void;
+    get childPropertyName(): string | undefined;
+    get tagName(): string;
+    get description(): string | undefined;
+    get properties(): ElementProperty[];
+    property(name: string): ElementProperty;
+}
+export declare class MeshSchema {
+    private readonly _rootTagName;
+    private readonly _elements;
+    readonly elementsByTagName: Record<string, ElementType>;
+    constructor(params: {
+        rootTagName: string;
+        elements: ElementType[];
+    });
+    static fromJson(json: Record<string, any>): MeshSchema;
+    toJson(): Record<string, any>;
+    element(name: string): ElementType;
+    validate(): void;
+    get root(): ElementType;
+    get elements(): ElementType[];
+}