@op-engineering/op-sqlite 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2021 Oscar Franco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,274 @@
+![screenshot](https://raw.githubusercontent.com/OP-Engineering/op-sqlite/main/Header.jpg)
+
+<div align="center">
+  <pre align="center">
+    yarn add @op-engineering/op-sqlite
+    npx pod-install</pre>
+  <br />
+</div>
+<br />
+
+OP SQLite embeds the latest version of SQLite and provides a low-level (JSI-backed) API to execute SQL queries.
+
+**Current SQLite version: 3.44.0**
+
+Created by [@ospfranco](https://twitter.com/ospfranco). Also created `react-native-quick-sqlite`, this is the next version. You can expect a new version once Static Hermes is out.
+
+**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.
+
+## 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:
+
+![benchmark](https://raw.githubusercontent.com/OP-Engineering/op-sqlite/main/benchmark.png)
+
+# DB Paths
+
+The library creates/opens databases by appending the passed name plus, the [library directory on iOS](https://github.com/OP-Engineering/op-sqlite/blob/main/ios/OPSQLite.mm#L51) and the [database directory on Android](https://github.com/OP-Engineering/op-sqlite/blob/main/android/src/main/java/com/op/sqlite/OPSQLiteBridge.java#L18). If you are migrating from `react-native-quick-sqlite` you will have to move your library using one of the many react-native fs libraries.
+
+If you have an existing database file you want to load you can navigate from these directories using dot notation. e.g.:
+
+```ts
+const largeDb = open({
+  name: 'largeDB',
+  location: '../files/databases',
+});
+```
+
+Note that on iOS the file system is sand-boxed, so you cannot access files/directories outside your app bundle directories.
+
+## API
+
+```typescript
+import {open} from '@op-engineering/op-sqlite'
+
+const db = open('myDb.sqlite')
+
+// The db object contains the following methods:
+db = {
+  close: () => void,
+  delete: () => void,
+  attach: (dbNameToAttach: string, alias: string, location?: string) => void,
+  detach: (alias: string) => void,
+  transaction: (fn: (tx: Transaction) => void) => Promise<void>,
+  execute: (query: string, params?: any[]) => QueryResult,
+  executeAsync: (
+    query: string,
+    params?: any[]
+  ) => Promise<QueryResult>,
+  executeBatch: (commands: SQLBatchParams[]) => BatchQueryResult,
+  executeBatchAsync: (commands: SQLBatchParams[]) => Promise<BatchQueryResult>,
+  loadFile: (location: string) => Promise<FileLoadResult>
+}
+```
+
+### Simple queries
+
+The basic query is **synchronous**, it will block rendering on large operations, further below you will find async versions.
+
+```typescript
+import { open } from '@op-engineering/op-sqlite';
+
+try {
+  const db = open('myDb.sqlite');
+
+  let { rows } = db.execute('SELECT somevalue FROM sometable');
+
+  rows.forEach((row) => {
+    console.log(row);
+  });
+
+  let { rowsAffected } = await db.executeAsync(
+    'UPDATE sometable SET somecolumn = ? where somekey = ?',
+    [0, 1]
+  );
+
+  console.log(`Update affected ${rowsAffected} rows`);
+} catch (e) {
+  console.error('Something went wrong executing SQL commands:', e.message);
+}
+```
+
+### Transactions
+
+Throwing an error inside the callback will ROLLBACK the transaction.
+
+If you want to execute a large set of commands as fast as possible you should use the `executeBatch` method, it wraps all the commands in a transaction and has less overhead.
+
+```typescript
+await db.transaction('myDatabase', (tx) => {
+  const { status } = tx.execute(
+    'UPDATE sometable SET somecolumn = ? where somekey = ?',
+    [0, 1]
+  );
+
+  // offload from JS thread
+  await tx.executeAsync = tx.executeAsync(
+    'UPDATE sometable SET somecolumn = ? where somekey = ?',
+    [0, 1]
+  );
+
+  // Any uncatched error ROLLBACK transaction
+  throw new Error('Random Error!');
+
+  // You can manually commit or rollback
+  tx.commit();
+  // or
+  tx.rollback();
+});
+```
+
+### Batch operation
+
+Batch execution allows the transactional execution of a set of commands
+
+```typescript
+const commands = [
+  ['CREATE TABLE TEST (id integer)'],
+  ['INSERT INTO TEST (id) VALUES (?)', [1]],
+  [('INSERT INTO TEST (id) VALUES (?)', [2])],
+  [('INSERT INTO TEST (id) VALUES (?)', [[3], [4], [5], [6]])],
+];
+
+const res = db.executeSqlBatch('myDatabase', commands);
+
+console.log(`Batch affected ${result.rowsAffected} rows`);
+```
+
+### Dynamic Column Metadata
+
+In some scenarios, dynamic applications may need to get some metadata information about the returned result set.
+
+This can be done by testing the returned data directly, but in some cases may not be enough, for example when data is stored outside
+SQLite datatypes. When fetching data directly from tables or views linked to table columns, SQLite can identify the table declared types:
+
+```typescript
+let { metadata } = db.executeSql(
+  'myDatabase',
+  'SELECT int_column_1, bol_column_2 FROM sometable'
+);
+
+metadata.forEach((column) => {
+  // Output:
+  // int_column_1 - INTEGER
+  // bol_column_2 - BOOLEAN
+  console.log(`${column.name} - ${column.type}`);
+});
+```
+
+### Async operations
+
+You might have too much SQL to process and it will cause your application to freeze. There are async versions for some of the operations. This will offload the SQLite processing to a different thread.
+
+```ts
+db.executeAsync(
+  'myDatabase',
+  'SELECT * FROM "User";',
+  []).then(({rows}) => {
+    console.log('users', rows);
+  })
+);
+```
+
+### Attach or Detach other databases
+
+SQLite supports attaching or detaching other database files into your main database connection through an alias.
+You can do any operation you like on this attached database like JOIN results across tables in different schemas, or update data or objects.
+These databases can have different configurations, like journal modes, and cache settings.
+
+You can, at any moment, detach a database that you don't need anymore. You don't need to detach an attached database before closing your connection. Closing the main connection will detach any attached databases.
+
+SQLite has a limit for attached databases: A default of 10, and a global max of 125
+
+References: [Attach](https://www.sqlite.org/lang_attach.html) - [Detach](https://www.sqlite.org/lang_detach.html)
+
+```ts
+db.attach('mainDatabase', 'statistics', 'stats', '../databases');
+
+const res = db.executeSql(
+  'mainDatabase',
+  '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
+}
+```
+
+### 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
+
+```typescript
+db.loadFileAsync('myDatabase', '/absolute/path/to/file.sql').then((res) => {
+  const { rowsAffected, commands } = res;
+});
+```
+
+## Use built-in SQLite
+
+On iOS you can use the embedded SQLite, when running `pod-install` add an environment flag:
+
+```
+OP_SQLITE_USE_PHONE_VERSION=1 npx pod-install
+```
+
+On Android, it is not possible to link the OS SQLite. It is also a bad idea due to vendor changes, old android bugs, etc. Unfortunately, this means this library will add some megabytes to your app size.
+
+## Enable compile-time options
+
+By specifying pre-processor flags, you can enable optional features like FTS5, Geopoly, etc.
+
+### iOS
+
+Add a `post_install` block to your `<PROJECT_ROOT>/ios/Podfile` like so:
+
+```ruby
+post_install do |installer|
+  installer.pods_project.targets.each do |target|
+    if target.name == "op-sqlite" then
+      target.build_configurations.each do |config|
+        config.build_settings['GCC_PREPROCESSOR_DEFINITIONS'] << 'SQLITE_ENABLE_FTS5=1'
+      end
+    end
+  end
+end
+```
+
+Replace the `<SQLITE_FLAGS>` part with the flags you want to add.
+For example, you could add `SQLITE_ENABLE_FTS5=1` to `GCC_PREPROCESSOR_DEFINITIONS` to enable FTS5 in the iOS project.
+
+### Android
+
+You can specify flags via `<PROJECT_ROOT>/android/gradle.properties` like so:
+
+```
+OPSQLiteFlags="<SQLITE_FLAGS>"
+```
+
+## Additional configuration
+
+### App groups (iOS only)
+
+On iOS, the SQLite database can be placed in an app group, in order to make it accessible from other apps in that app group. E.g. for sharing capabilities.
+
+To use an app group, add the app group ID as the value for the `OPSQLite_AppGroup` key in your project's `Info.plist` file. You'll also need to configure the app group in your project settings. (Xcode -> Project Settings -> Signing & Capabilities -> Add Capability -> App Groups)
+
+## License
+
+MIT License.

package/android/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>android_</name>
+	<comment>Project android_ created by Buildship.</comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
+	</natures>
+</projectDescription>

package/android/.settings/org.eclipse.buildship.core.prefs

@@ -0,0 +1,13 @@
+arguments=
+auto.sync=false
+build.scans.enabled=false
+connection.gradle.distribution=GRADLE_DISTRIBUTION(VERSION(6.0))
+connection.project.dir=
+eclipse.preferences.version=1
+gradle.user.home=
+java.home=/Library/Java/JavaVirtualMachines/jdk1.8.0_144.jdk/Contents/Home
+jvm.arguments=
+offline.mode=false
+override.workspace.settings=true
+show.console.view=true
+show.executions.view=true

package/android/CMakeLists.txt

@@ -0,0 +1,57 @@
+project(OPSQLite)
+cmake_minimum_required(VERSION 3.9.0)
+
+set (PACKAGE_NAME "op-sqlite")
+set (CMAKE_VERBOSE_MAKEFILE ON)
+set (CMAKE_CXX_STANDARD 17)
+set (BUILD_DIR ${CMAKE_SOURCE_DIR}/build)
+
+include_directories(
+  ../cpp
+)
+
+add_definitions(
+  ${SQLITE_FLAGS}
+)
+
+add_library(
+  ${PACKAGE_NAME}
+  SHARED
+  ../cpp/bridge.cpp
+  ../cpp/bridge.h
+  ../cpp/bindings.cpp
+  ../cpp/bindings.h
+  ../cpp/sqlite3.h
+  ../cpp/sqlite3.c
+  ../cpp/utils.h
+  ../cpp/utils.cpp
+  ../cpp/ThreadPool.h
+  ../cpp/ThreadPool.cpp
+  ../cpp/sqlbatchexecutor.h
+  ../cpp/sqlbatchexecutor.cpp
+  ../cpp/DynamicHostObject.cpp
+  ../cpp/DynamicHostObject.h
+  ../cpp/macros.h
+  cpp-adapter.cpp
+)
+
+set_target_properties(
+  ${PACKAGE_NAME} PROPERTIES
+  CXX_STANDARD 17
+  CXX_EXTENSIONS OFF
+  POSITION_INDEPENDENT_CODE ON
+)
+
+find_package(ReactAndroid REQUIRED CONFIG)
+find_package(fbjni REQUIRED CONFIG)
+find_library(LOG_LIB log)
+
+target_link_libraries(
+  ${PACKAGE_NAME}
+  ${LOG_LIB}
+  fbjni::fbjni
+  ReactAndroid::jsi
+  ReactAndroid::turbomodulejsijni
+  ReactAndroid::react_nativemodule_core
+  android
+)

package/android/build.gradle

@@ -0,0 +1,127 @@
+import java.nio.file.Paths
+
+buildscript {
+  repositories {
+    maven {
+      url "https://plugins.gradle.org/m2/"
+    }
+    mavenCentral()
+    google()
+  }
+
+  dependencies {
+    classpath("com.android.tools.build:gradle:7.2.2")
+  }
+}
+
+def resolveBuildType() {
+    Gradle gradle = getGradle()
+    String tskReqStr = gradle.getStartParameter().getTaskRequests()['args'].toString()
+
+    return tskReqStr.contains('Release') ? 'release' : 'debug'
+}
+
+def isNewArchitectureEnabled() {
+  // - Set `newArchEnabled` to true inside the `gradle.properties` file
+  return project.hasProperty("newArchEnabled") && project.newArchEnabled == "true"
+}
+
+def SQLITE_FLAGS = rootProject.properties['OPSQLiteFlags']
+
+apply plugin: 'com.android.library'
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+def reactNativeArchitectures() {
+  def value = project.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def USE_HERMES = rootProject.ext.hermesEnabled
+
+repositories {
+  mavenCentral()
+}
+
+android {
+  
+  compileSdkVersion safeExtGet("compileSdkVersion", 28)
+  
+  // Used to override the NDK path/version on internal CI or by allowing
+  // users to customize the NDK path/version from their root project (e.g. for M1 support)
+  if (rootProject.hasProperty("ndkPath")) {
+    ndkPath rootProject.ext.ndkPath
+  }
+  if (rootProject.hasProperty("ndkVersion")) {
+    ndkVersion rootProject.ext.ndkVersion
+  }
+
+  buildFeatures {
+    prefab true
+  }
+
+  defaultConfig {
+    minSdkVersion 21 
+    targetSdkVersion safeExtGet('targetSdkVersion', 28)
+    versionCode 1
+    versionName "1.0"
+    
+    externalNativeBuild {
+        cmake {
+            cppFlags "-O2", "-fexceptions", "-frtti", "-std=c++1y", "-DONANDROID"
+            abiFilters 'x86', 'x86_64', 'armeabi-v7a', 'arm64-v8a'
+            arguments '-DANDROID_STL=c++_shared',
+              "-DSQLITE_FLAGS='${SQLITE_FLAGS ? SQLITE_FLAGS : ''}'",
+              "-DUSE_HERMES=${USE_HERMES}"
+            abiFilters (*reactNativeArchitectures())
+        }
+    }
+
+    packagingOptions {
+      doNotStrip resolveBuildType() == 'debug' ? "**/**/*.so" : ''
+      excludes = [
+              "META-INF",
+              "META-INF/**",
+              "**/libjsi.so",
+              "**/libreact_nativemodule_core.so",
+              "**/libturbomodulejsijni.so",
+              "**/libc++_shared.so",
+              "**/libfbjni.so"
+      ]
+    }
+    
+  }
+  
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+}
+
+dependencies {
+  //noinspection GradleDynamicVersion
+  implementation 'com.facebook.react:react-android:+'
+}
+
+// Resolves "LOCAL_SRC_FILES points to a missing file, Check that libfb.so exists or that its path is correct".
+tasks.whenTaskAdded { task ->
+  if (task.name.contains("configureCMakeDebug")) {
+    rootProject.getTasksByName("packageReactNdkDebugLibs", true).forEach {
+      task.dependsOn(it)
+    }
+  }
+  // We want to add a dependency for both configureCMakeRelease and configureCMakeRelWithDebInfo
+  if (task.name.contains("configureCMakeRel")) {
+    rootProject.getTasksByName("packageReactNdkReleaseLibs", true).forEach {
+      task.dependsOn(it)
+    }
+  }
+}

package/android/cpp-adapter.cpp

@@ -0,0 +1,42 @@
+#include "bindings.h"
+#include "logs.h"
+#include <ReactCommon/CallInvokerHolder.h>
+#include <fbjni/fbjni.h>
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <typeinfo>
+
+struct OPSQLiteBridge : jni::JavaClass<OPSQLiteBridge> {
+  static constexpr auto kJavaDescriptor =
+      "Lcom/op/sqlite/OPSQLiteBridge;";
+
+  static void registerNatives() {
+    javaClassStatic()->registerNatives(
+        {// initialization for JSI
+         makeNativeMethod("installNativeJsi",
+                          OPSQLiteBridge::installNativeJsi),
+         makeNativeMethod("clearStateNativeJsi",
+                          OPSQLiteBridge::clearStateNativeJsi)
+        });
+  }
+
+private:
+  static void installNativeJsi(
+      jni::alias_ref<jni::JObject> thiz, jlong jsiRuntimePtr,
+      jni::alias_ref<react::CallInvokerHolder::javaobject> jsCallInvokerHolder,
+      jni::alias_ref<jni::JString> docPath) {
+    auto jsiRuntime = reinterpret_cast<jsi::Runtime *>(jsiRuntimePtr);
+    auto jsCallInvoker = jsCallInvokerHolder->cthis()->getCallInvoker();
+    std::string docPathString = docPath->toStdString();
+
+    osp::install(*jsiRuntime, jsCallInvoker, docPathString.c_str());
+  }
+ 
+  static void clearStateNativeJsi(jni::alias_ref<jni::JObject> thiz) {
+    osp::clearState();
+  }
+};
+
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *) {
+  return jni::initialize(vm, [] { OPSQLiteBridge::registerNatives(); });
+}

package/android/gradle.properties

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

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.op.sqlite">
+
+</manifest>

package/android/src/main/java/com/op/sqlite/OPSQLiteBridge.java

@@ -0,0 +1,29 @@
+package com.op.sqlite;
+
+import android.util.Log;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+
+public class OPSQLiteBridge {
+  private native void installNativeJsi(long jsContextNativePointer, CallInvokerHolderImpl jsCallInvokerHolder, String docPath);
+  private native void clearStateNativeJsi();
+  public static final OPSQLiteBridge instance = new OPSQLiteBridge();
+
+  public void install(ReactContext context) {
+      long jsContextPointer = context.getJavaScriptContextHolder().get();
+      CallInvokerHolderImpl jsCallInvokerHolder = (CallInvokerHolderImpl)context.getCatalystInstance().getJSCallInvokerHolder();
+      // Trick to get the base database path
+      final String dbPath = context.getDatabasePath("defaultDatabase").getAbsolutePath().replace("defaultDatabase", "");
+      installNativeJsi(
+        jsContextPointer,
+        jsCallInvokerHolder,
+        dbPath
+      );
+  }
+
+  public void clearState() {
+    clearStateNativeJsi();
+  }
+}

package/android/src/main/java/com/op/sqlite/OPSQLiteModule.java

@@ -0,0 +1,46 @@
+package com.op.sqlite;
+
+import androidx.annotation.NonNull;
+import android.util.Log;
+
+import com.facebook.jni.HybridData;
+import com.facebook.jni.annotations.DoNotStrip;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.turbomodule.core.CallInvokerHolderImpl;
+
+class OPSQLiteModule extends ReactContextBaseJavaModule {
+  public static final String NAME = "OPSQLite";
+  
+  public OPSQLiteModule(ReactApplicationContext context) {
+    super(context);
+  }
+
+  @NonNull
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean install() {
+    try {
+      System.loadLibrary("op-sqlite");
+      OPSQLiteBridge.instance.install(getReactApplicationContext());
+      return true;
+    } catch (Exception exception) {
+      Log.e(NAME, "Failed to install JSI Bindings!", exception);
+      return false;
+    }
+  }
+
+  @Override
+  public void onCatalystInstanceDestroy() {
+    try {
+      OPSQLiteBridge.instance.clearState();
+    } catch (Exception exception) {
+      Log.e(NAME, "Failed to clear state!", exception);
+    }
+  }
+}

package/android/src/main/java/com/op/sqlite/OPSQLitePackage.java

@@ -0,0 +1,26 @@
+package com.op.sqlite;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.Collections;
+import java.util.List;
+
+
+public class OPSQLitePackage implements ReactPackage {
+  @NonNull
+  @Override
+  public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+    return Collections.singletonList(new OPSQLiteModule(reactContext));
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/cpp/DynamicHostObject.cpp

@@ -0,0 +1,30 @@
+#include "DynamicHostObject.h"
+#include "utils.h"
+#include <iostream>
+
+namespace osp {
+
+namespace jsi = facebook::jsi;
+
+std::vector<jsi::PropNameID> DynamicHostObject::getPropertyNames(jsi::Runtime &rt) {
+    std::vector<jsi::PropNameID> keys;
+    
+    for (auto field : fields) {
+        keys.push_back(jsi::PropNameID::forAscii(rt, field.first));
+    }
+    
+    return keys;
+}
+
+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);
+    }
+}
+
+}