@taladb/react-native 0.5.0 → 0.6.0

package/ios/TalaDBFfi.xcframework/ios-arm64/Headers/taladb.h

@@ -0,0 +1,151 @@
+#pragma once
+#ifndef TALADB_FFI_H
+#define TALADB_FFI_H
+
+/*
+ * TalaDB C FFI header.
+ *
+ * This file is the stable C interface between the Rust taladb-ffi crate and
+ * the C++ JSI HostObject.  It is kept in sync with rust/src/lib.rs manually
+ * (or regenerated with cbindgen — see rust/cbindgen.toml).
+ *
+ * Ownership rules
+ * ---------------
+ *  - Strings IN  : caller-owned, UTF-8, null-terminated.
+ *  - Strings OUT : heap-allocated by Rust; caller must free with
+ *                  taladb_free_string().
+ *  - Handles     : allocated by taladb_open(); freed by taladb_close().
+ *  - Errors      : string functions return NULL; integer functions return -1.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* -------------------------------------------------------------------------
+ * Opaque database handle
+ * ---------------------------------------------------------------------- */
+typedef struct TalaDbHandle TalaDbHandle;
+
+/* -------------------------------------------------------------------------
+ * Lifecycle
+ * ---------------------------------------------------------------------- */
+
+/** Open (or create) a database at the given file-system path. */
+TalaDbHandle *taladb_open(const char *path);
+
+/**
+ * Open (or create) a database with HTTP push sync configuration.
+ *
+ * config_json — JSON-serialised TalaDbConfig, or NULL to open without sync.
+ * Returns an opaque handle (same semantics as taladb_open), or NULL on failure.
+ */
+TalaDbHandle *taladb_open_with_config(const char *path, const char *config_json);
+
+/** Flush and close the database, freeing the handle. */
+void taladb_close(TalaDbHandle *handle);
+
+/** Free a C string returned by any taladb_* function. */
+void taladb_free_string(char *s);
+
+/* -------------------------------------------------------------------------
+ * Insert
+ * ---------------------------------------------------------------------- */
+
+/**
+ * Insert a document (JSON object).
+ * Returns the new document's ULID as a C string, or NULL on error.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_insert(TalaDbHandle *handle,
+                    const char   *collection,
+                    const char   *doc_json);
+
+/**
+ * Insert multiple documents (JSON array of objects).
+ * Returns a JSON array of ULID strings, or NULL on error.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_insert_many(TalaDbHandle *handle,
+                         const char   *collection,
+                         const char   *docs_json);
+
+/* -------------------------------------------------------------------------
+ * Find
+ * ---------------------------------------------------------------------- */
+
+/**
+ * Find all documents matching filter_json.
+ * Pass "{}" or "null" to match all.
+ * Returns a JSON array string, or NULL on error.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_find(TalaDbHandle *handle,
+                  const char   *collection,
+                  const char   *filter_json);
+
+/**
+ * Find the first document matching filter_json.
+ * Returns a JSON object string, or the string "null" if not found.
+ * Caller must free with taladb_free_string().
+ */
+char *taladb_find_one(TalaDbHandle *handle,
+                      const char   *collection,
+                      const char   *filter_json);
+
+/* -------------------------------------------------------------------------
+ * Update
+ * ---------------------------------------------------------------------- */
+
+/** Update the first matching document. Returns 1 updated, 0 not found, -1 error. */
+int32_t taladb_update_one(TalaDbHandle *handle,
+                          const char   *collection,
+                          const char   *filter_json,
+                          const char   *update_json);
+
+/** Update all matching documents. Returns count updated, or -1 on error. */
+int32_t taladb_update_many(TalaDbHandle *handle,
+                           const char   *collection,
+                           const char   *filter_json,
+                           const char   *update_json);
+
+/* -------------------------------------------------------------------------
+ * Delete
+ * ---------------------------------------------------------------------- */
+
+/** Delete the first matching document. Returns 1 deleted, 0 not found, -1 error. */
+int32_t taladb_delete_one(TalaDbHandle *handle,
+                          const char   *collection,
+                          const char   *filter_json);
+
+/** Delete all matching documents. Returns count deleted, or -1 on error. */
+int32_t taladb_delete_many(TalaDbHandle *handle,
+                           const char   *collection,
+                           const char   *filter_json);
+
+/* -------------------------------------------------------------------------
+ * Count
+ * ---------------------------------------------------------------------- */
+
+/** Count documents matching filter_json. Returns count, or -1 on error. */
+int32_t taladb_count(TalaDbHandle *handle,
+                     const char   *collection,
+                     const char   *filter_json);
+
+/* -------------------------------------------------------------------------
+ * Index management
+ * ---------------------------------------------------------------------- */
+
+void taladb_create_index    (TalaDbHandle *handle, const char *collection, const char *field);
+void taladb_drop_index      (TalaDbHandle *handle, const char *collection, const char *field);
+void taladb_create_fts_index(TalaDbHandle *handle, const char *collection, const char *field);
+void taladb_drop_fts_index  (TalaDbHandle *handle, const char *collection, const char *field);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* TALADB_FFI_H */

