@meshagent/meshagent 0.0.11 → 0.0.13

package/dist/node/response.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmptyResponse = exports.ErrorResponse = exports.JsonResponse = exports.TextResponse = exports.FileResponse = exports.LinkResponse = void 0;
+exports.unpackResponse = unpackResponse;
+const utils_1 = require("./utils");
+class LinkResponse {
+    constructor({ url, name }) {
+        this.url = url;
+        this.name = name;
+    }
+    static unpack(header, payload) {
+        return new LinkResponse({
+            url: header["url"],
+            name: header["name"],
+        });
+    }
+    pack() {
+        return (0, utils_1.packMessage)({
+            type: "link",
+            name: this.name,
+            url: this.url,
+        });
+    }
+    toString() {
+        return `LinkResponse (${this.name}): ${this.url}`;
+    }
+}
+exports.LinkResponse = LinkResponse;
+class FileResponse {
+    constructor({ data, name, mimeType }) {
+        this.data = data;
+        this.name = name;
+        this.mimeType = mimeType;
+    }
+    static unpack(header, payload) {
+        return new FileResponse({
+            data: payload,
+            name: header["name"],
+            mimeType: header["mime_type"],
+        });
+    }
+    pack() {
+        return (0, utils_1.packMessage)({
+            type: "file",
+            name: this.name,
+            mime_type: this.mimeType,
+        }, this.data);
+    }
+    toString() {
+        return `FileResponse (${this.name}): ${this.mimeType}`;
+    }
+}
+exports.FileResponse = FileResponse;
+class TextResponse {
+    constructor({ text }) {
+        this.text = text;
+    }
+    static unpack(header, payload) {
+        return new TextResponse({
+            text: header["text"],
+        });
+    }
+    pack() {
+        return (0, utils_1.packMessage)({
+            type: "text",
+            text: this.text,
+        });
+    }
+    toString() {
+        return `TextResponse: ${this.text}`;
+    }
+}
+exports.TextResponse = TextResponse;
+class JsonResponse {
+    constructor({ json }) {
+        this.json = json;
+    }
+    static unpack(header, payload) {
+        return new JsonResponse({ json: header["json"] });
+    }
+    pack() {
+        return (0, utils_1.packMessage)({
+            type: "json",
+            json: this.json,
+        });
+    }
+    toString() {
+        return `JsonResponse: ${JSON.stringify(this.json)}`;
+    }
+}
+exports.JsonResponse = JsonResponse;
+class ErrorResponse {
+    constructor({ text }) {
+        this.text = text;
+    }
+    static unpack(header, payload) {
+        return new ErrorResponse({ text: header["text"] });
+    }
+    pack() {
+        return (0, utils_1.packMessage)({
+            type: "error",
+            text: this.text,
+        });
+    }
+    toString() {
+        return `ErrorResponse: ${this.text}`;
+    }
+}
+exports.ErrorResponse = ErrorResponse;
+class EmptyResponse {
+    static unpack(header, payload) {
+        return new EmptyResponse();
+    }
+    pack() {
+        return (0, utils_1.packMessage)({ type: "empty" });
+    }
+    toString() {
+        return `EmptyResponse`;
+    }
+}
+exports.EmptyResponse = EmptyResponse;
+const _responseTypes = {
+    empty: EmptyResponse.unpack,
+    error: ErrorResponse.unpack,
+    file: FileResponse.unpack,
+    json: JsonResponse.unpack,
+    link: LinkResponse.unpack,
+    text: TextResponse.unpack,
+};
+function unpackResponse(data) {
+    const header = JSON.parse((0, utils_1.splitMessageHeader)(data));
+    const payload = (0, utils_1.splitMessagePayload)(data);
+    const typeKey = header["type"];
+    if (!_responseTypes[typeKey]) {
+        throw new Error(`Unknown response type: ${typeKey}`);
+    }
+    return _responseTypes[typeKey](header, payload);
+}

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

