@meshagent/meshagent 0.38.4 → 0.39.1

package/dist/node/room-client.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RoomClient = exports.RoomProtocolProxy = void 0;
 const completer_1 = require("./completer");
-const database_client_1 = require("./database-client");
+const datasets_client_1 = require("./datasets-client");
 const developer_client_1 = require("./developer-client");
 const event_emitter_1 = require("./event-emitter");
 const messaging_client_1 = require("./messaging-client");
@@ -248,7 +248,7 @@ class RoomClient {
         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.datasets = new datasets_client_1.DatasetsClient({ room: this });
         this.agents = new agent_client_1.AgentsClient({ room: this });
         this.secrets = new secrets_client_1.SecretsClient({
             room: this,
@@ -302,8 +302,74 @@ class RoomClient {
         this._eventsController.add(event);
         this._eventEmitter.emit(event.name, event);
     }
-    listen() {
-        return this._eventsController.stream;
+    listen({ abortSignal } = {}) {
+        if (abortSignal === undefined || abortSignal === null) {
+            return this._eventsController.stream;
+        }
+        const source = this._eventsController.stream;
+        return {
+            [Symbol.asyncIterator]() {
+                const eventIterator = source[Symbol.asyncIterator]();
+                let abortReject = null;
+                let cleanedUp = false;
+                const abortError = () => {
+                    if (abortSignal.reason != null) {
+                        return abortSignal.reason;
+                    }
+                    const error = new Error("Aborted");
+                    error.name = "AbortError";
+                    return error;
+                };
+                const cleanup = async () => {
+                    if (cleanedUp) {
+                        return;
+                    }
+                    cleanedUp = true;
+                    abortSignal.removeEventListener("abort", onAbort);
+                    await eventIterator.return?.();
+                };
+                const onAbort = () => {
+                    const reject = abortReject;
+                    abortReject = null;
+                    reject?.(abortError());
+                    void cleanup();
+                };
+                abortSignal.addEventListener("abort", onAbort, { once: true });
+                return {
+                    async next() {
+                        if (abortSignal.aborted) {
+                            await cleanup();
+                            return Promise.reject(abortError());
+                        }
+                        const abortPromise = new Promise((_, reject) => {
+                            abortReject = reject;
+                        });
+                        try {
+                            const result = await Promise.race([eventIterator.next(), abortPromise]);
+                            if (result.done) {
+                                await cleanup();
+                            }
+                            return result;
+                        }
+                        catch (error) {
+                            await cleanup();
+                            throw error;
+                        }
+                        finally {
+                            abortReject = null;
+                        }
+                    },
+                    async return() {
+                        await cleanup();
+                        return { done: true, value: undefined };
+                    },
+                    async throw(e) {
+                        await cleanup();
+                        return Promise.reject(e);
+                    },
+                };
+            },
+        };
     }
     async waitForClose() {
         await this._roomClosed.fut;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@meshagent/meshagent",
-    "version": "0.38.4",
+    "version": "0.39.1",
     "description": "Meshagent Client",
     "homepage": "https://github.com/meshagent/meshagent-ts",
     "scripts": {
@@ -45,11 +45,12 @@
     },
     "dependencies": {
         "@kayahr/text-encoding": "^2.0.0",
+        "apache-arrow": "^21.0.0",
         "base-64": "^1.0.0",
         "isomorphic-ws": "^5.0.0",
         "jose": "^6.0.8",
         "livekit-client": "^2.15.5",
-        "uuid": "^11.0.5",
+        "uuid": "^14.0.0",
         "ws": "^8.18.0",
         "yjs": "^13.6.28"
     },

package/dist/browser/data-types.d.ts

@@ -1,67 +0,0 @@
-export declare const _dataTypes: Record<string, typeof DataType>;
-export declare abstract class DataType {
-    constructor(_?: any);
-    abstract toJson(): Record<string, unknown>;
-    static fromJson(data: any): DataType;
-    static int(): IntDataType;
-    static date(): DateDataType;
-    static float(): FloatDataType;
-    static vector({ size, elementType }: {
-        size: number;
-        elementType: DataType;
-    }): VectorDataType;
-    static text(): TextDataType;
-    static json(): JsonDataType;
-    static uuid(): UuidDataType;
-    static binary(): BinaryDataType;
-}
-export declare class BoolDataType extends DataType {
-    constructor();
-    static fromJson(data: any): IntDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class IntDataType extends DataType {
-    constructor();
-    static fromJson(data: any): IntDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class DateDataType extends DataType {
-    constructor();
-    static fromJson(data: any): DateDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class FloatDataType extends DataType {
-    constructor();
-    static fromJson(data: any): FloatDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class VectorDataType extends DataType {
-    size: number;
-    elementType: DataType;
-    constructor({ size, elementType }: {
-        size: number;
-        elementType: DataType;
-    });
-    static fromJson(data: any): VectorDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class TextDataType extends DataType {
-    constructor();
-    static fromJson(data: any): TextDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class JsonDataType extends DataType {
-    constructor();
-    static fromJson(data: any): JsonDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class UuidDataType extends DataType {
-    constructor();
-    static fromJson(data: any): UuidDataType;
-    toJson(): Record<string, unknown>;
-}
-export declare class BinaryDataType extends DataType {
-    constructor();
-    static fromJson(data: any): BinaryDataType;
-    toJson(): Record<string, unknown>;
-}

package/dist/browser/data-types.js

@@ -1,192 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BinaryDataType = exports.UuidDataType = exports.JsonDataType = exports.TextDataType = exports.VectorDataType = exports.FloatDataType = exports.DateDataType = exports.IntDataType = exports.BoolDataType = exports.DataType = exports._dataTypes = void 0;
-exports._dataTypes = {};
-class DataType {
-    constructor(_) { }
-    static fromJson(data) {
-        const ctor = exports._dataTypes[data.type];
-        if (!ctor) {
-            throw new Error(`Unknown data type: ${data.type}`);
-        }
-        return ctor.fromJson(data);
-    }
-    static int() {
-        return new IntDataType();
-    }
-    static date() {
-        return new DateDataType();
-    }
-    static float() {
-        return new FloatDataType();
-    }
-    static vector({ size, elementType }) {
-        return new VectorDataType({ size, elementType });
-    }
-    static text() {
-        return new TextDataType();
-    }
-    static json() {
-        return new JsonDataType();
-    }
-    static uuid() {
-        return new UuidDataType();
-    }
-    static binary() {
-        return new BinaryDataType();
-    }
-}
-exports.DataType = DataType;
-class BoolDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "bool") {
-            throw new Error(`Expected type 'bool', got '${data.type}'`);
-        }
-        return new BoolDataType();
-    }
-    toJson() {
-        return { type: "bool" };
-    }
-}
-exports.BoolDataType = BoolDataType;
-exports._dataTypes["bool"] = BoolDataType;
-class IntDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "int") {
-            throw new Error(`Expected type 'int', got '${data.type}'`);
-        }
-        return new IntDataType();
-    }
-    toJson() {
-        return { type: "int" };
-    }
-}
-exports.IntDataType = IntDataType;
-exports._dataTypes["int"] = IntDataType;
-class DateDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "date") {
-            throw new Error(`Expected type 'date', got '${data.type}'`);
-        }
-        return new DateDataType();
-    }
-    toJson() {
-        return { type: "date" };
-    }
-}
-exports.DateDataType = DateDataType;
-exports._dataTypes["date"] = DateDataType;
-class FloatDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "float") {
-            throw new Error(`Expected type 'float', got '${data.type}'`);
-        }
-        return new FloatDataType();
-    }
-    toJson() {
-        return { type: "float" };
-    }
-}
-exports.FloatDataType = FloatDataType;
-exports._dataTypes["float"] = FloatDataType;
-class VectorDataType extends DataType {
-    constructor({ size, elementType }) {
-        super();
-        this.size = size;
-        this.elementType = elementType;
-    }
-    static fromJson(data) {
-        if (data.type !== "vector") {
-            throw new Error(`Expected type 'vector', got '${data.type}'`);
-        }
-        return new VectorDataType({
-            size: data.size,
-            elementType: DataType.fromJson(data.element_type),
-        });
-    }
-    toJson() {
-        return {
-            type: "vector",
-            size: this.size,
-            element_type: this.elementType.toJson(),
-        };
-    }
-}
-exports.VectorDataType = VectorDataType;
-exports._dataTypes["vector"] = VectorDataType;
-class TextDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "text") {
-            throw new Error(`Expected type 'text', got '${data.type}'`);
-        }
-        return new TextDataType();
-    }
-    toJson() {
-        return { type: "text" };
-    }
-}
-exports.TextDataType = TextDataType;
-exports._dataTypes["text"] = TextDataType;
-class JsonDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "json") {
-            throw new Error(`Expected type 'json', got '${data.type}'`);
-        }
-        return new JsonDataType();
-    }
-    toJson() {
-        return { type: "json" };
-    }
-}
-exports.JsonDataType = JsonDataType;
-exports._dataTypes["json"] = JsonDataType;
-class UuidDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "uuid") {
-            throw new Error(`Expected type 'uuid', got '${data.type}'`);
-        }
-        return new UuidDataType();
-    }
-    toJson() {
-        return { type: "uuid" };
-    }
-}
-exports.UuidDataType = UuidDataType;
-exports._dataTypes["uuid"] = UuidDataType;
-class BinaryDataType extends DataType {
-    constructor() {
-        super();
-    }
-    static fromJson(data) {
-        if (data.type !== "binary") {
-            throw new Error(`Expected type 'binary', got '${data.type}'`);
-        }
-        return new BinaryDataType();
-    }
-    toJson() {
-        return { type: "binary" };
-    }
-}
-exports.BinaryDataType = BinaryDataType;
-exports._dataTypes["binary"] = BinaryDataType;

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