package/ios/TalaDBFfi.xcframework/ios-arm64_x86_64-simulator/Headers/TalaDBHostObject.cpp

@@ -0,0 +1,285 @@
+#include "TalaDBHostObject.h"
+
+#include <stdexcept>
+#include <vector>
+
+using namespace facebook::jsi;
+
+namespace taladb {
+
+// ---------------------------------------------------------------------------
+// Constructor / Destructor
+// ---------------------------------------------------------------------------
+
+TalaDBHostObject::TalaDBHostObject(TalaDbHandle *db) : db_(db) {}
+
+TalaDBHostObject::~TalaDBHostObject() {
+    if (db_) {
+        taladb_close(db_);
+        db_ = nullptr;
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Static installer
+// ---------------------------------------------------------------------------
+
+void TalaDBHostObject::install(Runtime &rt, TalaDbHandle *db) {
+    auto hostObject = std::make_shared<TalaDBHostObject>(db);
+    auto jsiObject  = Object::createFromHostObject(rt, hostObject);
+    rt.global().setProperty(rt, "__TalaDB__", std::move(jsiObject));
+}
+
+// ---------------------------------------------------------------------------
+// JSON helpers
+// ---------------------------------------------------------------------------
+
+std::string TalaDBHostObject::stringify(Runtime &rt, const Value &val) {
+    auto json    = rt.global().getPropertyAsObject(rt, "JSON");
+    auto strFn   = json.getPropertyAsFunction(rt, "stringify");
+    auto result  = strFn.call(rt, val);
+    if (result.isString()) {
+        return result.getString(rt).utf8(rt);
+    }
+    return "null";
+}
+
+Value TalaDBHostObject::parse(Runtime &rt, const std::string &json) {
+    auto jsonObj = rt.global().getPropertyAsObject(rt, "JSON");
+    auto parseFn = jsonObj.getPropertyAsFunction(rt, "parse");
+    return parseFn.call(rt, String::createFromUtf8(rt, json));
+}
+
+std::string TalaDBHostObject::valueToFilterJson(Runtime &rt, const Value &val) {
+    if (val.isNull() || val.isUndefined()) {
+        return "{}";
+    }
+    return stringify(rt, val);
+}
+
+// ---------------------------------------------------------------------------
+// Property names advertised to JS
+// ---------------------------------------------------------------------------
+
+std::vector<PropNameID> TalaDBHostObject::getPropertyNames(Runtime &rt) {
+    std::vector<std::string> names = {
+        "insert", "insertMany",
+        "find", "findOne",
+        "updateOne", "updateMany",
+        "deleteOne", "deleteMany",
+        "count",
+        "createIndex", "dropIndex",
+        "createFtsIndex", "dropFtsIndex",
+        "close",
+    };
+    std::vector<PropNameID> result;
+    result.reserve(names.size());
+    for (auto &n : names) {
+        result.push_back(PropNameID::forUtf8(rt, n));
+    }
+    return result;
+}
+
+void TalaDBHostObject::set(Runtime &, const PropNameID &, const Value &) {}
+
+// ---------------------------------------------------------------------------
+// Property dispatch
+// ---------------------------------------------------------------------------
+
+Value TalaDBHostObject::get(Runtime &rt, const PropNameID &propName) {
+    auto name = propName.utf8(rt);
+
+    // ------------------------------------------------------------------
+    // insert(collection: string, doc: object): string
+    // ------------------------------------------------------------------
+    if (name == "insert") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "insert"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "insert requires 2 arguments");
+                auto col     = args[0].getString(rt).utf8(rt);
+                auto docJson = stringify(rt, args[1]);
+                char *result = taladb_insert(db_, col.c_str(), docJson.c_str());
+                if (!result) throw JSError(rt, "taladb_insert failed");
+                std::string id(result);
+                taladb_free_string(result);
+                return String::createFromUtf8(rt, id);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // insertMany(collection: string, docs: object[]): string[]
+    // ------------------------------------------------------------------
+    if (name == "insertMany") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "insertMany"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "insertMany requires 2 arguments");
+                auto col      = args[0].getString(rt).utf8(rt);
+                auto docsJson = stringify(rt, args[1]);
+                char *result  = taladb_insert_many(db_, col.c_str(), docsJson.c_str());
+                if (!result) throw JSError(rt, "taladb_insert_many failed");
+                std::string json(result);
+                taladb_free_string(result);
+                return parse(rt, json);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // find(collection: string, filter: object | null): object[]
+    // ------------------------------------------------------------------
+    if (name == "find") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "find"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 1) throw JSError(rt, "find requires at least 1 argument");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = count > 1 ? valueToFilterJson(rt, args[1]) : "{}";
+                char *result    = taladb_find(db_, col.c_str(), filterJson.c_str());
+                if (!result) throw JSError(rt, "taladb_find failed");
+                std::string json(result);
+                taladb_free_string(result);
+                return parse(rt, json);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // findOne(collection: string, filter: object | null): object | null
+    // ------------------------------------------------------------------
+    if (name == "findOne") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "findOne"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 1) throw JSError(rt, "findOne requires at least 1 argument");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = count > 1 ? valueToFilterJson(rt, args[1]) : "{}";
+                char *result    = taladb_find_one(db_, col.c_str(), filterJson.c_str());
+                if (!result) throw JSError(rt, "taladb_find_one failed");
+                std::string json(result);
+                taladb_free_string(result);
+                return parse(rt, json);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // updateOne(collection, filter, update): boolean
+    // ------------------------------------------------------------------
+    if (name == "updateOne") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "updateOne"), 3,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 3) throw JSError(rt, "updateOne requires 3 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                auto updateJson = stringify(rt, args[2]);
+                int32_t res = taladb_update_one(
+                    db_, col.c_str(), filterJson.c_str(), updateJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_update_one failed");
+                return Value(res == 1);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // updateMany(collection, filter, update): number
+    // ------------------------------------------------------------------
+    if (name == "updateMany") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "updateMany"), 3,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 3) throw JSError(rt, "updateMany requires 3 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                auto updateJson = stringify(rt, args[2]);
+                int32_t res = taladb_update_many(
+                    db_, col.c_str(), filterJson.c_str(), updateJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_update_many failed");
+                return Value(static_cast<double>(res));
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // deleteOne(collection, filter): boolean
+    // ------------------------------------------------------------------
+    if (name == "deleteOne") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "deleteOne"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "deleteOne requires 2 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                int32_t res = taladb_delete_one(db_, col.c_str(), filterJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_delete_one failed");
+                return Value(res == 1);
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // deleteMany(collection, filter): number
+    // ------------------------------------------------------------------
+    if (name == "deleteMany") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "deleteMany"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, "deleteMany requires 2 arguments");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = stringify(rt, args[1]);
+                int32_t res = taladb_delete_many(db_, col.c_str(), filterJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_delete_many failed");
+                return Value(static_cast<double>(res));
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // count(collection, filter): number
+    // ------------------------------------------------------------------
+    if (name == "count") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "count"), 2,
+            [this](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 1) throw JSError(rt, "count requires at least 1 argument");
+                auto col        = args[0].getString(rt).utf8(rt);
+                auto filterJson = count > 1 ? valueToFilterJson(rt, args[1]) : "{}";
+                int32_t res = taladb_count(db_, col.c_str(), filterJson.c_str());
+                if (res < 0) throw JSError(rt, "taladb_count failed");
+                return Value(static_cast<double>(res));
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // createIndex / dropIndex / createFtsIndex / dropFtsIndex
+    // ------------------------------------------------------------------
+    if (name == "createIndex" || name == "dropIndex" ||
+        name == "createFtsIndex" || name == "dropFtsIndex") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forUtf8(rt, name), 2,
+            [this, name](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+                if (count < 2) throw JSError(rt, (name + " requires 2 arguments").c_str());
+                auto col   = args[0].getString(rt).utf8(rt);
+                auto field = args[1].getString(rt).utf8(rt);
+                if      (name == "createIndex")    taladb_create_index    (db_, col.c_str(), field.c_str());
+                else if (name == "dropIndex")      taladb_drop_index      (db_, col.c_str(), field.c_str());
+                else if (name == "createFtsIndex") taladb_create_fts_index(db_, col.c_str(), field.c_str());
+                else                               taladb_drop_fts_index  (db_, col.c_str(), field.c_str());
+                return Value::undefined();
+            });
+    }
+
+    // ------------------------------------------------------------------
+    // close(): void  (synchronous — the destructor does the real work)
+    // ------------------------------------------------------------------
+    if (name == "close") {
+        return Function::createFromHostFunction(
+            rt, PropNameID::forAscii(rt, "close"), 0,
+            [this](Runtime &rt, const Value &, const Value *, size_t) -> Value {
+                if (db_) {
+                    taladb_close(db_);
+                    db_ = nullptr;
+                }
+                return Value::undefined();
+            });
+    }
+
+    return Value::undefined();
+}
+
+} // namespace taladb

