@op-engineering/op-sqlite 11.2.14 → 11.3.0

package/cpp/DBHostObject.h

@@ -19,79 +19,80 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
 struct PendingReactiveInvocation {
-  std::string db_name;
-  std::string table;
-  std::string rowid;
+    std::string db_name;
+    std::string table;
+    std::string rowid;
 };
 
 struct TableRowDiscriminator {
-  std::string table;
-  std::vector<int> ids;
+    std::string table;
+    std::vector<int> ids;
 };
 
 struct ReactiveQuery {
 #ifndef OP_SQLITE_USE_LIBSQL
-  sqlite3_stmt *stmt;
+    sqlite3_stmt *stmt;
 #endif
-  std::vector<TableRowDiscriminator> discriminators;
-  std::shared_ptr<jsi::Value> callback;
+    std::vector<TableRowDiscriminator> discriminators;
+    std::shared_ptr<jsi::Value> callback;
 };
 
 class JSI_EXPORT DBHostObject : public jsi::HostObject {
-public:
-  // Normal constructor shared between all backends
-  DBHostObject(jsi::Runtime &rt, std::string &base_path,
-               std::shared_ptr<react::CallInvoker> invoker,
-               std::string &db_name, std::string &path,
-               std::string &crsqlite_path, std::string &sqlite_vec_path,
-               std::string &encryption_key);
+  public:
+    // Normal constructor shared between all backends
+    DBHostObject(jsi::Runtime &rt, std::string &base_path,
+                 std::shared_ptr<react::CallInvoker> invoker,
+                 std::string &db_name, std::string &path,
+                 std::string &crsqlite_path, std::string &sqlite_vec_path,
+                 std::string &encryption_key);
 
 #ifdef OP_SQLITE_USE_LIBSQL
-  // Constructor for remoteOpen, purely for remote databases
-  DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token,
-               std::shared_ptr<react::CallInvoker> invoker);
+    // Constructor for remoteOpen, purely for remote databases
+    DBHostObject(jsi::Runtime &rt, std::string &url, std::string &auth_token,
+                 std::shared_ptr<react::CallInvoker> invoker);
 
-  // Constructor for a local database with remote sync
-  DBHostObject(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
-               std::string &db_name, std::string &path, std::string &url,
-               std::string &auth_token, int sync_interval);
+    // Constructor for a local database with remote sync
+    DBHostObject(jsi::Runtime &rt, std::shared_ptr<react::CallInvoker> invoker,
+                 std::string &db_name, std::string &path, std::string &url,
+                 std::string &auth_token, int sync_interval);
 #endif
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
-  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
-           const jsi::Value &value) override;
-  void on_update(const std::string &table, const std::string &operation,
-                 long long row_id);
-  void on_commit();
-  void on_rollback();
-  void invalidate();
-  ~DBHostObject() override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    jsi::Value get(jsi::Runtime &rt,
+                   const jsi::PropNameID &propNameID) override;
+    void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+             const jsi::Value &value) override;
+    void on_update(const std::string &table, const std::string &operation,
+                   long long row_id);
+    void on_commit();
+    void on_rollback();
+    void invalidate();
+    ~DBHostObject() override;
 
-private:
-  std::set<std::shared_ptr<ReactiveQuery>> pending_reactive_queries;
-  void auto_register_update_hook();
-  void create_jsi_functions();
-  void
-  flush_pending_reactive_queries(const std::shared_ptr<jsi::Value> &resolve);
+  private:
+    std::set<std::shared_ptr<ReactiveQuery>> pending_reactive_queries;
+    void auto_register_update_hook();
+    void create_jsi_functions();
+    void
+    flush_pending_reactive_queries(const std::shared_ptr<jsi::Value> &resolve);
 
