Merge pull request #256 from OP-Engineering/oscar/rework-attach

Rework attach function

Author: ospfranco

cpp/DBHostObject.cpp

@@ -188,54 +188,43 @@ DBHostObject::DBHostObject(jsi::Runtime &rt, std::string &base_path,
 
 void DBHostObject::create_jsi_functions() {
     function_map["attach"] = HOSTFN("attach") {
-        if (count < 3) {
-            throw std::runtime_error(
-                "[op-sqlite][attach] Incorrect number of arguments");
-        }
-        if (!args[0].isString() || !args[1].isString() || !args[2].isString()) {
-            throw std::runtime_error("[op-sqlite] name, database to attach and "
-                                     "alias must be strings");
-        }
-
         std::string secondary_db_path = std::string(base_path);
-        if (count > 3) {
-            if (!args[3].isString()) {
-                throw std::runtime_error(
-                    "[op-sqlite][attach] database location must be a string");
-            }
 
-            secondary_db_path += "/" + args[3].asString(rt).utf8(rt);
+        auto obj_params = args[0].asObject(rt);
+
+        std::string secondary_db_name =
+            obj_params.getProperty(rt, "secondaryDbFileName")
+                .asString(rt)
+                .utf8(rt);
+        std::string alias =
+            obj_params.getProperty(rt, "alias").asString(rt).utf8(rt);
+
+        if (obj_params.hasProperty(rt, "location")) {
+            std::string location =
+                obj_params.getProperty(rt, "location").asString(rt).utf8(rt);
+            secondary_db_path = secondary_db_path + location;
         }
 
-        std::string main_db_name = args[0].asString(rt).utf8(rt);
-        std::string secondary_db_name = args[1].asString(rt).utf8(rt);
-        std::string alias = args[2].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
         opsqlite_libsql_attach(db, secondary_db_path, secondary_db_name, alias);
 #else
-        opsqlite_attach(db, main_db_name, secondary_db_path, secondary_db_name,
-                        alias);
+        opsqlite_attach(db, secondary_db_path, secondary_db_name, alias);
 #endif
 
         return {};
     });
 
     function_map["detach"] = HOSTFN("detach") {
-        if (count < 2) {
-            throw std::runtime_error(
-                "[op-sqlite][detach] Incorrect number of arguments");
-        }
-        if (!args[0].isString() || !args[1].isString()) {
-            throw std::runtime_error(
-                "[op-sqlite] database name and alias must be a strings");
+
+        if (!args[0].isString()) {
+            throw std::runtime_error("[op-sqlite] alias must be a strings");
         }
 
-        std::string dbName = args[0].asString(rt).utf8(rt);
-        std::string alias = args[1].asString(rt).utf8(rt);
+        std::string alias = args[0].asString(rt).utf8(rt);
 #ifdef OP_SQLITE_USE_LIBSQL
         opsqlite_libsql_detach(db, alias);
 #else
-        opsqlite_detach(db, dbName, alias);
+        opsqlite_detach(db, alias);
 #endif
 
         return {};

cpp/bridge.cpp

@@ -150,8 +150,7 @@ void opsqlite_close(sqlite3 *db) {
     sqlite3_close_v2(db);
 }
 
-void opsqlite_attach(sqlite3 *db, std::string const &main_db_name,
-                     std::string const &doc_path,
+void opsqlite_attach(sqlite3 *db, std::string const &doc_path,
                      std::string const &secondary_db_name,
                      std::string const &alias) {
     auto secondary_db_path = opsqlite_get_db_path(secondary_db_name, doc_path);
@@ -160,8 +159,7 @@ void opsqlite_attach(sqlite3 *db, std::string const &main_db_name,
     opsqlite_execute(db, statement, nullptr);
 }
 
-void opsqlite_detach(sqlite3 *db, std::string const &main_db_name,
-                     std::string const &alias) {
+void opsqlite_detach(sqlite3 *db, std::string const &alias) {
     std::string statement = "DETACH DATABASE " + alias;
     opsqlite_execute(db, statement, nullptr);
 }

cpp/bridge.h

@@ -37,13 +37,11 @@ void opsqlite_close(sqlite3 *db);
 void opsqlite_remove(sqlite3 *db, std::string const &name,
                      std::string const &doc_path);
 
-void opsqlite_attach(sqlite3 *db, std::string const &main_db_name,
-                     std::string const &doc_path,
+void opsqlite_attach(sqlite3 *db, std::string const &doc_path,
                      std::string const &secondary_db_name,
                      std::string const &alias);
 
-void opsqlite_detach(sqlite3 *db, std::string const &main_db_name,
-                     std::string const &alias);
+void opsqlite_detach(sqlite3 *db, std::string const &alias);
 
 BridgeResult opsqlite_execute(sqlite3 *db, std::string const &query,
                               const std::vector<JSVariant> *params);

docs/docs/api.md

@@ -188,17 +188,19 @@ SQLite has a limit for attached databases: A default of 10, and a global max of
 SQLite docs for [Attach](https://www.sqlite.org/lang_attach.html) - [Detach](https://www.sqlite.org/lang_detach.html)
 
 ```tsx
-db.attach('mainDatabase', 'statistics', 'stats', '../databases');
+// Follows similar API to the `open` call
+db.attach({
+  secondaryDbFileName: 'statistics.sqlite', // Filename of the database (JUST THE FILENAME)
+  alias: 'stats', // Alias to be applied to the db
+  location: '../databases', // Path to be prepended to secondaryFileName, in this case full db path: ../databases/statistics.sqlite
+});
 
 const res = await db.execute(
   'SELECT * FROM some_table_from_mainschema a INNER JOIN stats.some_table b on a.id_column = b.id_column'
 );
 
 // You can detach databases at any moment
-db.detach('mainDatabase', 'stats');
-if (!detachResult.status) {
-  // Database de-attached
-}
+db.detach('stats');
 ```
 
 ## Loading SQL Dump Files

example/ios/Podfile.lock

@@ -1785,7 +1785,7 @@ SPEC CHECKSUMS:
   GCDWebServer: 2c156a56c8226e2d5c0c3f208a3621ccffbe3ce4
   glog: 08b301085f15bcbb6ff8632a8ebaf239aae04e6a
   hermes-engine: 06a9c6900587420b90accc394199527c64259db4
-  op-sqlite: 4f4f7845e0208b1a6dfa6ac3db7dcab039c109b7
+  op-sqlite: e71ef23bf3ab929cc6f2263ad2683317b21a80a6
   RCT-Folly: bf5c0376ffe4dd2cf438dcf86db385df9fdce648
   RCTDeprecation: fb7d408617e25d7f537940000d766d60149c5fea
   RCTRequired: 9aaf0ffcc1f41f0c671af863970ef25c422a9920

example/package.json

@@ -66,7 +66,7 @@
     "node": ">=18"
   },
   "op-sqlite": {
-    "libsql": true,
+    "libsql": false,
     "sqlcipher": false,
     "iosSqlite": false,
     "fts5": true,

example/src/tests/dbsetup.spec.ts

@@ -238,14 +238,21 @@ export function dbSetupTests() {
       encryptionKey: 'test',
     });
     db2.close();
-    db.attach('attachTest.sqlite', 'attachTest2.sqlite', 'attach2');
+
+    db.attach({
+      secondaryDbFileName: 'attachTest2.sqlite',
+      alias: 'attach2',
+    });
+
     db.executeSync('DROP TABLE IF EXISTS attach2.test;');
     db.executeSync(
       'CREATE TABLE IF NOT EXISTS attach2.test (id INTEGER PRIMARY KEY);',
     );
     let res = db.executeSync('INSERT INTO attach2.test (id) VALUES (1);');
     expect(res).to.exist;
-    db.detach('attachTest2.sqlite', 'attach2');
+
+    db.detach('attach2');
+
     db.delete();
 
     db2 = open({

mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "3.3.0"

src/index.ts

@@ -103,13 +103,12 @@ export type PreparedStatement = {
 type InternalDB = {
   close: () => void;
   delete: (location?: string) => void;
-  attach: (
-    mainDbName: string,
-    dbNameToAttach: string,
-    alias: string,
-    location?: string
-  ) => void;
-  detach: (mainDbName: string, alias: string) => void;
+  attach: (params: {
+    secondaryDbFileName: string;
+    alias: string;
+    location?: string;
+  }) => void;
+  detach: (alias: string) => void;
   transaction: (fn: (tx: Transaction) => Promise<void>) => Promise<void>;
   executeSync: (query: string, params?: Scalar[]) => QueryResult;
   execute: (query: string, params?: Scalar[]) => Promise<QueryResult>;
@@ -151,13 +150,12 @@ type InternalDB = {
 export type DB = {
   close: () => void;
   delete: (location?: string) => void;
-  attach: (
-    mainDbName: string,
-    dbNameToAttach: string,
-    alias: string,
-    location?: string
-  ) => void;
-  detach: (mainDbName: string, alias: string) => void;
+  attach: (params: {
+    secondaryDbFileName: string;
+    alias: string;
+    location?: string;
+  }) => void;
+  detach: (alias: string) => void;
   /**
    * Wraps all the executions into a transaction. If an error is thrown it will rollback all of the changes
    *