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

package/dist-engine-src/src/commit_store/types.rs

@@ -1,215 +0,0 @@
-use crate::entity_identity::EntityIdentity;
-use crate::json_store::JsonRef;
-
-/// Physical append/locality unit for commit metadata and derived commit SQL
-/// surfaces.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) struct Commit {
-    pub(crate) id: String,
-    pub(crate) change_id: String,
-    pub(crate) parent_ids: Vec<String>,
-    pub(crate) author_account_ids: Vec<String>,
-    pub(crate) created_at: String,
-    pub(crate) change_pack_count: u32,
-    pub(crate) membership_pack_count: u32,
-}
-
-impl Commit {
-    pub(crate) fn as_ref(&self) -> StoredCommitRef<'_> {
-        StoredCommitRef {
-            id: &self.id,
-            change_id: &self.change_id,
-            parent_ids: &self.parent_ids,
-            author_account_ids: &self.author_account_ids,
-            created_at: &self.created_at,
-            change_pack_count: self.change_pack_count,
-            membership_pack_count: self.membership_pack_count,
-        }
-    }
-}
-
-/// Zero-copy view of stored [`Commit`] bytes.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct StoredCommitRef<'a> {
-    pub(crate) id: &'a str,
-    pub(crate) change_id: &'a str,
-    pub(crate) parent_ids: &'a [String],
-    pub(crate) author_account_ids: &'a [String],
-    pub(crate) created_at: &'a str,
-    pub(crate) change_pack_count: u32,
-    pub(crate) membership_pack_count: u32,
-}
-
-/// Zero-copy view of a logical commit supplied before physical packing.
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct CommitDraftRef<'a> {
-    pub(crate) id: &'a str,
-    pub(crate) change_id: &'a str,
-    pub(crate) parent_ids: &'a [String],
-    pub(crate) author_account_ids: &'a [String],
-    pub(crate) created_at: &'a str,
-}
-
-/// Logical entity mutation fact stored in a commit change pack.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) struct Change {
-    pub(crate) id: String,
-    pub(crate) entity_id: EntityIdentity,
-    pub(crate) schema_key: String,
-    pub(crate) file_id: Option<String>,
-    pub(crate) snapshot_ref: Option<JsonRef>,
-    pub(crate) metadata_ref: Option<JsonRef>,
-    pub(crate) created_at: String,
-}
-
-/// Read-boundary view of a commit-store change with JSON refs resolved.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct MaterializedChange {
-    pub(crate) id: String,
-    pub(crate) entity_id: EntityIdentity,
-    pub(crate) schema_key: String,
-    pub(crate) file_id: Option<String>,
-    pub(crate) snapshot_content: Option<String>,
-    pub(crate) metadata: Option<String>,
-    pub(crate) created_at: String,
-}
-
-/// Commit-store change plus the physical pack that owns its JSON payloads.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct LocatedChange {
-    pub(crate) record: Change,
-    pub(crate) source_commit_id: String,
-    pub(crate) source_pack_id: u32,
-}
-
-impl Change {
-    pub(crate) fn as_ref(&self) -> ChangeRef<'_> {
-        ChangeRef {
-            id: &self.id,
-            entity_id: &self.entity_id,
-            schema_key: &self.schema_key,
-            file_id: self.file_id.as_deref(),
-            snapshot_ref: self.snapshot_ref.as_ref(),
-            metadata_ref: self.metadata_ref.as_ref(),
-            created_at: &self.created_at,
-        }
-    }
-}
-
-/// Zero-copy view of [`Change`].
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct ChangeRef<'a> {
-    pub(crate) id: &'a str,
-    pub(crate) entity_id: &'a EntityIdentity,
-    pub(crate) schema_key: &'a str,
-    pub(crate) file_id: Option<&'a str>,
-    pub(crate) snapshot_ref: Option<&'a JsonRef>,
-    pub(crate) metadata_ref: Option<&'a JsonRef>,
-    pub(crate) created_at: &'a str,
-}
-
-/// Logical scan request for the `lix_change` SQL surface over commit_store.
-#[derive(Debug, Clone, Default)]
-pub(crate) struct ChangeScanRequest {
-    pub(crate) limit: Option<usize>,
-}
-
-/// Commit-local physical pack of newly authored change payloads.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) struct ChangePack {
-    pub(crate) commit_id: String,
-    pub(crate) pack_id: u32,
-    pub(crate) changes: Vec<Change>,
-}
-
-impl ChangePack {
-    pub(crate) fn as_view(&self) -> ChangePackView<'_> {
-        ChangePackView {
-            commit_id: &self.commit_id,
-            pack_id: self.pack_id,
-            changes: &self.changes,
-        }
-    }
-}
-
-/// Zero-copy view for a decoded [`ChangePack`].
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct ChangePackView<'a> {
-    pub(crate) commit_id: &'a str,
-    pub(crate) pack_id: u32,
-    pub(crate) changes: &'a [Change],
-}
-
-/// Storage location of an existing change payload.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) struct ChangeLocator {
-    pub(crate) source_commit_id: String,
-    pub(crate) source_pack_id: u32,
-    pub(crate) source_ordinal: u32,
-    pub(crate) change_id: String,
-}
-
-impl ChangeLocator {
-    pub(crate) fn as_ref(&self) -> ChangeLocatorRef<'_> {
-        ChangeLocatorRef {
-            source_commit_id: &self.source_commit_id,
-            source_pack_id: self.source_pack_id,
-            source_ordinal: self.source_ordinal,
-            change_id: &self.change_id,
-        }
-    }
-}
-
-/// Zero-copy view of [`ChangeLocator`].
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct ChangeLocatorRef<'a> {
-    pub(crate) source_commit_id: &'a str,
-    pub(crate) source_pack_id: u32,
-    pub(crate) source_ordinal: u32,
-    pub(crate) change_id: &'a str,
-}
-
-/// Exact lookup entry for a derived-surface-visible change id.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) enum ChangeIndexEntry {
-    CommitHeader {
-        commit_id: String,
-        change_id: String,
-    },
-    PackedChange {
-        locator: ChangeLocator,
-    },
-}
-
-/// Commit-local physical pack of adopted/shared membership locators.
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub(crate) struct MembershipPack {
-    pub(crate) commit_id: String,
-    pub(crate) pack_id: u32,
-    pub(crate) members: Vec<ChangeLocator>,
-}
-
-impl MembershipPack {
-    pub(crate) fn as_view(&self) -> MembershipPackView<'_> {
-        MembershipPackView {
-            commit_id: &self.commit_id,
-            pack_id: self.pack_id,
-            members: &self.members,
-        }
-    }
-}
-
-/// Zero-copy view for a decoded [`MembershipPack`].
-#[derive(Debug, Clone, Copy)]
-pub(crate) struct MembershipPackView<'a> {
-    pub(crate) commit_id: &'a str,
-    pub(crate) pack_id: u32,
-    pub(crate) members: &'a [ChangeLocator],
-}
-
-/// Locators produced while staging a commit.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) struct StagedCommitStoreCommit {
-    pub(crate) authored_locators: Vec<ChangeLocator>,
-    pub(crate) adopted_locators: Vec<ChangeLocator>,
-}

