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

package/dist-engine-src/src/sql2/public_bind/assignment.rs

@@ -1,46 +0,0 @@
-use std::collections::BTreeSet;
-
-use crate::LixError;
-
-use super::table::{PublicSurface, PublicTableContracts};
-
-pub(crate) fn validate_update_assignments(
-    surface: &PublicSurface,
-    columns: Vec<String>,
-    contracts: &PublicTableContracts,
-) -> Result<(), LixError> {
-    let Some(contract) = contracts.get(surface) else {
-        return Ok(());
-    };
-    let mut seen = BTreeSet::new();
-    for column in columns {
-        if !seen.insert(column.clone()) {
-            return Err(LixError::new(
-                LixError::CODE_INVALID_PARAM,
-                format!(
-                    "update {} assigns column '{column}' more than once",
-                    surface.name()
-                ),
-            ));
-        }
-        let Some(column_contract) = contract.column(&column) else {
-            return Err(LixError::new(
-                LixError::CODE_INVALID_PARAM,
-                format!(
-                    "update {} references unknown column '{column}'",
-                    surface.name()
-                ),
-            ));
-        };
-        if !column_contract.writable {
-            return Err(LixError::new(
-                LixError::CODE_UNSUPPORTED_SQL,
-                format!(
-                    "update {} cannot assign read-only column '{column}'",
-                    surface.name()
-                ),
-            ));
-        }
-    }
-    Ok(())
-}

package/dist-engine-src/src/sql2/public_bind/capability.rs

@@ -1,41 +0,0 @@
-use crate::LixError;
-
-use super::table::{Capability, PublicSurface, PublicTableContracts};
-use super::DmlOperation;
-
-pub(crate) fn validate_table_operation(
-    surface: &PublicSurface,
-    operation: DmlOperation,
-    contracts: &PublicTableContracts,
-) -> Result<(), LixError> {
-    let Some(contract) = contracts.get(surface) else {
-        return Ok(());
-    };
-    match contract.operation(operation) {
-        Capability::Allowed => Ok(()),
-        Capability::ReadOnly(hint) => {
-            let message = if surface.name().ends_with("_history") {
-                format!(
-                    "DML cannot write read-only history view '{}'",
-                    surface.name()
-                )
-            } else {
-                format!(
-                    "{} {} is not allowed because the SQL surface is read-only",
-                    operation.as_str(),
-                    surface.name()
-                )
-            };
-            Err(LixError::new(LixError::CODE_READ_ONLY, message).with_hint(hint))
-        }
-        Capability::Unsupported(hint) => Err(LixError::new(
-            LixError::CODE_UNSUPPORTED_SQL,
-            format!(
-                "{} {} is not supported by Lix SQL",
-                operation.as_str(),
-                surface.name()
-            ),
-        )
-        .with_hint(hint)),
-    }
-}

package/dist-engine-src/src/sql2/public_bind/dml.rs

