@op-engineering/op-sqlite 0.0.0-resolution-test

package/cpp/types.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <variant>
+#include <vector>
+
+struct ArrayBuffer {
+    std::shared_ptr<uint8_t> data;
+    size_t size;
+};
+
+using JSVariant = std::variant<nullptr_t, bool, int, double, long, long long,
+                               std::string, ArrayBuffer>;
+
+struct BridgeResult {
+    std::string message;
+    int affectedRows;
+    double insertId;
+    std::vector<std::vector<JSVariant>> rows;
+    std::vector<std::string> column_names;
+};
+
+struct BatchResult {
+    std::string message;
+    int affectedRows;
+    int commands;
+};
+
+struct BatchArguments {
+    std::string sql;
+    std::vector<JSVariant> params;
+};

package/cpp/utils.cpp

@@ -0,0 +1,327 @@
+#include "utils.h"
+#include "SmartHostObject.h"
+#ifndef OP_SQLITE_USE_LIBSQL
+#include "bridge.h"
+#endif
+#include <fstream>
+#include <sys/stat.h>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+inline jsi::Value to_jsi(jsi::Runtime &rt, const JSVariant &value) {
+    if (std::holds_alternative<bool>(value)) {
+        return std::get<bool>(value);
+    } else if (std::holds_alternative<int>(value)) {
+        return jsi::Value(std::get<int>(value));
+    } else if (std::holds_alternative<long long>(value)) {
+        return jsi::Value(static_cast<double>(std::get<long long>(value)));
+    } else if (std::holds_alternative<double>(value)) {
+        return jsi::Value(std::get<double>(value));
+    } else if (std::holds_alternative<std::string>(value)) {
+        auto str = std::get<std::string>(value);
+        return jsi::String::createFromUtf8(rt, str);
+    } else if (std::holds_alternative<ArrayBuffer>(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);
+        memcpy(buf.data(rt), jsBuffer.data.get(), jsBuffer.size);
+        return o;
+    }
+
+    return jsi::Value::null();
+
+    // I wanted to use the visitor pattern here but on the ArrayBuffer case it
+    // is somehow throwing a pointer exception Somehow the v.size or
+    // v.data.get() is loosing the data when called from the lambda I'm guessing
+    // the I created the shared pointer wrong and the memory is being freed
+    // before the lambda is called
+    //  return std::visit(
+    //      [&](auto &&v) -> jsi::Value {
+    //        using T = std::decay_t<decltype(v)>;
+    //        if constexpr (std::is_same_v<T, bool>) {
+    //          return jsi::Value(v);
+    //        } else if constexpr (std::is_same_v<T, int>) {
+    //          return jsi::Value(v);
+    //        } else if constexpr (std::is_same_v<T, long long>) {
+    //          return jsi::Value(
+    //              static_cast<double>(v)); // JSI doesn't support long long
+    //        } else if constexpr (std::is_same_v<T, double>) {
+    //          return jsi::Value(v);
+    //        } else if constexpr (std::is_same_v<T, std::string>) {
+    //          return jsi::String::createFromUtf8(rt, v);
+    //        } else if constexpr (std::is_same_v<T, ArrayBuffer>) {
+    //          static jsi::Function buffer_constructor =
+    //              rt.global().getPropertyAsFunction(rt, "ArrayBuffer");
+    //          jsi::Object o =
+    //              buffer_constructor.callAsConstructor(rt,
+    //              static_cast<int>(v.size))
+    //                  .getObject(rt);
+    //          jsi::ArrayBuffer buf = o.getArrayBuffer(rt);
+    //          memcpy(buf.data(rt), v.data.get(), v.size);
+    //          return o;
+    //        } else {
+    //          return jsi::Value::null();
+    //        }
+    //      },
+    //      value);
+}
+
+inline JSVariant to_variant(jsi::Runtime &rt, const jsi::Value &value) {
+    if (value.isNull() || value.isUndefined()) {
+        return JSVariant(nullptr);
+    } else if (value.isBool()) {
+        return JSVariant(value.getBool());
+    } else if (value.isNumber()) {
+        double doubleVal = value.asNumber();
+        int intVal = (int)doubleVal;
+        long long longVal = (long)doubleVal;
+        if (intVal == doubleVal) {
+            return JSVariant(intVal);
+        } else if (longVal == doubleVal) {
+            return JSVariant(longVal);
+        } else {
+            return JSVariant(doubleVal);
+        }
+    } else if (value.isString()) {
+        std::string strVal = value.asString(rt).utf8(rt);
+        return JSVariant(strVal);
+    } else if (value.isObject()) {
+        auto obj = value.asObject(rt);
+
+        if (!obj.isArrayBuffer(rt)) {
+            throw std::runtime_error(
+                "Object is not an ArrayBuffer, cannot bind to SQLite");
+        }
+
+        auto buffer = obj.getArrayBuffer(rt);
+        uint8_t *data = new uint8_t[buffer.size(rt)];
+        memcpy(data, buffer.data(rt), buffer.size(rt));
+
+        return JSVariant(ArrayBuffer{.data = std::shared_ptr<uint8_t>{data},
+                                     .size = buffer.size(rt)});
+    }
+
+    throw std::runtime_error("Cannot convert JSI value to C++ Variant value");
+}
+
+std::vector<std::string> to_string_vec(jsi::Runtime &rt, jsi::Value const &xs) {
+    jsi::Array values = xs.asObject(rt).asArray(rt);
+    std::vector<std::string> res;
+    for (int ii = 0; ii < values.length(rt); ii++) {
+        std::string value =
+            values.getValueAtIndex(rt, ii).asString(rt).utf8(rt);
+        res.emplace_back(value);
+    }
+    return res;
+}
+
+std::vector<int> to_int_vec(jsi::Runtime &rt, jsi::Value const &xs) {
+    jsi::Array values = xs.asObject(rt).asArray(rt);
+    std::vector<int> res;
+    for (int ii = 0; ii < values.length(rt); ii++) {
+        int value = static_cast<int>(values.getValueAtIndex(rt, ii).asNumber());
+        res.emplace_back(value);
+    }
+    return res;
+}
+
+std::vector<JSVariant> to_variant_vec(jsi::Runtime &rt, jsi::Value const &xs) {
+    std::vector<JSVariant> res;
+    jsi::Array values = xs.asObject(rt).asArray(rt);
+
+    for (int ii = 0; ii < values.length(rt); ii++) {
+        jsi::Value value = values.getValueAtIndex(rt, ii);
+        res.emplace_back(to_variant(rt, value));
+    }
+
+    return res;
+}
+
+jsi::Value create_js_rows(jsi::Runtime &rt, const BridgeResult &status) {
+    jsi::Object res = jsi::Object(rt);
+
+    res.setProperty(rt, "rowsAffected", status.affectedRows);
+    if (status.affectedRows > 0 && status.insertId != 0) {
+        res.setProperty(rt, "insertId", jsi::Value(status.insertId));
+    }
+
+    size_t row_count = status.rows.size();
+    auto rows = jsi::Array(rt, row_count);
+
+    if (row_count > 0) {
+        for (int i = 0; i < row_count; i++) {
+            auto row = jsi::Array(rt, status.column_names.size());
+            std::vector<JSVariant> native_row = status.rows[i];
+            for (int j = 0; j < native_row.size(); j++) {
+                auto value = to_jsi(rt, native_row[j]);
+                row.setValueAtIndex(rt, j, value);
+            }
+            rows.setValueAtIndex(rt, i, row);
+        }
+    }
+    res.setProperty(rt, "rawRows", rows);
+
+    size_t column_count = status.column_names.size();
+    auto column_array = jsi::Array(rt, column_count);
+    for (int i = 0; i < column_count; i++) {
+        auto column = status.column_names.at(i);
+        column_array.setValueAtIndex(rt, i, to_jsi(rt, column));
+    }
+    res.setProperty(rt, "columnNames", std::move(column_array));
+    return res;
+}
+
+jsi::Value
+create_result(jsi::Runtime &rt, const BridgeResult &status,
+              std::vector<DumbHostObject> *results,
+              std::shared_ptr<std::vector<SmartHostObject>> metadata) {
+    jsi::Object res = jsi::Object(rt);
+
+    res.setProperty(rt, "rowsAffected", status.affectedRows);
+    if (status.affectedRows > 0 && status.insertId != 0) {
+        res.setProperty(rt, "insertId", jsi::Value(status.insertId));
+    }
+
+    size_t rowCount = results->size();
+
+    auto array = jsi::Array(rt, rowCount);
+    for (int i = 0; i < rowCount; i++) {
+        auto obj = results->at(i);
+        array.setValueAtIndex(rt, i,
+                              jsi::Object::createFromHostObject(
+                                  rt, std::make_shared<DumbHostObject>(obj)));
+    }
+    res.setProperty(rt, "rows", std::move(array));
+
+    size_t column_count = metadata->size();
+    auto column_array = jsi::Array(rt, column_count);
+    for (int i = 0; i < column_count; i++) {
+        auto column = metadata->at(i);
+        column_array.setValueAtIndex(
+            rt, i,
+            jsi::Object::createFromHostObject(
+                rt, std::make_shared<SmartHostObject>(column)));
+    }
+    res.setProperty(rt, "metadata", std::move(column_array));
+
+    return std::move(res);
+}
+
+jsi::Value
+create_raw_result(jsi::Runtime &rt, const BridgeResult &status,
+                  const std::vector<std::vector<JSVariant>> *results) {
+    size_t row_count = results->size();
+    jsi::Array res = jsi::Array(rt, row_count);
+    for (int i = 0; i < row_count; i++) {
+        auto row = results->at(i);
+        auto array = jsi::Array(rt, row.size());
+        for (int j = 0; j < row.size(); j++) {
+            array.setValueAtIndex(rt, j, to_jsi(rt, row[j]));
+        }
+        res.setValueAtIndex(rt, i, array);
+    }
+    return res;
+}
+
+void to_batch_arguments(jsi::Runtime &rt, jsi::Array const &tuples,
+                        std::vector<BatchArguments> *commands) {
+    for (int i = 0; i < tuples.length(rt); i++) {
+        const jsi::Array &tuple =
+            tuples.getValueAtIndex(rt, i).asObject(rt).asArray(rt);
+        const size_t length = tuple.length(rt);
+        if (length == 0) {
+            continue;
+        }
+
+        const std::string query =
+            tuple.getValueAtIndex(rt, 0).asString(rt).utf8(rt);
+        if (length == 1) {
+            commands->push_back({query});
+            continue;
+        }
+
+        const jsi::Value &tuple_params = tuple.getValueAtIndex(rt, 1);
+
+        if (!tuple_params.isUndefined() &&
+            tuple_params.asObject(rt).isArray(rt) &&
+            tuple_params.asObject(rt).asArray(rt).length(rt) > 0 &&
+            tuple_params.asObject(rt)
+                .asArray(rt)
+                .getValueAtIndex(rt, 0)
+                .isObject()) {
+            // The params for this tuple is an array itself
+            // The query should repeat for each element in the array
+            const jsi::Array &params_array =
+                tuple_params.asObject(rt).asArray(rt);
+            for (int x = 0; x < params_array.length(rt); x++) {
+                const jsi::Value &p = params_array.getValueAtIndex(rt, x);
+                auto params = std::vector<JSVariant>(to_variant_vec(rt, p));
+                commands->push_back({query, params});
+            }
+        } else {
+            auto params =
+                std::vector<JSVariant>(to_variant_vec(rt, tuple_params));
+            commands->push_back({query, params});
+        }
+    }
+}
+
+#ifndef OP_SQLITE_USE_LIBSQL
+BatchResult import_sql_file(sqlite3 *db, std::string path) {
+    std::string line;
+    std::ifstream sqFile(path);
+    if (!sqFile.is_open()) {
+        throw std::runtime_error("Could not open file: " + path);
+    }
+
+    try {
+        int affectedRows = 0;
+        int commands = 0;
+        opsqlite_execute(db, "BEGIN EXCLUSIVE TRANSACTION", nullptr);
+        while (std::getline(sqFile, line, '\n')) {
+            if (!line.empty()) {
+                try {
+                    auto result = opsqlite_execute(db, line, nullptr);
+                    affectedRows += result.affectedRows;
+                    commands++;
+                } catch (std::exception &exc) {
+                    opsqlite_execute(db, "ROLLBACK", nullptr);
+                    sqFile.close();
+                    throw exc;
+                }
+            }
+        }
+        sqFile.close();
+        opsqlite_execute(db, "COMMIT", nullptr);
+        return {"", affectedRows, commands};
+    } catch (std::exception &exc) {
+        sqFile.close();
+        opsqlite_execute(db, "ROLLBACK", nullptr);
+        throw exc;
+    }
+}
+#endif
+
+bool folder_exists(const std::string &name) {
+    struct stat buffer;
+    return (stat(name.c_str(), &buffer) == 0);
+}
+
+bool file_exists(const std::string &path) {
+    struct stat buffer;
+    return (stat(path.c_str(), &buffer) == 0);
+}
+
+void log_to_console(jsi::Runtime &runtime, const std::string &message) {
+    auto console = runtime.global().getPropertyAsObject(runtime, "console");
+    auto log = console.getPropertyAsFunction(runtime, "log");
+    log.call(runtime, jsi::String::createFromUtf8(runtime, message));
+}
+
+} // namespace opsqlite