-  std::unordered_map<std::string, jsi::Value> function_map;
-  std::string base_path;
-  std::shared_ptr<react::CallInvoker> invoker;
-  std::shared_ptr<ThreadPool> _thread_pool;
-  std::string db_name;
-  std::shared_ptr<jsi::Value> update_hook_callback;
-  std::shared_ptr<jsi::Value> commit_hook_callback;
-  std::shared_ptr<jsi::Value> rollback_hook_callback;
-  jsi::Runtime &rt;
-  std::vector<std::shared_ptr<ReactiveQuery>> reactive_queries;
-  std::vector<PendingReactiveInvocation> pending_reactive_invocations;
-  bool is_update_hook_registered = false;
-  bool invalidated = false;
+    std::unordered_map<std::string, jsi::Value> function_map;
+    std::string base_path;
+    std::shared_ptr<react::CallInvoker> invoker;
+    std::shared_ptr<ThreadPool> _thread_pool;
+    std::string db_name;
+    std::shared_ptr<jsi::Value> update_hook_callback;
+    std::shared_ptr<jsi::Value> commit_hook_callback;
+    std::shared_ptr<jsi::Value> rollback_hook_callback;
+    jsi::Runtime &rt;
+    std::vector<std::shared_ptr<ReactiveQuery>> reactive_queries;
+    std::vector<PendingReactiveInvocation> pending_reactive_invocations;
+    bool is_update_hook_registered = false;
+    bool invalidated = false;
 #ifdef OP_SQLITE_USE_LIBSQL
-  DB db;
+    DB db;
 #else
-  sqlite3 *db;
+    sqlite3 *db;
 #endif
 };
 

package/cpp/DumbHostObject.cpp

