@meshagent/meshagent 0.38.4 → 0.39.1

package/dist/node/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/node/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 {};