@plures/pluresdb 1.5.3 → 2.9.6

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

@@ -1,226 +0,0 @@
-// @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

@@ -1,135 +0,0 @@
-// @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

@@ -1,173 +0,0 @@
-// @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();
-  }
-});