@@ -1,166 +0,0 @@
-use datafusion::logical_expr::{LogicalPlan, WriteOp};
-use datafusion::sql::sqlparser::ast::{
-    Assignment, AssignmentTarget, Delete, FromTable, ObjectName, Statement, TableFactor,
-    TableObject, TableWithJoins, Update,
-};
-use datafusion::sql::sqlparser::dialect::GenericDialect;
-use datafusion::sql::sqlparser::parser::Parser;
-use serde_json::Value as JsonValue;
-
-use crate::LixError;
-
-use super::assignment::validate_update_assignments;
-use super::capability::validate_table_operation;
-use super::table::{PublicSurface, PublicTableContracts};
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum DmlOperation {
-    Insert,
-    Update,
-    Delete,
-}
-
-impl DmlOperation {
-    pub(crate) fn as_str(self) -> &'static str {
-        match self {
-            Self::Insert => "insert",
-            Self::Update => "update",
-            Self::Delete => "delete",
-        }
-    }
-}
-
-pub(crate) fn validate_sql(sql: &str, visible_schemas: &[JsonValue]) -> Result<(), LixError> {
-    let statements = Parser::parse_sql(&GenericDialect {}, sql).map_err(|error| {
-        LixError::new(
-            LixError::CODE_PARSE_ERROR,
-            format!("sql2 SQL parse error: {error}"),
-        )
-    })?;
-    let [statement] = statements.as_slice() else {
-        return Ok(());
-    };
-    let contracts = PublicTableContracts::new(visible_schemas)?;
-    validate_statement(statement, &contracts)
-}
-
-pub(crate) fn validate_plan(
-    plan: &LogicalPlan,
-    visible_schemas: &[JsonValue],
-) -> Result<(), LixError> {
-    let contracts = PublicTableContracts::new(visible_schemas)?;
-    validate_plan_with_contracts(plan, &contracts)
-}
-
-fn validate_plan_with_contracts(
-    plan: &LogicalPlan,
-    contracts: &PublicTableContracts,
-) -> Result<(), LixError> {
-    if let LogicalPlan::Dml(dml) = plan {
-        let surface = PublicSurface::named(dml.table_name.table());
-        validate_table_operation(&surface, operation_from_write_op(&dml.op), contracts)?;
-    }
-    for input in plan.inputs() {
-        validate_plan_with_contracts(input, contracts)?;
-    }
-    Ok(())
-}
-
-fn operation_from_write_op(op: &WriteOp) -> DmlOperation {
-    match op {
-        WriteOp::Insert(_) | WriteOp::Ctas => DmlOperation::Insert,
-        WriteOp::Update => DmlOperation::Update,
-        WriteOp::Delete | WriteOp::Truncate => DmlOperation::Delete,
-    }
-}
-
-fn validate_statement(
-    statement: &Statement,
-    contracts: &PublicTableContracts,
-) -> Result<(), LixError> {
-    match statement {
-        Statement::Insert(insert) => {
-            let Some(table_name) = insert_target_name(&insert.table) else {
-                return Ok(());
-            };
-            let surface = PublicSurface::named(table_name);
-            validate_table_operation(&surface, DmlOperation::Insert, contracts)
-        }
-        Statement::Update(update) => validate_update(update, contracts),
-        Statement::Delete(delete) => validate_delete(delete, contracts),
-        Statement::Explain { statement, .. } => validate_statement(statement, contracts),
-        _ => Ok(()),
-    }
-}
-
-fn validate_update(update: &Update, contracts: &PublicTableContracts) -> Result<(), LixError> {
-    let Some(table_name) = table_with_joins_target_name(&update.table) else {
-        return Ok(());
-    };
-    let surface = PublicSurface::named(table_name);
-    validate_table_operation(&surface, DmlOperation::Update, contracts)?;
-    validate_update_assignments(
-        &surface,
-        assignment_column_names(&update.assignments)?,
-        contracts,
-    )
-}
-
-fn validate_delete(delete: &Delete, contracts: &PublicTableContracts) -> Result<(), LixError> {
-    for table in delete_from_tables(delete) {
-        let Some(table_name) = table_with_joins_target_name(table) else {
-            continue;
-        };
-        let surface = PublicSurface::named(table_name);
-        validate_table_operation(&surface, DmlOperation::Delete, contracts)?;
-    }
-    Ok(())
-}
-
-fn delete_from_tables(delete: &Delete) -> &[TableWithJoins] {
-    match &delete.from {
-        FromTable::WithFromKeyword(tables) | FromTable::WithoutKeyword(tables) => tables,
-    }
-}
-
-fn assignment_column_names(assignments: &[Assignment]) -> Result<Vec<String>, LixError> {
-    let mut columns = Vec::new();
-    for assignment in assignments {
-        match &assignment.target {
-            AssignmentTarget::ColumnName(name) => {
-                if let Some(column) = object_name_leaf(name) {
-                    columns.push(column);
-                }
-            }
-            AssignmentTarget::Tuple(names) => {
-                for name in names {
-                    if let Some(column) = object_name_leaf(name) {
-                        columns.push(column);
-                    }
-                }
-            }
-        }
-    }
-    Ok(columns)
-}
-
-fn insert_target_name(table: &TableObject) -> Option<String> {
-    match table {
-        TableObject::TableName(name) => object_name_leaf(name),
-        _ => None,
-    }
-}
-
-fn table_with_joins_target_name(table: &TableWithJoins) -> Option<String> {
-    match &table.relation {
-        TableFactor::Table { name, .. } => object_name_leaf(name),
-        _ => None,
-    }
-}
-
-fn object_name_leaf(name: &ObjectName) -> Option<String> {
-    name.0
-        .last()
-        .and_then(|part| part.as_ident())
-        .map(|ident| ident.value.to_ascii_lowercase())
-}

package/dist-engine-src/src/sql2/public_bind/mod.rs

@@ -1,25 +0,0 @@
-mod assignment;
-mod capability;
-mod dml;
-mod table;
-
-use datafusion::logical_expr::LogicalPlan;
-use serde_json::Value as JsonValue;
-
-use crate::LixError;
-
-pub(crate) use dml::DmlOperation;
-
-pub(crate) fn validate_public_dml_sql(
-    sql: &str,
-    visible_schemas: &[JsonValue],
-) -> Result<(), LixError> {
-    dml::validate_sql(sql, visible_schemas)
-}
-
-pub(crate) fn validate_public_dml_plan(
-    plan: &LogicalPlan,
-    visible_schemas: &[JsonValue],
-) -> Result<(), LixError> {
-    dml::validate_plan(plan, visible_schemas)
-}

package/dist-engine-src/src/sql2/public_bind/table.rs