package/dist-engine-src/src/schema/builtin/lix_version_descriptor.json

@@ -1,34 +0,0 @@
-{
-  "x-lix-key": "lix_version_descriptor",
-  "description": "User-facing version metadata (name and visibility) for a branch-like version. The stable identity of a version; the matching `lix_version_ref` carries the moving head pointer. The catalog's `lix_version` surface joins this descriptor with its ref to present a single user-visible version row.",
-  "x-lix-primary-key": [
-    "/id"
-  ],
-  "x-lix-unique": [
-    [
-      "/name"
-    ]
-  ],
-  "type": "object",
-  "properties": {
-    "id": {
-      "type": "string",
-      "x-lix-default": "lix_uuid_v7()",
-      "description": "Stable version identifier (UUIDv7). Referenced by `lix_version_ref.id`."
-    },
-    "name": {
-      "type": "string",
-      "description": "Human-readable version name (e.g. `main`, `feature-x`) shown in version listings and CLI output."
-    },
-    "hidden": {
-      "type": "boolean",
-      "default": false,
-      "description": "When true, the version is filtered from default listings (CLI, catalog views); operations by explicit id still succeed."
-    }
-  },
-  "required": [
-    "id",
-    "name"
-  ],
-  "additionalProperties": false
-}

package/dist-engine-src/src/schema/builtin/lix_version_ref.json