@@ -9,63 +9,64 @@ namespace jsi = facebook::jsi;
 
 DumbHostObject::DumbHostObject(
     std::shared_ptr<std::vector<SmartHostObject>> metadata) {
-  this->metadata = metadata;
+    this->metadata = metadata;
 };
 
 std::vector<jsi::PropNameID>
 DumbHostObject::getPropertyNames(jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> keys;
+    std::vector<jsi::PropNameID> keys;
 
-  for (auto field : *metadata) {
-    // TODO improve this by generating the propName once on metadata creation
-    keys.push_back(jsi::PropNameID::forAscii(
-        rt, std::get<std::string>(field.fields[0].second)));
-  }
+    for (auto field : *metadata) {
+        // TODO improve this by generating the propName once on metadata
+        // creation
+        keys.push_back(jsi::PropNameID::forAscii(
+            rt, std::get<std::string>(field.fields[0].second)));
+    }
 
-  return keys;
+    return keys;
 }
 
 jsi::Value DumbHostObject::get(jsi::Runtime &rt,
                                const jsi::PropNameID &propNameID) {
 
-  auto name = propNameID.utf8(rt);
-  auto fields = metadata.get();
-  for (int i = 0; i < fields->size(); i++) {
-    auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
-    if (fieldName == name) {
-      return to_jsi(rt, values.at(i));
+    auto name = propNameID.utf8(rt);
+    auto fields = metadata.get();
+    for (int i = 0; i < fields->size(); i++) {
+        auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
+        if (fieldName == name) {
+            return to_jsi(rt, values.at(i));
+        }
     }
-  }
 
-  for (auto pairField : ownValues) {
-    if (name == pairField.first) {
-      return to_jsi(rt, pairField.second);
+    for (auto pairField : ownValues) {
+        if (name == pairField.first) {
+            return to_jsi(rt, pairField.second);
+        }
     }
-  }
 
-  return {};
+    return {};
 }
 
 void DumbHostObject::set(jsi::Runtime &rt, const jsi::PropNameID &name,
                          const jsi::Value &value) {
-  auto key = name.utf8(rt);
-  auto fields = metadata.get();
-  for (int i = 0; i < fields->size(); i++) {
-    auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
-    if (fieldName == key) {
-      values[i] = to_variant(rt, value);
-      return;
+    auto key = name.utf8(rt);
+    auto fields = metadata.get();
+    for (int i = 0; i < fields->size(); i++) {
+        auto fieldName = std::get<std::string>(fields->at(i).fields[0].second);
+        if (fieldName == key) {
+            values[i] = to_variant(rt, value);
+            return;
+        }
     }
-  }
 
-  for (auto pairField : ownValues) {
-    if (key == pairField.first) {
-      pairField.second = to_variant(rt, value);
-      return;
+    for (auto pairField : ownValues) {
+        if (key == pairField.first) {
+            pairField.second = to_variant(rt, value);
+            return;
+        }
     }
-  }
 
-  ownValues.push_back(std::make_pair(key, to_variant(rt, value)));
+    ownValues.push_back(std::make_pair(key, to_variant(rt, value)));
 }
 
 } // namespace opsqlite

package/cpp/DumbHostObject.h

@@ -12,24 +12,25 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 
 class JSI_EXPORT DumbHostObject : public jsi::HostObject {
-public:
-  DumbHostObject() = default;
+  public:
+    DumbHostObject() = default;
 
-  explicit DumbHostObject(
-      std::shared_ptr<std::vector<SmartHostObject>> metadata);
+    explicit DumbHostObject(
+        std::shared_ptr<std::vector<SmartHostObject>> metadata);
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
+    jsi::Value get(jsi::Runtime &rt,
+                   const jsi::PropNameID &propNameID) override;
 
-  void set(jsi::Runtime &rt, const jsi::PropNameID &name,
-           const jsi::Value &value) override;
+    void set(jsi::Runtime &rt, const jsi::PropNameID &name,
+             const jsi::Value &value) override;
 
-  std::vector<JSVariant> values;
+    std::vector<JSVariant> values;
 
-  std::shared_ptr<std::vector<SmartHostObject>> metadata;
+    std::shared_ptr<std::vector<SmartHostObject>> metadata;
 
-  std::vector<std::pair<std::string, JSVariant>> ownValues;
+    std::vector<std::pair<std::string, JSVariant>> ownValues;
 };
 
 } // namespace opsqlite

package/cpp/PreparedStatementHostObject.cpp

@@ -13,132 +13,138 @@ namespace jsi = facebook::jsi;
 
 std::vector<jsi::PropNameID>
 PreparedStatementHostObject::getPropertyNames(jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> keys;
+    std::vector<jsi::PropNameID> keys;
 
-  return keys;
+    return keys;
 }
 
 jsi::Value PreparedStatementHostObject::get(jsi::Runtime &rt,
                                             const jsi::PropNameID &propNameID) {
-  auto name = propNameID.utf8(rt);
+    auto name = propNameID.utf8(rt);
 
-  if (name == "bind") {
-    return HOSTFN("bind") {
-      if (_stmt == nullptr) {
-        throw std::runtime_error("statement has been freed");
-      }
+    if (name == "bind") {
+        return HOSTFN("bind") {
+            if (_stmt == nullptr) {
+                throw std::runtime_error("statement has been freed");
+            }
 
-      const jsi::Value &js_params = args[0];
-      std::vector<JSVariant> params = to_variant_vec(rt, js_params);
+            const jsi::Value &js_params = args[0];
+            std::vector<JSVariant> params = to_variant_vec(rt, js_params);
 
-      auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+            auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
       auto promise = promiseCtr.callAsConstructor(
           rt, HOSTFN("executor") {
-        auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
-        auto reject = std::make_shared<jsi::Value>(rt, args[1]);
-        auto task = [&rt, this, resolve, reject,
-                     invoker = this->_js_call_invoker, params]() {
-          try {
+                auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+                auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+                auto task = [&rt, this, resolve, reject,
+                             invoker = this->_js_call_invoker, params]() {
+                    try {
 #ifdef OP_SQLITE_USE_LIBSQL
-            opsqlite_libsql_bind_statement(_stmt, &params);
+                        opsqlite_libsql_bind_statement(_stmt, &params);
 #else
-            opsqlite_bind_statement(_stmt, &params);
+                        opsqlite_bind_statement(_stmt, &params);
 #endif
-            invoker->invokeAsync([&rt, resolve] {
-              resolve->asObject(rt).asFunction(rt).call(rt, {});
-            });
-          } catch (const std::runtime_error &e) {
-            invoker->invokeAsync([&rt, e, reject] {
-              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
-              auto error = errorCtr.callAsConstructor(
-                  rt, jsi::String::createFromUtf8(rt, e.what()));
-              reject->asObject(rt).asFunction(rt).call(rt, error);
-            });
-          } catch (const std::exception &e) {
-            invoker->invokeAsync([&rt, e, reject] {
-              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
-              auto error = errorCtr.callAsConstructor(
-                  rt, jsi::String::createFromUtf8(rt, e.what()));
-              reject->asObject(rt).asFunction(rt).call(rt, error);
-            });
-          }
-        };
-
-        _thread_pool->queueWork(task);
-
-        return {};
+                        invoker->invokeAsync([&rt, resolve] {
+                            resolve->asObject(rt).asFunction(rt).call(rt, {});
+                        });
+                    } catch (const std::runtime_error &e) {
+                        invoker->invokeAsync([&rt, e, reject] {
+                            auto errorCtr =
+                                rt.global().getPropertyAsFunction(rt, "Error");
+                            auto error = errorCtr.callAsConstructor(
+                                rt, jsi::String::createFromUtf8(rt, e.what()));
+                            reject->asObject(rt).asFunction(rt).call(rt, error);
+                        });
+                    } catch (const std::exception &e) {
+                        invoker->invokeAsync([&rt, e, reject] {
+                            auto errorCtr =
+                                rt.global().getPropertyAsFunction(rt, "Error");
+                            auto error = errorCtr.callAsConstructor(
+                                rt, jsi::String::createFromUtf8(rt, e.what()));
+                            reject->asObject(rt).asFunction(rt).call(rt, error);
+                        });
+                    }
+                };
+
+                _thread_pool->queueWork(task);
+
+                return {};
           }));
       return promise;
-    });
-  }
+        });
+    }
 
