@op-engineering/op-sqlite 1.0.4 → 1.0.5

package/README.md

@@ -16,10 +16,6 @@ Created by [@ospfranco](https://twitter.com/ospfranco). Also created `react-nati
 
 **Please consider Sponsoring**, none of this work is for free. I pay for it with my time and knowledge. If you are a company in need of help with your React Native/React apps feel free to reach out. I also do a lot of C++ and nowadays Rust.
 
-## Known issues
-
-[ArrayBuffer support is commented out right now](https://github.com/OP-Engineering/op-sqlite/blob/main/cpp/bridge.cpp#L247). I will get to it in the next days or feel free to submit a PR.
-
 ## Coming up
 
 I will gladly review bug fixes, but in order for me to continue support and add new features, I ask you to sponsor me. Some of the things that can still be done to make this package faster and more complete:
@@ -35,9 +31,9 @@ You can find the [benchmarking code in the example app](https://github.com/OP-En
 
 | Library      | iPhone 15 Pro | Galaxy S22 |
 | ------------ | ------------- | ---------- |
-| quick-sqlite | 2719          | 8851       |
-| expo-sqlite  | 2293          | 10626      |
-| op-sqlite    | 507           | 1125       |
+| quick-sqlite | 2719ms        | 8851ms     |
+| expo-sqlite  | 2293ms        | 10626ms    |
+| op-sqlite    | 507ms         | 1125ms     |
 
 Memory consumption is also is also 1/4 compared to `react-native-quick-sqlite`. This query used to take 1.2gb of peak memory usage, now runs in 250mbs.
 
@@ -100,7 +96,7 @@ db = {
 
 The basic query is **synchronous**, it will block rendering on large operations, further below you will find async versions.
 
-```typescript
+```ts
 import { open } from '@op-engineering/op-sqlite';
 
 try {
@@ -108,7 +104,8 @@ try {
 
   let { rows } = db.execute('SELECT somevalue FROM sometable');
 
-  rows.forEach((row) => {
+  // _array internally holds the values, this is meant to comply with the webSQL spec
+  rows._array.forEach((row) => {
     console.log(row);
   });
 
@@ -123,6 +120,30 @@ try {
 }
 ```
 
+### Multiple statements in a single string
+
+You can execute multiple statements in a single operation. The API however is not really thought for this use case and the results (and their metadata) will be mangled, so you can discard it.
+
+```ts
+// The result of this query will all be in a single array, no point in trying to read it
+db.execute(
+  `CREATE TABLE T1 ( id INT PRIMARY KEY) STRICT;
+  CREATE TABLE T2 ( id INT PRIMARY KEY) STRICT;`
+);
+
+let t1name = db.execute(
+  "SELECT name FROM sqlite_master WHERE type='table' AND name='T1';"
+);
+
+console.log(t1name.rows?._array[0].name); // outputs "T1"
+
+let t2name = db.execute(
+  "SELECT name FROM sqlite_master WHERE type='table' AND name='T2';"
+);
+
+console.log(t2name.rows?._array[0].name); // outputs "T2"
+```
+
 ### Transactions
 
 Throwing an error inside the callback will ROLLBACK the transaction.
@@ -199,7 +220,7 @@ db.executeAsync(
   'myDatabase',
   'SELECT * FROM "User";',
   []).then(({rows}) => {
-    console.log('users', rows);
+    console.log('users', rows._array);
   })
 );
 ```
@@ -281,7 +302,7 @@ For example, you could add `SQLITE_ENABLE_FTS5=1` to `GCC_PREPROCESSOR_DEFINITIO
 You can specify flags via `<PROJECT_ROOT>/android/gradle.properties` like so:
 
 ```
-quickSqliteFlags="-DSQLITE_ENABLE_FTS5=1"
+OPSQLiteFlags="-DSQLITE_ENABLE_FTS5=1"
 ```
 
 ## Additional configuration

package/android/cpp-adapter.cpp

@@ -29,11 +29,11 @@ private:
     auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
     std::string docPathString = docPath->toStdString();
 
-    osp::install(*jsiRuntime, jsCallInvoker, docPathString.c_str());
+    opsqlite::install(*jsiRuntime, jsCallInvoker, docPathString.c_str());
   }
  
   static void clearStateNativeJsi(jni::alias_ref<jni::JObject> thiz) {
-    osp::clearState();
+    opsqlite::clearState();
   }
 };
 

package/cpp/DumbHostObject.cpp

@@ -2,7 +2,7 @@
 #include "utils.h"
 #include <iostream>
 
-namespace osp {
+namespace opsqlite {
 
     namespace jsi = facebook::jsi;
 

package/cpp/DumbHostObject.h

@@ -9,7 +9,7 @@
 #include "types.h"
 #include "DynamicHostObject.h"
 
-namespace osp {
+namespace opsqlite {
 
     namespace jsi = facebook::jsi;
 
@@ -23,7 +23,7 @@ namespace osp {
 
         jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
-        std::vector<jsVal> values;
+        std::vector<JSVariant> values;
         
         std::shared_ptr<std::vector<DynamicHostObject>> metadata;
     };

package/cpp/DynamicHostObject.cpp

@@ -2,7 +2,7 @@
 #include "utils.h"
 #include <iostream>
 
-namespace osp {
+namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 

package/cpp/DynamicHostObject.h

@@ -6,7 +6,7 @@
 #include <vector>
 #include "types.h"
 
-namespace osp {
+namespace opsqlite {
 
     namespace jsi = facebook::jsi;
 
@@ -18,7 +18,7 @@ namespace osp {
 
         jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
-        std::vector<std::pair<std::string, jsVal>> fields;
+        std::vector<std::pair<std::string, JSVariant>> fields;
     };
 
 }

package/cpp/ThreadPool.cpp

@@ -1,6 +1,6 @@
 #include "ThreadPool.h"
 
-namespace osp {
+namespace opsqlite {
 
 ThreadPool::ThreadPool() : done(false)
 {

package/cpp/ThreadPool.h

@@ -9,7 +9,7 @@
 #include <thread>
 #include <vector>
 
-namespace osp {
+namespace opsqlite {
 
 class ThreadPool {
 public:

package/cpp/bindings.cpp

@@ -10,7 +10,7 @@
 #include <iostream>
 #include "DumbHostObject.h"
 
-namespace osp {
+namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
@@ -192,7 +192,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
     {
         const std::string dbName = args[0].asString(rt).utf8(rt);
         const std::string query = args[1].asString(rt).utf8(rt);
-        std::vector<jsVal> params;
+        std::vector<JSVariant> params;
         if(count == 3) {
             const jsi::Value &originalParams = args[2];
             params = toAnyVec(rt, originalParams);
@@ -226,7 +226,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
         const std::string query = args[1].asString(rt).utf8(rt);
         const jsi::Value &originalParams = args[2];
         
-        std::vector<jsVal> params = toAnyVec(rt, originalParams);
+        std::vector<JSVariant> params = toAnyVec(rt, originalParams);
         
         auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
         auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
@@ -234,7 +234,7 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
             auto reject = std::make_shared<jsi::Value>(rt, args[1]);
             
             auto task =
-            [&rt, dbName, query, params = std::make_shared<std::vector<jsVal>>(params), resolve, reject]()
+            [&rt, dbName, query, params = std::make_shared<std::vector<JSVariant>>(params), resolve, reject]()
             {
                 try
                 {

package/cpp/bindings.h

@@ -4,7 +4,7 @@
 
 using namespace facebook;
 
-namespace osp {
+namespace opsqlite {
 
 void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker, const char *docPath);
 void clearState();

package/cpp/bridge.cpp

@@ -11,7 +11,7 @@
 #include "DumbHostObject.h"
 #include <variant>
 
-namespace osp {
+namespace opsqlite {
 
 std::unordered_map<std::string, sqlite3 *> dbMap = std::unordered_map<std::string, sqlite3 *>();
 
@@ -201,14 +201,14 @@ BridgeResult sqliteRemoveDb(std::string const dbName, std::string const docPath)
     };
 }
 
-inline void bindStatement(sqlite3_stmt *statement, std::vector<jsVal> *values)
+inline void bindStatement(sqlite3_stmt *statement, std::vector<JSVariant> *values)
 {
     size_t size = values->size();
     
     for (int ii = 0; ii < size; ii++)
     {
         int sqIndex = ii + 1;
-        jsVal value = values->at(ii);
+        JSVariant value = values->at(ii);
         
         if (std::holds_alternative<bool>(value))
         {
@@ -231,24 +231,19 @@ inline void bindStatement(sqlite3_stmt *statement, std::vector<jsVal> *values)
             std::string str = std::get<std::string>(value);
             sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(), SQLITE_TRANSIENT);
         }
-        else if(std::holds_alternative<JSBuffer>(value))
+        else if(std::holds_alternative<ArrayBuffer>(value))
         {
-            JSBuffer buffer = std::get<JSBuffer>(value);
+            ArrayBuffer buffer = std::get<ArrayBuffer>(value);
             sqlite3_bind_blob(statement, sqIndex, buffer.data.get(), buffer.size, SQLITE_STATIC);
         } else {
             sqlite3_bind_null(statement, sqIndex);
         }
-        //        else if (value.type() == typeid(const char*))
-        //        {
-        //            sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(), SQLITE_TRANSIENT);
-        //            return jsi::String::createFromAscii(rt, std::any_cast<const char*>(value));
-        //        }
     }
 }
 
 BridgeResult sqliteExecute(std::string const dbName,
                            std::string const &query,
-                           std::vector<jsVal> *params,
+                           std::vector<JSVariant> *params,
                            std::vector<DumbHostObject> *results,
                            std::shared_ptr<std::vector<DynamicHostObject>> metadatas)
 {
@@ -257,146 +252,151 @@ BridgeResult sqliteExecute(std::string const dbName,
     {
         return {
             .type = SQLiteError,
-            .message = "[op-sqlite]: Database " + dbName + " is not open",
-            .affectedRows = 0
+            .message = "[op-sqlite]: Database " + dbName + " is not open"
         };
     }
     
     sqlite3 *db = dbMap[dbName];
     
     sqlite3_stmt *statement;
-    
-    int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
-    
-    if (statementStatus == SQLITE_ERROR)
-    {
-        const char *message = sqlite3_errmsg(db);
-        return {
-            .type = SQLiteError,
-            .message = "[op-sqlite] SQL execution error: " + std::string(message),
-            .affectedRows = 0};
-    }
-    
-    bindStatement(statement, params);
+    const char *remainingStatement = nullptr;
     
     bool isConsuming = true;
     bool isFailed = false;
     
-    int result, i, count, column_type;
-    std::string column_name, column_declared_type;
-    
-    while (isConsuming)
-    {
-        result = sqlite3_step(statement);
+    do {
+        const char *queryStr = remainingStatement == nullptr ? query.c_str() : remainingStatement;
         
-        switch (result)
+        int statementStatus = sqlite3_prepare_v2(db, queryStr, -1, &statement, &remainingStatement);
+        
+        if (statementStatus == SQLITE_ERROR)
         {
-            case SQLITE_ROW: {
-                if(results == NULL)
-                {
-                    break;
-                }
-                
-                i = 0;
-                DumbHostObject row = DumbHostObject(metadatas);
-                
-                count = sqlite3_column_count(statement);
-                
-                while (i < count)
-                {
-                    column_type = sqlite3_column_type(statement, i);
+            const char *message = sqlite3_errmsg(db);
+            return {
+                .type = SQLiteError,
+                .message = "[op-sqlite] SQL execution error: " + std::string(message),
+            };
+        }
+        
+        bindStatement(statement, params);
+        
+        isConsuming = true;
+        
+        int result, i, count, column_type;
+        std::string column_name, column_declared_type;
+        
+        while (isConsuming)
+        {
+            result = sqlite3_step(statement);
+            
+            switch (result)
+            {
+                case SQLITE_ROW: {
+                    if(results == NULL)
+                    {
+                        break;
+                    }
+                    
+                    i = 0;
+                    DumbHostObject row = DumbHostObject(metadatas);
+                    
+                    count = sqlite3_column_count(statement);
                     
-                    switch (column_type)
+                    while (i < count)
                     {
-                        case SQLITE_INTEGER:
+                        column_type = sqlite3_column_type(statement, i);
+                        
+                        switch (column_type)
                         {
-                            /**
-                             * Warning this will loose precision because JS can
-                             * only represent Integers up to 53 bits
-                             */
-                            double column_value = sqlite3_column_double(statement, i);
-                            row.values.push_back(jsVal(column_value));
-                            break;
+                            case SQLITE_INTEGER:
+                            {
+                                /**
+                                 * Warning this will loose precision because JS can
+                                 * only represent Integers up to 53 bits
+                                 */
+                                double column_value = sqlite3_column_double(statement, i);
+                                row.values.push_back(JSVariant(column_value));
+                                break;
+                            }
+                                
+                            case SQLITE_FLOAT:
+                            {
+                                double column_value = sqlite3_column_double(statement, i);
+                                row.values.push_back(JSVariant(column_value));
+                                break;
+                            }
+                                
+                            case SQLITE_TEXT:
+                            {
+                                const char *column_value = reinterpret_cast<const char *>(sqlite3_column_text(statement, i));
+                                int byteLen = sqlite3_column_bytes(statement, i);
+                                // Specify length too; in case string contains NULL in the middle (which SQLite supports!)
+                                row.values.push_back(JSVariant(std::string(column_value, byteLen)));
+                                break;
+                            }
+                                
+                            case SQLITE_BLOB:
+                            {
+                                int blob_size = sqlite3_column_bytes(statement, i);
+                                const void *blob = sqlite3_column_blob(statement, i);
+                                uint8_t *data = new uint8_t[blob_size];
+                                memcpy(data, blob, blob_size);
+                                row.values.push_back(JSVariant(ArrayBuffer {
+                                    .data =  std::shared_ptr<uint8_t>{data},
+                                    .size =  static_cast<size_t>(blob_size)
+                                }));
+                                break;
+                            }
+                                
+                            case SQLITE_NULL:
+                                // Intentionally left blank
+                                
+                            default:
+                                row.values.push_back(JSVariant(NULL));
+                                break;
                         }
-                            
-                        case SQLITE_FLOAT:
-                        {
-                            double column_value = sqlite3_column_double(statement, i);
-                            row.values.push_back(jsVal(column_value));
-                            break;
-                        }
-                            
-                        case SQLITE_TEXT:
-                        {
-                            const char *column_value = reinterpret_cast<const char *>(sqlite3_column_text(statement, i));
-                            int byteLen = sqlite3_column_bytes(statement, i);
-                            // Specify length too; in case string contains NULL in the middle (which SQLite supports!)
-                            row.values.push_back(jsVal(std::string(column_value, byteLen)));
-                            break;
-                        }
-                            
-                        case SQLITE_BLOB:
-                        {
-                            int blob_size = sqlite3_column_bytes(statement, i);
-                            const void *blob = sqlite3_column_blob(statement, i);
-                            uint8_t *data = new uint8_t[blob_size];
-                            memcpy(data, blob, blob_size);
-                            row.values.push_back(jsVal(JSBuffer {
-                                .data =  std::shared_ptr<uint8_t>{data},
-                                .size =  static_cast<size_t>(blob_size)
-                            }));
-                            break;
-                        }
-                            
-                        case SQLITE_NULL:
-                            // Intentionally left blank
-                            
-                        default:
-                            row.values.push_back(jsVal(NULL));
-                            break;
+                        i++;
                     }
-                    i++;
+                    results->push_back(row);
+                    break;
                 }
-                results->push_back(row);
-                break;
-            }
-                
-            case SQLITE_DONE:
-                i = 0;
-                count = sqlite3_column_count(statement);
-                
-                while (i < count)
-                {
-                    column_name = sqlite3_column_name(statement, i);
-                    const char *type = sqlite3_column_decltype(statement, i);
-                    auto metadata = DynamicHostObject();
-                    metadata.fields.push_back(std::make_pair("name", column_name));
-                    metadata.fields.push_back(std::make_pair("index", i));
-                    metadata.fields.push_back(std::make_pair("type", type));
                     
-                    metadatas->push_back(metadata);
-                    i++;
-                }
-                
-                isConsuming = false;
-                break;
-                
-            default:
-                isFailed = true;
-                isConsuming = false;
+                case SQLITE_DONE:
+                    i = 0;
+                    count = sqlite3_column_count(statement);
+                    
+                    while (i < count)
+                    {
+                        column_name = sqlite3_column_name(statement, i);
+                        const char *type = sqlite3_column_decltype(statement, i);
+                        auto metadata = DynamicHostObject();
+                        metadata.fields.push_back(std::make_pair("name", column_name));
+                        metadata.fields.push_back(std::make_pair("index", i));
+                        metadata.fields.push_back(std::make_pair("type", type));
+                        
+                        metadatas->push_back(metadata);
+                        i++;
+                    }
+                    
+                    isConsuming = false;
+                    break;
+                    
+                default:
+                    isFailed = true;
+                    isConsuming = false;
+            }
         }
-    }
+        
+        sqlite3_finalize(statement);
+    } while (strcmp(remainingStatement, "") != 0 && !isFailed);
     
-    sqlite3_finalize(statement);
     
     if (isFailed)
     {
         const char *message = sqlite3_errmsg(db);
         return {
             .type = SQLiteError,
-            .message = "[op-sqlite] SQL execution error: " + std::string(message),
-            .affectedRows = 0,
-            .insertId = 0
+            .message = "[op-sqlite] SQL execution error: " + std::string(message)
         };
     }
     

package/cpp/bridge.h

@@ -7,7 +7,7 @@
 #include "DumbHostObject.h"
 #include "types.h"
 
-namespace osp {
+namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
@@ -23,7 +23,7 @@ BridgeResult sqliteDetachDb(std::string const mainDBName, std::string const alia
 
 BridgeResult sqliteExecute(std::string const dbName,
                            std::string const &query,
-                           std::vector<jsVal> *values,
+                           std::vector<JSVariant> *values,
                            std::vector<DumbHostObject> *results,
                            std::shared_ptr<std::vector<DynamicHostObject>> metadatas);
 

package/cpp/sqlbatchexecutor.cpp

@@ -1,6 +1,6 @@
 #include "sqlbatchexecutor.h"
 
-namespace osp {
+namespace opsqlite {
 
 /**
  * Batch execution implementation
@@ -25,7 +25,7 @@ void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams, std::vect
             for (int x = 0; x < batchUpdateParams.length(rt); x++)
             {
                 const jsi::Value &p = batchUpdateParams.getValueAtIndex(rt, x);
-                auto params = std::make_shared<std::vector<jsVal>>(toAnyVec(rt, p));
+                auto params = std::make_shared<std::vector<JSVariant>>(toAnyVec(rt, p));
                 commands->push_back({
                     query,
                     params
@@ -34,7 +34,7 @@ void toBatchArguments(jsi::Runtime &rt, jsi::Array const &batchParams, std::vect
         }
         else
         {
-            auto params = std::make_shared<std::vector<jsVal>>(toAnyVec(rt, commandParams));
+            auto params = std::make_shared<std::vector<JSVariant>>(toAnyVec(rt, commandParams));
             commands->push_back({
                 query,
                 params

package/cpp/sqlbatchexecutor.h

@@ -5,13 +5,13 @@
 #include "bridge.h"
 #include "types.h"
 
-namespace osp {
+namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
 struct BatchArguments {
   std::string sql;
-  std::shared_ptr<std::vector<jsVal>> params;
+  std::shared_ptr<std::vector<JSVariant>> params;
 };
 
 /**

package/cpp/types.h

@@ -1,14 +1,14 @@
-#ifndef jsVal_h
-#define jsVal_h
+#ifndef types_h
+#define types_h
 
 #include <variant>
 
-struct JSBuffer {
+struct ArrayBuffer {
     std::shared_ptr<uint8_t> data;
     size_t size;
 };
 
 
-using jsVal = std::variant<nullptr_t, bool, int, double, long, long long, std::string, JSBuffer>;
+using JSVariant = std::variant<nullptr_t, bool, int, double, long, long long, std::string, ArrayBuffer>;
 
-#endif /* jsVal_h */
+#endif /* types_h */

package/cpp/utils.cpp

@@ -4,18 +4,18 @@
 #include <fstream>
 #include "bridge.h"
 
-namespace osp {
+namespace opsqlite {
 
 namespace jsi = facebook::jsi;
 
-jsVal toAny(jsi::Runtime &rt, jsi::Value &value) {
+JSVariant toAny(jsi::Runtime &rt, jsi::Value &value) {
     if (value.isNull() || value.isUndefined())
     {
-        return jsVal(nullptr);
+        return JSVariant(nullptr);
     }
     else if (value.isBool())
     {
-        return jsVal(value.getBool());
+        return JSVariant(value.getBool());
     }
     else if (value.isNumber())
     {
@@ -24,21 +24,21 @@ jsVal toAny(jsi::Runtime &rt, jsi::Value &value) {
         long long longVal = (long)doubleVal;
         if (intVal == doubleVal)
         {
-            return jsVal(intVal);
+            return JSVariant(intVal);
         }
         else if (longVal == doubleVal)
         {
-            return jsVal(longVal);
+            return JSVariant(longVal);
         }
         else
         {
-            return jsVal(doubleVal);
+            return JSVariant(doubleVal);
         }
     }
     else if (value.isString())
     {
         std::string strVal = value.asString(rt).utf8(rt);
-        return jsVal(strVal);
+        return JSVariant(strVal);
     }
     else if (value.isObject())
     {
@@ -46,7 +46,7 @@ jsVal toAny(jsi::Runtime &rt, jsi::Value &value) {
         if (object.isArrayBuffer(rt))
         {
             auto buffer = object.getArrayBuffer(rt);
-            return jsVal(JSBuffer {
+            return JSVariant(ArrayBuffer {
                 .data =  std::shared_ptr<uint8_t>{buffer.data(rt)},
                 .size =  buffer.size(rt)
             });
@@ -56,7 +56,7 @@ jsVal toAny(jsi::Runtime &rt, jsi::Value &value) {
     throw new std::invalid_argument("Unknown JSI to any value conversion");
 }
 
-jsi::Value toJSI(jsi::Runtime &rt, jsVal value) {
+jsi::Value toJSI(jsi::Runtime &rt, JSVariant value) {
     
     if (std::holds_alternative<bool>(value))
     {
@@ -82,9 +82,9 @@ jsi::Value toJSI(jsi::Runtime &rt, jsVal value) {
 //    {
 //        return jsi::String::createFromAscii(rt, std::get<const char*>(value));
 //    }
-    else if (std::holds_alternative<JSBuffer>(value))
+    else if (std::holds_alternative<ArrayBuffer>(value))
     {
-        auto jsBuffer = std::get<JSBuffer>(value);
+        auto jsBuffer = std::get<ArrayBuffer>(value);
         jsi::Function array_buffer_ctor = rt.global().getPropertyAsFunction(rt, "ArrayBuffer");
         jsi::Object o = array_buffer_ctor.callAsConstructor(rt, (int)jsBuffer.size).getObject(rt);
         jsi::ArrayBuffer buf = o.getArrayBuffer(rt);
@@ -96,9 +96,9 @@ jsi::Value toJSI(jsi::Runtime &rt, jsVal value) {
     return jsi::Value::null();
 }
 
-std::vector<jsVal> toAnyVec(jsi::Runtime &rt, jsi::Value const &params)
+std::vector<JSVariant> toAnyVec(jsi::Runtime &rt, jsi::Value const &params)
 {
-    std::vector<jsVal> res;
+    std::vector<JSVariant> res;
     
     if (params.isNull() || params.isUndefined())
     {

package/cpp/utils.h

@@ -11,46 +11,44 @@
 #include "DynamicHostObject.h"
 #include "DumbHostObject.h"
 
-namespace osp {
+namespace opsqlite {
 
-namespace jsi = facebook::jsi;
+    namespace jsi = facebook::jsi;
 
+    enum ResultType
+    {
+        SQLiteOk,
+        SQLiteError
+    };
 
+    struct BridgeResult
+    {
+        ResultType type;
+        std::string message;
+        int affectedRows;
+        double insertId;
+    };
 
-enum ResultType
-{
-    SQLiteOk,
-    SQLiteError
-};
+    struct BatchResult
+    {
+        ResultType type;
+        std::string message;
+        int affectedRows;
+        int commands;
+    };
 
-struct BridgeResult
-{
-    ResultType type;
-    std::string message;
-    int affectedRows;
-    double insertId;
-};
+    JSVariant toAny(jsi::Runtime &rt, jsi::Value &value);
 
-struct BatchResult
-{
-    ResultType type;
-    std::string message;
-    int affectedRows;
-    int commands;
-};
+    jsi::Value toJSI(jsi::Runtime &rt, JSVariant value);
 
-jsVal toAny(jsi::Runtime &rt, jsi::Value &value);
+    std::vector<JSVariant> toAnyVec(jsi::Runtime &rt, jsi::Value const &args);
 
-jsi::Value toJSI(jsi::Runtime &rt, jsVal value);
+    jsi::Value createResult(jsi::Runtime &rt,
+                            BridgeResult status,
+                            std::vector<DumbHostObject> *results,
+                            std::shared_ptr<std::vector<DynamicHostObject>> metadata);
 
-std::vector<jsVal> toAnyVec(jsi::Runtime &rt, jsi::Value const &args);
-
-jsi::Value createResult(jsi::Runtime &rt,
-                        BridgeResult status,
-                        std::vector<DumbHostObject> *results,
-                        std::shared_ptr<std::vector<DynamicHostObject>> metadata);
-
-BatchResult importSQLFile(std::string dbName, std::string fileLocation);
+    BatchResult importSQLFile(std::string dbName, std::string fileLocation);
 
 }
 

package/ios/OPSQLite.mm

@@ -51,14 +51,14 @@ RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
         documentPath = [paths objectAtIndex:0];
     }
     
-    osp::install(runtime, callInvoker, [documentPath UTF8String]);
+    opsqlite::install(runtime, callInvoker, [documentPath UTF8String]);
     
     NSLog(@"OP-SQLite initialized");
     return @true;
 }
 
 - (void)invalidate {
-    osp::clearState();
+    opsqlite::clearState();
 }
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",