package/cpp/utils.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "DumbHostObject.h"
+#include "SmartHostObject.h"
+#include "types.h"
+#include <jsi/jsi.h>
+#include <sqlite3.h>
+#include <string>
+#include <vector>
+
+namespace opsqlite {
+
+namespace jsi = facebook::jsi;
+
+jsi::Value to_jsi(jsi::Runtime &rt, const JSVariant &value);
+
+JSVariant to_variant(jsi::Runtime &rt, jsi::Value const &value);
+
+std::vector<std::string> to_string_vec(jsi::Runtime &rt, jsi::Value const &xs);
+
+std::vector<JSVariant> to_variant_vec(jsi::Runtime &rt, jsi::Value const &xs);
+
+std::vector<int> to_int_vec(jsi::Runtime &rt, jsi::Value const &xs);
+
+jsi::Value
+create_result(jsi::Runtime &rt, const BridgeResult &status,
+              std::vector<DumbHostObject> *results,
+              std::shared_ptr<std::vector<SmartHostObject>> metadata);
+
+jsi::Value create_js_rows(jsi::Runtime &rt, const BridgeResult &status);
+
+jsi::Value
+create_raw_result(jsi::Runtime &rt, const BridgeResult &status,
+                  const std::vector<std::vector<JSVariant>> *results);
+
+void to_batch_arguments(jsi::Runtime &rt, jsi::Array const &batch_params,
+                        std::vector<BatchArguments> *commands);
+
+BatchResult import_sql_file(sqlite3 *db, std::string path);
+
+bool folder_exists(const std::string &name);
+
+bool file_exists(const std::string &path);
+
+void log_to_console(jsi::Runtime &rt, const std::string &message);
+
+} // namespace opsqlite