-  if (name == "execute") {
-    return HOSTFN("execute") {
-      if (_stmt == nullptr) {
-        throw std::runtime_error("statement has been freed");
-      }
+    if (name == "execute") {
+        return HOSTFN("execute") {
+            if (_stmt == nullptr) {
+                throw std::runtime_error("statement has been freed");
+            }
 
-      auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
+            auto promiseCtr = rt.global().getPropertyAsFunction(rt, "Promise");
         auto promise = promiseCtr.callAsConstructor(rt, HOSTFN("executor") {
-        auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
-        auto reject = std::make_shared<jsi::Value>(rt, args[1]);
-
-        auto task = [&rt, this, resolve, reject,
-                     invoker = this->_js_call_invoker]() {
-          std::vector<DumbHostObject> results;
-          std::shared_ptr<std::vector<SmartHostObject>> metadata =
-              std::make_shared<std::vector<SmartHostObject>>();
-          try {
+                auto resolve = std::make_shared<jsi::Value>(rt, args[0]);
+                auto reject = std::make_shared<jsi::Value>(rt, args[1]);
+
+                auto task = [&rt, this, resolve, reject,
+                             invoker = this->_js_call_invoker]() {
+                    std::vector<DumbHostObject> results;
+                    std::shared_ptr<std::vector<SmartHostObject>> metadata =
+                        std::make_shared<std::vector<SmartHostObject>>();
+                    try {
 #ifdef OP_SQLITE_USE_LIBSQL
-            auto status = opsqlite_libsql_execute_prepared_statement(
-                _db, _stmt, &results, metadata);
+                        auto status =
+                            opsqlite_libsql_execute_prepared_statement(
+                                _db, _stmt, &results, metadata);
 #else
-            auto status = opsqlite_execute_prepared_statement(
-                _db, _stmt, &results, metadata);
+                        auto status = opsqlite_execute_prepared_statement(
+                            _db, _stmt, &results, metadata);
 #endif
-            invoker->invokeAsync(
-                [&rt, status = std::move(status),
-                 results =
-                     std::make_shared<std::vector<DumbHostObject>>(results),
-                 metadata, resolve] {
-                  auto jsiResult =
-                      create_result(rt, status, results.get(), metadata);
-                  resolve->asObject(rt).asFunction(rt).call(
-                      rt, std::move(jsiResult));
-                });
-          } catch (std::exception &exc) {
-            invoker->invokeAsync([&rt, &exc, reject] {
-              auto errorCtr = rt.global().getPropertyAsFunction(rt, "Error");
-              auto error = errorCtr.callAsConstructor(
-                  rt, jsi::String::createFromUtf8(rt, exc.what()));
-              reject->asObject(rt).asFunction(rt).call(rt, error);
-            });
-          }
-        };
-
-        _thread_pool->queueWork(task);
-
-        return {};
+                        invoker->invokeAsync(
+                            [&rt, status = std::move(status),
+                             results =
+                                 std::make_shared<std::vector<DumbHostObject>>(
+                                     results),
+                             metadata, resolve] {
+                                auto jsiResult = create_result(
+                                    rt, status, results.get(), metadata);
+                                resolve->asObject(rt).asFunction(rt).call(
+                                    rt, std::move(jsiResult));
+                            });
+                    } catch (std::exception &exc) {
+                        invoker->invokeAsync([&rt, &exc, reject] {
+                            auto errorCtr =
+                                rt.global().getPropertyAsFunction(rt, "Error");
+                            auto error = errorCtr.callAsConstructor(
+                                rt,
+                                jsi::String::createFromUtf8(rt, exc.what()));
+                            reject->asObject(rt).asFunction(rt).call(rt, error);
+                        });
+                    }
+                };
+
+                _thread_pool->queueWork(task);
+
+                return {};
           }));
 
         return promise;
-    });
-  }
+        });
+    }
 
