@lix-js/sdk 0.6.0-preview.5 → 0.6.1

package/dist/sqlite/index.js

@@ -1,359 +0,0 @@
-import DatabaseConstructor from "better-sqlite3";
-const openFileHandles = new Set();
-export function createBetterSqlite3Backend(options) {
-    if (!options.path) {
-        throw new Error("createBetterSqlite3Backend() requires a non-empty path");
-    }
-    const registryKey = registryKeyForPath(options.path);
-    if (registryKey && openFileHandles.has(registryKey)) {
-        throw doubleOpenError(options.path);
-    }
-    let activeRegistryKey = registryKey;
-    let db;
-    if (activeRegistryKey) {
-        openFileHandles.add(activeRegistryKey);
-    }
-    try {
-        db = new DatabaseConstructor(options.path, options.databaseOptions);
-        initializeDatabase(db);
-        return new BetterSqlite3Backend(db, activeRegistryKey);
-    }
-    catch (error) {
-        if (activeRegistryKey) {
-            openFileHandles.delete(activeRegistryKey);
-        }
-        if (db) {
-            try {
-                db.close();
-            }
-            catch {
-                // Ignore close errors while preserving the original open failure.
-            }
-        }
-        throw error;
-    }
-}
-function initializeDatabase(db) {
-    db.exec(`
-		CREATE TABLE IF NOT EXISTS lix_kv (
-			namespace TEXT NOT NULL,
-			key BLOB NOT NULL,
-			value BLOB NOT NULL,
-			PRIMARY KEY (namespace, key)
-		) WITHOUT ROWID
-	`);
-}
-class BetterSqlite3Backend {
-    #db;
-    #registryKey;
-    #transactionMode = null;
-    #closed = false;
-    constructor(db, registryKey) {
-        this.#db = db;
-        this.#registryKey = registryKey;
-    }
-    beginReadTransaction() {
-        this.#ensureOpen();
-        return new BetterSqlite3Transaction(this.#db, {
-            ownsTransaction: false,
-            writable: false,
-        });
-    }
-    beginWriteTransaction() {
-        this.#ensureOpen();
-        if (this.#db.inTransaction) {
-            return new BetterSqlite3Transaction(this.#db, {
-                ownsTransaction: false,
-                writable: true,
-            });
-        }
-        this.#db.exec("BEGIN IMMEDIATE");
-        this.#transactionMode = "write";
-        return new BetterSqlite3Transaction(this.#db, {
-            ownsTransaction: true,
-            writable: true,
-            onClose: () => {
-                this.#transactionMode = null;
-            },
-        });
-    }
-    close() {
-        if (this.#closed)
-            return;
-        try {
-            this.#db.close();
-        }
-        finally {
-            this.#closed = true;
-            if (this.#registryKey) {
-                openFileHandles.delete(this.#registryKey);
-            }
-        }
-    }
-    #ensureOpen() {
-        if (this.#closed) {
-            throw new Error("better-sqlite3 Lix backend is closed");
-        }
-    }
-}
-class BetterSqlite3Transaction {
-    #db;
-    #ownsTransaction;
-    #writable;
-    #onClose;
-    #closed = false;
-    constructor(db, options) {
-        this.#db = db;
-        this.#ownsTransaction = options.ownsTransaction;
-        this.#writable = options.writable;
-        this.#onClose = options.onClose;
-    }
-    getValues(request) {
-        this.#ensureOpen();
-        return getValues(this.#db, request);
-    }
-    existsMany(request) {
-        this.#ensureOpen();
-        return existsMany(this.#db, request);
-    }
-    scanKeys(request) {
-        this.#ensureOpen();
-        const { pairs, resumeAfter } = scanPage(this.#db, request);
-        return {
-            keys: pairs.map(({ key }) => key),
-            resumeAfter,
-        };
-    }
-    scanValues(request) {
-        this.#ensureOpen();
-        const { pairs, resumeAfter } = scanPage(this.#db, request);
-        return {
-            values: pairs.map(({ value }) => value),
-            resumeAfter,
-        };
-    }
-    scanEntries(request) {
-        this.#ensureOpen();
-        const { pairs, resumeAfter } = scanPage(this.#db, request);
-        return {
-            keys: pairs.map(({ key }) => key),
-            values: pairs.map(({ value }) => value),
-            resumeAfter,
-        };
-    }
-    writeKvBatch(batch) {
-        this.#ensureOpen();
-        if (!this.#writable) {
-            throw new Error("Lix backend transaction is read-only");
-        }
-        const stats = {
-            puts: 0,
-            deletes: 0,
-            deleteRanges: 0,
-            bytesWritten: 0,
-        };
-        for (const group of batch.groups) {
-            for (const op of group.ops) {
-                if (op.kind === "put") {
-                    stats.puts += 1;
-                    stats.bytesWritten += op.key.length + op.value.length;
-                    kvPut(this.#db, group.namespace, op.key, op.value);
-                }
-                else if (op.kind === "delete") {
-                    stats.deletes += 1;
-                    stats.bytesWritten += op.key.length;
-                    kvDelete(this.#db, group.namespace, op.key);
-                }
-                else {
-                    stats.deleteRanges += 1;
-                    stats.bytesWritten += deleteRangeBytes(op.range);
-                    kvDeleteRange(this.#db, group.namespace, op.range);
-                }
-            }
-        }
-        return stats;
-    }
-    commit() {
-        this.#ensureOpen();
-        try {
-            if (this.#ownsTransaction) {
-                this.#db.exec("COMMIT");
-            }
-        }
-        finally {
-            this.#closed = true;
-            this.#onClose?.();
-        }
-    }
-    rollback() {
-        this.#ensureOpen();
-        try {
-            if (this.#ownsTransaction) {
-                this.#db.exec("ROLLBACK");
-            }
-        }
-        finally {
-            this.#closed = true;
-            this.#onClose?.();
-        }
-    }
-    #ensureOpen() {
-        if (this.#closed) {
-            throw new Error("Lix backend transaction is closed");
-        }
-    }
-}
-function getValues(db, request) {
-    return {
-        groups: request.groups.map((group) => ({
-            namespace: group.namespace,
-            values: group.keys.map((key) => kvGet(db, group.namespace, key)),
-        })),
-    };
-}
-function existsMany(db, request) {
-    return {
-        groups: request.groups.map((group) => ({
-            namespace: group.namespace,
-            exists: group.keys.map((key) => kvGet(db, group.namespace, key) !== null),
-        })),
-    };
-}
-function scanPage(db, request) {
-    const scanLimit = request.limit + 1 + (request.after ? 1 : 0);
-    const pairs = kvScan(db, request.namespace, request.range, scanLimit).filter((pair) => !request.after || compareBytes(pair.key, request.after) > 0);
-    const hasMore = pairs.length > request.limit;
-    const pagePairs = pairs.slice(0, request.limit);
-    return {
-        pairs: pagePairs,
-        resumeAfter: hasMore ? (pagePairs.at(-1)?.key ?? null) : null,
-    };
-}
-function kvGet(db, namespace, key) {
-    const row = db
-        .prepare("SELECT value FROM lix_kv WHERE namespace = ? AND key = ?")
-        .get(namespace, sqliteBytes(key));
-    if (!isObject(row) || !("value" in row)) {
-        return null;
-    }
-    return bytesFromUnknown(row.value, "lix_kv.value");
-}
-function kvPut(db, namespace, key, value) {
-    db.prepare(`INSERT INTO lix_kv (namespace, key, value)
-		 VALUES (?, ?, ?)
-		 ON CONFLICT(namespace, key) DO UPDATE SET value = excluded.value`).run(namespace, sqliteBytes(key), sqliteBytes(value));
-}
-function kvDelete(db, namespace, key) {
-    db.prepare("DELETE FROM lix_kv WHERE namespace = ? AND key = ?").run(namespace, sqliteBytes(key));
-}
-function kvDeleteRange(db, namespace, range) {
-    const { clauses, params } = rangeClauses(namespace, range);
-    db.prepare(`DELETE FROM lix_kv WHERE ${clauses.join(" AND ")}`).run(...params);
-}
-function kvScan(db, namespace, range, limit) {
-    const { sql, params } = scanQuery(namespace, range, limit);
-    return db
-        .prepare(sql)
-        .all(...params)
-        .map((row) => {
-        if (!isObject(row) || !("key" in row) || !("value" in row)) {
-            throw new Error("invalid lix_kv scan row");
-        }
-        return {
-            key: bytesFromUnknown(row.key, "lix_kv.key"),
-            value: bytesFromUnknown(row.value, "lix_kv.value"),
-        };
-    });
-}
-function scanQuery(namespace, range, limit) {
-    const { clauses, params } = rangeClauses(namespace, range);
-    let sql = `SELECT key, value FROM lix_kv WHERE ${clauses.join(" AND ")} ORDER BY key`;
-    if (limit != null) {
-        sql += " LIMIT ?";
-        params.push(limit);
-    }
-    return { sql, params };
-}
-function rangeClauses(namespace, range) {
-    const params = [namespace];
-    const clauses = ["namespace = ?"];
-    if (range.kind === "prefix") {
-        clauses.push("key >= ?");
-        params.push(sqliteBytes(range.prefix));
-        const end = prefixUpperBound(range.prefix);
-        if (end) {
-            clauses.push("key < ?");
-            params.push(sqliteBytes(end));
-        }
-    }
-    else {
-        clauses.push("key >= ?", "key < ?");
-        params.push(sqliteBytes(range.start), sqliteBytes(range.end));
-    }
-    return { clauses, params };
-}
-function deleteRangeBytes(range) {
-    if (range.kind === "prefix") {
-        return range.prefix.length;
-    }
-    return range.start.length + range.end.length;
-}
-function compareBytes(left, right) {
-    const length = Math.min(left.length, right.length);
-    for (let index = 0; index < length; index++) {
-        const delta = left[index] - right[index];
-        if (delta !== 0)
-            return delta;
-    }
-    return left.length - right.length;
-}
-function prefixUpperBound(prefix) {
-    const end = new Uint8Array(prefix);
-    for (let index = end.length - 1; index >= 0; index--) {
-        if (end[index] !== 0xff) {
-            end[index] += 1;
-            return end.slice(0, index + 1);
-        }
-    }
-    return null;
-}
-function bytesFromUnknown(value, context) {
-    if (value instanceof Uint8Array) {
-        return new Uint8Array(value);
-    }
-    throw new Error(`${context} must be bytes`);
-}
-function sqliteBytes(bytes) {
-    const buffer = globalThis.Buffer;
-    return buffer ? buffer.from(bytes) : bytes;
-}
-function registryKeyForPath(filename) {
-    if (filename === ":memory:") {
-        return null;
-    }
-    if (filename.startsWith("/")) {
-        return normalizeAbsolutePath(filename);
-    }
-    const cwd = globalThis.process?.cwd?.() ?? "/";
-    return normalizeAbsolutePath(`${cwd}/${filename}`);
-}
-function normalizeAbsolutePath(filename) {
-    const segments = [];
-    for (const segment of filename.split("/")) {
-        if (!segment || segment === ".") {
-            continue;
-        }
-        if (segment === "..") {
-            segments.pop();
-            continue;
-        }
-        segments.push(segment);
-    }
-    return `/${segments.join("/")}`;
-}
-function doubleOpenError(filename) {
-    return new Error(`createBetterSqlite3Backend() already has an open handle for ${filename}; close the existing Lix handle before opening this file again`);
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null;
-}

package/dist-engine-src/README.md

@@ -1,18 +0,0 @@
-# Bundled Lix Engine Source
-
-This directory is a generated snapshot of the Rust engine source that backs this @lix-js/sdk release.
-
-Source in the Lix monorepo: `packages/engine/src`
-
-Agents should inspect these files when SDK behavior is unclear instead of relying only on SKILL.md prose.
-
-Useful entry points:
-
-- `src/sql2/providers/entity.rs` - registered schema SQL surfaces
-- `src/sql2/providers/change.rs` - `lix_change` projection
-- `src/sql2/providers/branch.rs` - writable `lix_branch` surface
-- `src/transaction/validation.rs` - primary-key, unique, foreign-key, and shape validation
-- `src/schema/definition.json` - Lix schema-definition meta-schema
-- `src/schema/builtin/` - built-in schema definitions
-
-Regenerate with `pnpm --filter @lix-js/sdk sync:engine-src` from the repo root.

package/dist-engine-src/src/backend/capabilities.rs

@@ -1,67 +0,0 @@
-use crate::backend::PredicateSupportLevel;
-
-#[derive(Clone, Debug)]
-pub struct BackendCapabilities {
-    pub profile: BackendProfile,
-    pub projection: ProjectionCapabilities,
-    pub scan: ScanCapabilities,
-    pub write: WriteCapabilities,
-    pub pushdown: PushdownCapabilities,
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum BackendProfile {
-    /// Ordered byte keys, coherent read views, batched point reads,
-    /// chunked forward scans, and atomic write commit.
-    V0 { write_concurrency: WriteConcurrency },
-}
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum WriteConcurrency {
-    SingleWriter,
-    ConcurrentWithConflictDetection,
-    ConcurrentWithoutConflictDetection,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ProjectionCapabilities {
-    pub header: bool,
-    pub refs: bool,
-    pub header_and_refs: bool,
-    pub payload: bool,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ScanCapabilities {
-    pub native_prefix_scan: bool,
-    pub reverse: bool,
-    pub limit_bytes: bool,
-    pub long_lived_cursors: bool,
-    pub parallel_partitions: bool,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct WriteCapabilities {
-    pub preconditions: bool,
-    pub idempotent_commit: bool,
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct PushdownCapabilities {
-    pub key: PredicateSupportLevel,
-    pub header: PredicateSupportLevel,
-    pub refs: PredicateSupportLevel,
-    pub object_pruning: PredicateSupportLevel,
-}
-
-impl BackendCapabilities {
-    pub fn v0(write_concurrency: WriteConcurrency) -> Self {
-        Self {
-            profile: BackendProfile::V0 { write_concurrency },
-            projection: ProjectionCapabilities::default(),
-            scan: ScanCapabilities::default(),
-            write: WriteCapabilities::default(),
-            pushdown: PushdownCapabilities::default(),
-        }
-    }
-}