HACKS

Author: penberg

index.d.ts

@@ -40,7 +40,7 @@ export declare class Database {
   aggregate(): void
   table(): void
   authorizer(rulesObj: object): void
-  loadExtension(path: string): void
+  loadExtension(path: string, entryPoint?: string | undefined | null): void
   maxWriteReplicationIndex(): number
   exec(sql: string): void
   interrupt(): void

src/lib.rs

@@ -285,54 +285,22 @@ impl Database {
         ))
     }
 
-    #[napi]
-    pub fn backup(&self) -> Result<()> {
-        todo!();
-    }
-
-    #[napi]
-    pub fn serialize(&self) -> Result<()> {
-        todo!();
-    }
-
-    #[napi]
-    pub fn function(&self) -> Result<()> {
-        todo!();
-    }
-
-    #[napi]
-    pub fn aggregate(&self) -> Result<()> {
-        todo!();
-    }
-
-    #[napi]
-    pub fn table(&self) -> Result<()> {
-        todo!();
-    }
-
     #[napi]
     pub fn authorizer(&self, env: Env, rules_obj: napi::JsObject) -> Result<()> {
-        // Acquire database connection
         let conn = match &self.conn {
             Some(c) => c.clone(),
             None => {
                 return Err(throw_database_closed_error(&env).into());
             }
         };
-
-        // Build allow/deny rules based on the provided object
         let mut builder = crate::auth::AuthorizerBuilder::new();
-
-        let prop_names = rules_obj.get_property_names()?; // JsObject (array)
+        let prop_names = rules_obj.get_property_names()?;
         let len = prop_names.get_array_length()?;
-
         for idx in 0..len {
             let key_js: napi::JsString = prop_names.get_element::<napi::JsString>(idx)?;
             let key = key_js.into_utf8()?.into_owned()?;
-
             let value_js: napi::JsNumber = rules_obj.get_named_property(&key)?;
             let value = value_js.get_int32()?;
-
             match value {
                 0 => {
                     // Authorization.ALLOW
@@ -351,29 +319,52 @@ impl Database {
                 }
             }
         }
-
         let authorizer = builder.build();
-
-        // Prepare closure
         let auth_arc = std::sync::Arc::new(authorizer);
         let closure = {
             let auth_arc = auth_arc.clone();
             move |ctx: &libsql::AuthContext| auth_arc.authorize(ctx)
         };
-
-        // Register with connection
         let rt = runtime()?;
         let guard_conn = rt.block_on(async { conn.lock().await });
         guard_conn
             .authorizer(Some(std::sync::Arc::new(closure)))
             .map_err(Error::from)?;
-
         Ok(())
     }
 
     #[napi]
-    pub fn loadExtension(&self, _path: String) -> Result<()> {
-        todo!();
+    pub fn loadExtension(&self, path: String, entry_point: Option<String>) -> Result<()> {
+        let rt = runtime()?;
+        let conn = match &self.conn {
+            Some(conn) => conn.clone(),
+            None => {
+                return Err(throw_sqlite_error(
+                    "The database connection is not open".to_string(),
+                    "SQLITE_NOTOPEN".to_string(),
+                    0,
+                ));
+            }
+        };
+
+        rt.block_on(async move {
+            let conn = conn.lock().await;
+            
+            // Enable extension loading
+            conn.load_extension_enable().map_err(Error::from)?;
+            
+            // Load the extension
+            if let Err(err) = conn.load_extension(&path, entry_point.as_deref()) {
+                // Disable extension loading on error
+                let _ = conn.load_extension_disable();
+                return Err(Error::from(err));
+            }
+            
+            // Disable extension loading after successful load
+            conn.load_extension_disable().map_err(Error::from)?;
+            
+            Ok(())
+        }).map_err(|e| napi::Error::from(e))
     }
 
     #[napi]