@fadhilp/stateql 0.9.0 → 0.10.0

package/dist/src/mongodb.js

@@ -257,7 +257,7 @@ export class MongoAdapter {
             throw new AdapterWriteError(errorText(error), knownNoWrite(error) ? false : true);
         }
     }
-    async writeBatch(commands, isolation) {
+    async writeBatch(commands, isolation, expectedRows = false) {
         if (isolation.toLowerCase() !== "snapshot") {
             throw new BatchWriteError(`Unsupported MongoDB isolation level "${isolation}".`, false);
         }
@@ -295,7 +295,10 @@ export class MongoAdapter {
             for (const command of values) {
                 throwIfStopped(this.context, dispatched);
                 dispatched = true;
-                results.push(await withContext(this.executeWrite(command, session), this.context, () => this.stop(), true));
+                const result = await withContext(this.executeWrite(command, session), this.context, () => this.stop(), true);
+                if (expectedRows && result.outcome.matched_count !== 1)
+                    throw new Error("ROW_CONFLICT: A document changed or was removed.");
+                results.push(result);
             }
             throwIfStopped(this.context, dispatched);
             committing = true;
@@ -373,6 +376,51 @@ export class MongoAdapter {
             throw readError(error, this.context);
         }
     }
+    async listObjects(filter) {
+        if (filter.kind !== undefined && filter.kind !== "collection" && filter.kind !== "view")
+            throw new Error(`MongoDB does not support catalog kind "${filter.kind}".`);
+        if (filter.schema !== undefined)
+            throw new Error("MongoDB collections do not use schemas.");
+        const offset = filter.offset ?? 0;
+        const limit = filter.limit ?? 50;
+        if (typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0 || offset > 1_000_000 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200)
+            throw new Error("Invalid MongoDB catalog page bounds.");
+        if (filter.search !== undefined && (!filter.search || filter.search.length > 200 || filter.search.includes("\0")))
+            throw new Error("Invalid MongoDB catalog search.");
+        await this.connect();
+        const query = {};
+        if (filter.kind === "collection")
+            query.type = "collection";
+        if (filter.kind === "view")
+            query.type = "view";
+        const cursor = this.client.db(this.databaseName).listCollections(query, {
+            nameOnly: true,
+            signal: operationSignal(this.context),
+            maxTimeMS: remainingMilliseconds(this.context),
+            timeoutMS: remainingMilliseconds(this.context),
+            batchSize: Math.min(limit + 1, 201),
+        });
+        const fetched = await collectCursor(cursor, offset + limit + 1, this.context);
+        const rows = fetched.slice(offset);
+        const more = rows.length > limit;
+        return {
+            objects: rows.slice(0, limit).map((row) => ({ kind: row.type === "view" ? "view" : "collection", name: String(row.name), identity: String(row.name) })),
+            next_offset: more ? offset + limit : null,
+            supported_kinds: ["collection", "view"],
+        };
+    }
+    async describeObject(object) {
+        if ((object.kind !== "collection" && object.kind !== "view") || object.schema !== undefined)
+            throw new Error(`MongoDB does not support catalog kind "${object.kind}".`);
+        const rows = await collectCursor(this.client.db(this.databaseName).listCollections({ name: object.name }, { nameOnly: false, signal: operationSignal(this.context), maxTimeMS: remainingMilliseconds(this.context), timeoutMS: remainingMilliseconds(this.context), batchSize: 1 }), 1, this.context);
+        const found = rows[0];
+        if (!found)
+            throw new Error("Catalog object was not found.");
+        return ejsonSafe({
+            object: { kind: found.type === "view" ? "view" : "collection", name: found.name, identity: found.name },
+            definition: { type: found.type, options: found.options ?? {} },
+        });
+    }
     async close() {
         if (this.closed)
             return;
@@ -786,6 +834,9 @@ function ejsonSafe(value) {
         return null;
     return JSON.parse(BSON.EJSON.stringify(value, { relaxed: false }));
 }
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function remainingMilliseconds(context) {
     return Math.max(1, Math.min(2_147_483_647, Math.ceil(context.deadline - Date.now())));
 }

package/dist/src/redis.d.ts

@@ -0,0 +1,44 @@
+import { type AdapterContext } from "./adapters.js";
+import type { CatalogObject, DescribeObjectData, ListObjectsData, ListObjectsFilter, RedisCommand, RedisWriteOutcome, Row, Column } from "./types.js";
+export interface RedisReadResult {
+    rows: Row[];
+    columns: Column[];
+    nextCursor?: string | null;
+}
+export interface RedisPrecondition {
+    key: string;
+    fingerprint: string;
+    /** Absolute expiry in epoch milliseconds, or Redis -1/-2 sentinel. */
+    expiresAt: number;
+}
+export interface RedisWriteResult {
+    affectedRows: number;
+    outcome: RedisWriteOutcome;
+}
+export declare function validateRedisReadCommand(value: unknown): RedisCommand;
+export declare function validateRedisWriteCommand(value: unknown): RedisCommand;
+export declare function serializeRedisCommand(command: RedisCommand): string;
+export declare function deserializeRedisCommand(value: string): RedisCommand;
+export declare class RedisAdapter {
+    private readonly readOnly;
+    private readonly context;
+    readonly confidence: "ttl_based";
+    private readonly client;
+    private connected;
+    private closed;
+    constructor(source: string, readOnly: boolean, context: AdapterContext);
+    ping(): Promise<void>;
+    signature(): Promise<string>;
+    read(input: RedisCommand): Promise<RedisReadResult>;
+    precondition(input: RedisCommand): Promise<RedisPrecondition>;
+    write(input: RedisCommand, precondition?: RedisPrecondition): Promise<RedisWriteResult>;
+    listObjects(filter: ListObjectsFilter): Promise<ListObjectsData>;
+    describeObject(object: CatalogObject): Promise<DescribeObjectData>;
+    close(): Promise<void>;
+    private scanValue;
+    private expirationIdentity;
+    private keyFingerprint;
+    private connect;
+    private execute;
+    private stop;
+}

package/dist/src/redis.js

@@ -0,0 +1,395 @@
+import { createClient, RESP_TYPES, WatchError } from "@redis/client";
+import { AdapterExecutionError, AdapterWriteError } from "./adapters.js";
+import { hash, toJsonSafe } from "./util.js";
+const MAX_ARGUMENTS = 100;
+const MAX_ARGUMENT_BYTES = 256 * 1024;
+const MAX_RESPONSE_BYTES = 1024 * 1024;
+const MAX_COLLECTION_VALUES = 200;
+const READ_COMMANDS = new Set([
+    "GET", "MGET", "TYPE", "EXISTS", "TTL", "PTTL", "HGET", "HMGET",
+    "LRANGE", "SCAN", "HSCAN", "SSCAN", "ZSCAN",
+]);
+const WRITE_COMMANDS = new Set([
+    "SET", "DEL", "HSET", "HDEL", "LPUSH", "RPUSH", "SADD", "SREM", "ZADD", "ZREM",
+]);
+export function validateRedisReadCommand(value) {
+    const command = validateCommandShape(value);
+    if (!READ_COMMANDS.has(command.command)) {
+        throw new Error(`Unsupported Redis read command "${command.command}".`);
+    }
+    const args = command.args ?? [];
+    switch (command.command) {
+        case "GET":
+        case "TYPE":
+        case "TTL":
+        case "PTTL":
+            requireCount(args, 1);
+            break;
+        case "MGET":
+        case "EXISTS":
+            requireRange(args, 1, MAX_ARGUMENTS);
+            break;
+        case "HGET":
+            requireCount(args, 2);
+            break;
+        case "HMGET":
+            requireRange(args, 2, MAX_ARGUMENTS + 1);
+            break;
+        case "LRANGE":
+            requireCount(args, 3);
+            boundedRange(args[1], args[2]);
+            break;
+        case "SCAN":
+            validateScanArgs(args, false);
+            break;
+        case "HSCAN":
+        case "SSCAN":
+        case "ZSCAN":
+            validateScanArgs(args, true);
+            break;
+    }
+    return command;
+}
+export function validateRedisWriteCommand(value) {
+    const command = validateCommandShape(value);
+    if (!WRITE_COMMANDS.has(command.command)) {
+        throw new Error(`Unsupported Redis write command "${command.command}".`);
+    }
+    const args = command.args ?? [];
+    switch (command.command) {
+        case "SET":
+            requireCount(args, 2);
+            break;
+        case "DEL":
+            requireCount(args, 1);
+            break;
+        case "HSET":
+            requireCount(args, 3);
+            break;
+        case "HDEL":
+            requireCount(args, 2);
+            break;
+        case "LPUSH":
+        case "RPUSH":
+        case "SADD":
+        case "SREM":
+        case "ZREM":
+            requireCount(args, 2);
+            break;
+        case "ZADD":
+            requireCount(args, 3);
+            if (!Number.isFinite(Number(args[1])))
+                throw new Error("Redis ZADD score must be finite.");
+            break;
+    }
+    return command;
+}
+export function serializeRedisCommand(command) {
+    return JSON.stringify({ command: command.command.toUpperCase(), args: command.args ?? [] });
+}
+export function deserializeRedisCommand(value) {
+    try {
+        return validateRedisWriteCommand(JSON.parse(value));
+    }
+    catch {
+        throw new Error("Stored Redis command is invalid.");
+    }
+}
+export class RedisAdapter {
+    readOnly;
+    context;
+    confidence = "ttl_based";
+    client;
+    connected = false;
+    closed = false;
+    constructor(source, readOnly, context) {
+        this.readOnly = readOnly;
+        this.context = context;
+        this.client = createClient({
+            url: source,
+            socket: {
+                connectTimeout: remainingMilliseconds(context),
+                reconnectStrategy: false,
+            },
+        });
+        this.client.on("error", () => undefined);
+    }
+    async ping() {
+        await this.connect();
+        await this.execute(["PING"], false);
+    }
+    async signature() {
+        throwIfStopped(this.context, false);
+        return "redis:watched-key";
+    }
+    async read(input) {
+        const command = validateRedisReadCommand(input);
+        await this.connect();
+        const raw = await this.execute([command.command, ...(command.args ?? [])], false);
+        const bytes = Buffer.byteLength(JSON.stringify(toJsonSafe(raw)), "utf8");
+        if (bytes > MAX_RESPONSE_BYTES)
+            throw new Error("Redis response exceeds the 1 MiB materialization limit.");
+        return redisRows(command, raw);
+    }
+    async precondition(input) {
+        const command = validateRedisWriteCommand(input);
+        await this.connect();
+        const key = command.args[0];
+        const [fingerprint, expiresAt] = await Promise.all([this.keyFingerprint(key), this.expirationIdentity(key)]);
+        return { key, fingerprint, expiresAt };
+    }
+    async write(input, precondition) {
+        const command = validateRedisWriteCommand(input);
+        if (this.readOnly)
+            throw new AdapterWriteError("Connection is read-only.", false);
+        await this.connect();
+        const key = command.args[0];
+        if (precondition && precondition.key !== key) {
+            throw new AdapterWriteError("Redis plan key does not match its command.", false);
+        }
+        let dispatched = false;
+        try {
+            let raw;
+            if (precondition) {
+                await this.execute(["WATCH", key], false);
+                const [fingerprint, expiresAt] = await Promise.all([this.keyFingerprint(key), this.expirationIdentity(key)]);
+                const expiryChanged = precondition.expiresAt < 0
+                    ? expiresAt !== precondition.expiresAt
+                    : expiresAt < 0 || Math.abs(expiresAt - precondition.expiresAt) > 2_000;
+                if (fingerprint !== precondition.fingerprint || expiryChanged) {
+                    await this.execute(["UNWATCH"], false).catch(() => undefined);
+                    throw new AdapterWriteError("ROW_CONFLICT: The Redis key changed. Reload before editing.", false);
+                }
+                const transaction = this.client.multi();
+                transaction.addCommand([command.command, ...(command.args ?? [])]);
+                dispatched = true;
+                const result = await withDeadline(transaction.exec(), this.context, true, () => this.stop());
+                if (result === null)
+                    throw new AdapterWriteError("ROW_CONFLICT: The Redis key changed. Reload before editing.", false);
+                raw = result[0];
+            }
+            else {
+                dispatched = true;
+                raw = await this.execute([command.command, ...(command.args ?? [])], true);
+            }
+            if (raw instanceof Error)
+                throw new AdapterWriteError(raw.message, false);
+            const normalized = normalizeScalar(raw);
+            return {
+                affectedRows: redisAffectedRows(command.command, normalized),
+                outcome: { acknowledged: true, result: normalized },
+            };
+        }
+        catch (error) {
+            if (error instanceof AdapterWriteError)
+                throw error;
+            if (error instanceof WatchError)
+                throw new AdapterWriteError("ROW_CONFLICT: The Redis key changed. Reload before editing.", false);
+            if (error instanceof AdapterExecutionError)
+                throw error;
+            throw new AdapterWriteError(errorText(error), dispatched);
+        }
+    }
+    async listObjects(filter) {
+        if (filter.kind !== undefined && filter.kind !== "key")
+            throw new Error(`Redis does not support catalog kind "${filter.kind}".`);
+        if (filter.schema !== undefined)
+            throw new Error("Redis keys do not have schemas.");
+        const cursor = filter.offset === undefined ? "0" : String(filter.offset);
+        if (!/^\d+$/.test(cursor))
+            throw new Error("Redis offset must be an opaque numeric SCAN cursor.");
+        const limit = boundedLimit(filter.limit);
+        const args = [cursor];
+        if (filter.search)
+            args.push("MATCH", `*${escapeGlob(filter.search)}*`);
+        args.push("COUNT", String(limit));
+        const result = await this.read({ command: "SCAN", args });
+        if (result.rows.length > MAX_COLLECTION_VALUES)
+            throw new Error("Redis SCAN page exceeded the hard response bound; retry with a smaller COUNT.");
+        return {
+            objects: result.rows.map((row) => ({ kind: "key", name: String(row.key), identity: String(row.key) })),
+            next_offset: result.nextCursor ?? null,
+            supported_kinds: ["key"],
+        };
+    }
+    async describeObject(object) {
+        if (object.kind !== "key" || !object.name || object.schema !== undefined)
+            throw new Error("Redis describeObject requires a key identity.");
+        await this.connect();
+        const key = object.name;
+        const type = String(await this.execute(["TYPE", key], false));
+        const ttl = Number(await this.execute(["PTTL", key], false));
+        let definition = { type, ttl_ms: ttl };
+        switch (type) {
+            case "none": break;
+            case "string": {
+                const length = Number(await this.execute(["STRLEN", key], false));
+                if (length > MAX_RESPONSE_BYTES)
+                    definition = { ...definition, length, value_omitted: true };
+                else
+                    definition = { ...definition, length, value: await this.execute(["GET", key], false) };
+                break;
+            }
+            case "hash":
+                definition = { ...definition, ...(await this.scanValue("HSCAN", key)) };
+                break;
+            case "list": {
+                const length = Number(await this.execute(["LLEN", key], false));
+                definition = { ...definition, length, values: await this.execute(["LRANGE", key, "0", "99"], false), truncated: length > 100 };
+                break;
+            }
+            case "set":
+                definition = { ...definition, ...(await this.scanValue("SSCAN", key)) };
+                break;
+            case "zset":
+                definition = { ...definition, ...(await this.scanValue("ZSCAN", key)) };
+                break;
+            default: definition = { ...definition, value_omitted: true, reason: "Unsupported Redis value type." };
+        }
+        if (Buffer.byteLength(JSON.stringify(toJsonSafe(definition)), "utf8") > MAX_RESPONSE_BYTES)
+            throw new Error("Redis value page exceeds 1 MiB.");
+        return { object: { kind: "key", name: key, identity: key }, definition: toJsonSafe(definition) };
+    }
+    async close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        if (this.client.isOpen)
+            this.client.destroy();
+        this.connected = false;
+    }
+    async scanValue(command, key) {
+        const raw = await this.execute([command, key, "0", "COUNT", "100"], false);
+        const cursor = String(raw[0]);
+        return { values: toJsonSafe(raw[1]), next_cursor: cursor === "0" ? null : cursor, truncated: cursor !== "0" };
+    }
+    async expirationIdentity(key) {
+        const ttl = Number(await this.execute(["PTTL", key], false));
+        return ttl >= 0 ? Date.now() + ttl : ttl;
+    }
+    async keyFingerprint(key) {
+        const usage = await this.execute(["MEMORY", "USAGE", key], false);
+        if (typeof usage === "number" && usage > MAX_RESPONSE_BYTES) {
+            throw new AdapterWriteError("Redis key is too large for guarded writes.", false);
+        }
+        const [type, dump] = await Promise.all([
+            this.execute(["TYPE", key], false),
+            withDeadline(this.client.sendCommand(["DUMP", key], { typeMapping: { [RESP_TYPES.BLOB_STRING]: Buffer } }), this.context, false, () => this.stop()),
+        ]);
+        const encoded = Buffer.isBuffer(dump) ? dump.toString("base64") : dump;
+        if (Buffer.byteLength(JSON.stringify(encoded), "utf8") > MAX_RESPONSE_BYTES * 2) {
+            throw new AdapterWriteError("Redis key is too large for guarded writes.", false);
+        }
+        return hash({ type, dump: encoded });
+    }
+    async connect() {
+        throwIfStopped(this.context, false);
+        if (this.closed)
+            throw new Error("Redis adapter is closed.");
+        if (this.connected)
+            return;
+        await withDeadline(this.client.connect(), this.context, false, () => this.stop());
+        this.connected = true;
+    }
+    async execute(command, outcomeUnknown) {
+        throwIfStopped(this.context, outcomeUnknown);
+        return withDeadline(this.client.sendCommand(command), this.context, outcomeUnknown, () => this.stop());
+    }
+    stop() { if (this.client.isOpen)
+        this.client.destroy(); this.closed = true; }
+}
+function validateCommandShape(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Redis command must be an object.");
+    const record = value;
+    if (Object.keys(record).some((key) => key !== "command" && key !== "args"))
+        throw new Error("Redis command contains unknown fields.");
+    if (typeof record.command !== "string" || !/^[A-Za-z]+$/.test(record.command))
+        throw new Error("Redis command name is invalid.");
+    const args = record.args ?? [];
+    if (!Array.isArray(args) || !args.every((arg) => typeof arg === "string") || args.some((arg) => arg.includes("\0")))
+        throw new Error("Redis command arguments must be strings without NUL bytes.");
+    if (args.length > MAX_ARGUMENTS + 4 || Buffer.byteLength(JSON.stringify(args), "utf8") > MAX_ARGUMENT_BYTES)
+        throw new Error("Redis command arguments exceed safety bounds.");
+    return { command: record.command.toUpperCase(), args: args };
+}
+function validateScanArgs(args, keyed) {
+    const base = keyed ? 2 : 1;
+    requireRange(args, base, base + 4);
+    if (!/^\d+$/.test(args[keyed ? 1 : 0]))
+        throw new Error("Redis SCAN cursor must be numeric.");
+    for (let index = base; index < args.length; index += 2) {
+        const option = args[index]?.toUpperCase();
+        const value = args[index + 1];
+        if (!value || (option !== "MATCH" && option !== "COUNT"))
+            throw new Error("Redis SCAN only supports MATCH and COUNT.");
+        if (option === "COUNT" && (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > MAX_COLLECTION_VALUES))
+            throw new Error(`Redis SCAN COUNT must be 1-${MAX_COLLECTION_VALUES}.`);
+    }
+}
+function requireCount(args, count) { if (args.length !== count)
+    throw new Error(`Redis command requires ${count} argument(s).`); }
+function requireRange(args, minimum, maximum) { if (args.length < minimum || args.length > maximum)
+    throw new Error(`Redis command requires ${minimum}-${maximum} arguments.`); }
+function boundedRange(startText, stopText) {
+    const start = Number(startText);
+    const stop = Number(stopText);
+    if (!Number.isSafeInteger(start) || !Number.isSafeInteger(stop) || start < 0 || stop < start || stop - start >= MAX_COLLECTION_VALUES)
+        throw new Error(`Redis LRANGE must request at most ${MAX_COLLECTION_VALUES} non-negative elements.`);
+}
+function boundedLimit(value) { const limit = value ?? 50; if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_COLLECTION_VALUES)
+    throw new Error(`limit must be 1-${MAX_COLLECTION_VALUES}.`); return limit; }
+function escapeGlob(value) { if (!value || value.length > 200 || value.includes("\0"))
+    throw new Error("Redis search must be 1-200 characters."); return value.replace(/[\\*?\[\]]/g, "\\$&"); }
+function redisRows(command, raw) {
+    if (["SCAN", "HSCAN", "SSCAN", "ZSCAN"].includes(command.command)) {
+        if (!Array.isArray(raw) || raw.length !== 2 || !Array.isArray(raw[1]))
+            throw new Error("Unexpected Redis SCAN response.");
+        const values = raw[1];
+        const field = command.command === "SCAN" ? "key" : command.command === "HSCAN" ? "field" : "value";
+        const rows = command.command === "HSCAN" || command.command === "ZSCAN"
+            ? Array.from({ length: Math.ceil(values.length / 2) }, (_, index) => ({ [field]: values[index * 2], value: values[index * 2 + 1] }))
+            : values.map((value) => ({ [field]: value }));
+        const cursor = String(raw[0]);
+        return { rows: toJsonSafe(rows), columns: inferColumns(rows), nextCursor: cursor === "0" ? null : cursor };
+    }
+    if (Array.isArray(raw)) {
+        const rows = raw.map((value, index) => ({ index, value }));
+        return { rows: toJsonSafe(rows), columns: inferColumns(rows) };
+    }
+    const rows = [{ value: raw }];
+    return { rows: toJsonSafe(rows), columns: inferColumns(rows) };
+}
+function inferColumns(rows) { const first = rows[0] ?? {}; return Object.keys(first).map((name) => ({ name, type: typeof first[name] })); }
+function normalizeScalar(value) { if (value === null || typeof value === "string" || typeof value === "number")
+    return value; return JSON.stringify(toJsonSafe(value)); }
+function redisAffectedRows(command, result) { if (typeof result === "number")
+    return result; return command === "SET" && result === "OK" ? 1 : 0; }
+function remainingMilliseconds(context) { const remaining = context.deadline - Date.now(); if (remaining <= 0)
+    throw new AdapterExecutionError("Database operation timed out.", "timeout", false); return Math.min(remaining, 2_147_483_647); }
+function throwIfStopped(context, outcomeUnknown) { if (context.signal?.aborted)
+    throw new AdapterExecutionError("Database operation was cancelled.", "aborted", outcomeUnknown); if (context.deadline <= Date.now())
+    throw new AdapterExecutionError("Database operation timed out.", "timeout", outcomeUnknown); }
+async function withDeadline(promise, context, outcomeUnknown, stop) {
+    throwIfStopped(context, outcomeUnknown);
+    let timer;
+    let abort;
+    const stopped = new Promise((_, reject) => {
+        timer = setTimeout(() => { stop(); reject(new AdapterExecutionError("Database operation timed out.", "timeout", outcomeUnknown)); }, remainingMilliseconds(context));
+        timer.unref();
+        if (context.signal) {
+            abort = () => { stop(); reject(new AdapterExecutionError("Database operation was cancelled.", "aborted", outcomeUnknown)); };
+            context.signal.addEventListener("abort", abort, { once: true });
+        }
+    });
+    try {
+        return await Promise.race([promise, stopped]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        if (abort && context.signal)
+            context.signal.removeEventListener("abort", abort);
+    }
+}
+function errorText(error) { return error instanceof Error ? error.message : String(error); }

package/dist/src/sqlite-process.js

@@ -100,6 +100,8 @@ function execute(request) {
             try {
                 for (const operation of operations) {
                     const result = bindRun(database.prepare(operation.sql), parseJson(operation.parameters, `operation "${operation.id}" parameters`, isSqlParameters));
+                    if (operation.expectedRows === 1 && Number(result.changes) !== 1)
+                        throw new Error("ROW_CONFLICT: The row changed or no longer has a unique identity.");
                     results.push({ affectedRows: Number(result.changes) });
                 }
             }
@@ -147,6 +149,14 @@ function execute(request) {
             const [kind, table] = request.args;
             return inspect(database, kind, table);
         }
+        case "listObjects": {
+            const [filter] = request.args;
+            return listObjects(database, filter);
+        }
+        case "describeObject": {
+            const [object] = request.args;
+            return describeObject(database, object);
+        }
     }
 }
 function inspect(database, kind, table) {
@@ -206,6 +216,37 @@ function inspect(database, kind, table) {
         foreign_keys: foreignKeys.length,
     };
 }
+function listObjects(database, filter) {
+    const supported = ["table", "view", "trigger"];
+    if (filter.kind !== undefined && !supported.includes(filter.kind))
+        throw new Error(`SQLite does not support catalog kind "${filter.kind}".`);
+    if (filter.schema !== undefined && filter.schema !== "main")
+        throw new Error("SQLite only supports the main schema.");
+    const offset = filter.offset ?? 0;
+    const limit = filter.limit ?? 50;
+    if (typeof offset !== "number" || !Number.isSafeInteger(offset) || offset < 0 || offset > 1_000_000 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200)
+        throw new Error("Invalid SQLite catalog page bounds.");
+    if (filter.search !== undefined && (!filter.search || filter.search.length > 200 || filter.search.includes("\0")))
+        throw new Error("Invalid SQLite catalog search.");
+    const types = filter.kind ? [filter.kind] : [...supported];
+    const placeholders = types.map(() => "?").join(", ");
+    const rows = database.prepare(`SELECT type AS kind, 'main' AS schema, name, 'main.' || name AS identity
+     FROM sqlite_master WHERE type IN (${placeholders}) AND name NOT LIKE 'sqlite_%'
+       AND (? IS NULL OR instr(lower(name), lower(?)) > 0)
+     ORDER BY kind, name LIMIT ? OFFSET ?`).all(...types, filter.search ?? null, filter.search ?? null, limit + 1, offset);
+    const more = rows.length > limit;
+    return { objects: rows.slice(0, limit), next_offset: more ? offset + limit : null, supported_kinds: [...supported] };
+}
+function describeObject(database, object) {
+    if (!["table", "view", "trigger"].includes(object.kind) || (object.schema !== undefined && object.schema !== "main"))
+        throw new Error(`SQLite does not support catalog kind "${object.kind}".`);
+    const row = database.prepare("SELECT type AS kind, 'main' AS schema, name, 'main.' || name AS identity, sql AS definition FROM sqlite_master WHERE type = ? AND name = ?").get(object.kind, object.name);
+    if (!row)
+        throw new Error("Catalog object was not found.");
+    const definition = row.definition === null ? null : String(row.definition);
+    delete row.definition;
+    return { object: row, definition };
+}
 function bindAll(statement, params) {
     if (Array.isArray(params))
         return statement.all(...params);

package/dist/src/stateql.d.ts

@@ -1,5 +1,5 @@
 import { type TableChange } from "./table-editor.js";
-import type { ActorLinkData, ActorResolutionData, ActorsData, ActorUnlinkData, AliasData, ApplyData, BatchCommand, CommandExecutionContext, CommandOrigin, BatchOptions, CapabilitiesData, CloseSessionData, ColumnsData, CommitTransactionData, ConnectOptions, ConnectionData, CountData, DisconnectData, DoctorData, ExecData, ExecOptions, ExecutionOptions, ExportData, FilterOptions, HistoryData, HistoryOptions, OperationData, PlanData, PlanOptions, ProfileData, ProfilesData, ProfileOptions, MongoExecOptions, MongoPlanOptions, MongoQueryOptions, MongoReadCommand, MongoWriteCommand, PurgeData, QueryOptions, RemovedProfileData, Response, ResultData, RollbackTransactionData, RowsData, RowsOptions, Column, StateQLActorOptions, StateQLOptions, StateQLSnapshot, StatusData, SessionData, SessionsData, SessionSummaryData, TransactionData } from "./types.js";
+import type { ActorLinkData, ActorResolutionData, ActorsData, ActorUnlinkData, AliasData, ApplyData, BatchCommand, CommandExecutionContext, CommandOrigin, BatchOptions, CapabilitiesData, CatalogObject, DescribeObjectData, ListObjectsData, ListObjectsFilter, CloseSessionData, ColumnsData, CommitTransactionData, ConnectOptions, ConnectionData, CountData, DisconnectData, DoctorData, ExecData, ExecOptions, ExecutionOptions, ExportData, FilterOptions, HistoryData, HistoryOptions, OperationData, PlanData, PlanOptions, ProfileData, ProfilesData, ProfileOptions, ProfileUpdateOptions, MongoExecOptions, MongoPlanOptions, MongoQueryOptions, MongoReadCommand, MongoWriteCommand, RedisCommand, RedisExecOptions, RedisPlanOptions, RedisQueryOptions, PurgeData, QueryOptions, RemovedProfileData, Response, ResultData, RollbackTransactionData, RowsData, RowsOptions, Column, StateQLActorOptions, StateQLOptions, StateQLSnapshot, StateQLSnapshotOptions, StatusData, SessionData, SessionsData, SessionSummaryData, TransactionData } from "./types.js";
 export declare class StateQL {
     static forActor(options: StateQLActorOptions): StateQL;
     private readonly store;
@@ -26,13 +26,12 @@ export declare class StateQL {
     [Symbol.dispose](): void;
     connect(target?: string, options?: ConnectOptions): Promise<Response<ConnectionData>>;
     addProfile(name: string, target?: string, options?: ProfileOptions): Promise<Response<ProfileData>>;
+    updateProfile(name: string, changes: ProfileUpdateOptions): Promise<Response<ProfileData>>;
     listProfiles(): Promise<Response<ProfilesData>>;
     showProfile(name: string): Promise<Response<ProfileData>>;
     removeProfile(name: string): Promise<Response<RemovedProfileData>>;
     disconnect(): Promise<Response<DisconnectData>>;
-    snapshot(options?: {
-        historyLimit?: number;
-    }): StateQLSnapshot;
+    snapshot(options?: StateQLSnapshotOptions): StateQLSnapshot;
     status(): Promise<Response<StatusData>>;
     linkActor(session: string, actorId: string): Promise<Response<ActorLinkData>>;
     unlinkActor(session: string, actorId: string): Promise<Response<ActorUnlinkData>>;
@@ -45,6 +44,7 @@ export declare class StateQL {
     closeSession(): Promise<Response<CloseSessionData>>;
     query(sql: string, options?: QueryOptions): Promise<Response<ResultData>>;
     mongoQuery(command: MongoReadCommand, options?: MongoQueryOptions): Promise<Response<ResultData>>;
+    redisQuery(command: RedisCommand, options?: RedisQueryOptions): Promise<Response<ResultData>>;
     show(idOrAlias: string): Promise<Response<ResultData>>;
     filter(idOrAlias: string, predicate: string, options?: FilterOptions): Promise<Response<ResultData>>;
     rows(idOrAlias: string, options?: RowsOptions): Promise<Response<RowsData>>;
@@ -82,20 +82,30 @@ export declare class StateQL {
     planTableUpdate(token: string, changes: TableChange, options?: ExecutionOptions & {
         origin?: CommandOrigin;
     }): Promise<Response<PlanData>>;
+    planTableUpdates(changes: Array<{
+        row_token: string;
+        changes: TableChange;
+    }>, options?: ExecutionOptions & {
+        origin?: CommandOrigin;
+    }): Promise<Response<PlanData>>;
     private editableMetadata;
     private panelResult;
     private fullResultRows;
     exportResult(idOrAlias: string, output: string, format?: "json" | "jsonl" | "csv"): Promise<Response<ExportData>>;
     exec(sql: string, options?: ExecOptions): Promise<Response<ExecData>>;
     mongoExec(command: MongoWriteCommand, options?: MongoExecOptions): Promise<Response<ExecData>>;
+    redisExec(command: RedisCommand, options?: RedisExecOptions): Promise<Response<ExecData>>;
     receipt(id: string): Promise<Response<OperationData>>;
     beginTransaction(isolation?: string): Promise<Response<TransactionData>>;
     transactionStatus(id?: string): Promise<Response<TransactionData>>;
     commitTransaction(id?: string, options?: ExecutionOptions): Promise<Response<CommitTransactionData>>;
     rollbackTransaction(id?: string): Promise<Response<RollbackTransactionData>>;
     inspect(kind: string, table?: string, options?: ExecutionOptions): Promise<Response<unknown>>;
+    listObjects(filter?: ListObjectsFilter, options?: ExecutionOptions): Promise<Response<ListObjectsData>>;
+    describeObject(object: CatalogObject, options?: ExecutionOptions): Promise<Response<DescribeObjectData>>;
     plan(sql: string, options?: PlanOptions): Promise<Response<PlanData>>;
     mongoPlan(command: MongoWriteCommand, options?: MongoPlanOptions): Promise<Response<PlanData>>;
+    redisPlan(command: RedisCommand, options?: RedisPlanOptions): Promise<Response<PlanData>>;
     apply(planId: string, options?: ExecutionOptions): Promise<Response<ApplyData>>;
     history(limit?: number, options?: HistoryOptions): Promise<Response<HistoryData>>;
     doctor(): Promise<Response<DoctorData>>;
@@ -105,12 +115,15 @@ export declare class StateQL {
     batch(commands: Iterable<BatchCommand> | AsyncIterable<BatchCommand>, options?: BatchOptions): AsyncGenerator<Response<unknown>>;
     private performExec;
     private performMongoExec;
+    private performRedisExec;
+    private performTableBatch;
     private batchFailure;
     private withResult;
     private rejectDuringStagedTransaction;
     private requireResult;
     private requireConnection;
     private requireMongoConnection;
+    private requireRedisConnection;
     private rejectMongoSql;
     private requireActiveTransaction;
     private requireSelectedSession;
@@ -120,6 +133,7 @@ export declare class StateQL {
     private resolveCredential;
     private openAdapter;
     private openMongoAdapter;
+    private openRedisAdapter;
     private executionContext;
     private resultData;
     private cacheValid;