@meshagent/meshagent 0.0.11 → 0.0.12

package/dist/node/data-types.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextDataType = exports.VectorDataType = exports.FloatDataType = exports.DateDataType = exports.IntDataType = 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();
+    }
+}
+exports.DataType = DataType;
+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;

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

@@ -0,0 +1,77 @@
+import { RoomClient } from "./room-client";
+import { DataType } from "./data-types";
+export type CreateMode = "create" | "overwrite" | "create_if_not_exists";
+export declare class DatabaseClient {
+    private room;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    listTables(): Promise<string[]>;
+    private createTable;
+    createTableWithSchema({ name, schema, data, mode }: {
+        name: string;
+        schema?: Record<string, DataType>;
+        data?: Array<Record<string, any>>;
+        mode?: CreateMode;
+    }): Promise<void>;
+    createTableFromData({ name, data, mode }: {
+        name: string;
+        data?: Array<Record<string, any>>;
+        mode?: CreateMode;
+    }): Promise<void>;
+    dropTable({ name, ignoreMissing }: {
+        name: string;
+        ignoreMissing?: boolean;
+    }): Promise<void>;
+    addColumns({ table, newColumns }: {
+        table: string;
+        newColumns: Record<string, string>;
+    }): Promise<void>;
+    dropColumns({ table, columns }: {
+        table: string;
+        columns: string[];
+    }): Promise<void>;
+    insert({ table, records }: {
+        table: string;
+        records: Array<Record<string, any>>;
+    }): Promise<void>;
+    update({ table, where, values, valuesSql }: {
+        table: string;
+        where: string;
+        values?: Record<string, any>;
+        valuesSql?: Record<string, string>;
+    }): Promise<void>;
+    delete({ table, where }: {
+        table: string;
+        where: string;
+    }): Promise<void>;
+    merge({ table, on, records }: {
+        table: string;
+        on: string;
+        records: any;
+    }): Promise<void>;
+    search({ table, text, vector, where, limit, select }: {
+        table: string;
+        text?: string;
+        vector?: number[];
+        where?: string | Record<string, any>;
+        limit?: number;
+        select?: string[];
+    }): Promise<Array<Record<string, any>>>;
+    optimize(table: string): Promise<void>;
+    createVectorIndex({ table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    createScalarIndex({ table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    createFullTextSearchIndex({ table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    listIndexes({ table }: {
+        table: string;
+    }): Promise<Record<string, any>>;
+}

package/dist/node/database-client.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseClient = void 0;
+const response_1 = require("./response");
+class DatabaseClient {
+    constructor({ room }) {
+        this.room = room;
+    }
+    async listTables() {
+        const response = await this.room.sendRequest("database.list_tables", {});
+        return response?.json?.tables ?? [];
+    }
+    async createTable({ name, data, schema, mode = "create" }) {
+        let schemaDict;
+        if (schema) {
+            schemaDict = {};
+            for (const [key, value] of Object.entries(schema)) {
+                schemaDict[key] = value.toJson();
+            }
+        }
+        const payload = {
+            name,
+            data,
+            schema: schemaDict,
+            mode,
+        };
+        await this.room.sendRequest("database.create_table", payload);
+    }
+    async createTableWithSchema({ name, schema, data, mode = "create" }) {
+        return this.createTable({ name, schema, data, mode });
+    }
+    async createTableFromData({ name, data, mode = "create" }) {
+        return this.createTable({ name, data, mode });
+    }
+    async dropTable({ name, ignoreMissing = false }) {
+        await this.room.sendRequest("database.drop_table", { name, ignoreMissing });
+    }
+    async addColumns({ table, newColumns }) {
+        await this.room.sendRequest("database.add_columns", {
+            table,
+            new_columns: newColumns
+        });
+    }
+    async dropColumns({ table, columns }) {
+        await this.room.sendRequest("database.drop_columns", { table, columns });
+    }
+    async insert({ table, records }) {
+        await this.room.sendRequest("database.insert", { table, records });
+    }
+    async update({ table, where, values, valuesSql }) {
+        const payload = {
+            table,
+            where,
+            values,
+            valuesSql,
+        };
+        await this.room.sendRequest("database.update", payload);
+    }
+    async delete({ table, where }) {
+        await this.room.sendRequest("database.delete", { table, where });
+    }
+    async merge({ table, on, records }) {
+        await this.room.sendRequest("database.merge", { table, on, records });
+    }
+    async search({ table, text, vector, where, limit, select }) {
+        let whereClause = where;
+        if (where && typeof where === "object" && !Array.isArray(where)) {
+            const parts = [];
+            for (const [key, value] of Object.entries(where)) {
+                parts.push(`${key} = ${JSON.stringify(value)}`);
+            }
+            whereClause = parts.join(" AND ");
+        }
+        const payload = {
+            table,
+            where: whereClause,
+            text,
+        };
+        if (limit !== undefined) {
+            payload.limit = limit;
+        }
+        if (select !== undefined) {
+            payload.select = select;
+        }
+        if (vector !== undefined) {
+            payload.vector = vector;
+        }
+        const response = await this.room.sendRequest("database.search", payload);
+        if (response instanceof response_1.JsonResponse) {
+            if (response?.json?.results) {
+                return response.json.results;
+            }
+        }
+        return [];
+    }
+    async optimize(table) {
+        await this.room.sendRequest("database.optimize", { table });
+    }
+    async createVectorIndex({ table, column }) {
+        await this.room.sendRequest("database.create_vector_index", { table, column });
+    }
+    async createScalarIndex({ table, column }) {
+        await this.room.sendRequest("database.create_scalar_index", { table, column });
+    }
+    async createFullTextSearchIndex({ table, column }) {
+        await this.room.sendRequest("database.create_full_text_search_index", { table, column });
+    }
+    async listIndexes({ table }) {
+        const response = await this.room.sendRequest("database.list_indexes", { table });
+        return response?.json ?? {};
+    }
+}
+exports.DatabaseClient = DatabaseClient;

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

@@ -0,0 +1,13 @@
+import { EventEmitter } from "./event-emitter";
+import { RoomClient } from "./room-client";
+import { RoomLogEvent } from "./room-event";
+export declare class DeveloperClient extends EventEmitter<RoomLogEvent> {
+    private client;
+    constructor({ room }: {
+        room: RoomClient;
+    });
+    private _handleDeveloperLog;
+    log(type: string, data: Record<string, any>): Promise<void>;
+    enable(): Promise<void>;
+    disable(): Promise<void>;
+}

package/dist/node/developer-client.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeveloperClient = void 0;
+const event_emitter_1 = require("./event-emitter");
+const utils_1 = require("./utils");
+const room_event_1 = require("./room-event");
+class DeveloperClient extends event_emitter_1.EventEmitter {
+    constructor({ room }) {
+        super();
+        this.client = room;
+        this.client.protocol.addHandler("developer.log", this._handleDeveloperLog.bind(this));
+    }
+    async _handleDeveloperLog(protocol, messageId, type, bytes) {
+        const rawJson = JSON.parse(utils_1.decoder.decode(bytes || new Uint8Array()));
+        const event = new room_event_1.RoomLogEvent({
+            type: rawJson["type"],
+            data: rawJson["data"],
+        });
+        this.client.emit(event);
+        this.emit("log", event);
+    }
+    async log(type, data) {
+        const message = (0, utils_1.packMessage)({ type, data }, undefined);
+        await this.client.protocol.send("developer.log", message);
+    }
+    async enable() {
+        const message = (0, utils_1.packMessage)({}, undefined);
+        await this.client.protocol.send("developer.watch", message);
+    }
+    async disable() {
+        const message = (0, utils_1.packMessage)({}, undefined);
+        await this.client.protocol.send("developer.unwatch", message);
+    }
+}
+exports.DeveloperClient = DeveloperClient;

package/dist/node/document.d.ts

@@ -0,0 +1,84 @@
+import { MeshSchema, ElementType } from "./schema";
+import { EventEmitter } from "./event-emitter";
+export interface RuntimeDocumentEvent {
+    type: string;
+    doc: RuntimeDocument;
+}
+export declare class RuntimeDocument extends EventEmitter<RuntimeDocumentEvent> {
+    readonly id: string;
+    readonly schema: MeshSchema;
+    readonly sendChanges: (changes: Record<string, any>) => void;
+    readonly sendChangesToBackend?: (msg: string) => void;
+    private _changeSubscribers;
+    constructor({ id, schema, sendChanges, sendChangesToBackend }: {
+        id: string;
+        schema: MeshSchema;
+        sendChanges: (changes: Record<string, any>) => void;
+        sendChangesToBackend?: (msg: string) => void;
+    });
+    listen(onData: (data: Record<string, any>) => void): {
+        unsubscribe: () => void;
+    };
+    private _root?;
+    get root(): Element;
+    private _createNode;
+    receiveChanges(message: Record<string, any>): void;
+}
+export interface NodeEvent {
+    type: string;
+    node: Node;
+}
+export declare class Node extends EventEmitter<NodeEvent> {
+    parent: Element | null;
+    doc: RuntimeDocument;
+    constructor({ parent, doc }: {
+        parent: Element | null;
+        doc: RuntimeDocument;
+    });
+}
+export declare class Element extends Node {
+    tagName: string;
+    attributes: Record<string, any>;
+    elementType: ElementType;
+    children: Node[];
+    constructor({ parent, tagName, attributes, doc, elementType }: {
+        parent: Element | null;
+        tagName: string;
+        attributes: Record<string, any>;
+        doc: RuntimeDocument;
+        elementType: ElementType;
+    });
+    getNodeByID(id: string): Element | null;
+    get id(): string | undefined;
+    getAttribute(name: string): any;
+    setAttribute(name: string, value: any): void;
+    removeAttribute(name: string): void;
+    private _ensureChildValid;
+    private _validateElementAttributes;
+    createChildElement(tagName: string, attributes: Record<string, any>, opts?: {
+        id?: string;
+    }): Element;
+    createChildElementAt(index: number, tagName: string, attributes: Record<string, any>, opts?: {
+        id?: string;
+    }): Element;
+    createChildElementAfter(element: Element, tagName: string, attributes: Record<string, any>, opts?: {
+        id?: string;
+    }): Element;
+    private _defaultChildren;
+    delete(): void;
+    getChildren(): Node[];
+    appendJson(json: Record<string, any>): Element;
+}
+export declare class TextElement extends Node {
+    delta: Array<Record<string, any>>;
+    constructor({ parent, delta, doc }: {
+        parent: Element;
+        delta: Array<Record<string, any>>;
+        doc: RuntimeDocument;
+    });
+    insert(index: number, text: string, attributes?: Record<string, any>): void;
+    format(from: number, length: number, attributes: Record<string, any>): void;
+    delete(index: number, length: number): void;
+}
+export declare function tagNameFromJson(json: Record<string, any>): string;
+export declare function attributesFromJson(json: Record<string, any>): Record<string, any>;