taladb 0.7.3 → 0.7.5

package/dist/index.react-native.mjs

@@ -0,0 +1,366 @@
+// src/config.browser.ts
+var ENDPOINT_FIELDS = [
+  "endpoint",
+  "insert_endpoint",
+  "update_endpoint",
+  "delete_endpoint"
+];
+function validateConfig(config) {
+  const sync = config.sync;
+  if (!sync) return;
+  for (const key of ENDPOINT_FIELDS) {
+    const url = sync[key];
+    if (url !== void 0 && !url.startsWith("http://") && !url.startsWith("https://")) {
+      throw new Error(
+        `TalaDB config: invalid endpoint URL "${url}" \u2014 must start with http:// or https://`
+      );
+    }
+  }
+}
+async function loadConfig(_configPath) {
+  return {};
+}
+
+// src/index.ts
+var TalaDbValidationError = class extends Error {
+  constructor(cause, context) {
+    const label = context ? ` (${context})` : "";
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    super(`TalaDB schema validation failed${label}: ${msg}`);
+    this.cause = cause;
+    this.name = "TalaDbValidationError";
+  }
+};
+function applySchema(col, options) {
+  const { schema, validateOnRead = false } = options;
+  if (!schema) return col;
+  function parseWrite(doc, label) {
+    try {
+      return schema.parse(doc);
+    } catch (err) {
+      throw new TalaDbValidationError(err, label);
+    }
+  }
+  function parseRead(doc) {
+    try {
+      return schema.parse(doc);
+    } catch (err) {
+      throw new TalaDbValidationError(err, "read");
+    }
+  }
+  return {
+    ...col,
+    insert: async (doc) => {
+      parseWrite(doc, "insert");
+      return col.insert(doc);
+    },
+    insertMany: async (docs) => {
+      docs.forEach((doc, i) => parseWrite(doc, `insertMany[${i}]`));
+      return col.insertMany(docs);
+    },
+    find: validateOnRead ? async (filter) => {
+      const docs = await col.find(filter);
+      return docs.map((d) => parseRead(d));
+    } : col.find.bind(col),
+    findOne: validateOnRead ? async (filter) => {
+      const doc = await col.findOne(filter);
+      return doc === null ? null : parseRead(doc);
+    } : col.findOne.bind(col)
+  };
+}
+function detectPlatform() {
+  if (globalThis.nativeCallSyncHook !== void 0) {
+    return "react-native";
+  }
+  if (globalThis.window !== void 0 && typeof navigator !== "undefined") {
+    return "browser";
+  }
+  return "node";
+}
+var WorkerProxy = class {
+  constructor(port) {
+    this.pending = /* @__PURE__ */ new Map();
+    this.nextId = 1;
+    this.port = port;
+    this.port.onmessage = (e) => {
+      const { id, result, error } = e.data;
+      const p = this.pending.get(id);
+      if (p) {
+        this.pending.delete(id);
+        if (error === void 0) p.resolve(result);
+        else p.reject(new Error(error));
+      }
+    };
+    this.port.start?.();
+  }
+  send(op, args = {}) {
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      this.port.postMessage({ id, op, ...args });
+    });
+  }
+};
+function makePoller(findFn, callback) {
+  let active = true;
+  let lastJson = "";
+  const poll = async () => {
+    if (!active) return;
+    try {
+      const docs = await findFn();
+      const json = JSON.stringify(docs);
+      if (json !== lastJson) {
+        lastJson = json;
+        callback(docs);
+      }
+    } catch {
+    }
+    if (active) setTimeout(poll, 300);
+  };
+  poll();
+  return () => {
+    active = false;
+  };
+}
+async function createBrowserDB(dbName, config) {
+  const workerUrl = new URL("@taladb/web/worker/taladb.worker.js", import.meta.url);
+  const worker = new Worker(workerUrl, { type: "module", name: "taladb" });
+  const proxy = new WorkerProxy(worker);
+  const configJson = config !== void 0 ? JSON.stringify(config) : void 0;
+  await proxy.send("init", { dbName, configJson });
+  const nudgeCallbacks = /* @__PURE__ */ new Set();
+  let channel = null;
+  if (typeof BroadcastChannel !== "undefined") {
+    channel = new BroadcastChannel(`taladb:${dbName}`);
+    channel.onmessage = (e) => {
+      if (e.data === "taladb:changed") {
+        for (const nudge of nudgeCallbacks) nudge();
+      }
+    };
+  }
+  function wrapCollection(name, opts) {
+    const s = JSON.stringify;
+    const wrapped = {
+      insert: (doc) => proxy.send("insert", { collection: name, docJson: s(doc) }),
+      insertMany: async (docs) => {
+        const json = await proxy.send("insertMany", {
+          collection: name,
+          docsJson: s(docs)
+        });
+        return JSON.parse(json);
+      },
+      find: async (filter) => {
+        const json = await proxy.send("find", {
+          collection: name,
+          filterJson: filter ? s(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      findOne: async (filter) => {
+        const json = await proxy.send("findOne", {
+          collection: name,
+          filterJson: filter ? s(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      updateOne: (filter, update) => proxy.send("updateOne", {
+        collection: name,
+        filterJson: s(filter),
+        updateJson: s(update)
+      }),
+      updateMany: (filter, update) => proxy.send("updateMany", {
+        collection: name,
+        filterJson: s(filter),
+        updateJson: s(update)
+      }),
+      deleteOne: (filter) => proxy.send("deleteOne", { collection: name, filterJson: s(filter) }),
+      deleteMany: (filter) => proxy.send("deleteMany", { collection: name, filterJson: s(filter) }),
+      count: (filter) => proxy.send("count", {
+        collection: name,
+        filterJson: filter ? s(filter) : "null"
+      }),
+      createIndex: (field) => proxy.send("createIndex", { collection: name, field }),
+      dropIndex: (field) => proxy.send("dropIndex", { collection: name, field }),
+      createFtsIndex: (field) => proxy.send("createFtsIndex", { collection: name, field }),
+      dropFtsIndex: (field) => proxy.send("dropFtsIndex", { collection: name, field }),
+      createVectorIndex: (field, options) => {
+        if (options.indexType === "hnsw") return Promise.reject(new Error("HNSW vector indexes are not available in the browser (requires native threads). Use Node.js or React Native."));
+        return proxy.send("createVectorIndex", {
+          collection: name,
+          field,
+          dimensions: options.dimensions,
+          metric: options.metric,
+          indexType: null,
+          hnswM: null,
+          hnswEfConstruction: null
+        });
+      },
+      dropVectorIndex: (field) => proxy.send("dropVectorIndex", { collection: name, field }),
+      upgradeVectorIndex: (_field) => Promise.reject(new Error("HNSW vector indexes are not available in the browser (requires native threads). Use Node.js or React Native.")),
+      listIndexes: async () => {
+        const json = await proxy.send("listIndexes", { collection: name });
+        return JSON.parse(json);
+      },
+      findNearest: async (field, vector, topK, filter) => {
+        const json = await proxy.send("findNearest", {
+          collection: name,
+          field,
+          queryJson: JSON.stringify(vector),
+          topK,
+          filterJson: filter ? JSON.stringify(filter) : "null"
+        });
+        return JSON.parse(json);
+      },
+      subscribe: (filter, callback) => {
+        let active = true;
+        let lastJson = "[]";
+        let timer = null;
+        const poll = async () => {
+          if (!active) return;
+          if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+          }
+          try {
+            const json = await proxy.send("find", {
+              collection: name,
+              filterJson: filter ? s(filter) : "null"
+            });
+            if (json !== lastJson) {
+              lastJson = json;
+              callback(JSON.parse(json));
+            }
+          } catch {
+          }
+          if (active) timer = setTimeout(poll, 300);
+        };
+        nudgeCallbacks.add(poll);
+        poll();
+        return () => {
+          active = false;
+          nudgeCallbacks.delete(poll);
+          if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+          }
+        };
+      }
+    };
+    return opts ? applySchema(wrapped, opts) : wrapped;
+  }
+  return {
+    collection: (name, opts) => wrapCollection(name, opts),
+    compact: () => proxy.send("compact"),
+    close: async () => {
+      channel?.close();
+      await proxy.send("close");
+      worker.terminate();
+    }
+  };
+}
+async function createNodeDB(dbName, config) {
+  const { TalaDBNode } = await import("@taladb/node");
+  const configJson = config !== void 0 ? JSON.stringify(config) : null;
+  const db = TalaDBNode.open(dbName, configJson);
+  function wrapCollection(name, opts) {
+    const col = db.collection(name);
+    const wrapped = {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? null),
+      findOne: async (filter) => col.findOne(filter) ?? null,
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? null),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      createFtsIndex: async (field) => col.createFtsIndex(field),
+      dropFtsIndex: async (field) => col.dropFtsIndex(field),
+      createVectorIndex: async (field, options) => col.createVectorIndex(field, options.dimensions, options.metric ?? null, options.indexType ?? null, options.hnswM ?? null, options.hnswEfConstruction ?? null),
+      dropVectorIndex: async (field) => col.dropVectorIndex(field),
+      upgradeVectorIndex: async (field) => col.upgradeVectorIndex(field),
+      listIndexes: async () => {
+        const json = col.listIndexes();
+        return JSON.parse(json);
+      },
+      findNearest: async (field, vector, topK, filter) => {
+        const raw = await col.findNearest(field, vector, topK, filter ?? null);
+        return raw;
+      },
+      subscribe: (filter, callback) => makePoller(async () => col.find(filter ?? null), callback)
+    };
+    return opts ? applySchema(wrapped, opts) : wrapped;
+  }
+  return {
+    collection: (name, opts) => wrapCollection(name, opts),
+    compact: async () => db.compact(),
+    close: async () => {
+    }
+  };
+}
+async function createNativeDB(_dbName) {
+  const maybeNative = globalThis.__TalaDB__;
+  if (!maybeNative) {
+    throw new Error(
+      "@taladb/react-native JSI HostObject not found. Did you call TalaDBModule.initialize() in your app entry point?"
+    );
+  }
+  const native = maybeNative;
+  function wrapCollection(name, opts) {
+    const col = native.collection(name);
+    const wrapped = {
+      insert: async (doc) => col.insert(doc),
+      insertMany: async (docs) => col.insertMany(docs),
+      find: async (filter) => col.find(filter ?? {}),
+      findOne: async (filter) => col.findOne(filter ?? {}),
+      updateOne: async (filter, update) => col.updateOne(filter, update),
+      updateMany: async (filter, update) => col.updateMany(filter, update),
+      deleteOne: async (filter) => col.deleteOne(filter),
+      deleteMany: async (filter) => col.deleteMany(filter),
+      count: async (filter) => col.count(filter ?? {}),
+      createIndex: async (field) => col.createIndex(field),
+      dropIndex: async (field) => col.dropIndex(field),
+      createFtsIndex: async (field) => col.createFtsIndex(field),
+      dropFtsIndex: async (field) => col.dropFtsIndex(field),
+      createVectorIndex: async (field, options) => col.createVectorIndex(field, options.dimensions, options.metric ?? null, options.indexType ?? null, options.hnswM ?? null, options.hnswEfConstruction ?? null),
+      dropVectorIndex: async (field) => col.dropVectorIndex(field),
+      upgradeVectorIndex: async (field) => col.upgradeVectorIndex(field),
+      listIndexes: async () => JSON.parse(col.listIndexes()),
+      findNearest: async (field, vector, topK, filter) => {
+        const raw = col.findNearest(field, vector, topK, filter ?? null);
+        return raw;
+      },
+      subscribe: (filter, callback) => makePoller(async () => col.find(filter ?? {}), callback)
+    };
+    return opts ? applySchema(wrapped, opts) : wrapped;
+  }
+  return {
+    collection: (name, opts) => wrapCollection(name, opts),
+    compact: async () => native.compact(),
+    close: async () => native.close()
+  };
+}
+async function openDB(dbName = "taladb.db", options) {
+  let resolvedConfig;
+  if (options?.config !== void 0) {
+    validateConfig(options.config);
+    resolvedConfig = options.config;
+  } else {
+    resolvedConfig = await loadConfig(options?.configPath);
+  }
+  const platform = detectPlatform();
+  switch (platform) {
+    case "browser":
+      return createBrowserDB(dbName, resolvedConfig);
+    case "react-native":
+      return createNativeDB(dbName);
+    case "node":
+      return createNodeDB(dbName, resolvedConfig);
+  }
+}
+export {
+  TalaDbValidationError,
+  openDB
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taladb",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Local-first document and vector database for React, React Native, and Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -8,6 +8,7 @@
   "sideEffects": false,
   "exports": {
     ".": {
+      "react-native": "./dist/index.react-native.mjs",
       "browser": "./dist/index.browser.mjs",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
@@ -60,8 +61,12 @@
     "typescript": "^5.9.3",
     "vitest": "^3.2.0"
   },
-  "optionalDependencies": {
+  "peerDependencies": {
     "@taladb/web": "workspace:*",
     "@taladb/node": "workspace:*"
+  },
+  "peerDependenciesMeta": {
+    "@taladb/web": { "optional": true },
+    "@taladb/node": { "optional": true }
   }
 }