feat: added support for loadExtension

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,41 @@ 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' });
+  
+  // Platform-specific extension paths
+  const extensionPath = Platform.OS === 'ios' 
+    ? 'path/to/extension.dylib'
+    : 'path/to/extension.so';
+  
+  // Load the extension
+  const success = db.loadExtension(extensionPath);
+  
+  if (success) {
+    // Use the extension's functionality
+    const result = db.execute('SELECT extension_function(?) as result', [someValue]);
+    console.log('Result:', result.rows._array[0].result);
+  }
+} catch (e) {
+  console.error('Failed to load extension:', e.message);
+}
+```
+
+Notes about extensions:
+- Extensions must be compiled specifically for each platform (iOS, Android)
+- The extension path should be accessible from your app's bundle
+- Extensions are useful for adding mathematical functions, encryption, full-text search, and more
+- For iOS, extensions need to be included in the app bundle
+- For Android, extensions should be in the app's native libs directory
+
 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
 }