@@ -1,48 +0,0 @@
-{
-  "x-lix-key": "lix_version_ref",
-  "description": "Version head pointer. Records which commit a version should currently resolve to in the local runtime. Intentionally not part of canonical commit membership: refs may be reset client-side after sync without introducing content conflicts. Each `lix_version_descriptor.id` has exactly one `lix_version_ref` row.",
-  "x-lix-primary-key": [
-    "/id"
-  ],
-  "x-lix-foreign-keys": [
-    {
-      "properties": [
-        "/id"
-      ],
-      "references": {
-        "schemaKey": "lix_version_descriptor",
-        "properties": [
-          "/id"
-        ]
-      }
-    },
-    {
-      "properties": [
-        "/commit_id"
-      ],
-      "references": {
-        "schemaKey": "lix_commit",
-        "properties": [
-          "/id"
-        ]
-      }
-    }
-  ],
-  "type": "object",
-  "properties": {
-    "id": {
-      "type": "string",
-      "x-lix-default": "lix_uuid_v7()",
-      "description": "Version identifier whose head pointer is being stored; matches `lix_version_descriptor.id`."
-    },
-    "commit_id": {
-      "type": "string",
-      "description": "Commit the version should currently resolve to in the local runtime (references `lix_commit.id`)."
-    }
-  },
-  "required": [
-    "id",
-    "commit_id"
-  ],
-  "additionalProperties": false
-}

package/dist-engine-src/src/session/create_version.rs

@@ -1,88 +0,0 @@
-use crate::transaction::types::{TransactionWrite, TransactionWriteMode};
-use crate::version::{
-    version_descriptor_stage_row, version_ref_stage_row, VersionLifecycle, VersionOperation,
-    VersionReferenceRole,
-};
-use crate::LixError;
-
-use super::context::SessionContext;
-
-/// Options for creating a new version from the session's active version.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CreateVersionOptions {
-    /// Optional caller-provided version id. If omitted, engine generates one.
-    pub id: Option<String>,
-    /// User-facing version name.
-    pub name: String,
-    /// Optional commit id for the new version head. If omitted, the current
-    /// active version head is used.
-    pub from_commit_id: Option<String>,
-}
-
-/// Receipt returned after creating a version.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CreateVersionReceipt {
-    pub id: String,
-    pub name: String,
-    pub hidden: bool,
-    pub commit_id: String,
-}
-
-impl SessionContext {
-    /// Creates a new version from this session's current version head.
-    ///
-    /// Version descriptors are tracked global facts so every version agrees on
-    /// which versions exist. Version refs are untracked global moving pointers,
-    /// so creating a ref does not add another changelog fact.
-    pub async fn create_version(
-        &self,
-        options: CreateVersionOptions,
-    ) -> Result<CreateVersionReceipt, LixError> {
-        self.with_write_transaction(|transaction| {
-            Box::pin(async move {
-                let version_id = options
-                    .id
-                    .unwrap_or_else(|| transaction.functions().call_uuid_v7());
-                let source_head = if let Some(from_commit_id) = options.from_commit_id {
-                    let mut commit_graph = transaction.commit_graph_reader();
-                    VersionLifecycle::require_existing_commit(
-                        &mut commit_graph,
-                        &from_commit_id,
-                        VersionOperation::CreateVersion,
-                        VersionReferenceRole::CommitSource,
-                    )
-                    .await?;
-                    from_commit_id
-                } else {
-                    let active_version_id = transaction.active_version_id().to_string();
-                    let reader = transaction.version_ref_reader();
-                    VersionLifecycle::new(&reader)
-                        .require_existing_commit_id(
-                            &active_version_id,
-                            VersionOperation::CreateVersion,
-                            VersionReferenceRole::Source,
-                        )
-                        .await?
-                };
-
-                transaction
-                    .stage_write(TransactionWrite::Rows {
-                        mode: TransactionWriteMode::Insert,
-                        rows: vec![
-                            version_descriptor_stage_row(&version_id, &options.name, false),
-                            version_ref_stage_row(&version_id, &source_head),
-                        ],
-                    })
-                    .await?;
-
-                Ok(CreateVersionReceipt {
-                    id: version_id,
-                    name: options.name,
-                    hidden: false,
-                    commit_id: source_head,
-                })
-            })
-        })
-        .await
-    }
-}

package/dist-engine-src/src/session/merge/apply.rs