package/ios/TalaDBFfi.xcframework/ios-arm64_x86_64-simulator/Headers/TalaDBHostObject.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <string>
+#include "taladb.h"
+
+namespace taladb {
+
+/**
+ * TalaDBHostObject — JSI HostObject wrapping the Rust taladb-ffi C library.
+ *
+ * Installed into the JS runtime as a global:
+ *   global.__TalaDB__ = <TalaDBHostObject instance>
+ *
+ * Every property access returns a JSI Function. All CRUD methods are
+ * synchronous (the Rust core does no async I/O); `initialize` and `close`
+ * are async only to conform to the TurboModule spec (they resolve immediately).
+ *
+ * JSON is used at the C boundary:
+ *   JS object  →  JSON.stringify  →  C string  →  Rust  →  C string  →  JSON.parse  →  JS object
+ */
+class TalaDBHostObject : public facebook::jsi::HostObject {
+public:
+    explicit TalaDBHostObject(TalaDbHandle *db);
+    ~TalaDBHostObject() override;
+
+    facebook::jsi::Value get(facebook::jsi::Runtime &rt,
+                             const facebook::jsi::PropNameID &name) override;
+
+    void set(facebook::jsi::Runtime &rt,
+             const facebook::jsi::PropNameID &name,
+             const facebook::jsi::Value &value) override;
+
+    std::vector<facebook::jsi::PropNameID>
+    getPropertyNames(facebook::jsi::Runtime &rt) override;
+
+    /** Install this object as global.__TalaDB__ in the given runtime. */
+    static void install(facebook::jsi::Runtime &rt, TalaDbHandle *db);
+
+private:
+    TalaDbHandle *db_;
+
+    // JSON helpers
+    static std::string stringify(facebook::jsi::Runtime &rt,
+                                 const facebook::jsi::Value &val);
+    static facebook::jsi::Value parse(facebook::jsi::Runtime &rt,
+                                      const std::string &json);
+
+    // Convenience: convert a nullable JSI Value to a JSON C-string.
+    // Returns "{}" when the value is null/undefined.
+    static std::string valueToFilterJson(facebook::jsi::Runtime &rt,
+                                         const facebook::jsi::Value &val);
+};
+
+} // namespace taladb

