@fadhilp/stateql 0.4.4 → 0.5.2

package/dist/src/stateql.js

@@ -8,7 +8,7 @@ import { filterMaterializedRows, prepareFilterStatement, validateFilterParameter
 import { operationData, paginationWarnings, profileData, rowsToCsv, sessionData, transactionData, } from "./response-data.js";
 import { analyzeSql } from "./sql.js";
 import { StateStore, } from "./store.js";
-import { compactRows, defaultHome, hash, parseJson, redact, } from "./util.js";
+import { compactRows, defaultHome, hash, isSqlParameters, parseJson, redact, } from "./util.js";
 const DEFAULT_SNAPSHOT_HISTORY_LIMIT = 50;
 const MAX_SNAPSHOT_HISTORY_LIMIT = 100;
 export class StateQL {
@@ -42,6 +42,7 @@ export class StateQL {
     signal;
     credentialResolver;
     now;
+    closed = false;
     constructor(options = {}) {
         this.now = options.now ?? (() => new Date());
         this.sessionName = options.session ?? env.STQL_SESSION ?? "default";
@@ -49,24 +50,38 @@ export class StateQL {
         if (!this.actorId.trim()) {
             throw new StateQLError("INVALID_COMMAND", "Actor ID is required.");
         }
-        this.previewRows = options.previewRows ?? 5;
-        this.cacheTtlSeconds = options.cacheTtlSeconds ?? 300;
-        this.resultTtlSeconds = options.resultTtlSeconds ?? 86_400;
-        this.maxCellCharacters = options.maxCellCharacters ?? 200;
+        this.previewRows = nonNegativeInteger(options.previewRows ?? 5, "previewRows");
+        this.cacheTtlSeconds = nonNegativeInteger(options.cacheTtlSeconds ?? 300, "cacheTtlSeconds");
+        this.resultTtlSeconds = positiveInteger(options.resultTtlSeconds ?? 86_400, "resultTtlSeconds");
+        this.maxCellCharacters = positiveInteger(options.maxCellCharacters ?? 200, "maxCellCharacters");
         this.maxResultRows = positiveInteger(options.maxResultRows ?? 10_000, "maxResultRows");
         this.maxResultBytes = positiveInteger(options.maxResultBytes ?? 16 * 1024 * 1024, "maxResultBytes");
         this.timeoutMs = executionTimeout(options.timeoutMs ?? 30_000);
+        const maxStateBytes = positiveInteger(options.maxStateBytes ?? 256 * 1024 * 1024, "maxStateBytes");
         this.signal = options.signal;
         this.credentialResolver = options.credentialResolver;
         if (this.maxResultRows >= Number.MAX_SAFE_INTEGER) {
             throw new StateQLError("INVALID_COMMAND", "maxResultRows is too large.");
         }
-        this.store = new StateStore(options.home ?? defaultHome(), this.now);
-        this.store.bootstrapSession(this.sessionName, this.actorId, options.actor === undefined);
+        const store = new StateStore(options.home ?? defaultHome(), this.now, maxStateBytes);
+        try {
+            store.bootstrapSession(this.sessionName, this.actorId, options.actor === undefined);
+        }
+        catch (error) {
+            store.close();
+            throw error;
+        }
+        this.store = store;
     }
     close() {
+        if (this.closed)
+            return;
+        this.closed = true;
         this.store.close();
     }
+    [Symbol.dispose]() {
+        this.close();
+    }
     async connect(target, options = {}) {
         return this.run("connect", async (session) => {
             if (session.active_transaction_id) {
@@ -811,14 +826,16 @@ export class StateQL {
             if (version(connection) !== transaction.start_version) {
                 throw new StateQLError("TRANSACTION_FAILED", "Connection state changed after the transaction began.", { suggestedAction: "Roll back and begin a new transaction." });
             }
+            // Validate durable payloads before opening a database adapter or changing
+            // the transaction state.
+            const operations = this.store.validatedTransactionOperations(transaction.id);
             const context = this.executionContext(options);
             const adapterSource = await this.resolveConnectionSource(connection, session, "transaction.commit", "write", context);
             const adapter = await this.openAdapter(connection, context, adapterSource);
             try {
-                if (!this.store.markTransactionCommitting(transaction.id, session.id, this.actorId)) {
+                if (!this.store.claimTransactionForCommit(transaction.id, session.id, this.actorId, operations)) {
                     throw new StateQLError("TRANSACTION_FAILED", "Transaction is no longer active.");
                 }
-                const operations = this.store.transactionOperations(transaction.id);
                 if (operations.some((operation) => operation.connection_id !== connection.id)) {
                     this.store.finishTransaction(transaction.id, session.id, this.actorId, "failed");
                     throw new StateQLError("TRANSACTION_FAILED", "Transaction contains writes staged for another connection.");
@@ -1026,6 +1043,7 @@ export class StateQL {
             if (Date.parse(plan.expires_at) <= this.now().getTime()) {
                 throw new StateQLError("STALE_PLAN", "Plan has expired.");
             }
+            const planParameters = parseJson(plan.parameters, `plan "${plan.id}" parameters`, isSqlParameters);
             const claimToken = this.store.nextId("claim");
             const claimed = this.store.claimPlan(plan.id, session.id, this.actorId, claimToken);
             if (!claimed) {
@@ -1058,7 +1076,7 @@ export class StateQL {
                     await closeAdapterQuietly(adapter);
                 }
                 const result = await this.performExec(session, connection, claimed.sql, {
-                    params: parseJson(claimed.parameters, []),
+                    params: planParameters,
                     allowUnbounded: Boolean(claimed.allow_unbounded),
                     allowDestructive: Boolean(claimed.allow_destructive),
                 }, context, { planId: claimed.id, claimToken }, adapterSource);
@@ -1089,6 +1107,25 @@ export class StateQL {
             },
         }));
     }
+    async doctor() {
+        return this.run("doctor", async (session) => ({
+            data: this.store.diagnostics(session.id),
+        }));
+    }
+    async purge(scope = "expired") {
+        return this.run("purge", async (session) => {
+            if (!["expired", "results", "history", "all"].includes(scope)) {
+                throw new StateQLError("INVALID_COMMAND", `Unknown purge scope "${scope}".`);
+            }
+            if (scope === "all" && session.active_transaction_id) {
+                throw new StateQLError("TRANSACTION_FAILED", "Commit or roll back the active transaction before purging all data.");
+            }
+            return {
+                data: { scope, deleted: this.store.purge(session.id, scope) },
+                executed: true,
+            };
+        });
+    }
     async capabilities() {
         return this.run("capabilities", async () => ({
             data: {
@@ -1104,6 +1141,9 @@ export class StateQL {
                     credential_resolver: true,
                     deadlines: true,
                     cancellation: true,
+                    state_diagnostics: true,
+                    state_purge: true,
+                    state_quota: true,
                 },
             },
         }));
@@ -1228,6 +1268,10 @@ export class StateQL {
                     return this.history(command.limit ?? 20);
                 case "receipt":
                     return this.receipt(batchString(command.handle, "handle"));
+                case "doctor":
+                    return this.doctor();
+                case "purge":
+                    return this.purge(command.scope ?? "expired");
                 case "capabilities":
                     return this.capabilities();
                 default:
@@ -1756,7 +1800,6 @@ async function resolveCredentialBeforeDeadline(resolver, request, context) {
         };
         const abort = () => finish(() => reject(new CredentialResolutionError("cancelled")));
         const timer = setTimeout(() => finish(() => reject(new CredentialResolutionError("timeout"))), remaining);
-        timer.unref?.();
         context.signal?.addEventListener("abort", abort, { once: true });
         Promise.resolve()
             .then(() => resolver(request))

package/dist/src/store.d.ts

@@ -111,8 +111,10 @@ export interface SessionMemberRecord {
 }
 export declare class StateStore {
     private readonly now;
+    private readonly maxStateBytes;
     readonly db: DatabaseSync;
-    constructor(home: string, now: () => Date);
+    private closed;
+    constructor(home: string, now: () => Date, maxStateBytes?: number);
     close(): void;
     nextId(prefix: string): string;
     ensureSession(name?: string): SessionRecord;
@@ -219,6 +221,8 @@ export declare class StateStore {
     }): TransactionRecord | undefined;
     getTransaction(id: string): TransactionRecord | undefined;
     transactionOperations(transactionId: string): OperationRecord[];
+    validatedTransactionOperations(transactionId: string): OperationRecord[];
+    claimTransactionForCommit(transactionId: string, sessionId: string, actorId: string, expectedOperations: OperationRecord[]): boolean;
     markTransactionCommitting(transactionId: string, sessionId: string, actorId: string): boolean;
     markTransactionOutcomeUnknown(transactionId: string, sessionId: string, actorId: string): void;
     finishTransaction(transactionId: string, sessionId: string, actorId: string, state: "rolled_back" | "failed"): boolean;
@@ -275,8 +279,22 @@ export declare class StateStore {
     knownResults(sessionId: string, limit: number): Array<ResultRecord & {
         alias: string | null;
     }>;
+    diagnostics(sessionId: string): {
+        integrity: "ok" | "issues";
+        issues: Array<{
+            code: string;
+            record?: string;
+        }>;
+        migrations: string[];
+        storage: {
+            result_bytes: number;
+            results: number;
+            history: number;
+        };
+    };
+    purge(sessionId: string, scope: "expired" | "results" | "history" | "all"): number;
+    private enforceResultQuota;
+    private resultBytes;
     private deleteExpiredData;
     private recoverStaleCommittingTransactions;
-    private migrate;
-    private addColumn;
 }

package/dist/src/store.js

@@ -1,24 +1,52 @@
-import { mkdirSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, statSync } from "node:fs";
 import { DatabaseSync } from "node:sqlite";
 import { join } from "node:path";
-import { parseJson, toJsonSafe } from "./util.js";
+import { platform } from "node:process";
+import { runMigrations } from "./migrations.js";
+import { StateQLError } from "./errors.js";
+import { isColumns, isRows, isSqlParameters, parseJson, toJsonSafe, } from "./util.js";
 const HISTORY_LIMIT_PER_SESSION = 10_000;
+const DEFAULT_MAX_STATE_BYTES = 256 * 1024 * 1024;
 export class StateStore {
     now;
+    maxStateBytes;
     db;
-    constructor(home, now) {
+    closed = false;
+    constructor(home, now, maxStateBytes = DEFAULT_MAX_STATE_BYTES) {
         this.now = now;
+        this.maxStateBytes = maxStateBytes;
         const path = join(home, "state.sqlite");
-        mkdirSync(home, { recursive: true });
+        mkdirSync(home, { recursive: true, mode: 0o700 });
+        if (platform !== "win32")
+            restrictMode(home, 0o700);
         this.db = new DatabaseSync(path);
-        this.db.exec("PRAGMA journal_mode = WAL");
-        this.db.exec("PRAGMA busy_timeout = 5000");
-        this.db.exec("PRAGMA foreign_keys = ON");
-        this.migrate();
-        this.recoverStaleCommittingTransactions();
-        this.deleteExpiredData();
+        try {
+            if (platform !== "win32")
+                restrictMode(path, 0o600);
+            this.db.exec("PRAGMA journal_mode = WAL");
+            if (platform !== "win32") {
+                for (const suffix of ["-wal", "-shm"]) {
+                    const sidecar = `${path}${suffix}`;
+                    if (existsSync(sidecar))
+                        restrictMode(sidecar, 0o600);
+                }
+            }
+            this.db.exec("PRAGMA busy_timeout = 5000");
+            this.db.exec("PRAGMA foreign_keys = ON");
+            runMigrations(this.db, this.now);
+            this.recoverStaleCommittingTransactions();
+            this.deleteExpiredData();
+        }
+        catch (error) {
+            this.db.close();
+            this.closed = true;
+            throw error;
+        }
     }
     close() {
+        if (this.closed)
+            return;
+        this.closed = true;
         this.db.close();
     }
     nextId(prefix) {
@@ -302,14 +330,24 @@ export class StateStore {
     }
     saveResult(input) {
         const id = this.nextId("q");
-        this.db
-            .prepare(`INSERT INTO results
-          (id, session_id, connection_id, fingerprint, sql, parameters,
-           rows_json, columns_json, row_count, state_version, state_signature,
-           state_confidence, expires_at, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(id, input.sessionId, input.connectionId, input.fingerprint, input.sql, JSON.stringify(toJsonSafe(input.parameters)), JSON.stringify(toJsonSafe(input.rows)), JSON.stringify(input.columns), input.rows.length, input.stateVersion, input.stateSignature, input.stateConfidence, input.expiresAt, this.now().toISOString());
-        return this.getResult(id);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            this.db
+                .prepare(`INSERT INTO results
+            (id, session_id, connection_id, fingerprint, sql, parameters,
+             rows_json, columns_json, row_count, state_version, state_signature,
+             state_confidence, expires_at, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(id, input.sessionId, input.connectionId, input.fingerprint, input.sql, JSON.stringify(toJsonSafe(input.parameters)), JSON.stringify(toJsonSafe(input.rows)), JSON.stringify(input.columns), input.rows.length, input.stateVersion, input.stateSignature, input.stateConfidence, input.expiresAt, this.now().toISOString());
+            this.enforceResultQuota(id);
+            const result = this.getResult(id);
+            this.db.exec("COMMIT");
+            return result;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
     }
     findResult(fingerprint) {
         return this.db
@@ -332,10 +370,10 @@ export class StateStore {
             .get(idOrAlias, idOrAlias, sessionId ?? null, sessionId ?? null);
     }
     resultRows(result) {
-        return parseJson(result.rows_json, []);
+        return parseJson(result.rows_json, `result "${result.id}" rows`, isRows);
     }
     resultColumns(result) {
-        return parseJson(result.columns_json, []);
+        return parseJson(result.columns_json, `result "${result.id}" columns`, isColumns);
     }
     setAlias(sessionId, name, resultId) {
         this.db
@@ -509,6 +547,46 @@ export class StateStore {
             .prepare("SELECT * FROM operations WHERE transaction_id = ? ORDER BY created_at")
             .all(transactionId);
     }
+    validatedTransactionOperations(transactionId) {
+        const operations = this.transactionOperations(transactionId);
+        for (const operation of operations) {
+            parseJson(operation.parameters, `operation "${operation.id}" parameters`, isSqlParameters);
+        }
+        return operations;
+    }
+    claimTransactionForCommit(transactionId, sessionId, actorId, expectedOperations) {
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            const current = this.transactionOperations(transactionId);
+            const unchanged = current.length === expectedOperations.length &&
+                current.every((operation, index) => {
+                    const expected = expectedOperations[index];
+                    return expected &&
+                        operation.id === expected.id &&
+                        operation.connection_id === expected.connection_id &&
+                        operation.sql === expected.sql &&
+                        operation.parameters === expected.parameters &&
+                        operation.status === expected.status;
+                });
+            if (!unchanged) {
+                this.db.exec("COMMIT");
+                return false;
+            }
+            const result = this.db.prepare(`UPDATE transactions SET state = 'committing', ended_at = ?
+         WHERE id = ? AND session_id = ? AND owner_actor_id = ?
+           AND state = 'active' AND EXISTS (
+             SELECT 1 FROM sessions
+             WHERE sessions.id = transactions.session_id
+               AND sessions.active_transaction_id = transactions.id
+           )`).run(this.now().toISOString(), transactionId, sessionId, actorId);
+            this.db.exec("COMMIT");
+            return Number(result.changes) === 1;
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+    }
     markTransactionCommitting(transactionId, sessionId, actorId) {
         this.db.exec("BEGIN IMMEDIATE");
         try {
@@ -758,6 +836,126 @@ export class StateStore {
          LIMIT ?`)
             .all(sessionId, limit);
     }
+    diagnostics(sessionId) {
+        const issues = [];
+        const integrity = this.db.prepare("PRAGMA integrity_check").all();
+        if (integrity.some((row) => row.integrity_check !== "ok")) {
+            issues.push({ code: "SQLITE_INTEGRITY" });
+        }
+        if (this.db.prepare("PRAGMA foreign_key_check").all().length) {
+            issues.push({ code: "FOREIGN_KEY_INTEGRITY" });
+        }
+        const results = this.db.prepare("SELECT * FROM results WHERE session_id = ?").all(sessionId);
+        for (const result of results) {
+            try {
+                const rows = this.resultRows(result);
+                this.resultColumns(result);
+                parseJson(result.parameters, `result "${result.id}" parameters`, isSqlParameters);
+                if (rows.length !== result.row_count)
+                    throw new Error("row count");
+            }
+            catch {
+                issues.push({ code: "CORRUPTED_RESULT", record: result.id });
+            }
+        }
+        for (const table of ["operations", "plans"]) {
+            const records = this.db.prepare(`SELECT id, parameters FROM ${table} WHERE session_id = ?`).all(sessionId);
+            for (const record of records) {
+                try {
+                    parseJson(record.parameters, `${table.slice(0, -1)} "${record.id}" parameters`, isSqlParameters);
+                }
+                catch {
+                    issues.push({
+                        code: table === "plans" ? "CORRUPTED_PLAN" : "CORRUPTED_OPERATION",
+                        record: record.id,
+                    });
+                }
+            }
+        }
+        const storage = this.db.prepare(`SELECT
+         COUNT(*) AS results,
+         COALESCE(SUM(length(CAST(sql AS BLOB)) + length(CAST(parameters AS BLOB)) +
+           length(CAST(rows_json AS BLOB)) + length(CAST(columns_json AS BLOB))), 0)
+           AS result_bytes,
+         (SELECT COUNT(*) FROM history WHERE session_id = ?) AS history
+       FROM results WHERE session_id = ?`).get(sessionId, sessionId);
+        return {
+            integrity: issues.length ? "issues" : "ok",
+            issues,
+            migrations: this.db.prepare("SELECT name FROM schema_migrations ORDER BY rowid").all().map((row) => row.name),
+            storage,
+        };
+    }
+    purge(sessionId, scope) {
+        const before = this.db.prepare(`SELECT
+         (SELECT COUNT(*) FROM results WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM plans WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM operations WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM transactions WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM history WHERE session_id = ?) AS count`).get(sessionId, sessionId, sessionId, sessionId, sessionId);
+        this.db.exec("BEGIN IMMEDIATE");
+        try {
+            if (scope === "expired") {
+                this.db.prepare(`DELETE FROM aliases WHERE session_id = ? AND result_id IN (
+             SELECT id FROM results WHERE session_id = ? AND expires_at <= ?
+           )`).run(sessionId, sessionId, this.now().toISOString());
+                this.db.prepare("DELETE FROM results WHERE session_id = ? AND expires_at <= ?").run(sessionId, this.now().toISOString());
+                this.db.prepare(`DELETE FROM plans WHERE session_id = ? AND expires_at <= ?
+             AND claim_token IS NULL`).run(sessionId, this.now().toISOString());
+            }
+            else {
+                if (scope === "results" || scope === "all") {
+                    this.db.prepare("DELETE FROM aliases WHERE session_id = ?").run(sessionId);
+                    this.db.prepare("DELETE FROM results WHERE session_id = ?").run(sessionId);
+                }
+                if (scope === "history" || scope === "all") {
+                    this.db.prepare("DELETE FROM history WHERE session_id = ?").run(sessionId);
+                }
+                if (scope === "all") {
+                    this.db.prepare("DELETE FROM plans WHERE session_id = ?").run(sessionId);
+                    this.db.prepare("DELETE FROM operations WHERE session_id = ?").run(sessionId);
+                    this.db.prepare("DELETE FROM transactions WHERE session_id = ?").run(sessionId);
+                }
+            }
+            this.db.exec("COMMIT");
+        }
+        catch (error) {
+            this.db.exec("ROLLBACK");
+            throw error;
+        }
+        const after = this.db.prepare(`SELECT
+         (SELECT COUNT(*) FROM results WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM plans WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM operations WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM transactions WHERE session_id = ?) +
+         (SELECT COUNT(*) FROM history WHERE session_id = ?) AS count`).get(sessionId, sessionId, sessionId, sessionId, sessionId);
+        return before.count - after.count;
+    }
+    enforceResultQuota(protectedId) {
+        this.db.prepare(`DELETE FROM aliases WHERE result_id IN (
+         SELECT id FROM results WHERE expires_at <= ?
+       )`).run(this.now().toISOString());
+        this.db.prepare("DELETE FROM results WHERE expires_at <= ?")
+            .run(this.now().toISOString());
+        while (this.resultBytes() > this.maxStateBytes) {
+            const candidate = this.db.prepare(`SELECT id FROM results
+         WHERE id <> ? AND NOT EXISTS (
+           SELECT 1 FROM aliases WHERE aliases.result_id = results.id
+         )
+         ORDER BY created_at, rowid LIMIT 1`).get(protectedId);
+            if (!candidate) {
+                throw new StateQLError("STATE_QUOTA_EXCEEDED", `Stored results exceed the ${this.maxStateBytes}-byte state quota.`, { suggestedAction: "Purge results or increase maxStateBytes." });
+            }
+            this.db.prepare("DELETE FROM results WHERE id = ?").run(candidate.id);
+        }
+    }
+    resultBytes() {
+        const row = this.db.prepare(`SELECT COALESCE(SUM(
+         length(CAST(sql AS BLOB)) + length(CAST(parameters AS BLOB)) +
+         length(CAST(rows_json AS BLOB)) + length(CAST(columns_json AS BLOB))
+       ), 0) AS bytes FROM results`).get();
+        return row.bytes;
+    }
     deleteExpiredData() {
         const timestamp = this.now().toISOString();
         this.db.exec("BEGIN IMMEDIATE");
@@ -811,193 +1009,7 @@ export class StateStore {
             throw error;
         }
     }
-    migrate() {
-        this.db.exec("BEGIN IMMEDIATE");
-        try {
-            this.db.exec(`
-      CREATE TABLE IF NOT EXISTS schema_migrations (
-        name TEXT PRIMARY KEY,
-        applied_at TEXT NOT NULL
-      );
-      `);
-            const actorMigrationApplied = Boolean(this.db
-                .prepare("SELECT 1 FROM schema_migrations WHERE name = 'shared_session_actors_v1'")
-                .get());
-            this.db.exec(`
-      CREATE TABLE IF NOT EXISTS counters (
-        prefix TEXT PRIMARY KEY,
-        value INTEGER NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS sessions (
-        id TEXT PRIMARY KEY,
-        name TEXT NOT NULL UNIQUE,
-        status TEXT NOT NULL,
-        active_connection_id TEXT,
-        active_transaction_id TEXT,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS session_members (
-        session_id TEXT NOT NULL,
-        actor_id TEXT NOT NULL UNIQUE,
-        attached_at TEXT NOT NULL,
-        PRIMARY KEY(session_id, actor_id),
-        FOREIGN KEY(session_id) REFERENCES sessions(id)
-      );
-      CREATE TABLE IF NOT EXISTS profiles (
-        name TEXT PRIMARY KEY,
-        target TEXT,
-        secret_env TEXT,
-        read_only INTEGER NOT NULL,
-        created_at TEXT NOT NULL,
-        updated_at TEXT NOT NULL,
-        CHECK(target IS NOT NULL OR secret_env IS NOT NULL)
-      );
-      CREATE TABLE IF NOT EXISTS connections (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        name TEXT NOT NULL,
-        driver TEXT NOT NULL,
-        database_name TEXT NOT NULL,
-        source TEXT NOT NULL,
-        secret_env TEXT,
-        read_only INTEGER NOT NULL,
-        version INTEGER NOT NULL,
-        created_at TEXT NOT NULL,
-        FOREIGN KEY(session_id) REFERENCES sessions(id)
-      );
-      CREATE TABLE IF NOT EXISTS results (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        connection_id TEXT NOT NULL,
-        fingerprint TEXT NOT NULL,
-        sql TEXT NOT NULL,
-        parameters TEXT NOT NULL,
-        rows_json TEXT NOT NULL,
-        columns_json TEXT NOT NULL,
-        row_count INTEGER NOT NULL,
-        state_version TEXT NOT NULL,
-        state_signature TEXT NOT NULL,
-        state_confidence TEXT NOT NULL,
-        expires_at TEXT NOT NULL,
-        created_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS results_fingerprint
-        ON results(fingerprint, created_at);
-      CREATE TABLE IF NOT EXISTS aliases (
-        session_id TEXT NOT NULL,
-        name TEXT NOT NULL,
-        result_id TEXT NOT NULL,
-        PRIMARY KEY(session_id, name),
-        FOREIGN KEY(result_id) REFERENCES results(id)
-      );
-      CREATE TABLE IF NOT EXISTS operations (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        actor_id TEXT NOT NULL,
-        connection_id TEXT NOT NULL,
-        fingerprint TEXT NOT NULL,
-        sql TEXT NOT NULL,
-        parameters TEXT NOT NULL,
-        statement_type TEXT NOT NULL,
-        affected_rows INTEGER,
-        status TEXT NOT NULL,
-        transaction_id TEXT,
-        replay_of TEXT,
-        idempotency_key TEXT,
-        state_version_before TEXT NOT NULL,
-        state_version_after TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS operations_fingerprint
-        ON operations(connection_id, fingerprint, status);
-      CREATE UNIQUE INDEX IF NOT EXISTS operations_idempotency
-        ON operations(connection_id, idempotency_key)
-        WHERE idempotency_key IS NOT NULL AND status IN ('committed', 'pending');
-      CREATE TABLE IF NOT EXISTS transactions (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        owner_actor_id TEXT NOT NULL,
-        connection_id TEXT NOT NULL,
-        state TEXT NOT NULL,
-        isolation_level TEXT NOT NULL,
-        start_version TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        ended_at TEXT
-      );
-      CREATE TABLE IF NOT EXISTS plans (
-        id TEXT PRIMARY KEY,
-        session_id TEXT NOT NULL,
-        owner_actor_id TEXT NOT NULL,
-        connection_id TEXT NOT NULL,
-        sql TEXT NOT NULL,
-        parameters TEXT NOT NULL,
-        statement_type TEXT NOT NULL,
-        state_version TEXT NOT NULL,
-        state_signature TEXT NOT NULL,
-        destructive INTEGER NOT NULL,
-        allow_unbounded INTEGER NOT NULL,
-        allow_destructive INTEGER NOT NULL,
-        expires_at TEXT NOT NULL,
-        applied_operation_id TEXT,
-        claim_token TEXT,
-        created_at TEXT NOT NULL
-      );
-      CREATE TABLE IF NOT EXISTS history (
-        id TEXT PRIMARY KEY,
-        timestamp TEXT NOT NULL,
-        session_id TEXT NOT NULL,
-        actor_id TEXT NOT NULL,
-        command TEXT NOT NULL,
-        handle TEXT,
-        executed INTEGER NOT NULL,
-        cached INTEGER NOT NULL,
-        success INTEGER NOT NULL,
-        error_code TEXT
-      );
-      CREATE INDEX IF NOT EXISTS history_session
-        ON history(session_id);
-      `);
-            this.addColumn("operations", "actor_id", "TEXT");
-            this.addColumn("transactions", "owner_actor_id", "TEXT");
-            this.addColumn("plans", "owner_actor_id", "TEXT");
-            this.addColumn("plans", "claim_token", "TEXT");
-            this.addColumn("history", "actor_id", "TEXT");
-            if (!actorMigrationApplied) {
-                this.db.exec(`
-          INSERT OR IGNORE INTO session_members(session_id, actor_id, attached_at)
-          SELECT id, name, created_at FROM sessions;
-        `);
-            }
-            this.db.exec(`
-        UPDATE operations SET actor_id = (
-          SELECT name FROM sessions WHERE sessions.id = operations.session_id
-        ) WHERE actor_id IS NULL;
-        UPDATE transactions SET owner_actor_id = (
-          SELECT name FROM sessions WHERE sessions.id = transactions.session_id
-        ) WHERE owner_actor_id IS NULL;
-        UPDATE plans SET owner_actor_id = (
-          SELECT name FROM sessions WHERE sessions.id = plans.session_id
-        ) WHERE owner_actor_id IS NULL;
-        UPDATE history SET actor_id = (
-          SELECT name FROM sessions WHERE sessions.id = history.session_id
-        ) WHERE actor_id IS NULL;
-      `);
-            this.db
-                .prepare(`INSERT OR IGNORE INTO schema_migrations(name, applied_at)
-           VALUES ('shared_session_actors_v1', ?)`)
-                .run(this.now().toISOString());
-            this.db.exec("COMMIT");
-        }
-        catch (error) {
-            this.db.exec("ROLLBACK");
-            throw error;
-        }
-    }
-    addColumn(table, column, definition) {
-        const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
-        if (!columns.some((candidate) => candidate.name === column)) {
-            this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
-        }
-    }
+}
+function restrictMode(path, allowed) {
+    chmodSync(path, statSync(path).mode & allowed);
 }