Use structured errors

Author: simolus3

Cargo.lock

@@ -22,6 +22,7 @@ serde = { version = "1.0", default-features = false, features = ["alloc", "deriv
 const_format = "0.2.34"
 futures-lite = { version = "2.6.0", default-features = false, features = ["alloc"] }
 rustc-hash = { version = "2.1", default-features = false }
+thiserror = { version = "2", default-features = false }
 
 [dependencies.uuid]
 version = "1.4.1"

crates/core/Cargo.toml

@@ -47,6 +47,8 @@ impl BsonError {
     }
 }
 
+impl core::error::Error for BsonError {}
+
 impl Display for BsonError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         self.err.fmt(f)

crates/core/src/bson/error.rs

@@ -11,7 +11,7 @@ use sqlite_nostd as sqlite;
 use sqlite_nostd::{Connection, Context, Value};
 
 use crate::create_sqlite_text_fn;
-use crate::error::SQLiteError;
+use crate::error::PowerSyncError;
 use crate::sync::checkpoint::{validate_checkpoint, OwnedBucketChecksum};
 use crate::sync::line::Checkpoint;
 
@@ -24,7 +24,7 @@ struct CheckpointResult {
 fn powersync_validate_checkpoint_impl(
     ctx: *mut sqlite::context,
     args: &[*mut sqlite::value],
-) -> Result<String, SQLiteError> {
+) -> Result<String, PowerSyncError> {
     let data = args[0].text();
     let checkpoint: Checkpoint = serde_json::from_str(data)?;
     let db = ctx.db_handle();

crates/core/src/checkpoint.rs

@@ -12,7 +12,7 @@ use sqlite::{Connection, ResultCode, Value};
 use sqlite_nostd::ManagedStmt;
 use sqlite_nostd::{self as sqlite, ColumnType};
 
-use crate::error::SQLiteError;
+use crate::error::{PowerSyncError, RawPowerSyncError};
 use crate::ext::SafeManagedStmt;
 use crate::schema::TableInfoFlags;
 use crate::state::DatabaseState;
@@ -81,11 +81,11 @@ impl VirtualTable {
         }
     }
 
-    fn handle_insert(&mut self, args: &[*mut sqlite::value]) -> Result<(), SQLiteError> {
+    fn handle_insert(&mut self, args: &[*mut sqlite::value]) -> Result<(), PowerSyncError> {
         let current_tx = self
             .current_tx
             .as_mut()
-            .ok_or_else(|| SQLiteError::misuse("No tx_id"))?;
+            .ok_or_else(|| PowerSyncError::from(RawPowerSyncError::CrudVtabOutsideOfTransaction))?;
         let db = self.db;
 
         if self.state.is_in_sync_local.load(Ordering::Relaxed) {
@@ -178,7 +178,7 @@ impl VirtualTable {
         Ok(())
     }
 
-    fn begin(&mut self) -> Result<(), SQLiteError> {
+    fn begin(&mut self) -> Result<(), PowerSyncError> {
         let db = self.db;
 
         // language=SQLite
@@ -187,7 +187,7 @@ impl VirtualTable {
         let tx_id = if statement.step()? == ResultCode::ROW {
             statement.column_int64(0) - 1
         } else {
-            return Err(SQLiteError::from(ResultCode::ABORT));
+            return Err(PowerSyncError::from(RawPowerSyncError::Internal));
         };
 
         self.current_tx = Some(ActiveCrudTransaction {
@@ -328,7 +328,7 @@ extern "C" fn disconnect(vtab: *mut sqlite::vtab) -> c_int {
 extern "C" fn begin(vtab: *mut sqlite::vtab) -> c_int {
     let tab = unsafe { &mut *(vtab.cast::<VirtualTable>()) };
     let result = tab.begin();
-    vtab_result(vtab, result)
+    vtab_result(vtab, tab.db, result)
 }
 
 extern "C" fn commit(vtab: *mut sqlite::vtab) -> c_int {
@@ -361,7 +361,7 @@ extern "C" fn update(
         // INSERT
         let tab = unsafe { &mut *(vtab.cast::<VirtualTable>()) };
         let result = tab.handle_insert(&args[2..]);
-        vtab_result(vtab, result)
+        vtab_result(vtab, tab.db, result)
     } else {
         // UPDATE - not supported
         ResultCode::MISUSE as c_int

crates/core/src/crud_vtab.rs

@@ -10,19 +10,19 @@ use sqlite_nostd::{Connection, Context, Value};
 use serde_json as json;
 
 use crate::create_sqlite_text_fn;
-use crate::error::SQLiteError;
+use crate::error::{PowerSyncError, RawPowerSyncError};
 
 fn powersync_diff_impl(
     _ctx: *mut sqlite::context,
     args: &[*mut sqlite::value],
-) -> Result<String, SQLiteError> {
+) -> Result<String, PowerSyncError> {
     let data_old = args[0].text();
     let data_new = args[1].text();
 
     diff_objects(data_old, data_new)
 }
 
-pub fn diff_objects(data_old: &str, data_new: &str) -> Result<String, SQLiteError> {
+pub fn diff_objects(data_old: &str, data_new: &str) -> Result<String, PowerSyncError> {
     let v_new: json::Value = json::from_str(data_new)?;
     let v_old: json::Value = json::from_str(data_old)?;
 
@@ -56,7 +56,7 @@ pub fn diff_objects(data_old: &str, data_new: &str) -> Result<String, SQLiteErro
 
         Ok(json::Value::Object(left).to_string())
     } else {
-        Err(SQLiteError::from(ResultCode::MISMATCH))
+        Err(RawPowerSyncError::ExpectedJsonObject.into())
     }
 }
 

crates/core/src/diff.rs

@@ -1,97 +1,145 @@
+use core::fmt::Display;
+
 use alloc::{
     borrow::Cow,
+    boxed::Box,
     format,
     string::{String, ToString},
 };
-use core::error::Error;
 use sqlite_nostd::{context, sqlite3, Connection, Context, ResultCode};
+use thiserror::Error;
 
 use crate::bson::BsonError;
 
-#[derive(Debug)]
-pub struct SQLiteError(pub ResultCode, pub Option<Cow<'static, str>>);
+/// A [RawPowerSyncError], but boxed.
+///
+/// We allocate errors in boxes to avoid large [Result] types returning these.
+pub struct PowerSyncError {
+    inner: Box<RawPowerSyncError>,
+}
 
-impl SQLiteError {
-    pub fn with_description(code: ResultCode, message: impl Into<Cow<'static, str>>) -> Self {
-        Self(code, Some(message.into()))
+impl PowerSyncError {
+    pub fn from_sqlite(code: ResultCode, context: impl Into<Cow<'static, str>>) -> Self {
+        RawPowerSyncError::Sqlite {
+            code,
+            context: Some(context.into()),
+        }
+        .into()
     }
 
-    pub fn misuse(message: impl Into<Cow<'static, str>>) -> Self {
-        Self::with_description(ResultCode::MISUSE, message)
+    pub fn argument_error(desc: &'static str) -> Self {
+        RawPowerSyncError::ArgumentError { desc }.into()
     }
-}
 
-impl core::fmt::Display for SQLiteError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "SQLiteError: {:?}", self.0)?;
-        if let Some(desc) = &self.1 {
-            write!(f, ", desc: {}", desc)?;
-        }
-        Ok(())
+    pub fn state_error(desc: &'static str) -> Self {
+        RawPowerSyncError::StateError { desc }.into()
     }
-}
 
-impl SQLiteError {
     pub fn apply_to_ctx(self, description: &str, ctx: *mut context) {
-        let SQLiteError(code, message) = self;
-
-        if let Some(msg) = message {
-            ctx.result_error(&format!("{:} {:}", description, msg));
-        } else {
-            let error = ctx.db_handle().errmsg().unwrap();
-            if error == "not an error" {
-                ctx.result_error(&format!("{:}", description));
-            } else {
-                ctx.result_error(&format!("{:} {:}", description, error));
+        let mut desc = self.description(ctx.db_handle());
+        desc.insert_str(0, description);
+        desc.insert_str(description.len(), ": ");
+
+        ctx.result_error(&desc);
+        ctx.result_error_code(self.sqlite_error_code());
+    }
+
+    /// Obtains a description of this error, fetching it from SQLite if necessary.
+    pub fn description(&self, db: *mut sqlite3) -> String {
+        if let RawPowerSyncError::Sqlite { .. } = &*self.inner {
+            let message = db.errmsg().unwrap_or(String::from("Conversion error"));
+            if message != "not an error" {
+                return format!("{}, caused by: {message}", self.inner);
             }
         }
-        ctx.result_error_code(code);
+
+        self.inner.to_string()
     }
-}
 
-impl Error for SQLiteError {}
+    pub fn sqlite_error_code(&self) -> ResultCode {
+        use RawPowerSyncError::*;
 
-pub trait PSResult<T> {
-    fn into_db_result(self, db: *mut sqlite3) -> Result<T, SQLiteError>;
+        match self.inner.as_ref() {
+            Sqlite { code, .. } => *code,
+            InvalidPendingStatement { .. }
+            | InvalidBucketPriority
+            | ExpectedJsonObject
+            | ArgumentError { .. }
+            | StateError { .. }
+            | JsonObjectTooBig
+            | CrudVtabOutsideOfTransaction => ResultCode::MISUSE,
+            MissingClientId | Internal => ResultCode::ABORT,
+            JsonError { .. } | BsonError { .. } => ResultCode::CONSTRAINT_DATATYPE,
+        }
+    }
 }
 
-impl<T> PSResult<T> for Result<T, ResultCode> {
-    fn into_db_result(self, db: *mut sqlite3) -> Result<T, SQLiteError> {
-        if let Err(code) = self {
-            let message = db.errmsg().unwrap_or(String::from("Conversion error"));
-            if message == "not an error" {
-                Err(SQLiteError(code, None))
-            } else {
-                Err(SQLiteError(code, Some(message.into())))
-            }
-        } else if let Ok(r) = self {
-            Ok(r)
-        } else {
-            Err(SQLiteError(ResultCode::ABORT, None))
-        }
+impl Display for PowerSyncError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.inner.fmt(f)
     }
 }
 
-impl From<ResultCode> for SQLiteError {
-    fn from(value: ResultCode) -> Self {
-        SQLiteError(value, None)
+impl From<RawPowerSyncError> for PowerSyncError {
+    fn from(value: RawPowerSyncError) -> Self {
+        return PowerSyncError {
+            inner: Box::new(value),
+        };
     }
 }
 
-impl From<serde_json::Error> for SQLiteError {
-    fn from(value: serde_json::Error) -> Self {
-        SQLiteError::with_description(ResultCode::ABORT, value.to_string())
+impl From<ResultCode> for PowerSyncError {
+    fn from(value: ResultCode) -> Self {
+        return RawPowerSyncError::Sqlite {
+            code: value,
+            context: None,
+        }
+        .into();
     }
 }
 
-impl From<core::fmt::Error> for SQLiteError {
-    fn from(value: core::fmt::Error) -> Self {
-        SQLiteError::with_description(ResultCode::INTERNAL, format!("{}", value))
+impl From<serde_json::Error> for PowerSyncError {
+    fn from(value: serde_json::Error) -> Self {
+        RawPowerSyncError::JsonError(value).into()
     }
 }
 
-impl From<BsonError> for SQLiteError {
+impl From<BsonError> for PowerSyncError {
     fn from(value: BsonError) -> Self {
-        SQLiteError::with_description(ResultCode::ERROR, value.to_string())
+        RawPowerSyncError::from(value).into()
     }
 }
+
+#[derive(Error, Debug)]
+pub enum RawPowerSyncError {
+    #[error("internal SQLite call returned {code}")]
+    Sqlite {
+        code: ResultCode,
+        context: Option<Cow<'static, str>>,
+    },
+    #[error("invalid argument: {desc}")]
+    ArgumentError { desc: &'static str },
+    #[error("invalid state: {desc}")]
+    StateError { desc: &'static str },
+    #[error("Function required a JSON object, but got another type of JSON value")]
+    ExpectedJsonObject,
+    #[error("No client_id found in ps_kv")]
+    MissingClientId,
+    #[error("Invalid pending statement for raw table: {description}")]
+    InvalidPendingStatement { description: Cow<'static, str> },
+    #[error("Invalid bucket priority value")]
+    InvalidBucketPriority,
+    #[error("Internal PowerSync error")]
+    Internal,
+    #[error("Error decoding JSON: {0}")]
+    JsonError(serde_json::Error),
+    #[error("Error decoding BSON")]
+    BsonError {
+        #[from]
+        source: BsonError,
+    },
+    #[error("Too many arguments passed to json_object_fragment")]
+    JsonObjectTooBig,
+    #[error("No tx_id")]
+    CrudVtabOutsideOfTransaction,
+}