package/generate_tokenizers_header_file.rb

@@ -0,0 +1,29 @@
+require 'fileutils'
+
+def generate_tokenizers_header_file(names, file_path)
+  # Ensure the directory exists
+  dir_path = File.dirname(file_path)
+  FileUtils.mkdir_p(dir_path) unless Dir.exist?(dir_path)
+  tokenizer_list = names.map { |name| "opsqlite_#{name}_init(db,&errMsg,nullptr);" }.join
+
+  File.open(file_path, 'w') do |file|
+    file.puts "#ifndef TOKENIZERS_H"
+    file.puts "#define TOKENIZERS_H"
+    file.puts
+    file.puts "#define TOKENIZER_LIST #{tokenizer_list}"
+    file.puts
+    file.puts "#include <sqlite3.h>"
+    file.puts
+    file.puts "namespace opsqlite {"
+    file.puts
+
+    names.each do |name|
+      file.puts "int opsqlite_#{name}_init(sqlite3 *db, char **error, sqlite3_api_routines const *api);"
+    end
+
+    file.puts
+    file.puts "} // namespace opsqlite"
+    file.puts
+    file.puts "#endif // TOKENIZERS_H"
+  end
+end

package/ios/OPSQLite.h

@@ -0,0 +1,7 @@
+#import <React/RCTBridge.h>
+
+@interface OPSQLite : NSObject <RCTBridgeModule>
+
+@property(nonatomic, assign) BOOL setBridgeOnMainQueue;
++ (void)expoUpdatesWorkaround;
+@end

