use crate::layer0::mcard_record::MCardRecord;
use rusqlite::functions::FunctionFlags;
use rusqlite::hooks::{AuthAction, AuthContext, Authorization};
use rusqlite::{Connection, Result};
pub fn install(conn: &Connection) -> Result<()> {
conn.create_scalar_function("clm_verified_algorithm", 3, FunctionFlags::SQLITE_UTF8, |ctx| {
let content = match ctx.get_raw(1) {
rusqlite::types::ValueRef::Text(bytes) | rusqlite::types::ValueRef::Blob(bytes) => bytes.to_vec(),
_ => return Err(rusqlite::Error::UserFunctionError("card content must be text or bytes".into())),
};
let record = MCardRecord { hash: ctx.get(0)?, content, g_time: ctx.get(2)? };
super::record_store::require_verified(&record)
.map_err(|error| rusqlite::Error::UserFunctionError(error.to_string().into()))
})?;
conn.execute_batch("PRAGMA recursive_triggers = ON;
DROP TRIGGER IF EXISTS temp.clm_card_insert;
DROP TRIGGER IF EXISTS temp.clm_card_update;
CREATE TEMP TRIGGER clm_card_insert BEFORE INSERT ON main.card BEGIN
SELECT clm_verified_algorithm(NEW.hash, NEW.content, NEW.g_time);
SELECT CASE WHEN EXISTS (SELECT 1 FROM main.card AS old WHERE old.hash = NEW.hash
AND (CAST(old.content AS BLOB) != CAST(NEW.content AS BLOB)
OR clm_verified_algorithm(old.hash, old.content, old.g_time)
!= clm_verified_algorithm(NEW.hash, NEW.content, NEW.g_time)))
THEN RAISE(ABORT, 'conflicting content-addressed row') END;
SELECT RAISE(IGNORE) WHERE EXISTS (SELECT 1 FROM main.card WHERE hash = NEW.hash);
END;
CREATE TEMP TRIGGER clm_card_update BEFORE UPDATE ON main.card BEGIN
SELECT clm_verified_algorithm(NEW.hash, NEW.content, NEW.g_time);
SELECT clm_verified_algorithm(OLD.hash, OLD.content, OLD.g_time);
SELECT CASE WHEN NEW.hash != OLD.hash OR CAST(NEW.content AS BLOB) != CAST(OLD.content AS BLOB)
OR NEW.g_time != OLD.g_time THEN RAISE(ABORT, 'content-addressed rows are immutable') END;
END;")?;
for (name, action) in [("clm_head_insert", "INSERT"), ("clm_head_update", "UPDATE")] {
conn.execute_batch(&format!("DROP TRIGGER IF EXISTS temp.{name};
CREATE TEMP TRIGGER {name} BEFORE {action} ON main.handle_registry BEGIN
SELECT clm_verified_algorithm(NEW.current_hash,
(SELECT content FROM main.card WHERE hash=NEW.current_hash OR hash=substr(NEW.current_hash,instr(NEW.current_hash,':')+1) ORDER BY hash=NEW.current_hash DESC LIMIT 1),
(SELECT g_time FROM main.card WHERE hash=NEW.current_hash OR hash=substr(NEW.current_hash,instr(NEW.current_hash,':')+1) ORDER BY hash=NEW.current_hash DESC LIMIT 1));
END;"))?;
}
conn.authorizer(Some(|context: AuthContext<'_>| {
let protected = |name: &str| ["card", "handle_registry"].iter().any(|table| name.eq_ignore_ascii_case(table));
let deny = match context.action {
AuthAction::Attach { .. } | AuthAction::Detach { .. } => true,
AuthAction::AlterTable { table_name, .. }
| AuthAction::DropTable { table_name }
| AuthAction::DropTempTable { table_name }
| AuthAction::CreateTempTable { table_name }
| AuthAction::CreateVtable { table_name, .. }
| AuthAction::DropVtable { table_name, .. }
| AuthAction::CreateTrigger { table_name, .. }
| AuthAction::CreateTempTrigger { table_name, .. }
| AuthAction::DropTrigger { table_name, .. }
| AuthAction::DropTempTrigger { table_name, .. } => protected(table_name),
AuthAction::CreateTempView { view_name } | AuthAction::CreateView { view_name } => protected(view_name),
AuthAction::Pragma { pragma_name, pragma_value } if pragma_name.eq_ignore_ascii_case("query_only") =>
pragma_value.is_some_and(|value| !["1", "on", "true"].iter().any(|safe| value.eq_ignore_ascii_case(safe))),
AuthAction::Pragma { pragma_name, pragma_value } => pragma_value.is_some()
&& ["writable_schema", "recursive_triggers", "trusted_schema", "temp_store", "temp_store_directory"].iter()
.any(|name| pragma_name.eq_ignore_ascii_case(name)),
AuthAction::Function { function_name } => function_name.eq_ignore_ascii_case("load_extension"),
AuthAction::Insert { table_name } | AuthAction::Update { table_name, .. }
| AuthAction::Delete { table_name } => protected(table_name)
&& context.database_name != Some("main"),
_ => false,
};
if deny { Authorization::Deny } else { Authorization::Allow }
}));
Ok(())
}