enhancement: WASM error codes, early exit on error or kill switch

packages/fuel-indexer-api-server/src/uses.rs

@@ -180,6 +180,12 @@ pub(crate) async fn remove_indexer(
     }))
     .await?;
 
+    // We have early termination on a kill switch. Yet, it is still possible for
+    // the database entries to be removed before the indexer has time to act on
+    // kill switch being triggered. Adding a small delay here should prevent
+    // unnecessary DatabaseError's appearing in the logs.
+    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+
     // Allways remove data when removing an indexer.
     if let Err(e) =
         queries::remove_indexer(&mut conn, &namespace, &identifier, true).await

packages/fuel-indexer-database/src/lib.rs

@@ -28,6 +28,8 @@ pub enum IndexerDatabaseError {
     Unknown,
     #[error("You don't own this indexer.")]
     NotYourIndexer,
+    #[error("No table mapping exists for TypeId({0:?})")]
+    TableMappingDoesNotExist(i64),
 }
 
 #[derive(Debug)]

packages/fuel-indexer-lib/src/lib.rs

@@ -36,6 +36,70 @@ impl ExecutionSource {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum WasmIndexerError {
+    DeserializationError = 1,
+    SerializationError,
+    PutObjectError,
+    UnableToSaveListType,
+    UninitializedMemory,
+    UnableToFetchLogString,
+    KillSwitch,
+    DatabaseError,
+    GeneralError,
+}
+
+impl From<i32> for WasmIndexerError {
+    fn from(value: i32) -> Self {
+        match value {
+            0 => unreachable!("WasmIndexerError index starts at 1"),
+            1 => Self::DeserializationError,
+            2 => Self::SerializationError,
+            3 => Self::PutObjectError,
+            4 => Self::UnableToSaveListType,
+            5 => Self::UninitializedMemory,
+            6 => Self::UnableToFetchLogString,
+            7 => Self::KillSwitch,
+            8 => Self::DatabaseError,
+            _ => Self::GeneralError,
+        }
+    }
+}
+
+impl std::fmt::Display for WasmIndexerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::SerializationError => {
+                write!(f, "Failed to serialize")
+            }
+            Self::DeserializationError => {
+                write!(f, "Failed to deserialize")
+            }
+            Self::UnableToSaveListType => {
+                write!(f, "Failed to save list")
+            }
+            Self::PutObjectError => {
+                write!(f, "Failed to save object")
+            }
+            Self::UninitializedMemory => {
+                write!(f, "Failed to create MemoryView for indexer")
+            }
+            Self::UnableToFetchLogString => {
+                write!(f, "Failed to fetch log string")
+            }
+            Self::KillSwitch => {
+                write!(f, "Kill switch has been triggered")
+            }
+            Self::DatabaseError => {
+                write!(f, "Failed performing a database operation")
+            }
+            Self::GeneralError => write!(f, "A WASM error occurred"),
+        }
+    }
+}
+
+impl std::error::Error for WasmIndexerError {}
+
 /// Return a fully qualified indexer namespace.
 pub fn fully_qualified_namespace(namespace: &str, identifier: &str) -> String {
     format!("{}_{}", namespace, identifier)

packages/fuel-indexer-macros/src/decoder.rs

@@ -833,7 +833,7 @@ impl From<ObjectDecoder> for TokenStream {
                                             .map(|query| query.to_string())
                                             .collect::<Vec<_>>();
 
-                                        d.lock().await.put_many_to_many_record(queries).await;
+                                        d.lock().await.put_many_to_many_record(queries).await.expect(&format!("Entity::save_many_to_many for {} failed.", stringify!(#ident)));
                                     }
                                 }
                                 None => {}
@@ -846,12 +846,15 @@ impl From<ObjectDecoder> for TokenStream {
                             match &db {
                                 Some(d) => {
                                     match d.lock().await.get_object(Self::TYPE_ID, id.to_string()).await {
-                                        Some(bytes) => {
+                                        Ok(Some(bytes)) => {
                                             let columns: Vec<FtColumn> = bincode::deserialize(&bytes).expect("Failed to deserialize Vec<FtColumn> for Entity::load.");
                                             let obj = Self::from_row(columns);
                                             Some(obj)
                                         },
-                                        None => None,
+                                        Ok(None) => None,
+                                        Err(e) => {
+                                            panic!("Entity::load for {} failed.", stringify!(#ident))
+                                        }
                                     }
                                 }
                                 None => None,
@@ -868,7 +871,7 @@ impl From<ObjectDecoder> for TokenStream {
                                         Self::TYPE_ID,
                                         self.to_row(),
                                         serialize(&self.to_row())
-                                    ).await;
+                                    ).await.expect(&format!("Entity::save for {} failed.", stringify!(#ident)));
                                 }
                                 None => {},
                             }