@@ -1,23 +0,0 @@
-use crate::tracked_state::TrackedStateMergePlan;
-use crate::transaction::types::TransactionAdoptedChange;
-
-pub(crate) fn adopted_changes_from_merge_plan(
-    plan: &TrackedStateMergePlan,
-    target_version_id: &str,
-) -> Vec<TransactionAdoptedChange> {
-    plan.patches
-        .iter()
-        .map(|patch| stage_adopted_change_from_patch(patch, target_version_id))
-        .collect()
-}
-
-fn stage_adopted_change_from_patch(
-    patch: &crate::tracked_state::TrackedStateMergePatch,
-    target_version_id: &str,
-) -> TransactionAdoptedChange {
-    TransactionAdoptedChange {
-        version_id: target_version_id.to_string(),
-        change_id: patch.change_id().to_string(),
-        projected_row: patch.projected_row().clone(),
-    }
-}

package/dist-engine-src/src/session/optimization9_sql2_bench.rs

@@ -1,100 +0,0 @@
-use crate::functions::FunctionContext;
-use crate::session::context::{SessionContext, SessionSqlExecutionContext};
-use crate::sql2::{self, SqlLogicalPlan};
-use crate::storage::StorageReadScope;
-use crate::transaction::open_transaction;
-use crate::{LixError, SqlQueryResult, Value};
-
-/// Opaque read plan used by the Optimization 9 SQL2 diagnostic benchmark.
-///
-/// This module is gated behind `storage-benches` and exists only to split SQL2
-/// planning cost from SQL2 execution cost without widening the normal session
-/// API.
-pub struct PreparedReadPlan {
-    plan: SqlLogicalPlan,
-    read_scope:
-        StorageReadScope<Box<dyn crate::storage::StorageReadTransaction + Send + Sync + 'static>>,
-    runtime_functions: FunctionContext,
-}
-
-pub async fn plan_read_only(session: &SessionContext, sql: &str) -> Result<(), LixError> {
-    let prepared = prepare_read_plan(session, sql).await?;
-    drop(prepared.plan);
-    drop(prepared.runtime_functions);
-    prepared.read_scope.rollback().await
-}
-
-pub async fn plan_write_only(session: &SessionContext, sql: &str) -> Result<(), LixError> {
-    session.ensure_open()?;
-    let opened = open_transaction(
-        &session.mode,
-        session.storage.clone(),
-        std::sync::Arc::clone(&session.live_state),
-        std::sync::Arc::clone(&session.tracked_state),
-        std::sync::Arc::clone(&session.binary_cas),
-        std::sync::Arc::clone(&session.commit_store),
-        std::sync::Arc::clone(&session.version_ctx),
-        std::sync::Arc::clone(&session.catalog_context),
-    )
-    .await?;
-    let mut transaction = opened.transaction;
-    let runtime_functions = opened.runtime_functions;
-    let plan = sql2::create_write_logical_plan(&mut transaction, sql).await?;
-    drop(plan);
-    drop(runtime_functions);
-    transaction.rollback().await
-}
-
-pub async fn prepare_read_plan(
-    session: &SessionContext,
-    sql: &str,
-) -> Result<PreparedReadPlan, LixError> {
-    session.ensure_open()?;
-    let read_scope = StorageReadScope::new(session.storage.begin_read_transaction().await?);
-    let mut read_store = read_scope.store();
-    let live_state: std::sync::Arc<dyn crate::live_state::LiveStateReader> =
-        std::sync::Arc::new(session.live_state.reader(read_store.clone()));
-    let runtime_functions = FunctionContext::prepare(live_state.as_ref()).await?;
-    let functions = runtime_functions.provider();
-    let active_version_id = session
-        .active_version_id_from_reader(&mut read_store)
-        .await?;
-    let visible_schemas = session
-        .catalog_context
-        .schema_jsons_for_sql_read_planning(live_state.as_ref(), &active_version_id)
-        .await?;
-    let ctx = SessionSqlExecutionContext {
-        active_version_id: &active_version_id,
-        read_store,
-        live_state: std::sync::Arc::clone(&session.live_state),
-        binary_cas: std::sync::Arc::clone(&session.binary_cas),
-        commit_store: std::sync::Arc::clone(&session.commit_store),
-        version_ctx: std::sync::Arc::clone(&session.version_ctx),
-        visible_schemas,
-        functions: functions.clone(),
-    };
-    let plan = sql2::create_logical_plan(&ctx, sql).await?;
-    drop(ctx);
-    drop(live_state);
-
-    Ok(PreparedReadPlan {
-        plan,
-        read_scope,
-        runtime_functions,
-    })
-}
-
-pub async fn execute_read_plan(
-    prepared: PreparedReadPlan,
-    params: &[Value],
-) -> Result<SqlQueryResult, LixError> {
-    let PreparedReadPlan {
-        plan,
-        read_scope,
-        runtime_functions,
-    } = prepared;
-    let result = sql2::execute_logical_plan(plan, params).await;
-    read_scope.rollback().await?;
-    drop(runtime_functions);
-    result
-}

