@meshagent/meshagent 0.44.13 → 0.45.1

package/dist/esm/services-client.js

@@ -15,6 +15,7 @@ function parseServiceRuntimeState(value) {
     }
     const state = value["state"];
     const containerId = value["container_id"];
+    const eventsRaw = value["events"];
     return {
         serviceId: value["service_id"],
         state: typeof state === "string" ? state : "unknown",
@@ -24,6 +25,22 @@ function parseServiceRuntimeState(value) {
         restartCount: toOptionalInteger(value["restart_count"]) ?? 0,
         lastExitCode: toOptionalInteger(value["last_exit_code"]),
         lastExitAt: toOptionalNumber(value["last_exit_at"]),
+        lastStartError: typeof value["last_start_error"] === "string" ? value["last_start_error"] : undefined,
+        lastStartErrorAt: toOptionalNumber(value["last_start_error_at"]),
+        events: Array.isArray(eventsRaw) ? eventsRaw.map((event) => parseServiceRuntimeEvent(event)) : [],
+    };
+}
+function parseServiceRuntimeEvent(value) {
+    if (!isRecord(value)) {
+        throw new RoomServerException("unexpected return type from services.list");
+    }
+    return {
+        type: typeof value["type"] === "string" ? value["type"] : "Normal",
+        reason: typeof value["reason"] === "string" ? value["reason"] : "Unknown",
+        message: typeof value["message"] === "string" ? value["message"] : "",
+        count: toOptionalInteger(value["count"]) ?? 1,
+        firstTimestamp: toOptionalNumber(value["first_timestamp"]) ?? 0,
+        lastTimestamp: toOptionalNumber(value["last_timestamp"]) ?? 0,
     };
 }
 function parseServiceSpecJson(value) {

package/dist/esm/sqlite-client.d.ts

@@ -0,0 +1,326 @@
+import { Schema, Table } from "apache-arrow";
+import { RoomClient } from "./room-client.js";
+import { DatasetRecord, DatasetValue } from "./datasets-client.js";
+export type SqliteCreateMode = "create" | "overwrite" | "create_if_not_exists";
+export type SqliteWhere = string | Record<string, DatasetValue>;
+export type SqliteSqlCancelStatus = "cancelled" | "cancelling" | "not_cancellable";
+export interface SqliteDatabaseDetails {
+    name: string;
+    namespace: string[] | null;
+    tables: number;
+    sizeBytes: number;
+}
+export interface SqliteSqlQuery {
+    kind: "query";
+    schema: Schema;
+    queryId: string;
+}
+export interface SqliteSqlStatement {
+    kind: "statement";
+    rowsAffected: number;
+}
+export type SqliteSqlExecution = SqliteSqlQuery | SqliteSqlStatement;
+export interface SqliteSqlCancelResult {
+    status: SqliteSqlCancelStatus;
+}
+type SqliteRoomInvoker = Pick<RoomClient, "invokeContent" | "invokeStream">;
+type ArrowTableChunks = Iterable<Table> | AsyncIterable<Table>;
+export declare class SqliteDatabaseClient {
+    private readonly client;
+    readonly database: string;
+    readonly namespace?: string[] | undefined;
+    constructor(client: SqliteClient, database: string, namespace?: string[] | undefined);
+    createDatabase({ mode }?: {
+        mode?: SqliteCreateMode;
+    }): Promise<void>;
+    dropDatabase({ ignoreMissing }?: {
+        ignoreMissing?: boolean;
+    }): Promise<void>;
+    inspectDatabase(): Promise<SqliteDatabaseDetails>;
+    listTables(): Promise<string[]>;
+    createTableWithSchema(params: {
+        name: string;
+        schema?: Schema;
+        data?: Iterable<Table> | Table;
+        mode?: SqliteCreateMode;
+    }): Promise<void>;
+    createTableFromData(params: {
+        name: string;
+        data?: Iterable<Table> | Table;
+        mode?: SqliteCreateMode;
+    }): Promise<void>;
+    dropTable(params: {
+        name: string;
+        ignoreMissing?: boolean;
+    }): Promise<void>;
+    renameTable(params: {
+        name: string;
+        newName: string;
+    }): Promise<void>;
+    inspect(params: {
+        table: string;
+    }): Promise<Schema>;
+    addColumns(params: {
+        table: string;
+        newColumns: Schema;
+    }): Promise<void>;
+    dropColumns(params: {
+        table: string;
+        columns: string[];
+    }): Promise<void>;
+    insert(params: {
+        table: string;
+        records: Table;
+    }): Promise<void>;
+    update(params: {
+        table: string;
+        where: string;
+        values: DatasetRecord;
+        params?: unknown;
+    }): Promise<number>;
+    delete(params: {
+        table: string;
+        where: string;
+        params?: unknown;
+    }): Promise<number>;
+    search(params: {
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+    }): Promise<Table[]>;
+    searchTable(params: {
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+    }): Promise<Table>;
+    searchStream(params: {
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+    }): Promise<AsyncIterable<Table>>;
+    count(params: {
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+    }): Promise<number>;
+    sql(params: {
+        query: string;
+        params?: unknown;
+    }): Promise<Table[]>;
+    sqlTable(params: {
+        query: string;
+        params?: unknown;
+    }): Promise<Table>;
+    sqlStream(params: {
+        query: string;
+        params?: unknown;
+    }): AsyncIterable<Table>;
+    executeSql(params: {
+        query: string;
+        params?: unknown;
+    }): Promise<SqliteSqlExecution>;
+    executeSqlStatement(params: {
+        query: string;
+        params?: unknown;
+    }): Promise<number>;
+}
+export declare class SqliteClient {
+    private readonly room;
+    constructor({ room }: {
+        room: SqliteRoomInvoker;
+    });
+    private unexpectedResponseError;
+    database(name: string, { namespace }?: {
+        namespace?: string[];
+    }): SqliteDatabaseClient;
+    private invoke;
+    private invokeContent;
+    private invokeStream;
+    private drainWriteStream;
+    private streamArrow;
+    listDatabases({ namespace }?: {
+        namespace?: string[];
+    }): Promise<string[]>;
+    createDatabase({ name, namespace, mode }: {
+        name: string;
+        namespace?: string[];
+        mode?: SqliteCreateMode;
+    }): Promise<void>;
+    dropDatabase({ name, namespace, ignoreMissing }: {
+        name: string;
+        namespace?: string[];
+        ignoreMissing?: boolean;
+    }): Promise<void>;
+    inspectDatabase({ name, namespace }: {
+        name: string;
+        namespace?: string[];
+    }): Promise<SqliteDatabaseDetails>;
+    listTables({ database, namespace }: {
+        database: string;
+        namespace?: string[];
+    }): Promise<string[]>;
+    private createTable;
+    createTableWithSchema({ database, name, schema, data, mode, namespace }: {
+        database: string;
+        name: string;
+        schema?: Schema;
+        data?: Iterable<Table> | Table;
+        mode?: SqliteCreateMode;
+        namespace?: string[];
+    }): Promise<void>;
+    createTableFromData({ database, name, data, mode, namespace }: {
+        database: string;
+        name: string;
+        data?: Iterable<Table> | Table;
+        mode?: SqliteCreateMode;
+        namespace?: string[];
+    }): Promise<void>;
+    dropTable({ database, name, ignoreMissing, namespace }: {
+        database: string;
+        name: string;
+        ignoreMissing?: boolean;
+        namespace?: string[];
+    }): Promise<void>;
+    renameTable({ database, name, newName, namespace }: {
+        database: string;
+        name: string;
+        newName: string;
+        namespace?: string[];
+    }): Promise<void>;
+    inspect({ database, table, namespace }: {
+        database: string;
+        table: string;
+        namespace?: string[];
+    }): Promise<Schema>;
+    addColumns({ database, table, newColumns, namespace }: {
+        database: string;
+        table: string;
+        newColumns: Schema;
+        namespace?: string[];
+    }): Promise<void>;
+    dropColumns({ database, table, columns, namespace }: {
+        database: string;
+        table: string;
+        columns: string[];
+        namespace?: string[];
+    }): Promise<void>;
+    insert({ database, table, records, namespace }: {
+        database: string;
+        table: string;
+        records: Table;
+        namespace?: string[];
+    }): Promise<void>;
+    insertStream({ database, table, chunks, namespace }: {
+        database: string;
+        table: string;
+        chunks: ArrowTableChunks;
+        namespace?: string[];
+    }): Promise<void>;
+    update({ database, table, where, values, params, namespace }: {
+        database: string;
+        table: string;
+        where: string;
+        values: DatasetRecord;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<number>;
+    delete({ database, table, where, params, namespace }: {
+        database: string;
+        table: string;
+        where: string;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<number>;
+    search({ database, table, where, params, offset, limit, select, namespace }: {
+        database: string;
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+        namespace?: string[];
+    }): Promise<Table[]>;
+    searchTable({ database, table, where, params, offset, limit, select, namespace }: {
+        database: string;
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+        namespace?: string[];
+    }): Promise<Table>;
+    searchStream({ database, table, where, params, offset, limit, select, namespace }: {
+        database: string;
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        offset?: number;
+        limit?: number;
+        select?: string[];
+        namespace?: string[];
+    }): AsyncIterable<Table>;
+    count({ database, table, where, params, namespace }: {
+        database: string;
+        table: string;
+        where?: SqliteWhere;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<number>;
+    sql({ database, query, params, namespace }: {
+        database: string;
+        query: string;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<Table[]>;
+    sqlTable({ database, query, params, namespace }: {
+        database: string;
+        query: string;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<Table>;
+    openSqlQuery({ database, query, params, namespace }: {
+        database: string;
+        query: string;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<SqliteSqlQuery>;
+    executeSql({ database, query, params, namespace }: {
+        database: string;
+        query: string;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<SqliteSqlExecution>;
+    sqlStream({ database, query, params, namespace }: {
+        database: string;
+        query: string;
+        params?: unknown;
+        namespace?: string[];
+    }): AsyncIterable<Table>;
+    readSqlQuery({ queryId }: {
+        queryId: string;
+    }): AsyncIterable<Table>;
+    closeSqlQuery({ queryId }: {
+        queryId: string;
+    }): Promise<void>;
+    cancelSqlQuery({ queryId }: {
+        queryId: string;
+    }): Promise<SqliteSqlCancelResult>;
+    executeSqlStatement({ database, query, params, namespace }: {
+        database: string;
+        query: string;
+        params?: unknown;
+        namespace?: string[];
+    }): Promise<number>;
+}
+export {};