@@ -1,168 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-
-use serde_json::Value as JsonValue;
-
-use crate::schema::schema_key_from_definition;
-use crate::LixError;
-
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum Capability {
-    Allowed,
-    ReadOnly(&'static str),
-    Unsupported(&'static str),
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct ColumnContract {
-    pub(crate) writable: bool,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct TableContract {
-    pub(crate) insert: Capability,
-    pub(crate) update: Capability,
-    pub(crate) delete: Capability,
-    pub(crate) columns: BTreeMap<String, ColumnContract>,
-}
-
-impl TableContract {
-    pub(crate) fn operation(&self, operation: super::DmlOperation) -> Capability {
-        match operation {
-            super::DmlOperation::Insert => self.insert,
-            super::DmlOperation::Update => self.update,
-            super::DmlOperation::Delete => self.delete,
-        }
-    }
-
-    pub(crate) fn column(&self, column: &str) -> Option<&ColumnContract> {
-        self.columns.get(column)
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
-pub(crate) struct PublicSurface {
-    name: String,
-}
-
-impl PublicSurface {
-    pub(crate) fn named(name: impl Into<String>) -> Self {
-        Self {
-            name: name.into().to_ascii_lowercase(),
-        }
-    }
-
-    pub(crate) fn name(&self) -> &str {
-        &self.name
-    }
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct PublicTableContracts {
-    contracts: BTreeMap<String, TableContract>,
-}
-
-impl PublicTableContracts {
-    pub(crate) fn new(visible_schemas: &[JsonValue]) -> Result<Self, LixError> {
-        let mut contracts = builtin_contracts();
-        for schema in visible_schemas {
-            let schema_key = schema_key_from_definition(schema)?.schema_key;
-            contracts.insert(
-                format!("{}_history", schema_key.to_ascii_lowercase()),
-                history_contract(),
-            );
-        }
-        Ok(Self { contracts })
-    }
-
-    pub(crate) fn get(&self, surface: &PublicSurface) -> Option<&TableContract> {
-        self.contracts.get(surface.name())
-    }
-}
-
-fn builtin_contracts() -> BTreeMap<String, TableContract> {
-    let mut contracts = BTreeMap::new();
-
-    for table in [
-        "lix_change",
-        "lix_commit",
-        "lix_commit_by_version",
-        "lix_commit_edge",
-        "lix_commit_edge_by_version",
-        "lix_change_set",
-        "lix_change_set_by_version",
-        "lix_change_set_element",
-        "lix_change_set_element_by_version",
-    ] {
-        contracts.insert(table.to_string(), commit_graph_contract());
-    }
-
-    for table in [
-        "lix_state_history",
-        "lix_file_history",
-        "lix_directory_history",
-    ] {
-        contracts.insert(table.to_string(), history_contract());
-    }
-
-    contracts.insert(
-        "lix_registered_schema".to_string(),
-        TableContract {
-            insert: Capability::Allowed,
-            update: Capability::Allowed,
-            delete: Capability::Unsupported(
-                "lix_registered_schema deletion is not supported; register an amended schema instead",
-            ),
-            columns: columns(&["value", "lixcol_metadata", "lixcol_global", "lixcol_untracked"]),
-        },
-    );
-
-    contracts.insert(
-        "lix_key_value".to_string(),
-        TableContract {
-            insert: Capability::Allowed,
-            update: Capability::Allowed,
-            delete: Capability::Allowed,
-            columns: columns(&["key", "value", "lixcol_metadata"]),
-        },
-    );
-
-    contracts
-}
-
-fn commit_graph_contract() -> TableContract {
-    TableContract {
-        insert: Capability::ReadOnly(
-            "Commit graph and changelog surfaces are read-only; Lix creates them when transactions commit.",
-        ),
-        update: Capability::ReadOnly(
-            "Commit graph and changelog surfaces are read-only; Lix creates them when transactions commit.",
-        ),
-        delete: Capability::ReadOnly(
-            "Commit graph and changelog surfaces are read-only; Lix creates them when transactions commit.",
-        ),
-        columns: BTreeMap::new(),
-    }
-}
-
-fn history_contract() -> TableContract {
-    TableContract {
-        insert: Capability::ReadOnly(
-            "History views are query-only; write to the live surface such as lix_state, lix_file, lix_directory, or the typed entity table.",
-        ),
-        update: Capability::ReadOnly(
-            "History views are query-only; write to the live surface such as lix_state, lix_file, lix_directory, or the typed entity table.",
-        ),
-        delete: Capability::ReadOnly(
-            "History views are query-only; write to the live surface such as lix_state, lix_file, lix_directory, or the typed entity table.",
-        ),
-        columns: BTreeMap::new(),
-    }
-}
-
-fn columns(writable: &[&str]) -> BTreeMap<String, ColumnContract> {
-    let writable = writable.iter().copied().collect::<BTreeSet<_>>();
-    writable
-        .into_iter()
-        .map(|column| (column.to_string(), ColumnContract { writable: true }))
-        .collect()
-}