feat: added support to load extension

Author: vardhanmabbu

README.md

@@ -71,7 +71,8 @@ db = {
   executeBatch: (commands: BatchQueryCommand[]) => BatchQueryResult,
   executeBatchAsync: (commands: BatchQueryCommand[]) => Promise<BatchQueryResult>,
   loadFile: (location: string) => FileLoadResult;,
-  loadFileAsync: (location: string) => Promise<FileLoadResult>
+  loadFileAsync: (location: string) => Promise<FileLoadResult>,
+  loadExtension: (path: string, entryPoint?: string) => void
 }
 ```
 
@@ -249,6 +250,78 @@ You can, at any moment, detach a database that you don't need anymore. You don't
 
 SQLite has a limit for attached databases: A default of 10, and a global max of 125
 
+## Loading SQLite Extensions
+
+SQLite supports loading extensions that can add new functions, virtual tables, collations, and more to your database connection. NitroSQLite provides the `loadExtension` method to dynamically load SQLite extensions.
+
+```typescript
+import { open } from 'react-native-nitro-sqlite';
+
+try {
+  const db = open({ name: 'myDb.sqlite' });
+  
+  // Load the extension
+  db.loadExtension('/path/to/extension');
+  
+  // Now you can use the extension's functionality
+  const result = db.execute('SELECT extension_function(?) as result', [someValue]);
+} catch (e) {
+  console.error('Failed to load extension:', e.message);
+}
+```
+
+### Setting up extensions in your project
+
+To use SQLite extensions with your app, you need to:
+
+#### Android
+1. Place extension files (`.so` files) in your app's assets folder
+2. Add these files to your Android project
+3. At runtime, copy the file from assets to a readable location before loading
+
+#### iOS
+1. Add extension files (`.dylib` files) to your Xcode project
+2. Make sure they're included in "Build Phases → Copy Bundle Resources"
+3. At runtime, the files will be available in your app's bundle
+
+### Implementation example
+
+```typescript
+async loadExtension(): Promise<void> {
+  try {
+    const appDir = getAppDirectory();
+    
+    if (Platform.OS === 'android') {
+      const libFileName = `libextension.so`;
+      const destinationPath = `${appDir}/${libFileName}`;
+      
+      // Copy from assets to app directory then load
+      try {
+        await RNFS.copyFileAssets(libFileName, destinationPath);
+        this.db.loadExtension(`${appDir}/libextension`);
+      } catch (error) {
+        console.error('Failed to copy or load extension:', error);
+      }
+    } else if (Platform.OS === 'ios') {
+      const sourcePath = `${RNFS.MainBundlePath}/extension.dylib`;
+      const destPath = `${appDir}/libextension.dylib`;
+      
+      // Copy and load
+      try {
+        await RNFS.copyFile(sourcePath, destPath);
+        this.db.loadExtension(`${appDir}/libextension`);
+      } catch (error) {
+        console.error('Failed to copy or load extension:', error);
+      }
+    }
+  } catch (error) {
+    console.error('Failed to load SQLite extension:', error);
+  }
+}
+```
+
+You'll need the `react-native-fs` package for this implementation.
+
 References: [Attach](https://www.sqlite.org/lang_attach.html) - [Detach](https://www.sqlite.org/lang_detach.html)
 
 ```ts

package/cpp/operations.cpp

@@ -286,4 +286,42 @@ SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std:
   return {.rowsAffected = sqlite3_changes(db)};
 }
 
+void sqliteLoadExtension(const std::string& dbName, const std::string& path, const std::optional<std::string>& entryPoint) {
+  // Check if db connection is opened
+  if (dbMap.count(dbName) == 0) {
+    throw NitroSQLiteException::DatabaseNotOpen(dbName);
+  }
+
+  sqlite3* db = dbMap[dbName];
+  
+  // Enable extension loading (required before loading extensions)
+  int result = sqlite3_enable_load_extension(db, 1);
+  if (result != SQLITE_OK) {
+    throw NitroSQLiteException::SqlExecution("Failed to enable extensions: " + std::string(sqlite3_errmsg(db)));
+  }
+  
+  // Load the extension
+  char* error_msg = nullptr;
+  result = sqlite3_load_extension(
+    db, 
+    path.c_str(), 
+    entryPoint.has_value() ? entryPoint.value().c_str() : nullptr,
+    &error_msg
+  );
+  
+  // Check for errors
+  if (result != SQLITE_OK) {
+    std::string error = error_msg ? std::string(error_msg) : "Unknown error loading extension";
+    sqlite3_free(error_msg);
+    
+    // Disable extension loading
+    sqlite3_enable_load_extension(db, 0);
+    
+    throw NitroSQLiteException::SqlExecution("Failed to load extension: " + error);
+  }
+  
+  // Disable extension loading (security best practice)
+  sqlite3_enable_load_extension(db, 0);
+}
+
 } // namespace margelo::rnnitrosqlite

package/cpp/operations.hpp

@@ -21,4 +21,6 @@ SQLiteOperationResult sqliteExecuteLiteral(const std::string& dbName, const std:
 
 void sqliteCloseAll();
 
+void sqliteLoadExtension(const std::string& dbName, const std::string& path, const std::optional<std::string>& entryPoint);
+
 } // namespace margelo::rnnitrosqlite

package/cpp/specs/HybridNitroSQLite.cpp

@@ -93,4 +93,8 @@ std::shared_ptr<Promise<FileLoadResult>> HybridNitroSQLite::loadFileAsync(const
   });
 };
 
+void HybridNitroSQLite::loadExtension(const std::string& dbName, const std::string& path, const std::optional<std::string>& entryPoint) {
+  sqliteLoadExtension(dbName, path, entryPoint);
+};
+
 } // namespace margelo::nitro::rnnitrosqlite

package/cpp/specs/HybridNitroSQLite.hpp

@@ -37,6 +37,8 @@ class HybridNitroSQLite : public HybridNitroSQLiteSpec {
 
   FileLoadResult loadFile(const std::string& dbName, const std::string& location) override;
   std::shared_ptr<Promise<FileLoadResult>> loadFileAsync(const std::string& dbName, const std::string& location) override;
+
+  void loadExtension(const std::string& dbName, const std::string& path, const std::optional<std::string>& entryPoint);
 };
 
 inline std::string HybridNitroSQLite::docPath = "";

package/nitrogen/generated/shared/c++/HybridNitroSQLiteSpec.cpp

@@ -21,6 +21,8 @@ export const NitroSQLite = {
   executeAsync,
   executeBatch,
   executeBatchAsync,
+  // Add loadExtension to make it accessible from the NitroSQLite object
+  loadExtension: HybridNitroSQLite.loadExtension,
 }
 
 export { open } from './operations/session'

package/nitrogen/generated/shared/c++/HybridNitroSQLiteSpec.hpp

@@ -41,6 +41,8 @@ export function open(
       HybridNitroSQLite.loadFile(options.name, location),
     loadFileAsync: (location: string) =>
       HybridNitroSQLite.loadFileAsync(options.name, location),
+    loadExtension: (path: string, entryPoint?: string) =>
+      HybridNitroSQLite.loadExtension(options.name, path, entryPoint),
   }
 }
 

package/src/index.ts

@@ -39,4 +39,5 @@ export interface NitroSQLite
   ): Promise<BatchQueryResult>
   loadFile(dbName: string, location: string): FileLoadResult
   loadFileAsync(dbName: string, location: string): Promise<FileLoadResult>
+  loadExtension(dbName: string, path: string, entryPoint?: string): void
 }