-  return {};
+    return {};
 }
 
 PreparedStatementHostObject::~PreparedStatementHostObject() {
 #ifdef OP_SQLITE_USE_LIBSQL
-  if (_stmt != nullptr) {
-    libsql_free_stmt(_stmt);
-    _stmt = nullptr;
-  }
+    if (_stmt != nullptr) {
+        libsql_free_stmt(_stmt);
+        _stmt = nullptr;
+    }
 #else
-  if (_stmt != nullptr) {
-//    sqlite3_finalize(_stmt);
-    _stmt = nullptr;
-  }
+    if (_stmt != nullptr) {
+        //    sqlite3_finalize(_stmt);
+        _stmt = nullptr;
+    }
 #endif
 }
 

package/cpp/PreparedStatementHostObject.h

@@ -4,8 +4,8 @@
 #include <jsi/jsi.h>
 #include <memory>
 #ifdef OP_SQLITE_USE_LIBSQL
-#include "libsql/bridge.h"
 #include "libsql.h"
+#include "libsql/bridge.h"
 #else
 #include <sqlite3.h>
 #endif
@@ -18,40 +18,42 @@ namespace jsi = facebook::jsi;
 namespace react = facebook::react;
 
 class PreparedStatementHostObject : public jsi::HostObject {
-public:
+  public:
 #ifdef OP_SQLITE_USE_LIBSQL
-  PreparedStatementHostObject(
-      DB const &db, std::string name, libsql_stmt_t stmt,
-      std::shared_ptr<react::CallInvoker> js_call_invoker,
-      std::shared_ptr<ThreadPool> thread_pool)
-      : _db(db), _name(std::move(name)), _stmt(stmt), _js_call_invoker(js_call_invoker),
-        _thread_pool(thread_pool) {};
+    PreparedStatementHostObject(
+        DB const &db, std::string name, libsql_stmt_t stmt,
+        std::shared_ptr<react::CallInvoker> js_call_invoker,
+        std::shared_ptr<ThreadPool> thread_pool)
+        : _db(db), _name(std::move(name)), _stmt(stmt),
+          _js_call_invoker(js_call_invoker), _thread_pool(thread_pool) {};
 #else
-  PreparedStatementHostObject(
-      sqlite3 *db, std::string name, sqlite3_stmt *stmt,
-      std::shared_ptr<react::CallInvoker> js_call_invoker,
-      std::shared_ptr<ThreadPool> thread_pool)
-      : _db(db), _name(std::move(name)), _stmt(stmt), _js_call_invoker(std::move(js_call_invoker)),
-        _thread_pool(std::move(thread_pool)) {};
+    PreparedStatementHostObject(
+        sqlite3 *db, std::string name, sqlite3_stmt *stmt,
+        std::shared_ptr<react::CallInvoker> js_call_invoker,
+        std::shared_ptr<ThreadPool> thread_pool)
+        : _db(db), _name(std::move(name)), _stmt(stmt),
+          _js_call_invoker(std::move(js_call_invoker)),
+          _thread_pool(std::move(thread_pool)) {};
 #endif
-  ~PreparedStatementHostObject() override;
+    ~PreparedStatementHostObject() override;
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
+    jsi::Value get(jsi::Runtime &rt,
+                   const jsi::PropNameID &propNameID) override;
 
-private:
-  std::string _name;
+  private:
+    std::string _name;
 #ifdef OP_SQLITE_USE_LIBSQL
-  DB _db;
-  libsql_stmt_t _stmt;
+    DB _db;
+    libsql_stmt_t _stmt;
 #else
-  sqlite3 *_db;
-  // This shouldn't be de-allocated until sqlite3_finalize is called on it
-  sqlite3_stmt *_stmt;
+    sqlite3 *_db;
+    // This shouldn't be de-allocated until sqlite3_finalize is called on it
+    sqlite3_stmt *_stmt;
 #endif
-  std::shared_ptr<react::CallInvoker> _js_call_invoker;
-  std::shared_ptr<ThreadPool> _thread_pool;
+    std::shared_ptr<react::CallInvoker> _js_call_invoker;
+    std::shared_ptr<ThreadPool> _thread_pool;
 };
 
 } // namespace opsqlite