@@ -1,281 +0,0 @@
-import { DataType } from "./data-types";
-import { RoomClient } from "./room-client";
-export type CreateMode = "create" | "overwrite" | "create_if_not_exists";
-export interface TableRef {
-    name: string;
-    namespace?: string[];
-    alias?: string;
-    branch?: string;
-    version?: number;
-}
-export interface TableVersion {
-    version: number;
-    timestamp: Date;
-    metadata: Record<string, unknown>;
-}
-export interface TableIndex {
-    name: string;
-    columns: string[];
-    type: string;
-}
-export interface TableBranch {
-    name: string;
-    parentBranch: string | null;
-    parentVersion: number | null;
-    createdAt: Date | null;
-    manifestSize: number | null;
-}
-export declare abstract class DatabaseValueEncoder {
-    abstract encodeDatabaseValue(): unknown;
-}
-export declare class DatabaseExpression extends DatabaseValueEncoder {
-    readonly expression: string;
-    constructor(expression: string);
-    encodeDatabaseValue(): Record<string, string>;
-    toString(): string;
-}
-export declare class DatabaseDate extends DatabaseValueEncoder {
-    readonly value: string;
-    constructor(value: string);
-    encodeDatabaseValue(): Record<string, string>;
-    toString(): string;
-}
-export type DatabaseJsonScalarValue = null | boolean | number | string;
-export type DatabaseJsonValue = DatabaseJsonScalarValue | DatabaseJsonValue[] | {
-    [key: string]: DatabaseJsonValue;
-};
-export declare class DatabaseStruct extends DatabaseValueEncoder {
-    readonly fields: Record<string, DatabaseValue>;
-    constructor(fields: Record<string, DatabaseValue>);
-    toJson(): Record<string, unknown>;
-    encodeDatabaseValue(): Record<string, Record<string, unknown>>;
-}
-export declare class DatabaseJson extends DatabaseValueEncoder {
-    readonly value: DatabaseJsonValue;
-    constructor(value: DatabaseJsonValue);
-    toJson(): DatabaseJsonValue;
-    encodeDatabaseValue(): Record<string, DatabaseJsonValue>;
-}
-export type DatabaseScalarValue = null | boolean | number | string | Uint8Array | DatabaseUuid | Date;
-export type DatabaseValue = DatabaseScalarValue | DatabaseValueEncoder | DatabaseValue[];
-export type DatabaseRecord = Record<string, DatabaseValue>;
-export type DatabaseRows = DatabaseRecord[];
-export type DatabaseRowChunks = AsyncIterable<DatabaseRows> | Iterable<DatabaseRows>;
-export type DatabaseWhere = string | Record<string, DatabaseValue>;
-type DatabaseRoomInvoker = Pick<RoomClient, "invoke" | "invokeStream">;
-export declare class DatabaseUuid {
-    readonly value: string;
-    constructor(value: string);
-    toString(): string;
-}
-export declare class DatabaseClient {
-    private room;
-    constructor({ room }: {
-        room: DatabaseRoomInvoker;
-    });
-    private _unexpectedResponseError;
-    private invoke;
-    private invokeStream;
-    private drainWriteStream;
-    private streamRows;
-    listTables({ namespace, branch }?: {
-        namespace?: string[];
-        branch?: string;
-    }): Promise<string[]>;
-    private createTable;
-    createTableWithSchema({ name, schema, data, mode, namespace, branch, metadata }: {
-        name: string;
-        schema?: Record<string, DataType>;
-        data?: DatabaseRows;
-        mode?: CreateMode;
-        namespace?: string[];
-        branch?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    createTableFromData({ name, data, mode, namespace, branch, metadata }: {
-        name: string;
-        data?: DatabaseRows;
-        mode?: CreateMode;
-        namespace?: string[];
-        branch?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    createTableFromDataStream({ name, chunks, schema, mode, namespace, branch, metadata }: {
-        name: string;
-        chunks: DatabaseRowChunks;
-        schema?: Record<string, DataType>;
-        mode?: CreateMode;
-        namespace?: string[];
-        branch?: string;
-        metadata?: Record<string, unknown>;
-    }): Promise<void>;
-    dropTable({ name, ignoreMissing, namespace, branch }: {
-        name: string;
-        ignoreMissing?: boolean;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    dropIndex({ table, name, namespace, branch }: {
-        table: string;
-        name: string;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    addColumns({ table, newColumns, namespace, branch }: {
-        table: string;
-        newColumns: Record<string, string | DataType>;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    dropColumns({ table, columns, namespace, branch }: {
-        table: string;
-        columns: string[];
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    insert({ table, records, namespace, branch }: {
-        table: string;
-        records: DatabaseRows;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    insertStream({ table, chunks, namespace, branch }: {
-        table: string;
-        chunks: DatabaseRowChunks;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    update({ table, where, values, namespace, branch }: {
-        table: string;
-        where: string;
-        values: DatabaseRecord;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    delete({ table, where, namespace, branch }: {
-        table: string;
-        where: string;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    merge({ table, on, records, namespace, branch }: {
-        table: string;
-        on: string;
-        records: DatabaseRows;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    mergeStream({ table, on, chunks, namespace, branch }: {
-        table: string;
-        on: string;
-        chunks: DatabaseRowChunks;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    sql({ query, tables, params }: {
-        query: string;
-        tables: Array<TableRef | string>;
-        params?: DatabaseRecord;
-    }): Promise<DatabaseRows>;
-    sqlStream({ query, tables, params }: {
-        query: string;
-        tables: Array<TableRef | string>;
-        params?: DatabaseRecord;
-    }): AsyncIterable<DatabaseRows>;
-    search({ table, text, vector, where, offset, limit, select, namespace, branch, version }: {
-        table: string;
-        text?: string;
-        vector?: number[];
-        where?: DatabaseWhere;
-        offset?: number;
-        limit?: number;
-        select?: string[];
-        namespace?: string[];
-        branch?: string;
-        version?: number;
-    }): Promise<DatabaseRows>;
-    searchStream({ table, text, vector, where, offset, limit, select, namespace, branch, version }: {
-        table: string;
-        text?: string;
-        vector?: number[];
-        where?: DatabaseWhere;
-        offset?: number;
-        limit?: number;
-        select?: string[];
-        namespace?: string[];
-        branch?: string;
-        version?: number;
-    }): AsyncIterable<DatabaseRows>;
-    count({ table, text, vector, where, namespace, branch, version }: {
-        table: string;
-        text?: string;
-        vector?: number[];
-        where?: DatabaseWhere;
-        namespace?: string[];
-        branch?: string;
-        version?: number;
-    }): Promise<number>;
-    inspect({ table, namespace, branch, version }: {
-        table: string;
-        namespace?: string[];
-        branch?: string;
-        version?: number;
-    }): Promise<Record<string, DataType>>;
-    optimize(table: string): Promise<void>;
-    optimize(params: {
-        table: string;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    restore({ table, version, namespace, branch }: {
-        table: string;
-        version: number;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    listVersions({ table, namespace, branch }: {
-        table: string;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<TableVersion[]>;
-    createVectorIndex({ table, column, replace, namespace, branch }: {
-        table: string;
-        column: string;
-        replace?: boolean;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    createScalarIndex({ table, column, replace, namespace, branch }: {
-        table: string;
-        column: string;
-        replace?: boolean;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    createFullTextSearchIndex({ table, column, replace, namespace, branch }: {
-        table: string;
-        column: string;
-        replace?: boolean;
-        namespace?: string[];
-        branch?: string;
-    }): Promise<void>;
-    listIndexes({ table, namespace, branch, version }: {
-        table: string;
-        namespace?: string[];
-        branch?: string;
-        version?: number;
-    }): Promise<TableIndex[]>;
-    listBranches({ namespace }?: {
-        namespace?: string[];
-    }): Promise<TableBranch[]>;
-    createBranch({ branch, fromBranch, namespace }: {
-        branch: string;
-        fromBranch?: string;
-        namespace?: string[];
-    }): Promise<void>;
-    deleteBranch({ branch, namespace }: {
-        branch: string;
-        namespace?: string[];
-    }): Promise<void>;
-}
-export {};