@plures/pluresdb 1.4.0

package/legacy/tests/unit/core.test.ts

@@ -0,0 +1,226 @@
+// @ts-nocheck
+import {
+  assertEquals,
+  assertExists,
+  assertRejects,
+} from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+import { mergeNodes } from "../../core/crdt.ts";
+import type { NodeRecord } from "../../types/index.ts";
+
+Deno.test("Core Database - Basic CRUD Operations", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Test put and get
+    const user = { name: "Alice", age: 30, email: "alice@example.com" };
+    await db.put("user:alice", user as unknown as Record<string, unknown>);
+    const got = await db.get<typeof user>("user:alice");
+
+    assertEquals(got?.name, "Alice");
+    assertEquals(got?.age, 30);
+    assertEquals(got?.email, "alice@example.com");
+
+    // Test update
+    await db.put("user:alice", { ...user, age: 31 });
+    const updated = await db.get<typeof user>("user:alice");
+    assertEquals(updated?.age, 31);
+
+    // Test delete
+    await db.delete("user:alice");
+    const deleted = await db.get<typeof user>("user:alice");
+    assertEquals(deleted, null);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Core Database - Vector Clock Increments", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const id = "vc:test";
+    await db.put(id, { value: 1 });
+    await db.put(id, { value: 2 });
+    await db.put(id, { value: 3 });
+
+    // Inspect underlying record
+    const { KvStorage } = await import("../../storage/kv-storage.ts");
+    const kv = new KvStorage();
+    await kv.open(kvPath);
+    const node = await kv.getNode(id);
+    await kv.close();
+
+    assertExists(node);
+    const clockValues = Object.values(node.vectorClock);
+    assertEquals(clockValues.length, 1);
+    assertEquals(clockValues[0], 3);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Core Database - Type System", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Test setType and instancesOf
+    await db.put("person:1", { name: "Alice" });
+    await db.setType("person:1", "Person");
+
+    await db.put("company:1", { name: "Acme Corp" });
+    await db.setType("company:1", "Company");
+
+    const people = await db.instancesOf("Person");
+    assertEquals(people.length, 1);
+    assertEquals(people[0].id, "person:1");
+
+    const companies = await db.instancesOf("Company");
+    assertEquals(companies.length, 1);
+    assertEquals(companies[0].id, "company:1");
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Core Database - Vector Search", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add documents with text content
+    await db.put("doc:1", {
+      text: "Machine learning and artificial intelligence",
+    });
+    await db.put("doc:2", { text: "Cooking recipes and food preparation" });
+    await db.put("doc:3", { text: "Deep learning neural networks" });
+
+    // Test vector search
+    const results = await db.vectorSearch("machine learning", 2);
+    assertExists(results);
+    assertEquals(results.length, 2);
+
+    // Should find the most relevant documents
+    const docIds = results.map((r) => r.id);
+    assertExists(docIds.includes("doc:1"));
+    assertExists(docIds.includes("doc:3"));
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("CRDT Merge - Equal Timestamps", () => {
+  const timestamp = Date.now();
+  const local: NodeRecord = {
+    id: "test:1",
+    data: { a: 1, shared: 1, nested: { x: 1, y: 1 } },
+    vector: [0.1, 0.2],
+    type: "TestType",
+    timestamp,
+    vectorClock: { peerA: 2 },
+  };
+
+  const incoming: NodeRecord = {
+    id: "test:1",
+    data: { b: 2, shared: 2, nested: { y: 2, z: 3 } },
+    timestamp,
+    vectorClock: { peerB: 3 },
+  } as unknown as NodeRecord;
+
+  const merged = mergeNodes(local, incoming);
+
+  assertEquals(merged.id, "test:1");
+  assertEquals(merged.timestamp, timestamp);
+  assertEquals(merged.data, {
+    a: 1,
+    shared: 2,
+    b: 2,
+    nested: { x: 1, y: 2, z: 3 },
+  });
+  assertEquals(merged.type, "TestType");
+  assertEquals(merged.vector, [0.1, 0.2]);
+  assertEquals(merged.vectorClock.peerA, 2);
+  assertEquals(merged.vectorClock.peerB, 3);
+});
+
+Deno.test("CRDT Merge - LWW on Different Timestamps", () => {
+  const t1 = 1000;
+  const t2 = 2000;
+
+  const older: NodeRecord = {
+    id: "test:2",
+    data: { a: 1, b: 1 },
+    timestamp: t1,
+    vectorClock: { p1: 1 },
+  } as unknown as NodeRecord;
+
+  const newer: NodeRecord = {
+    id: "test:2",
+    data: { a: 999, b: 2, c: 3 },
+    timestamp: t2,
+    vectorClock: { p2: 1 },
+  } as unknown as NodeRecord;
+
+  const merged = mergeNodes(older, newer);
+
+  assertEquals(merged.data, { a: 999, b: 2, c: 3 });
+  assertEquals(merged.timestamp, t2);
+});
+
+Deno.test("Core Database - Error Handling", async () => {
+  const db = new GunDB();
+
+  // Test operations before ready
+  await assertRejects(
+    () => db.put("test", { value: 1 }),
+    Error,
+    "Database not ready",
+  );
+
+  await assertRejects(() => db.get("test"), Error, "Database not ready");
+
+  await assertRejects(() => db.delete("test"), Error, "Database not ready");
+});
+
+Deno.test("Core Database - Persistence Across Restarts", async () => {
+  const kvPath = await Deno.makeTempFile({
+    prefix: "kv_",
+    suffix: ".sqlite",
+  });
+  const id = "persist:test";
+
+  // First session
+  const db1 = new GunDB();
+  await db1.ready(kvPath);
+  await db1.put(id, { value: 123, text: "persistent data" });
+  await db1.close();
+
+  // Second session
+  const db2 = new GunDB();
+  await db2.ready(kvPath);
+  const got = await db2.get<{ value: number; text: string }>(id);
+  await db2.close();
+
+  assertExists(got);
+  assertEquals(got.value, 123);
+  assertEquals(got.text, "persistent data");
+});

package/legacy/tests/unit/subscriptions.test.ts

@@ -0,0 +1,135 @@
+// @ts-nocheck
+import { assertEquals, assertThrows } from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+
+Deno.test("Subscriptions - Basic Update Events", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const id = "user:test";
+    let updateCount = 0;
+    let lastData: any = null;
+
+    const unsubscribe = db.on(id, (node) => {
+      updateCount++;
+      lastData = node?.data;
+    });
+
+    // Test initial put
+    await db.put(id, { name: "Alice", age: 30 });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    assertEquals(updateCount, 1);
+    assertEquals(lastData?.name, "Alice");
+
+    // Test update
+    await db.put(id, { name: "Alice", age: 31 });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    assertEquals(updateCount, 2);
+    assertEquals(lastData?.age, 31);
+
+    // Test unsubscribe
+    unsubscribe();
+    await db.put(id, { name: "Alice", age: 32 });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    assertEquals(updateCount, 2); // Should not increment
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Subscriptions - Delete Events", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const id = "user:delete";
+    let deleteReceived = false;
+
+    const unsubscribe = db.on(id, (node) => {
+      if (node === null) {
+        deleteReceived = true;
+      }
+    });
+
+    await db.put(id, { name: "Bob" });
+    await db.delete(id);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    assertEquals(deleteReceived, true);
+    unsubscribe();
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Subscriptions - Multiple Subscribers", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const id = "user:multi";
+    let subscriber1Count = 0;
+    let subscriber2Count = 0;
+
+    const unsubscribe1 = db.on(id, () => subscriber1Count++);
+    const unsubscribe2 = db.on(id, () => subscriber2Count++);
+
+    await db.put(id, { name: "Charlie" });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    assertEquals(subscriber1Count, 1);
+    assertEquals(subscriber2Count, 1);
+
+    unsubscribe1();
+    unsubscribe2();
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Subscriptions - Error Handling", () => {
+  const db = new GunDB();
+
+  // Test subscription before ready
+  assertThrows(() => db.on("test", () => {}), Error, "Database not ready");
+});
+
+Deno.test("Subscriptions - Off Method", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const id = "user:off";
+    let called = false;
+
+    const callback = () => {
+      called = true;
+    };
+    db.on(id, callback);
+    db.off(id, callback);
+
+    await db.put(id, { name: "Dave" });
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    assertEquals(called, false);
+  } finally {
+    await db.close();
+  }
+});

