@lix-js/sdk 0.6.0-preview.4 → 0.6.0

package/dist/sqlite/index.js

@@ -1,303 +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;
-    #closed = false;
-    constructor(db, registryKey) {
-        this.#db = db;
-        this.#registryKey = registryKey;
-    }
-    beginReadTransaction() {
-        this.#ensureOpen();
-        if (this.#db.inTransaction) {
-            throw new Error("cannot open nested Lix backend transaction");
-        }
-        this.#db.exec("BEGIN DEFERRED");
-        return new BetterSqlite3Transaction(this.#db);
-    }
-    beginWriteTransaction() {
-        this.#ensureOpen();
-        if (this.#db.inTransaction) {
-            throw new Error("cannot open nested Lix backend transaction");
-        }
-        this.#db.exec("BEGIN IMMEDIATE");
-        return new BetterSqlite3Transaction(this.#db);
-    }
-    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;
-    #closed = false;
-    constructor(db) {
-        this.#db = db;
-    }
-    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();
-        const stats = {
-            puts: 0,
-            deletes: 0,
-            bytesWritten: 0,
-        };
-        for (const group of batch.groups) {
-            for (const put of group.puts) {
-                stats.puts += 1;
-                stats.bytesWritten += put.key.length + put.value.length;
-                kvPut(this.#db, group.namespace, put.key, put.value);
-            }
-            for (const key of group.deletes) {
-                stats.deletes += 1;
-                stats.bytesWritten += key.length;
-                kvDelete(this.#db, group.namespace, key);
-            }
-        }
-        return stats;
-    }
-    commit() {
-        this.#ensureOpen();
-        this.#db.exec("COMMIT");
-        this.#closed = true;
-    }
-    rollback() {
-        this.#ensureOpen();
-        this.#db.exec("ROLLBACK");
-        this.#closed = true;
-    }
-    #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 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 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));
-    }
-    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 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/entity_provider.rs` - registered schema SQL surfaces
-- `src/sql2/change_provider.rs` - `lix_change` projection
-- `src/sql2/version_provider.rs` - writable `lix_version` 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/kv.rs

@@ -1,358 +0,0 @@
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct BytePage {
-    bytes: Vec<u8>,
-    offsets: Vec<u32>,
-}
-
-impl BytePage {
-    pub fn new() -> Self {
-        Self {
-            bytes: Vec::new(),
-            offsets: vec![0],
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.offsets.len().saturating_sub(1)
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn get(&self, index: usize) -> Option<&[u8]> {
-        let start = usize::try_from(*self.offsets.get(index)?).ok()?;
-        let end = usize::try_from(*self.offsets.get(index + 1)?).ok()?;
-        self.bytes.get(start..end)
-    }
-
-    pub fn iter(&self) -> BytePageIter<'_> {
-        BytePageIter {
-            page: self,
-            index: 0,
-        }
-    }
-}
-
-pub struct BytePageIter<'a> {
-    page: &'a BytePage,
-    index: usize,
-}
-
-impl<'a> Iterator for BytePageIter<'a> {
-    type Item = &'a [u8];
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let value = self.page.get(self.index)?;
-        self.index += 1;
-        Some(value)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct BytePageBuilder {
-    bytes: Vec<u8>,
-    offsets: Vec<u32>,
-}
-
-impl BytePageBuilder {
-    pub fn new() -> Self {
-        Self {
-            bytes: Vec::new(),
-            offsets: vec![0],
-        }
-    }
-
-    pub fn with_capacity(items: usize, bytes: usize) -> Self {
-        let mut offsets = Vec::with_capacity(items.saturating_add(1));
-        offsets.push(0);
-        Self {
-            bytes: Vec::with_capacity(bytes),
-            offsets,
-        }
-    }
-
-    pub fn from_page(page: BytePage) -> Self {
-        Self {
-            bytes: page.bytes,
-            offsets: page.offsets,
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.offsets.len().saturating_sub(1)
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn get(&self, index: usize) -> Option<&[u8]> {
-        let start = usize::try_from(*self.offsets.get(index)?).ok()?;
-        let end = usize::try_from(*self.offsets.get(index + 1)?).ok()?;
-        self.bytes.get(start..end)
-    }
-
-    pub fn push(&mut self, value: impl AsRef<[u8]>) {
-        let value = value.as_ref();
-        self.bytes.extend_from_slice(value);
-        let end = u32::try_from(self.bytes.len()).expect("byte page exceeds u32 offset capacity");
-        self.offsets.push(end);
-    }
-
-    pub fn finish(self) -> BytePage {
-        BytePage {
-            bytes: self.bytes,
-            offsets: self.offsets,
-        }
-    }
-}
-
-/// Ordered byte range for backend KV scans.
-///
-/// Ranges are half-open: `start <= key < end`. `Prefix` is explicit because it
-/// is a common access pattern and lets each backend choose the safest
-/// implementation for its storage engine.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum BackendKvScanRange {
-    Prefix(Vec<u8>),
-    Range { start: Vec<u8>, end: Vec<u8> },
-}
-
-impl BackendKvScanRange {
-    pub fn prefix(prefix: impl Into<Vec<u8>>) -> Self {
-        Self::Prefix(prefix.into())
-    }
-
-    pub fn range(start: impl Into<Vec<u8>>, end: impl Into<Vec<u8>>) -> Self {
-        Self::Range {
-            start: start.into(),
-            end: end.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvGetRequest {
-    pub groups: Vec<BackendKvGetGroup>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvGetGroup {
-    pub namespace: String,
-    pub keys: Vec<Vec<u8>>,
-}
-
-impl BackendKvGetGroup {
-    pub fn namespace(&self) -> &str {
-        &self.namespace
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvValueBatch {
-    pub groups: Vec<BackendKvValueGroup>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvValueGroup {
-    namespace: String,
-    values: BytePage,
-    present: Vec<bool>,
-}
-
-impl BackendKvValueGroup {
-    pub fn new(namespace: impl Into<String>, values: BytePage, present: Vec<bool>) -> Self {
-        assert_eq!(
-            values.len(),
-            present.len(),
-            "backend value batch must have one value slot per presence bit"
-        );
-        Self {
-            namespace: namespace.into(),
-            values,
-            present,
-        }
-    }
-
-    pub fn namespace(&self) -> &str {
-        &self.namespace
-    }
-
-    pub fn len(&self) -> usize {
-        self.present.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.present.is_empty()
-    }
-
-    pub fn value(&self, index: usize) -> Option<Option<&[u8]>> {
-        let present = *self.present.get(index)?;
-        if present {
-            Some(Some(
-                self.values
-                    .get(index)
-                    .expect("backend value batch invariant violated"),
-            ))
-        } else {
-            Some(None)
-        }
-    }
-
-    pub fn values_iter(&self) -> impl Iterator<Item = Option<&[u8]>> {
-        (0..self.len()).filter_map(|index| self.value(index))
-    }
-
-    pub fn into_parts(self) -> (String, BytePage, Vec<bool>) {
-        (self.namespace, self.values, self.present)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvExistsBatch {
-    pub groups: Vec<BackendKvExistsGroup>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvExistsGroup {
-    pub namespace: String,
-    pub exists: Vec<bool>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvScanRequest {
-    pub namespace: String,
-    pub range: BackendKvScanRange,
-    pub after: Option<Vec<u8>>,
-    pub limit: usize,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvKeyPage {
-    pub keys: BytePage,
-    pub resume_after: Option<Vec<u8>>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvValuePage {
-    pub values: BytePage,
-    pub resume_after: Option<Vec<u8>>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvEntryPage {
-    pub keys: BytePage,
-    pub values: BytePage,
-    pub resume_after: Option<Vec<u8>>,
-}
-
-impl BackendKvEntryPage {
-    pub fn len(&self) -> usize {
-        self.keys.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.keys.is_empty()
-    }
-
-    pub fn key(&self, index: usize) -> Option<&[u8]> {
-        self.keys.get(index)
-    }
-
-    pub fn value(&self, index: usize) -> Option<&[u8]> {
-        self.values.get(index)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct BackendKvWriteBatch {
-    pub groups: Vec<BackendKvWriteGroup>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct BackendKvWriteGroup {
-    namespace: String,
-    put_keys: BytePageBuilder,
-    put_values: BytePageBuilder,
-    deletes: BytePageBuilder,
-}
-
-impl BackendKvWriteGroup {
-    pub fn new(namespace: impl Into<String>) -> Self {
-        Self {
-            namespace: namespace.into(),
-            put_keys: BytePageBuilder::new(),
-            put_values: BytePageBuilder::new(),
-            deletes: BytePageBuilder::new(),
-        }
-    }
-
-    pub fn from_pages(
-        namespace: impl Into<String>,
-        put_keys: BytePage,
-        put_values: BytePage,
-        deletes: BytePage,
-    ) -> Self {
-        assert_eq!(
-            put_keys.len(),
-            put_values.len(),
-            "backend write batch must have one value per put key"
-        );
-        Self {
-            namespace: namespace.into(),
-            put_keys: BytePageBuilder::from_page(put_keys),
-            put_values: BytePageBuilder::from_page(put_values),
-            deletes: BytePageBuilder::from_page(deletes),
-        }
-    }
-
-    pub fn put(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) {
-        self.put_keys.push(key);
-        self.put_values.push(value);
-    }
-
-    pub fn delete(&mut self, key: impl AsRef<[u8]>) {
-        self.deletes.push(key);
-    }
-
-    pub fn namespace(&self) -> &str {
-        &self.namespace
-    }
-
-    pub fn put_count(&self) -> usize {
-        self.put_keys.len()
-    }
-
-    pub fn delete_count(&self) -> usize {
-        self.deletes.len()
-    }
-
-    pub fn put_key(&self, index: usize) -> Option<&[u8]> {
-        self.put_keys.get(index)
-    }
-
-    pub fn put_value(&self, index: usize) -> Option<&[u8]> {
-        self.put_values.get(index)
-    }
-
-    pub fn delete_key(&self, index: usize) -> Option<&[u8]> {
-        self.deletes.get(index)
-    }
-
-    pub fn into_parts(self) -> (String, BytePage, BytePage, BytePage) {
-        (
-            self.namespace,
-            self.put_keys.finish(),
-            self.put_values.finish(),
-            self.deletes.finish(),
-        )
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub struct BackendKvWriteStats {
-    pub puts: usize,
-    pub deletes: usize,
-    pub bytes_written: usize,
-}

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

@@ -1,12 +0,0 @@
-mod kv;
-#[cfg(test)]
-pub(crate) mod testing;
-mod types;
-
-pub use kv::{
-    BackendKvEntryPage, BackendKvExistsBatch, BackendKvExistsGroup, BackendKvGetGroup,
-    BackendKvGetRequest, BackendKvKeyPage, BackendKvScanRange, BackendKvScanRequest,
-    BackendKvValueBatch, BackendKvValueGroup, BackendKvValuePage, BackendKvWriteBatch,
-    BackendKvWriteGroup, BackendKvWriteStats, BytePage, BytePageBuilder,
-};
-pub use types::{Backend, BackendReadTransaction, BackendWriteTransaction};