@meshagent/meshagent 0.35.5 → 0.35.7

package/dist/browser/database-client.d.ts

@@ -6,118 +6,189 @@ export interface TableRef {
     namespace?: string[];
     alias?: string;
 }
+export interface TableVersion {
+    version: number;
+    timestamp: Date;
+    metadata: Record<string, unknown>;
+}
+export interface TableIndex {
+    name: string;
+    columns: string[];
+    type: string;
+}
+type DatabaseRoomInvoker = Pick<RoomClient, "invoke" | "invokeStream">;
 export declare class DatabaseClient {
     private room;
     constructor({ room }: {
-        room: RoomClient;
+        room: DatabaseRoomInvoker;
     });
     private _unexpectedResponseError;
     private invoke;
     private invokeStream;
     private drainWriteStream;
     private streamRows;
-    listTables(): Promise<string[]>;
+    listTables({ namespace }?: {
+        namespace?: string[];
+    }): Promise<string[]>;
     private createTable;
-    createTableWithSchema({ name, schema, data, mode }: {
+    createTableWithSchema({ name, schema, data, mode, namespace, metadata }: {
         name: string;
         schema?: Record<string, DataType>;
         data?: Array<Record<string, any>>;
         mode?: CreateMode;
+        namespace?: string[];
+        metadata?: Record<string, unknown>;
     }): Promise<void>;
-    createTableFromData({ name, data, mode }: {
+    createTableFromData({ name, data, mode, namespace, metadata }: {
         name: string;
         data?: Array<Record<string, any>>;
         mode?: CreateMode;
+        namespace?: string[];
+        metadata?: Record<string, unknown>;
     }): Promise<void>;
-    createTableFromDataStream({ name, chunks, schema, mode }: {
+    createTableFromDataStream({ name, chunks, schema, mode, namespace, metadata }: {
         name: string;
         chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
         schema?: Record<string, DataType>;
         mode?: CreateMode;
+        namespace?: string[];
+        metadata?: Record<string, unknown>;
     }): Promise<void>;
-    dropTable({ name, ignoreMissing }: {
+    dropTable({ name, ignoreMissing, namespace }: {
         name: string;
         ignoreMissing?: boolean;
+        namespace?: string[];
+    }): Promise<void>;
+    dropIndex({ table, name, namespace }: {
+        table: string;
+        name: string;
+        namespace?: string[];
     }): Promise<void>;
-    addColumns({ table, newColumns }: {
+    addColumns({ table, newColumns, namespace }: {
         table: string;
-        newColumns: Record<string, string>;
+        newColumns: Record<string, string | DataType>;
+        namespace?: string[];
     }): Promise<void>;
-    dropColumns({ table, columns }: {
+    dropColumns({ table, columns, namespace }: {
         table: string;
         columns: string[];
+        namespace?: string[];
     }): Promise<void>;
-    insert({ table, records }: {
+    insert({ table, records, namespace }: {
         table: string;
         records: Array<Record<string, any>>;
+        namespace?: string[];
     }): Promise<void>;
-    insertStream({ table, chunks }: {
+    insertStream({ table, chunks, namespace }: {
         table: string;
         chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+        namespace?: string[];
     }): Promise<void>;
-    update({ table, where, values, valuesSql }: {
+    update({ table, where, values, valuesSql, namespace }: {
         table: string;
         where: string;
         values?: Record<string, any>;
         valuesSql?: Record<string, string>;
+        namespace?: string[];
     }): Promise<void>;
-    delete({ table, where }: {
+    delete({ table, where, namespace }: {
         table: string;
         where: string;
+        namespace?: string[];
     }): Promise<void>;
-    merge({ table, on, records }: {
+    merge({ table, on, records, namespace }: {
         table: string;
         on: string;
         records: Array<Record<string, any>>;
+        namespace?: string[];
     }): Promise<void>;
-    mergeStream({ table, on, chunks }: {
+    mergeStream({ table, on, chunks, namespace }: {
         table: string;
         on: string;
         chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+        namespace?: string[];
     }): Promise<void>;
     sql({ query, tables, params }: {
         query: string;
-        tables: TableRef[];
+        tables: Array<TableRef | string>;
         params?: Record<string, any>;
     }): Promise<Array<Record<string, any>>>;
     sqlStream({ query, tables, params }: {
         query: string;
-        tables: TableRef[];
+        tables: Array<TableRef | string>;
         params?: Record<string, any>;
     }): AsyncIterable<Array<Record<string, any>>>;
-    search({ table, text, vector, where, limit, select }: {
+    search({ table, text, vector, where, offset, limit, select, namespace }: {
         table: string;
         text?: string;
         vector?: number[];
         where?: string | Record<string, any>;
+        offset?: number;
         limit?: number;
         select?: string[];
+        namespace?: string[];
     }): Promise<Array<Record<string, any>>>;
-    searchStream({ table, text, vector, where, limit, select }: {
+    searchStream({ table, text, vector, where, offset, limit, select, namespace }: {
         table: string;
         text?: string;
         vector?: number[];
         where?: string | Record<string, any>;
+        offset?: number;
         limit?: number;
         select?: string[];
+        namespace?: string[];
     }): AsyncIterable<Array<Record<string, any>>>;
+    count({ table, text, vector, where, namespace }: {
+        table: string;
+        text?: string;
+        vector?: number[];
+        where?: string | Record<string, any>;
+        namespace?: string[];
+    }): Promise<number>;
+    inspect({ table, namespace }: {
+        table: string;
+        namespace?: string[];
+    }): Promise<Record<string, DataType>>;
     optimize(table: string): Promise<void>;
-    createVectorIndex({ table, column, replace }: {
+    optimize(params: {
+        table: string;
+        namespace?: string[];
+    }): Promise<void>;
+    restore({ table, version, namespace }: {
+        table: string;
+        version: number;
+        namespace?: string[];
+    }): Promise<void>;
+    checkout({ table, version, namespace }: {
+        table: string;
+        version: number;
+        namespace?: string[];
+    }): Promise<void>;
+    listVersions({ table, namespace }: {
+        table: string;
+        namespace?: string[];
+    }): Promise<TableVersion[]>;
+    createVectorIndex({ table, column, replace, namespace }: {
         table: string;
         column: string;
         replace?: boolean;
+        namespace?: string[];
     }): Promise<void>;
-    createScalarIndex({ table, column, replace }: {
+    createScalarIndex({ table, column, replace, namespace }: {
         table: string;
         column: string;
         replace?: boolean;
+        namespace?: string[];
     }): Promise<void>;
-    createFullTextSearchIndex({ table, column, replace }: {
+    createFullTextSearchIndex({ table, column, replace, namespace }: {
         table: string;
         column: string;
         replace?: boolean;
+        namespace?: string[];
     }): Promise<void>;
-    listIndexes({ table }: {
+    listIndexes({ table, namespace }: {
         table: string;
-    }): Promise<Array<Record<string, any>>>;
+        namespace?: string[];
+    }): Promise<TableIndex[]>;
 }
+export {};

package/dist/browser/database-client.js

@@ -302,6 +302,48 @@ function buildWhereClause(where) {
     }
     return null;
 }
+function normalizeTableRefs(tables) {
+    return tables.map((table) => typeof table === "string" ? { name: table } : table);
+}
+function tableIndexFromJson(value) {
+    if (!isRecord(value) || typeof value.name !== "string" || typeof value.type !== "string" || !Array.isArray(value.columns)) {
+        throw new room_server_client_1.RoomServerException("unexpected return type from database.list_indexes");
+    }
+    return {
+        name: value.name,
+        type: value.type,
+        columns: value.columns.map((column) => {
+            if (typeof column !== "string") {
+                throw new room_server_client_1.RoomServerException("unexpected return type from database.list_indexes");
+            }
+            return column;
+        }),
+    };
+}
+function tableVersionFromJson(value) {
+    if (!isRecord(value) || typeof value.metadata_json !== "string" || typeof value.timestamp !== "string" || typeof value.version !== "number") {
+        throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+    }
+    const timestamp = new Date(value.timestamp);
+    if (Number.isNaN(timestamp.getTime())) {
+        throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+    }
+    let metadata;
+    try {
+        metadata = JSON.parse(value.metadata_json);
+    }
+    catch (_) {
+        throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+    }
+    if (!isRecord(metadata)) {
+        throw new room_server_client_1.RoomServerException("unexpected return type from database.list_versions");
+    }
+    return {
+        version: value.version,
+        timestamp,
+        metadata,
+    };
+}
 class DatabaseWriteInputStream {
     constructor(start, chunks) {
         this.start = start;
@@ -482,79 +524,92 @@ class DatabaseClient {
             input.close();
         }
     }
-    async listTables() {
-        const response = await this.invoke("list_tables", { namespace: null });
+    async listTables({ namespace } = {}) {
+        const response = await this.invoke("list_tables", { namespace: namespace ?? null });
         if (!(response instanceof response_1.JsonContent)) {
             throw this._unexpectedResponseError("list_tables");
         }
         return Array.isArray(response.json.tables) ? response.json.tables : [];
     }
-    async createTable({ name, data, schema, mode = "create", }) {
+    async createTable({ name, data, schema, mode = "create", namespace, metadata, }) {
         const input = new DatabaseWriteInputStream({
             kind: "start",
             name,
             fields: schemaEntries(schema),
             mode,
-            namespace: null,
-            metadata: null,
+            namespace: namespace ?? null,
+            metadata: metadataEntries(metadata),
         }, data ?? []);
         await this.drainWriteStream("create_table", input);
     }
-    async createTableWithSchema({ name, schema, data, mode = "create" }) {
+    async createTableWithSchema({ name, schema, data, mode = "create", namespace, metadata }) {
         return this.createTable({
             name,
             schema,
             data: data == null ? undefined : rowChunkList(data),
             mode,
+            namespace,
+            metadata,
         });
     }
-    async createTableFromData({ name, data, mode = "create" }) {
+    async createTableFromData({ name, data, mode = "create", namespace, metadata }) {
         return this.createTable({
             name,
             data: data == null ? undefined : rowChunkList(data),
             mode,
+            namespace,
+            metadata,
         });
     }
-    async createTableFromDataStream({ name, chunks, schema, mode = "create" }) {
-        return this.createTable({ name, data: chunks, schema, mode });
+    async createTableFromDataStream({ name, chunks, schema, mode = "create", namespace, metadata }) {
+        return this.createTable({ name, data: chunks, schema, mode, namespace, metadata });
     }
-    async dropTable({ name, ignoreMissing = false }) {
+    async dropTable({ name, ignoreMissing = false, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "drop_table",
-            input: { name, ignore_missing: ignoreMissing, namespace: null },
+            input: { name, ignore_missing: ignoreMissing, namespace: namespace ?? null },
         });
     }
-    async addColumns({ table, newColumns }) {
+    async dropIndex({ table, name, namespace }) {
+        await this.room.invoke({
+            toolkit: "database",
+            tool: "drop_index",
+            input: { table, name, namespace: namespace ?? null },
+        });
+    }
+    async addColumns({ table, newColumns, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "add_columns",
             input: {
                 table,
-                columns: Object.entries(newColumns).map(([name, valueSql]) => ({ name, value_sql: valueSql, data_type: null })),
-                namespace: null,
+                columns: Object.entries(newColumns).map(([name, value]) => (value instanceof data_types_1.DataType
+                    ? { name, value_sql: null, data_type: toolkitDataTypeJson(value) }
+                    : { name, value_sql: value, data_type: null })),
+                namespace: namespace ?? null,
             },
         });
     }
-    async dropColumns({ table, columns }) {
+    async dropColumns({ table, columns, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "drop_columns",
-            input: { table, columns, namespace: null },
+            input: { table, columns, namespace: namespace ?? null },
         });
     }
-    async insert({ table, records }) {
-        await this.insertStream({ table, chunks: rowChunkList(records) });
+    async insert({ table, records, namespace }) {
+        await this.insertStream({ table, chunks: rowChunkList(records), namespace });
     }
-    async insertStream({ table, chunks }) {
+    async insertStream({ table, chunks, namespace }) {
         const input = new DatabaseWriteInputStream({
             kind: "start",
             table,
-            namespace: null,
+            namespace: namespace ?? null,
         }, chunks);
         await this.drainWriteStream("insert", input);
     }
-    async update({ table, where, values, valuesSql }) {
+    async update({ table, where, values, valuesSql, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "update",
@@ -563,26 +618,26 @@ class DatabaseClient {
                 where,
                 values: values == null ? null : Object.entries(values).map(([column, value]) => ({ column, value_json: JSON.stringify(encodeLegacyValue(value)) })),
                 values_sql: valuesSql == null ? null : Object.entries(valuesSql).map(([column, expression]) => ({ column, expression })),
-                namespace: null,
+                namespace: namespace ?? null,
             },
         });
     }
-    async delete({ table, where }) {
+    async delete({ table, where, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "delete",
-            input: { table, where, namespace: null },
+            input: { table, where, namespace: namespace ?? null },
         });
     }
-    async merge({ table, on, records }) {
-        await this.mergeStream({ table, on, chunks: rowChunkList(records) });
+    async merge({ table, on, records, namespace }) {
+        await this.mergeStream({ table, on, chunks: rowChunkList(records), namespace });
     }
-    async mergeStream({ table, on, chunks }) {
+    async mergeStream({ table, on, chunks, namespace }) {
         const input = new DatabaseWriteInputStream({
             kind: "start",
             table,
             on,
-            namespace: null,
+            namespace: namespace ?? null,
         }, chunks);
         await this.drainWriteStream("merge", input);
     }
@@ -597,18 +652,18 @@ class DatabaseClient {
         yield* this.streamRows("sql", {
             kind: "start",
             query,
-            tables,
+            tables: normalizeTableRefs(tables),
             params_json: params == null ? null : JSON.stringify(encodeLegacyValue(params)),
         });
     }
-    async search({ table, text, vector, where, limit, select }) {
+    async search({ table, text, vector, where, offset, limit, select, namespace }) {
         const rows = [];
-        for await (const chunk of this.searchStream({ table, text, vector, where, limit, select })) {
+        for await (const chunk of this.searchStream({ table, text, vector, where, offset, limit, select, namespace })) {
             rows.push(...chunk);
         }
         return rows;
     }
-    async *searchStream({ table, text, vector, where, limit, select }) {
+    async *searchStream({ table, text, vector, where, offset, limit, select, namespace }) {
         yield* this.streamRows("search", {
             kind: "start",
             table,
@@ -616,45 +671,91 @@ class DatabaseClient {
             vector: vector ?? null,
             text_columns: null,
             where: buildWhereClause(where),
-            offset: null,
+            offset: offset ?? null,
             limit: limit ?? null,
             select: select ?? null,
-            namespace: null,
+            namespace: namespace ?? null,
+        });
+    }
+    async count({ table, text, vector, where, namespace }) {
+        const response = await this.invoke("count", {
+            table,
+            text: text ?? null,
+            vector: vector ?? null,
+            text_columns: null,
+            where: buildWhereClause(where),
+            namespace: namespace ?? null,
         });
+        if (!(response instanceof response_1.JsonContent) || typeof response.json.count !== "number" || !Number.isInteger(response.json.count)) {
+            throw this._unexpectedResponseError("count");
+        }
+        return response.json.count;
+    }
+    async inspect({ table, namespace }) {
+        const response = await this.invoke("inspect", { table, namespace: namespace ?? null });
+        if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json.fields)) {
+            throw this._unexpectedResponseError("inspect");
+        }
+        return Object.fromEntries(response.json.fields.map((field) => {
+            if (!isRecord(field) || typeof field.name !== "string") {
+                throw this._unexpectedResponseError("inspect");
+            }
+            return [field.name, data_types_1.DataType.fromJson(publicDataTypeJson(field.data_type))];
+        }));
     }
-    async optimize(table) {
-        await this.room.invoke({ toolkit: "database", tool: "optimize", input: { table, namespace: null } });
+    async optimize(tableOrParams) {
+        const table = typeof tableOrParams === "string" ? tableOrParams : tableOrParams.table;
+        const namespace = typeof tableOrParams === "string" ? undefined : tableOrParams.namespace;
+        await this.room.invoke({ toolkit: "database", tool: "optimize", input: { table, namespace: namespace ?? null } });
     }
-    async createVectorIndex({ table, column, replace = false }) {
+    async restore({ table, version, namespace }) {
+        await this.room.invoke({
+            toolkit: "database",
+            tool: "restore",
+            input: { table, version, namespace: namespace ?? null },
+        });
+    }
+    async checkout({ table, version, namespace }) {
+        await this.room.invoke({
+            toolkit: "database",
+            tool: "checkout",
+            input: { table, version, namespace: namespace ?? null },
+        });
+    }
+    async listVersions({ table, namespace }) {
+        const response = await this.invoke("list_versions", { table, namespace: namespace ?? null });
+        if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json.versions)) {
+            throw this._unexpectedResponseError("list_versions");
+        }
+        return response.json.versions.map((version) => tableVersionFromJson(version));
+    }
+    async createVectorIndex({ table, column, replace = false, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "create_vector_index",
-            input: { table, column, replace, namespace: null },
+            input: { table, column, replace, namespace: namespace ?? null },
         });
     }
-    async createScalarIndex({ table, column, replace = false }) {
+    async createScalarIndex({ table, column, replace = false, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "create_scalar_index",
-            input: { table, column, replace, namespace: null },
+            input: { table, column, replace, namespace: namespace ?? null },
         });
     }
-    async createFullTextSearchIndex({ table, column, replace = false }) {
+    async createFullTextSearchIndex({ table, column, replace = false, namespace }) {
         await this.room.invoke({
             toolkit: "database",
             tool: "create_full_text_search_index",
-            input: { table, column, replace, namespace: null },
+            input: { table, column, replace, namespace: namespace ?? null },
         });
     }
-    async listIndexes({ table }) {
-        const response = await this.invoke("list_indexes", { table, namespace: null });
-        if (!(response instanceof response_1.JsonContent)) {
-            throw this._unexpectedResponseError("list_indexes");
-        }
-        if (!Array.isArray(response.json.indexes)) {
+    async listIndexes({ table, namespace }) {
+        const response = await this.invoke("list_indexes", { table, namespace: namespace ?? null });
+        if (!(response instanceof response_1.JsonContent) || !Array.isArray(response.json.indexes)) {
             throw this._unexpectedResponseError("list_indexes");
         }
-        return response.json.indexes;
+        return response.json.indexes.map((index) => tableIndexFromJson(index));
     }
 }
 exports.DatabaseClient = DatabaseClient;

package/dist/browser/messaging-client.d.ts

@@ -2,80 +2,61 @@ import { EventEmitter } from "./event-emitter";
 import { RoomClient } from "./room-client";
 import { Participant, RemoteParticipant } from "./participant";
 import { RoomMessageEvent } from "./room-event";
-import { StreamController } from "./stream-controller";
-export declare class MessageStreamChunk {
-    header: Record<string, any>;
-    data?: Uint8Array;
-    constructor({ header, data }: {
-        header: Record<string, any>;
-        data?: Uint8Array;
-    });
-}
+type MessagePayload = Record<string, unknown>;
 export declare class MessagingClient extends EventEmitter<RoomMessageEvent> {
-    private client;
-    private _streamWriters;
-    private _streamReaders;
-    private _onStreamAcceptCallback?;
-    private _participants;
+    private readonly client;
+    private readonly _messageHandler;
+    private readonly _participants;
+    private readonly _messageQueue;
+    private _messageQueued;
+    private _sendTask;
+    private _messageQueueClosed;
+    private _enabled;
     constructor({ room }: {
         room: RoomClient;
     });
     private _messageInput;
+    private _syntheticMessageEvent;
     private _removeParticipant;
+    private _markParticipantOffline;
     private _resolveMessageRecipient;
-    private _participantNotFound;
-    createStream({ to, header }: {
-        to: Participant;
-        header: Record<string, any>;
-    }): Promise<MessageStreamWriter>;
+    private _queueMessage;
+    private _rejectQueuedMessages;
+    private _isParticipantNotFound;
+    private _nextQueuedMessage;
+    private _sendMessages;
+    start(): Promise<void>;
+    stop(): Promise<void>;
     sendMessage({ to, type, message, attachment, ignoreOffline }: {
         to: Participant;
         type: string;
-        message: Record<string, any>;
+        message: MessagePayload;
         attachment?: Uint8Array;
         ignoreOffline?: boolean;
     }): Promise<void>;
-    enable(onStreamAccept?: (reader: MessageStreamReader) => void): Promise<void>;
+    sendMessageNowait({ to, type, message, attachment }: {
+        to: Participant;
+        type: string;
+        message: MessagePayload;
+        attachment?: Uint8Array;
+    }): void;
+    enable(): Promise<void>;
     disable(): Promise<void>;
     broadcastMessage({ type, message, attachment }: {
         type: string;
-        message: Record<string, any>;
+        message: MessagePayload;
         attachment?: Uint8Array;
     }): Promise<void>;
-    get remoteParticipants(): Iterable<RemoteParticipant>;
+    get remoteParticipants(): RemoteParticipant[];
+    get isEnabled(): boolean;
+    getParticipants(): RemoteParticipant[];
+    getParticipant(id: string): RemoteParticipant | null;
+    getParticipantByName(name: string): RemoteParticipant | null;
     private _handleMessageSend;
     private _onParticipantEnabled;
     private _onParticipantAttributes;
     private _onParticipantDisabled;
     private _onMessagingEnabled;
-    private _onStreamOpen;
-    private _onStreamAccept;
-    private _onStreamReject;
-    private _onStreamChunk;
-    private _onStreamClose;
     dispose(): void;
 }
-export declare class MessageStreamWriter {
-    private _streamId;
-    private _to;
-    private _client;
-    constructor({ streamId, to, client }: {
-        streamId: string;
-        to: Participant;
-        client: MessagingClient;
-    });
-    write(chunk: MessageStreamChunk): Promise<void>;
-    close(): Promise<void>;
-}
-export declare class MessageStreamReader {
-    _streamId: string;
-    _to: Participant;
-    _client: MessagingClient;
-    _controller: StreamController<MessageStreamChunk>;
-    constructor({ streamId, to, client, controller }: {
-        streamId: string;
-        to: Participant;
-        client: MessagingClient;
-        controller: StreamController<MessageStreamChunk>;
-    });
-}
+export {};