package/ios/OPSQLite.mm

@@ -0,0 +1,157 @@
+#import "OPSQLite.h"
+#import "../cpp/bindings.h"
+#import <React/RCTBridge+Private.h>
+#import <React/RCTLog.h>
+#import <React/RCTUtils.h>
+#import <ReactCommon/RCTTurboModule.h>
+#import <jsi/jsi.h>
+
+@implementation OPSQLite
+
+@synthesize bridge = _bridge;
+
+RCT_EXPORT_MODULE()
+
++ (BOOL)requiresMainQueueSetup {
+    return YES;
+}
+
+- (NSDictionary *)constantsToExport {
+    NSArray *libraryPaths = NSSearchPathForDirectoriesInDomains(
+        NSLibraryDirectory, NSUserDomainMask, true);
+    NSString *libraryPath = [libraryPaths objectAtIndex:0];
+
+    NSArray *documentPaths = NSSearchPathForDirectoriesInDomains(
+        NSDocumentDirectory, NSUserDomainMask, true);
+    NSString *documentPath = [documentPaths objectAtIndex:0];
+    return @{
+        @"IOS_DOCUMENT_PATH" : documentPath,
+        @"IOS_LIBRARY_PATH" : libraryPath
+    };
+}
+
+- (NSDictionary *)getConstants {
+    return [self constantsToExport];
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(install) {
+    RCTCxxBridge *cxxBridge = (RCTCxxBridge *)_bridge;
+    if (cxxBridge == nil) {
+        return @false;
+    }
+
+    auto jsiRuntime = (facebook::jsi::Runtime *)cxxBridge.runtime;
+    if (jsiRuntime == nil) {
+        return @false;
+    }
+
+    auto &runtime = *jsiRuntime;
+    auto callInvoker = _bridge.jsCallInvoker;
+
+    // Get appGroupID value from Info.plist using key "AppGroup"
+    NSString *appGroupID =
+        [[NSBundle mainBundle] objectForInfoDictionaryKey:@"OPSQLite_AppGroup"];
+    NSString *documentPath;
+
+    if (appGroupID != nil) {
+        // Get the app groups container storage url
+        NSFileManager *fileManager = [NSFileManager defaultManager];
+        NSURL *storeUrl = [fileManager
+            containerURLForSecurityApplicationGroupIdentifier:appGroupID];
+
+        if (storeUrl == nil) {
+            NSLog(@"OP-SQLite: Invalid AppGroup ID provided (%@). Check the "
+                  @"value of "
+                  @"\"AppGroup\" in your Info.plist file",
+                  appGroupID);
+            return @false;
+        }
+
+        documentPath = [storeUrl path];
+    } else {
+        NSArray *paths = NSSearchPathForDirectoriesInDomains(
+            NSLibraryDirectory, NSUserDomainMask, true);
+        documentPath = [paths objectAtIndex:0];
+    }
+
+    NSBundle *crsqlite_bundle =
+        [NSBundle bundleWithIdentifier:@"io.vlcn.crsqlite"];
+    NSString *crsqlite_path = [crsqlite_bundle pathForResource:@"crsqlite"
+                                                        ofType:@""];
+    NSBundle *libsqlitevec_bundle =
+        [NSBundle bundleWithIdentifier:@"com.ospfranco.sqlitevec"];
+    NSString *sqlite_vec_path =
+        [libsqlitevec_bundle pathForResource:@"sqlitevec" ofType:@""];
+
+    if (crsqlite_path == nil) {
+        crsqlite_path = @"";
+    }
+
+    if (sqlite_vec_path == nil) {
+        sqlite_vec_path = @"";
+    }
+
+    opsqlite::install(runtime, callInvoker, [documentPath UTF8String],
+                      [crsqlite_path UTF8String], [sqlite_vec_path UTF8String]);
+    return @true;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(getDylibPath : (
+    NSString *)bundleId andResource : (NSString *)resourceName) {
+    NSBundle *bundle = [NSBundle bundleWithIdentifier:bundleId];
+    NSString *path = [bundle pathForResource:resourceName ofType:@""];
+    return path;
+}
+
+RCT_EXPORT_METHOD(moveAssetsDatabase : (NSDictionary *)args resolve : (
+    RCTPromiseResolveBlock)resolve reject : (RCTPromiseRejectBlock)reject) {
+    NSString *documentPath = [NSSearchPathForDirectoriesInDomains(
+        NSLibraryDirectory, NSUserDomainMask, true) objectAtIndex:0];
+
+    NSString *filename = args[@"filename"];
+    BOOL overwrite = args[@"overwrite"];
+
+    NSString *sourcePath = [[NSBundle mainBundle] pathForResource:filename
+                                                           ofType:nil];
+
+    NSString *destinationPath =
+        [documentPath stringByAppendingPathComponent:filename];
+
+    NSError *error;
+    NSFileManager *fileManager = [NSFileManager defaultManager];
+    if ([fileManager fileExistsAtPath:destinationPath]) {
+        if (overwrite) {
+            [fileManager removeItemAtPath:destinationPath error:&error];
+            if (error) {
+                NSLog(@"Error: %@", error);
+                resolve(@false);
+                return;
+            }
+        } else {
+            resolve(@true);
+            return;
+        }
+    }
+
+    [fileManager copyItemAtPath:sourcePath toPath:destinationPath error:&error];
+    if (error) {
+        NSLog(@"Error: %@", error);
+        resolve(@false);
+        return;
+    }
+    resolve(@true);
+    return;
+}
+
+- (void)invalidate {
+    opsqlite::invalidate();
+}
+
++ (void)expoUpdatesWorkaround {
+    NSArray *paths = NSSearchPathForDirectoriesInDomains(
+        NSLibraryDirectory, NSUserDomainMask, true);
+    NSString *documentPath = [paths objectAtIndex:0];
+    opsqlite::expoUpdatesWorkaround([documentPath UTF8String]);
+}
+
+@end