package/ios/TalaDBFfi.xcframework/ios-arm64_x86_64-simulator/Headers/TalaDBJni.cpp

@@ -0,0 +1,53 @@
+/**
+ * TalaDB JNI glue — Android only.
+ *
+ * Exposes `nativeInstall(jsContextNativePtr, dbPath, configJson)` to Kotlin so
+ * that `TalaDBModule.kt` can install the JSI HostObject from the JS thread.
+ *
+ * The function signature must match the Kotlin `external fun` declaration:
+ *   package  : com.taladb
+ *   class    : TalaDBModule
+ *   method   : nativeInstall(Long, String, String?)
+ *
+ * CMakeLists.txt compiles this file together with TalaDBHostObject.cpp.
+ */
+
+#include <jni.h>
+#include <jsi/jsi.h>
+#include <string>
+
+#include "TalaDBHostObject.h"
+#include "taladb.h"
+
+using namespace facebook::jsi;
+
+extern "C" JNIEXPORT void JNICALL
+Java_com_taladb_TalaDBModule_nativeInstall(
+        JNIEnv  *env,
+        jobject  /* thiz */,
+        jlong    jsContextNativePtr,
+        jstring  dbPathJ,
+        jstring  configJsonJ)
+{
+    // Resolve db path
+    const char *dbPathC = env->GetStringUTFChars(dbPathJ, nullptr);
+    std::string dbPath(dbPathC);
+    env->ReleaseStringUTFChars(dbPathJ, dbPathC);
+
+    // Open the Rust database — use taladb_open_with_config when config provided
+    TalaDbHandle *db = nullptr;
+    if (configJsonJ != nullptr) {
+        const char *configC = env->GetStringUTFChars(configJsonJ, nullptr);
+        db = taladb_open_with_config(dbPath.c_str(), configC);
+        env->ReleaseStringUTFChars(configJsonJ, configC);
+    } else {
+        db = taladb_open(dbPath.c_str());
+    }
+    if (!db) return; // failed to open — JS will see no __TalaDB__ global
+
+    // Get the JSI runtime from the pointer passed by RN internals
+    auto &rt = *reinterpret_cast<Runtime *>(jsContextNativePtr);
+
+    // Install the JSI HostObject as global.__TalaDB__
+    taladb::TalaDBHostObject::install(rt, db);
+}