@meshagent/meshagent 0.36.3 → 0.37.0

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

@@ -5,6 +5,8 @@ export interface TableRef {
     name: string;
     namespace?: string[];
     alias?: string;
+    branch?: string;
+    version?: number;
 }
 export interface TableVersion {
     version: number;
@@ -16,7 +18,56 @@ export interface TableIndex {
     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 }: {
@@ -27,168 +78,204 @@ export declare class DatabaseClient {
     private invokeStream;
     private drainWriteStream;
     private streamRows;
-    listTables({ namespace }?: {
+    listTables({ namespace, branch }?: {
         namespace?: string[];
+        branch?: string;
     }): Promise<string[]>;
     private createTable;
-    createTableWithSchema({ name, schema, data, mode, namespace, metadata }: {
+    createTableWithSchema({ name, schema, data, mode, namespace, branch, metadata }: {
         name: string;
         schema?: Record<string, DataType>;
-        data?: Array<Record<string, any>>;
+        data?: DatabaseRows;
         mode?: CreateMode;
         namespace?: string[];
+        branch?: string;
         metadata?: Record<string, unknown>;
     }): Promise<void>;
-    createTableFromData({ name, data, mode, namespace, metadata }: {
+    createTableFromData({ name, data, mode, namespace, branch, metadata }: {
         name: string;
-        data?: Array<Record<string, any>>;
+        data?: DatabaseRows;
         mode?: CreateMode;
         namespace?: string[];
+        branch?: string;
         metadata?: Record<string, unknown>;
     }): Promise<void>;
-    createTableFromDataStream({ name, chunks, schema, mode, namespace, metadata }: {
+    createTableFromDataStream({ name, chunks, schema, mode, namespace, branch, metadata }: {
         name: string;
-        chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+        chunks: DatabaseRowChunks;
         schema?: Record<string, DataType>;
         mode?: CreateMode;
         namespace?: string[];
+        branch?: string;
         metadata?: Record<string, unknown>;
     }): Promise<void>;
-    dropTable({ name, ignoreMissing, namespace }: {
+    dropTable({ name, ignoreMissing, namespace, branch }: {
         name: string;
         ignoreMissing?: boolean;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    dropIndex({ table, name, namespace }: {
+    dropIndex({ table, name, namespace, branch }: {
         table: string;
         name: string;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    addColumns({ table, newColumns, namespace }: {
+    addColumns({ table, newColumns, namespace, branch }: {
         table: string;
         newColumns: Record<string, string | DataType>;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    dropColumns({ table, columns, namespace }: {
+    dropColumns({ table, columns, namespace, branch }: {
         table: string;
         columns: string[];
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    insert({ table, records, namespace }: {
+    insert({ table, records, namespace, branch }: {
         table: string;
-        records: Array<Record<string, any>>;
+        records: DatabaseRows;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    insertStream({ table, chunks, namespace }: {
+    insertStream({ table, chunks, namespace, branch }: {
         table: string;
-        chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+        chunks: DatabaseRowChunks;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    update({ table, where, values, valuesSql, namespace }: {
+    update({ table, where, values, namespace, branch }: {
         table: string;
         where: string;
-        values?: Record<string, any>;
-        valuesSql?: Record<string, string>;
+        values: DatabaseRecord;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    delete({ table, where, namespace }: {
+    delete({ table, where, namespace, branch }: {
         table: string;
         where: string;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    merge({ table, on, records, namespace }: {
+    merge({ table, on, records, namespace, branch }: {
         table: string;
         on: string;
-        records: Array<Record<string, any>>;
+        records: DatabaseRows;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    mergeStream({ table, on, chunks, namespace }: {
+    mergeStream({ table, on, chunks, namespace, branch }: {
         table: string;
         on: string;
-        chunks: AsyncIterable<Array<Record<string, any>>> | Iterable<Array<Record<string, any>>>;
+        chunks: DatabaseRowChunks;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
     sql({ query, tables, params }: {
         query: string;
         tables: Array<TableRef | string>;
-        params?: Record<string, any>;
-    }): Promise<Array<Record<string, any>>>;
+        params?: DatabaseRecord;
+    }): Promise<DatabaseRows>;
     sqlStream({ query, tables, params }: {
         query: string;
         tables: Array<TableRef | string>;
-        params?: Record<string, any>;
-    }): AsyncIterable<Array<Record<string, any>>>;
-    search({ table, text, vector, where, offset, limit, select, namespace }: {
+        params?: DatabaseRecord;
+    }): AsyncIterable<DatabaseRows>;
+    search({ table, text, vector, where, offset, limit, select, namespace, branch, version }: {
         table: string;
         text?: string;
         vector?: number[];
-        where?: string | Record<string, any>;
+        where?: DatabaseWhere;
         offset?: number;
         limit?: number;
         select?: string[];
         namespace?: string[];
-    }): Promise<Array<Record<string, any>>>;
-    searchStream({ table, text, vector, where, offset, limit, select, namespace }: {
+        branch?: string;
+        version?: number;
+    }): Promise<DatabaseRows>;
+    searchStream({ table, text, vector, where, offset, limit, select, namespace, branch, version }: {
         table: string;
         text?: string;
         vector?: number[];
-        where?: string | Record<string, any>;
+        where?: DatabaseWhere;
         offset?: number;
         limit?: number;
         select?: string[];
         namespace?: string[];
-    }): AsyncIterable<Array<Record<string, any>>>;
-    count({ table, text, vector, where, namespace }: {
+        branch?: string;
+        version?: number;
+    }): AsyncIterable<DatabaseRows>;
+    count({ table, text, vector, where, namespace, branch, version }: {
         table: string;
         text?: string;
         vector?: number[];
-        where?: string | Record<string, any>;
+        where?: DatabaseWhere;
         namespace?: string[];
+        branch?: string;
+        version?: number;
     }): Promise<number>;
-    inspect({ table, namespace }: {
+    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 }: {
+    restore({ table, version, namespace, branch }: {
         table: string;
         version: number;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    checkout({ table, version, namespace }: {
-        table: string;
-        version: number;
-        namespace?: string[];
-    }): Promise<void>;
-    listVersions({ table, namespace }: {
+    listVersions({ table, namespace, branch }: {
         table: string;
         namespace?: string[];
+        branch?: string;
     }): Promise<TableVersion[]>;
-    createVectorIndex({ table, column, replace, namespace }: {
+    createVectorIndex({ table, column, replace, namespace, branch }: {
         table: string;
         column: string;
         replace?: boolean;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    createScalarIndex({ table, column, replace, namespace }: {
+    createScalarIndex({ table, column, replace, namespace, branch }: {
         table: string;
         column: string;
         replace?: boolean;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    createFullTextSearchIndex({ table, column, replace, namespace }: {
+    createFullTextSearchIndex({ table, column, replace, namespace, branch }: {
         table: string;
         column: string;
         replace?: boolean;
         namespace?: string[];
+        branch?: string;
     }): Promise<void>;
-    listIndexes({ table, namespace }: {
+    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 {};