package/legacy/tests/unit/vector-search.test.ts

@@ -0,0 +1,173 @@
+// @ts-nocheck
+import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+
+Deno.test("Vector Search - Basic Functionality", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add documents with different content
+    await db.put("doc:1", {
+      text: "Machine learning and artificial intelligence algorithms",
+      content: "Deep learning neural networks for pattern recognition",
+    });
+    await db.put("doc:2", {
+      text: "Cooking recipes and food preparation techniques",
+      content: "Italian pasta recipes and cooking methods",
+    });
+    await db.put("doc:3", {
+      text: "Web development and JavaScript programming",
+      content: "React and TypeScript for modern web applications",
+    });
+
+    // Test search with text field
+    const results1 = await db.vectorSearch("machine learning", 2);
+    assertExists(results1);
+    assertEquals(results1.length, 2);
+
+    // Test search with content field
+    const results2 = await db.vectorSearch("neural networks", 1);
+    assertExists(results2);
+    assertEquals(results2.length, 1);
+    assertEquals(results2[0].id, "doc:1");
+
+    // Test search with different query
+    const results3 = await db.vectorSearch("cooking food", 1);
+    assertExists(results3);
+    assertEquals(results3.length, 1);
+    assertEquals(results3[0].id, "doc:2");
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Similarity Scoring", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    await db.put("doc:1", { text: "Machine learning algorithms" });
+    await db.put("doc:2", { text: "Machine learning and AI" });
+    await db.put("doc:3", { text: "Cooking recipes" });
+
+    const results = await db.vectorSearch("machine learning", 3);
+    assertExists(results);
+    assertEquals(results.length, 3);
+
+    // Results should be ordered by similarity (highest first)
+    assertExists(results[0].similarity);
+    assertExists(results[1].similarity);
+    assertExists(results[2].similarity);
+
+    // First result should have highest similarity
+    assertEquals(results[0].similarity >= results[1].similarity, true);
+    assertEquals(results[1].similarity >= results[2].similarity, true);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Limit Parameter", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add multiple documents
+    for (let i = 1; i <= 10; i++) {
+      await db.put(`doc:${i}`, {
+        text: `Document ${i} about machine learning and AI`,
+      });
+    }
+
+    // Test different limits
+    const results1 = await db.vectorSearch("machine learning", 3);
+    assertEquals(results1.length, 3);
+
+    const results2 = await db.vectorSearch("machine learning", 5);
+    assertEquals(results2.length, 5);
+
+    const results3 = await db.vectorSearch("machine learning", 1);
+    assertEquals(results3.length, 1);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Empty Results", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Search in empty database
+    const results = await db.vectorSearch("anything", 5);
+    assertEquals(results.length, 0);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - Custom Vector Input", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add document with custom vector
+    const customVector = [0.1, 0.2, 0.3, 0.4, 0.5];
+    await db.put("doc:custom", {
+      text: "Custom vector document",
+      vector: customVector,
+    });
+
+    // Search with custom vector
+    const results = await db.vectorSearch(customVector, 1);
+    assertExists(results);
+    assertEquals(results.length, 1);
+    assertEquals(results[0].id, "doc:custom");
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Vector Search - No Text Content", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add document without text or content
+    await db.put("doc:no-text", {
+      name: "Document without text",
+      value: 123,
+    });
+
+    // Search should return empty results
+    const results = await db.vectorSearch("anything", 5);
+    assertEquals(results.length, 0);
+  } finally {
+    await db.close();
+  }
+});