@@ -0,0 +1,43 @@
+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(): 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/node/room-client.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomClient = void 0;
+const completer_1 = require("./completer");
+const utils_1 = require("./utils");
+const participant_1 = require("./participant");
+const stream_controller_1 = require("./stream-controller");
+const sync_client_1 = require("./sync-client");
+const developer_client_1 = require("./developer-client");
+const storage_client_1 = require("./storage-client");
+const messaging_client_1 = require("./messaging-client");
+const queues_client_1 = require("./queues-client");
+const database_client_1 = require("./database-client");
+const agent_client_1 = require("./agent-client");
+const response_1 = require("./response");
+class RoomClient {
+    constructor({ protocol }) {
+        this._pendingRequests = new Map();
+        this._ready = new completer_1.Completer();
+        this._localParticipant = null;
+        this._eventsController = new stream_controller_1.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 sync_client_1.SyncClient({ room: this });
+        this.storage = new storage_client_1.StorageClient({ room: this });
+        this.developer = new developer_client_1.DeveloperClient({ room: this });
+        this.messaging = new messaging_client_1.MessagingClient({ room: this });
+        this.queues = new queues_client_1.QueuesClient({ room: this });
+        this.database = new database_client_1.DatabaseClient({ room: this });
+        this.agents = new agent_client_1.AgentsClient({ room: this });
+    }
+    get localParticipant() {
+        return this._localParticipant;
+    }
+    get ready() {
+        return this._ready.fut;
+    }
+    async start() {
+        this.sync.start();
+        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_1.Completer();
+        this._pendingRequests.set(requestId, pr);
+        const message = (0, utils_1.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 = (0, response_1.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 response_1.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) {
+        this._ready.complete(JSON.parse(utils_1.decoder.decode(data))["room_name"]);
+    }
+    _onParticipantInit(participantId, attributes) {
+        this._localParticipant = new participant_1.LocalParticipant(this, participantId);
+        for (const k in attributes) {
+            this._localParticipant.setAttribute(k, attributes[k]);
+        }
+    }
+    async _handleParticipant(protocol, messageId, type, data) {
+        const message = JSON.parse(utils_1.decoder.decode(data));
+        switch (message["type"]) {
+            case "init": this._onParticipantInit(message["participantId"], message["attributes"]);
+        }
+    }
+    emit(event) {
+        this._eventsController.add(event);
+    }
+    listen() {
+        return this._eventsController.stream;
+    }
+}
+exports.RoomClient = RoomClient;

package/dist/node/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/node/room-event.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoomLogEvent = exports.FileUpdatedEvent = exports.FileDeletedEvent = exports.FileCreatedEvent = exports.RoomMessageEvent = exports.RoomMessage = exports.RoomEvent = void 0;
+class RoomEvent {
+}
+exports.RoomEvent = RoomEvent;
+class RoomMessage {
+    constructor({ fromParticipantId, type, message, local = false, attachment }) {
+        this.fromParticipantId = fromParticipantId;
+        this.type = type;
+        this.message = message;
+        this.local = local;
+        this.attachment = attachment;
+    }
+}
+exports.RoomMessage = RoomMessage;
+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)}`;
+    }
+}
+exports.RoomMessageEvent = RoomMessageEvent;
+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}`;
+    }
+}
+exports.FileCreatedEvent = FileCreatedEvent;
+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}`;
+    }
+}
+exports.FileDeletedEvent = FileDeletedEvent;
+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}`;
+    }
+}
+exports.FileUpdatedEvent = FileUpdatedEvent;
+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);
+    }
+}
+exports.RoomLogEvent = RoomLogEvent;

package/dist/node/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/node/room-server-client.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshDocument = exports.RoomServerException = void 0;
+const uuid_1 = require("uuid");
+const document_1 = require("./document");
+const completer_1 = require("./completer");
+const runtime_1 = require("./runtime");
+class RoomServerException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RoomServerException";
+    }
+}
+exports.RoomServerException = RoomServerException;
+class MeshDocument extends document_1.RuntimeDocument {
+    constructor({ schema, sendChangesToBackend }) {
+        super({
+            id: (0, uuid_1.v4)(),
+            schema,
+            sendChanges: (base64) => (0, runtime_1.applyChanges)(base64),
+            sendChangesToBackend,
+        });
+        this._synchronized = new completer_1.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);
+        };
+        (0, runtime_1.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();
+        (0, runtime_1.unregisterDocument)(this.id);
+    }
+}
+exports.MeshDocument = MeshDocument;

package/dist/node/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/node/runtime.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterDocument = exports.registerDocument = exports.applyChanges = exports.applyBackendChanges = void 0;
+var entrypoint_js_1 = require("./entrypoint.js");
+Object.defineProperty(exports, "applyBackendChanges", { enumerable: true, get: function () { return entrypoint_js_1.applyBackendChanges; } });
+Object.defineProperty(exports, "applyChanges", { enumerable: true, get: function () { return entrypoint_js_1.applyChanges; } });
+Object.defineProperty(exports, "registerDocument", { enumerable: true, get: function () { return entrypoint_js_1.registerDocument; } });
+Object.defineProperty(exports, "unregisterDocument", { enumerable: true, get: function () { return entrypoint_js_1.unregisterDocument; } });

package/dist/node/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[];
+}