package/dist-engine-src/src/session/switch_version.rs

@@ -1,110 +0,0 @@
-use std::sync::Arc;
-
-use serde_json::json;
-
-use crate::transaction::types::{TransactionJson, TransactionWriteRow};
-use crate::version::{VersionLifecycle, VersionOperation, VersionReferenceRole};
-use crate::LixError;
-use crate::GLOBAL_VERSION_ID;
-
-use super::context::{SessionContext, SessionMode, WORKSPACE_VERSION_KEY};
-
-const KEY_VALUE_SCHEMA_KEY: &str = "lix_key_value";
-
-/// Options for switching a session to another version.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SwitchVersionOptions {
-    pub version_id: String,
-}
-
-/// Receipt returned after switching to another version.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct SwitchVersionReceipt {
-    pub version_id: String,
-}
-
-impl SessionContext {
-    /// Switches the session's active version selector.
-    ///
-    /// Pinned sessions switch in memory and return a new pinned session.
-    /// Workspace sessions update the shared workspace selector so other
-    /// workspace sessions observe the new active version on their next use.
-    pub async fn switch_version(
-        &self,
-        options: SwitchVersionOptions,
-    ) -> Result<(SessionContext, SwitchVersionReceipt), LixError> {
-        let version_id = options.version_id;
-        let receipt_version_id = version_id.clone();
-        let current_mode = self.mode.clone();
-        let next_mode = self
-            .with_write_transaction(|transaction| {
-                Box::pin(async move {
-                    {
-                        let reader = transaction.version_ref_reader();
-                        VersionLifecycle::new(&reader)
-                            .require_existing_commit_id(
-                                &version_id,
-                                VersionOperation::SwitchVersion,
-                                VersionReferenceRole::Target,
-                            )
-                            .await?
-                    };
-
-                    match current_mode {
-                        SessionMode::Pinned { .. } => Ok(SessionMode::Pinned {
-                            version_id: version_id.clone(),
-                        }),
-                        SessionMode::Workspace => {
-                            transaction
-                                .stage_rows(vec![workspace_version_stage_row(&version_id)?])
-                                .await?;
-                            Ok(SessionMode::Workspace)
-                        }
-                    }
-                })
-            })
-            .await?;
-
-        let session = SessionContext::new_with_closed(
-            next_mode,
-            self.storage.clone(),
-            Arc::clone(&self.live_state),
-            Arc::clone(&self.tracked_state),
-            Arc::clone(&self.binary_cas),
-            Arc::clone(&self.commit_store),
-            Arc::clone(&self.version_ctx),
-            Arc::clone(&self.catalog_context),
-            self.closed_flag(),
-            self.active_transaction_flag(),
-        );
-        Ok((
-            session,
-            SwitchVersionReceipt {
-                version_id: receipt_version_id,
-            },
-        ))
-    }
-}
-
-fn workspace_version_stage_row(version_id: &str) -> Result<TransactionWriteRow, LixError> {
-    Ok(TransactionWriteRow {
-        entity_id: Some(crate::entity_identity::EntityIdentity::single(
-            WORKSPACE_VERSION_KEY,
-        )),
-        schema_key: KEY_VALUE_SCHEMA_KEY.to_string(),
-        file_id: None,
-        snapshot: Some(TransactionJson::from_value_unchecked(json!({
-            "key": WORKSPACE_VERSION_KEY,
-            "value": version_id,
-        }))),
-        metadata: None,
-        origin: None,
-        created_at: None,
-        updated_at: None,
-        global: true,
-        change_id: None,
-        commit_id: None,
-        untracked: true,
-        version_id: GLOBAL_VERSION_ID.to_string(),
-    })
-}