package/cpp/SmartHostObject.cpp

@@ -7,28 +7,28 @@ namespace jsi = facebook::jsi;
 
 std::vector<jsi::PropNameID>
 SmartHostObject::getPropertyNames(jsi::Runtime &rt) {
-  std::vector<jsi::PropNameID> keys;
+    std::vector<jsi::PropNameID> keys;
 
-  keys.reserve(fields.size());
-for (const auto& field : fields) {
-    keys.emplace_back(jsi::PropNameID::forAscii(rt, field.first));
-  }
+    keys.reserve(fields.size());
+    for (const auto &field : fields) {
+        keys.emplace_back(jsi::PropNameID::forAscii(rt, field.first));
+    }
 
-  return keys;
+    return keys;
 }
 
 jsi::Value SmartHostObject::get(jsi::Runtime &rt,
                                 const jsi::PropNameID &propNameID) {
-  auto name = propNameID.utf8(rt);
+    auto name = propNameID.utf8(rt);
 
-  for (const auto& field : fields) {
-    auto fieldName = field.first;
-    if (fieldName == name) {
-      return to_jsi(rt, field.second);
+    for (const auto &field : fields) {
+        auto fieldName = field.first;
+        if (fieldName == name) {
+            return to_jsi(rt, field.second);
+        }
     }
-  }
 
-  return {};
+    return {};
 }
 
 } // namespace opsqlite

package/cpp/SmartHostObject.h

@@ -10,14 +10,15 @@ namespace opsqlite {
 namespace jsi = facebook::jsi;
 
 class JSI_EXPORT SmartHostObject : public jsi::HostObject {
-public:
-  SmartHostObject() = default;
+  public:
+    SmartHostObject() = default;
 
-  std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
+    std::vector<jsi::PropNameID> getPropertyNames(jsi::Runtime &rt) override;
 
-  jsi::Value get(jsi::Runtime &rt, const jsi::PropNameID &propNameID) override;
+    jsi::Value get(jsi::Runtime &rt,
+                   const jsi::PropNameID &propNameID) override;
 
-  std::vector<std::pair<std::string, JSVariant>> fields;
+    std::vector<std::pair<std::string, JSVariant>> fields;
 };
 
 } // namespace opsqlite