@op-engineering/op-sqlite 1.0.0 → 1.0.2

package/README.md

@@ -1,4 +1,4 @@
-![screenshot](https://raw.githubusercontent.com/OP-Engineering/op-sqlite/main/Header.jpg)
+![screenshot](https://raw.githubusercontent.com/OP-Engineering/op-sqlite/main/Header.png)
 
 <div align="center">
   <pre align="center">
@@ -20,11 +20,26 @@ Created by [@ospfranco](https://twitter.com/ospfranco). Also created `react-nati
 
 [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:
+
+- Prepared statements
+- Inlining functions
+- Batching queries
+- Update hook
+
 ## Benchmarks
 
-You can find the [benchmarking code in the example app](https://github.com/OP-Engineering/op-sqlite/blob/main/example/src/Database.ts#L44). Loading a 300k record database:
+You can find the [benchmarking code in the example app](https://github.com/OP-Engineering/op-sqlite/blob/main/example/src/Database.ts#L44). Non JSI libraries are not even a contender anymore, you should expect anywhere between a 5x to a 8x improvement over sqlite-storage, sqlite2 and so on. Loading a 300k record database (in milliseconds).
 
-![benchmark](https://raw.githubusercontent.com/OP-Engineering/op-sqlite/main/benchmark.png)
+| Library      | iPhone 15 Pro | Galaxy S22 |
+| ------------ | ------------- | ---------- |
+| quick-sqlite | 2719          | 8851       |
+| expo-sqlite  | 2293          | 10626      |
+| op-sqlite    | 488           | 981        |
+
+Memory consumption is also 50% to 80% reduced compared to `react-native-quick-sqlite`. `expo-sqlite` OOMS itself even when trying to insert 300k elements in a row. Queries that before might have OOM now can run just fine.
 
 # DB Paths
 
@@ -46,7 +61,7 @@ Note that on iOS the file system is sand-boxed, so you cannot access files/direc
 ```typescript
 import {open} from '@op-engineering/op-sqlite'
 
-const db = open('myDb.sqlite')
+const db = open({name: 'myDb.sqlite'})
 
 // The db object contains the following methods:
 db = {
@@ -203,21 +218,14 @@ if (!detachResult.status) {
 
 ### Loading SQL Dump Files
 
-If you have a plain SQL file, you can load it directly, with low memory consumption.
-
-```typescript
-const { rowsAffected, commands } = db.loadFile(
-  'myDatabase',
-  '/absolute/path/to/file.sql'
-);
-```
-
-Or use the async version which will load the file in another native thread
+If you have a SQL dump file, you can load it directly, with low memory consumption:
 
 ```typescript
-db.loadFileAsync('myDatabase', '/absolute/path/to/file.sql').then((res) => {
-  const { rowsAffected, commands } = res;
-});
+const { rowsAffected, commands } = db
+  .loadFile('myDatabase', '/absolute/path/to/file.sql')
+  .then((res) => {
+    const { rowsAffected, commands } = res;
+  });
 ```
 
 ## Use built-in SQLite
@@ -258,7 +266,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:
 
 ```
-OPSQLiteFlags="<SQLITE_FLAGS>"
+quickSqliteFlags="-DSQLITE_ENABLE_FTS5=1"
 ```
 
 ## Additional configuration

package/android/CMakeLists.txt

@@ -32,6 +32,7 @@ add_library(
   ../cpp/DynamicHostObject.cpp
   ../cpp/DynamicHostObject.h
   ../cpp/macros.h
+  ../cpp/types.h
   cpp-adapter.cpp
 )
 

package/cpp/DynamicHostObject.cpp

@@ -19,12 +19,14 @@ std::vector<jsi::PropNameID> DynamicHostObject::getPropertyNames(jsi::Runtime &r
 jsi::Value DynamicHostObject::get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) {
     auto name = propNameID.utf8(rt);
     
-    if(fields.find(name) == fields.end()) {
-        return {};
-    } else {
-        std::any val = fields[name];
-        return toJSI(rt, val);
+    for (auto field: fields) {
+        auto fieldName = field.first;
+        if(fieldName == name) {
+            return toJSI(rt, field.second);
+        }
     }
+    
+    return {};
 }
 
 }

package/cpp/DynamicHostObject.h

@@ -4,7 +4,7 @@
 #include <jsi/jsi.h>
 #include <any>
 #include <vector>
-#include <unordered_map>
+#include "types.h"
 
 namespace osp {
 
@@ -20,9 +20,8 @@ namespace osp {
 
         jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID);
 
-        std::unordered_map<std::string, std::any> fields;
-
 
+        std::vector<std::pair<std::string, jsVal>> fields;
     };
 
 }

package/cpp/bindings.cpp

@@ -182,7 +182,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<std::any> params;
+        std::vector<jsVal> params;
         if(count == 3) {
             const jsi::Value &originalParams = args[2];
             params = toAnyVec(rt, originalParams);
@@ -216,7 +216,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<std::any> params = toAnyVec(rt, originalParams);
+        std::vector<jsVal> params = toAnyVec(rt, originalParams);
         
         auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
         auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor", 2) {
@@ -224,7 +224,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<std::any>>(params), resolve, reject]()
+            [&rt, dbName, query, params = std::make_shared<std::vector<jsVal>>(params), resolve, reject]()
             {
                 try
                 {
@@ -252,8 +252,10 @@ void install(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> jsCallInvoker
                 }
                 catch (std::exception &exc)
                 {
-                    invoker->invokeAsync([&rt, &exc] {
-                        jsi::JSError(rt, exc.what());
+                    invoker->invokeAsync([&rt, exc = std::move(exc), reject] {
+                        auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
+                        auto error = errorCtr.callAsConstructor(rt, jsi::String::createFromAscii(rt, exc.what()));
+                        reject->asObject(rt).asFunction(rt).call(rt, error);
                     });
                 }
             };

package/cpp/bridge.cpp

@@ -5,9 +5,10 @@
 #include <ctime>
 #include <unistd.h>
 #include <sys/stat.h>
-#include <map>
+#include <unordered_map>
 #include "logs.h"
 #include "DynamicHostObject.h"
+#include <variant>
 
 namespace osp {
 
@@ -199,75 +200,54 @@ BridgeResult sqliteRemoveDb(std::string const dbName, std::string const docPath)
     };
 }
 
-void bindStatement(sqlite3_stmt *statement, std::vector<std::any> *values)
+inline void bindStatement(sqlite3_stmt *statement, std::vector<jsVal> *values)
 {
     size_t size = values->size();
-    if (size <= 0)
-    {
-        return;
-    }
     
     for (int ii = 0; ii < size; ii++)
     {
         int sqIndex = ii + 1;
-        std::any value = values->at(ii);
-        
-        if (value.type() == typeid(NULL) || value.type() == typeid(nullptr))
+        jsVal value = values->at(ii);
+
+        if (std::holds_alternative<bool>(value))
         {
-            sqlite3_bind_null(statement, sqIndex);
+            sqlite3_bind_int(statement, sqIndex, std::get<bool>(value));
         }
-        else if (value.type() == typeid(bool))
+        else if (std::holds_alternative<int>(value))
         {
-            sqlite3_bind_int(statement, sqIndex, std::any_cast<bool>(value));
+            sqlite3_bind_int(statement, sqIndex, std::get<int>(value));
         }
-        else if (value.type() == typeid(int))
+        else if (std::holds_alternative<long long>(value))
         {
-            sqlite3_bind_int(statement, sqIndex, std::any_cast<int>(value));
+            sqlite3_bind_double(statement, sqIndex, std::get<long long>(value));
         }
-        else if (value.type() == typeid(long long))
+        else if (std::holds_alternative<double>(value))
         {
-            sqlite3_bind_double(statement, sqIndex, std::any_cast<long long>(value));
+            sqlite3_bind_double(statement, sqIndex, std::get<double>(value));
         }
-        else if (value.type() == typeid(double))
+        else if (std::holds_alternative<std::string>(value))
         {
-            sqlite3_bind_double(statement, sqIndex, std::any_cast<double>(value));
+            std::string str = std::get<std::string>(value);
+            sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(), SQLITE_TRANSIENT);
         }
-        else if (value.type() == typeid(std::string))
+        else if(std::holds_alternative<JSBuffer>(value))
         {
-            std::string str = std::any_cast<std::string>(value);
-            sqlite3_bind_text(statement, sqIndex, str.c_str(), str.length(), SQLITE_TRANSIENT);
+            JSBuffer buffer = std::get<JSBuffer>(value);
+            sqlite3_bind_blob(statement, sqIndex, buffer.data.get(), buffer.size, SQLITE_STATIC);
         } else {
-            throw std::invalid_argument("Unsupported scalar type, cannot convert to JSI Value");
+            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));
 //        }
-        // TODO Add support for array buffers
-        //        else if (value.isObject())
-        //        {
-        //            auto obj = value.asObject(rt);
-        //            if(obj.isArrayBuffer(rt)) {
-        //                auto buf = obj.getArrayBuffer(rt);
-        //                sqlite3_bind_blob(statement, sqIndex, buf.data(rt), buf.size(rt), SQLITE_STATIC);
-        //            }
-        //
-//        else if (dataType == ARRAY_BUFFER)
-//        {
-//            
-//        }
-//        sqlite3_bind_blob(statement, sqIndex, value.arrayBufferValue.get(), value.arrayBufferSize, SQLITE_STATIC);
-        //        }
-        
-        
-        
     }
 }
 
 BridgeResult sqliteExecute(std::string const dbName,
                              std::string const &query,
-                             std::vector<std::any> *params,
+                             std::vector<jsVal> *params,
                              std::vector<std::shared_ptr<DynamicHostObject>> *results,
                              std::vector<std::shared_ptr<DynamicHostObject>> *metadatas)
 {
@@ -287,11 +267,7 @@ BridgeResult sqliteExecute(std::string const dbName,
     
     int statementStatus = sqlite3_prepare_v2(db, query.c_str(), -1, &statement, NULL);
     
-    if (statementStatus == SQLITE_OK) // statemnet is correct, bind the passed parameters
-    {
-        bindStatement(statement, params);
-    }
-    else
+    if (statementStatus == SQLITE_ERROR)
     {
         const char *message = sqlite3_errmsg(db);
         return {
@@ -300,6 +276,8 @@ BridgeResult sqliteExecute(std::string const dbName,
             .affectedRows = 0};
     }
     
+    bindStatement(statement, params);
+    
     bool isConsuming = true;
     bool isFailed = false;
     
@@ -338,14 +316,14 @@ BridgeResult sqliteExecute(std::string const dbName,
                              * only represent Integers up to 53 bits
                              */
                             double column_value = sqlite3_column_double(statement, i);
-                            row->fields[column_name] = std::any(column_value);
+                            row->fields.push_back(std::make_pair(column_name, jsVal(column_value)));
                             break;
                         }
                             
                         case SQLITE_FLOAT:
                         {
                             double column_value = sqlite3_column_double(statement, i);
-                            row->fields[column_name] = std::any(column_value);
+                            row->fields.push_back(std::make_pair(column_name, jsVal(column_value)));
                             break;
                         }
                             
@@ -354,7 +332,7 @@ BridgeResult sqliteExecute(std::string const dbName,
                             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->fields[column_name] = std::any(std::string(column_value, byteLen));
+                            row->fields.push_back(std::make_pair(column_name, jsVal(std::string(column_value, byteLen))));
                             break;
                         }
                             
@@ -364,8 +342,10 @@ BridgeResult sqliteExecute(std::string const dbName,
                             const void *blob = sqlite3_column_blob(statement, i);
                             uint8_t *data = new uint8_t[blob_size];
                             memcpy(data, blob, blob_size);
-                            // TODO array buffer support
-                            //                            row[column_name] = createArrayBufferQuickValue(data, blob_size);
+                            row->fields.push_back(std::make_pair(column_name, jsVal(JSBuffer {
+                                .data =  std::shared_ptr<uint8_t>{data},
+                                .size =  static_cast<size_t>(blob_size)
+                            })));
                             break;
                         }
                             
@@ -373,7 +353,7 @@ BridgeResult sqliteExecute(std::string const dbName,
                             // Intentionally left blank
 
                         default:
-                            row->fields[column_name] = std::any(NULL);
+                            row->fields.push_back(std::make_pair(column_name, jsVal(NULL)));
                             break;
                     }
                     i++;
@@ -391,9 +371,9 @@ BridgeResult sqliteExecute(std::string const dbName,
                         column_name = sqlite3_column_name(statement, i);
                         const char *type = sqlite3_column_decltype(statement, i);
                         auto metadata = std::make_shared<DynamicHostObject>();
-                        metadata->fields["name"] = column_name;
-                        metadata->fields["index"] = i;
-                        metadata->fields["type"] = type;
+                        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));
                         
                         i++;
                     }
@@ -426,7 +406,8 @@ BridgeResult sqliteExecute(std::string const dbName,
     return {
         .type = SQLiteOk,
         .affectedRows = changedRowCount,
-        .insertId = static_cast<double>(latestInsertRowId)};
+        .insertId = static_cast<double>(latestInsertRowId)
+    };
 }
 
 BridgeResult sqliteExecuteLiteral(std::string const dbName, std::string const &query)

package/cpp/bridge.h

@@ -4,6 +4,7 @@
 #include "utils.h"
 #include <vector>
 #include "DynamicHostObject.h"
+#include "types.h"
 
 namespace osp {
 
@@ -21,7 +22,7 @@ BridgeResult sqliteDetachDb(std::string const mainDBName, std::string const alia
 
 BridgeResult sqliteExecute(std::string const dbName,
                            std::string const &query,
-                           std::vector<std::any> *values,
+                           std::vector<jsVal> *values,
                            std::vector<std::shared_ptr<DynamicHostObject>> *result,
                            std::vector<std::shared_ptr<DynamicHostObject>> *metadata);
 

package/cpp/sqlbatchexecutor.cpp

@@ -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<std::any>>(toAnyVec(rt, p));
+                auto params = std::make_shared<std::vector<jsVal>>(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<std::any>>(toAnyVec(rt, commandParams));
+            auto params = std::make_shared<std::vector<jsVal>>(toAnyVec(rt, commandParams));
             commands->push_back({
                 query,
                 params

package/cpp/sqlbatchexecutor.h

@@ -3,6 +3,7 @@
 */
 #include "utils.h"
 #include "bridge.h"
+#include "types.h"
 
 namespace osp {
 
@@ -10,7 +11,7 @@ namespace jsi = facebook::jsi;
 
 struct BatchArguments {
   std::string sql;
-  std::shared_ptr<std::vector<std::any>> params;
+  std::shared_ptr<std::vector<jsVal>> params;
 };
 
 /**

package/cpp/types.h

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

package/cpp/utils.cpp

@@ -8,14 +8,14 @@ namespace osp {
 
 namespace jsi = facebook::jsi;
 
-std::any toAny(jsi::Runtime &rt, jsi::Value &value) {
+jsVal toAny(jsi::Runtime &rt, jsi::Value &value) {
     if (value.isNull() || value.isUndefined())
     {
-        return std::any(nullptr);
+        return jsVal(nullptr);
     }
     else if (value.isBool())
     {
-        return std::any(value.getBool());
+        return jsVal(value.getBool());
     }
     else if (value.isNumber())
     {
@@ -24,87 +24,81 @@ std::any toAny(jsi::Runtime &rt, jsi::Value &value) {
         long long longVal = (long)doubleVal;
         if (intVal == doubleVal)
         {
-            return std::any(intVal);
+            return jsVal(intVal);
         }
         else if (longVal == doubleVal)
         {
-            return std::any(longVal);
+            return jsVal(longVal);
         }
         else
         {
-            return std::any(doubleVal);
+            return jsVal(doubleVal);
         }
     }
     else if (value.isString())
     {
         std::string strVal = value.asString(rt).utf8(rt);
-        return std::any(strVal);
-    }
-    //    else if (value.isObject())
-    //    {
-    //        auto obj = value.asObject(rt);
-    //        if (obj.isArrayBuffer(rt))
-    //        {
-    //            auto buf = obj.getArrayBuffer(rt);
-    //            target->push_back(createArrayBufferQuickValue(buf.data(rt), buf.size(rt)));
-    //        }
-    //    }
-    //    else
-    //    {
-    //        target->push_back(createNullQuickValue());
-    //    }
+        return jsVal(strVal);
+    }
+    else if (value.isObject())
+    {
+        auto object = value.asObject(rt);
+        if (object.isArrayBuffer(rt))
+        {
+            auto buffer = object.getArrayBuffer(rt);
+            return jsVal(JSBuffer {
+                .data =  std::shared_ptr<uint8_t>{buffer.data(rt)},
+                .size =  buffer.size(rt)
+            });
+        }
+    }
     
     throw new std::invalid_argument("Unknown JSI to any value conversion");
 }
 
-jsi::Value toJSI(jsi::Runtime &rt, std::any value) {
-    const std::type_info &type(value.type());
+jsi::Value toJSI(jsi::Runtime &rt, jsVal value) {
     
-    if (type == typeid(NULL) || type == typeid(nullptr))
-    {
-        return jsi::Value::null();
-    }
-    else if (type == typeid(bool))
+    if (std::holds_alternative<bool>(value))
     {
-        return std::any_cast<bool>(value);
+        return std::get<bool>(value);
     }
-    else if (type == typeid(int))
+    else if (std::holds_alternative<int>(value))
     {
-        return jsi::Value(std::any_cast<int>(value));
+        return jsi::Value(std::get<int>(value));
     }
-    else if (type == typeid(long long))
+    else if (std::holds_alternative<long long>(value))
     {
-        return jsi::Value(static_cast<double>(std::any_cast<long long>(value)));
+        return jsi::Value(static_cast<double>(std::get<long long>(value)));
     }
-    else if (type == typeid(double))
+    else if (std::holds_alternative<double>(value))
     {
-        return jsi::Value(std::any_cast<double>(value));
+        return jsi::Value(std::get<double>(value));
     }
-    else if (type == typeid(std::string))
+    else if (std::holds_alternative<std::string>(value))
     {
-        return jsi::String::createFromUtf8(rt, std::any_cast<std::string>(value));
+        return jsi::String::createFromUtf8(rt, std::get<std::string>(value));
     }
-    else if (type == typeid(const char*))
+//    else if (std::holds_alternative<const char*>(value))
+//    {
+//        return jsi::String::createFromAscii(rt, std::get<const char*>(value));
+//    }
+    else if (std::holds_alternative<JSBuffer>(value))
     {
-        return jsi::String::createFromAscii(rt, std::any_cast<const char*>(value));
+        auto jsBuffer = std::get<JSBuffer>(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);
+        // It's a shame we have to copy here: see https://github.com/facebook/hermes/pull/419 and https://github.com/facebook/hermes/issues/564.
+        memcpy(buf.data(rt), jsBuffer.data.get(), jsBuffer.size);
+        return buf;
     }
-    // TODO Add support for array buffers
-    //        else if (value.isObject())
-    //        {
-    //            auto obj = value.asObject(rt);
-    //            if(obj.isArrayBuffer(rt)) {
-    //                auto buf = obj.getArrayBuffer(rt);
-    //                sqlite3_bind_blob(statement, sqIndex, buf.data(rt), buf.size(rt), SQLITE_STATIC);
-    //            }
-    //
-    //        }
     
-    throw std::invalid_argument("Unsupported scalar type, cannot convert to JSI Value");
+    return jsi::Value::null();
 }
 
-std::vector<std::any> toAnyVec(jsi::Runtime &rt, jsi::Value const &params)
+std::vector<jsVal> toAnyVec(jsi::Runtime &rt, jsi::Value const &params)
 {
-    std::vector<std::any> res;
+    std::vector<jsVal> res;
     
     if (params.isNull() || params.isUndefined())
     {

package/cpp/utils.h

@@ -7,12 +7,15 @@
 #include <vector>
 #include <map>
 #include <any>
+#include "types.h"
 #include "DynamicHostObject.h"
 
 namespace osp {
 
 namespace jsi = facebook::jsi;
 
+
+
 enum ResultType
 {
     SQLiteOk,
@@ -35,13 +38,11 @@ struct BatchResult
     int commands;
 };
 
-std::any toAny(jsi::Runtime &rt, jsi::Value &value);
+jsVal toAny(jsi::Runtime &rt, jsi::Value &value);
 
-// TODO I tried to inline this function but it is not working
-// throws an undefined Symbol
-jsi::Value toJSI(jsi::Runtime &rt, std::any value);
+jsi::Value toJSI(jsi::Runtime &rt, jsVal value);
 
-std::vector<std::any> toAnyVec(jsi::Runtime &rt, jsi::Value const &args);
+std::vector<jsVal> toAnyVec(jsi::Runtime &rt, jsi::Value const &args);
 
 jsi::Value createResult(jsi::Runtime &rt,
                         BridgeResult status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@op-engineering/op-sqlite",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Next generation SQLite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -13,7 +13,7 @@
     "android",
     "ios",
     "cpp",
-    "op-sqlite.podspec",
+    "@op-engineering/op-sqlite.podspec",
     "!lib/typescript/example",
     "!android/build",
     "!android/.cxx",

package/android/gradle.properties

@@ -1,4 +0,0 @@
-Sequel_kotlinVersion=1.6.0
-Sequel_compileSdkVersion=31
-Sequel_buildToolsVersion=31
-Sequel_targetSdkVersion=31

package/op-sqlite.podspec

@@ -1,39 +0,0 @@
-require "json"
-
-package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-
-Pod::Spec.new do |s|
-  s.name         = "op-sqlite"
-  s.version      = package["version"]
-  s.summary      = package["description"]
-  s.homepage     = package["homepage"]
-  s.license      = package["license"]
-  s.authors      = package["author"]
-
-  s.platforms    = { :ios => "12.0", :osx => "10.7" }
-  s.source       = { :git => "https://github.com/ospfranco/op-sqlite.git", :tag => "#{s.version}" }
-
-  s.pod_target_xcconfig = {
-    :GCC_PREPROCESSOR_DEFINITIONS => "HAVE_FULLFSYNC=1",
-    :WARNING_CFLAGS => "-Wno-shorten-64-to-32 -Wno-comma -Wno-unreachable-code -Wno-conditional-uninitialized -Wno-deprecated-declarations",
-    :USE_HEADERMAP => "No"
-  }
-  
-  s.header_mappings_dir = "cpp"
-  s.source_files = "ios/**/*.{h,hpp,m,mm}", "cpp/**/*.{h,hpp,cpp,c}"
-  
-  s.dependency "React-callinvoker"
-  s.dependency "React"
-  s.dependency "React-Core"
-
-  s.xcconfig = {
-    'CLANG_CXX_LANGUAGE_STANDARD' => 'c++17',
-  }
-
-
-  if ENV['OP_SQLITE_USE_PHONE_VERSION'] == '1' then
-    s.exclude_files = "cpp/sqlite3.c", "cpp/sqlite3.h"
-    s.library = "sqlite3"
-  end
-  
-end