@plures/pluresdb 1.4.0

package/legacy/storage/kv-storage.ts

@@ -0,0 +1,73 @@
+import type { NodeRecord } from "../types/index.ts";
+
+export class KvStorage {
+  private kv: Deno.Kv | null = null;
+
+  async open(path?: string): Promise<void> {
+    this.kv = await Deno.openKv(path);
+  }
+
+  async close(): Promise<void> {
+    if (this.kv) {
+      try {
+        this.kv.close();
+      } catch {
+        /* ignore */
+      }
+      this.kv = null;
+    }
+    // Allow microtasks to flush for callers awaiting close()
+    await Promise.resolve();
+  }
+
+  private ensureKv(): Deno.Kv {
+    if (!this.kv) {
+      throw new Error("KvStorage is not opened. Call open() first.");
+    }
+    return this.kv;
+  }
+
+  async getNode(id: string): Promise<NodeRecord | null> {
+    const kv = this.ensureKv();
+    const res = await kv.get<NodeRecord>(["node", id]);
+    return res.value ?? null;
+  }
+
+  async setNode(node: NodeRecord): Promise<void> {
+    const kv = this.ensureKv();
+    await kv.set(["node", node.id], node);
+
+    // Store version history
+    const historyKey = ["history", node.id, node.timestamp];
+    await kv.set(historyKey, node);
+  }
+
+  async deleteNode(id: string): Promise<void> {
+    const kv = this.ensureKv();
+    await kv.delete(["node", id]);
+  }
+
+  async *listNodes(): AsyncIterable<NodeRecord> {
+    const kv = this.ensureKv();
+    for await (const entry of kv.list<NodeRecord>({ prefix: ["node"] })) {
+      if (entry.value) yield entry.value;
+    }
+  }
+
+  async *listNodeHistory(id: string): AsyncIterable<NodeRecord> {
+    const kv = this.ensureKv();
+    for await (
+      const entry of kv.list<NodeRecord>({ prefix: ["history", id] })
+    ) {
+      if (entry.value) yield entry.value;
+    }
+  }
+
+  async getNodeHistory(id: string): Promise<NodeRecord[]> {
+    const history: NodeRecord[] = [];
+    for await (const version of this.listNodeHistory(id)) {
+      history.push(version);
+    }
+    return history.sort((a, b) => b.timestamp - a.timestamp); // Most recent first
+  }
+}

package/legacy/tests/core.test.ts

@@ -0,0 +1,305 @@
+// @ts-nocheck
+import { assertEquals } 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";
+import type { Rule } from "../logic/rules.ts";
+
+Deno.test("put and get returns stored data", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+    const user = { name: "Alice", age: 30 } as const;
+    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);
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test(
+  {
+    name: "subscription receives updates",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
+  async () => {
+    const db = new GunDB();
+    try {
+      const kvPath = await Deno.makeTempFile({
+        prefix: "kv_",
+        suffix: ".sqlite",
+      });
+      await db.ready(kvPath);
+      const updated = new Promise((resolve) =>
+        db.on(
+          "user:bob",
+          (n) =>
+            n && (n.data as Record<string, unknown>).age === 42 &&
+            resolve(true),
+        )
+      );
+      await db.put("user:bob", { name: "Bob", age: 41 });
+      await db.put("user:bob", { name: "Bob", age: 42 });
+      const timeout = new Promise((_, rej) =>
+        setTimeout(() => rej(new Error("timeout: subscription")), 2000)
+      );
+      await Promise.race([updated, timeout]);
+    } finally {
+      await db.close();
+    }
+  },
+);
+
+Deno.test("vector search returns relevant notes", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+    await db.put("note:london1", { text: "Museums and galleries in London" });
+    await db.put("note:newyork1", { text: "Pizza places in New York" });
+    const results = await db.vectorSearch("London", 1);
+    if (results.length === 0) throw new Error("No vector results");
+    if (results[0].id !== "note:london1") {
+      throw new Error(`Expected note:london1 got ${results[0].id}`);
+    }
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test(
+  {
+    name: "delete emits subscription with null",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
+  async () => {
+    const db = new GunDB();
+    try {
+      const kvPath = await Deno.makeTempFile({
+        prefix: "kv_",
+        suffix: ".sqlite",
+      });
+      await db.ready(kvPath);
+      await db.put("user:carol", { name: "Carol" });
+      const deleted = new Promise((resolve) =>
+        db.on("user:carol", (n) => n === null && resolve(true))
+      );
+      await db.delete("user:carol");
+      const timeout = new Promise((_, rej) =>
+        setTimeout(() => rej(new Error("timeout: delete")), 2000)
+      );
+      await Promise.race([deleted, timeout]);
+    } finally {
+      await db.close();
+    }
+  },
+);
+
+Deno.test(
+  {
+    name: "mesh snapshot sync and propagation",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
+  async () => {
+    function randomPort() {
+      return 18000 + Math.floor(Math.random() * 10000);
+    }
+    const port = randomPort();
+    const serverUrl = `ws://localhost:${port}`;
+
+    const dbA = new GunDB();
+    const dbB = new GunDB();
+    try {
+      const kvA = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+      const kvB = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+      await dbA.ready(kvA);
+      await dbB.ready(kvB);
+      await dbA.serve({ port });
+
+      await dbA.put("mesh:one", { text: "hello from A" });
+
+      const receivedSnapshot = new Promise((resolve) =>
+        dbB.on("mesh:one", (n) => n && resolve(true))
+      );
+      dbB.connect(serverUrl);
+      await receivedSnapshot;
+
+      const receivedOnA = new Promise((resolve) =>
+        dbA.on(
+          "mesh:fromB",
+          (n) =>
+            n && (n.data as Record<string, unknown>).who === "B" &&
+            resolve(true),
+        )
+      );
+      await dbB.put("mesh:fromB", { who: "B", text: "hi A" });
+      await receivedOnA;
+    } finally {
+      await dbB.close();
+      await dbA.close();
+    }
+  },
+);
+
+// --- Additional tests to cover remaining checklist items ---
+
+Deno.test("persists across restarts", async () => {
+  const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+  const id = "persist:one";
+
+  const db1 = new GunDB();
+  await db1.ready(kvPath);
+  await db1.put(id, { value: 123 });
+  await db1.close();
+
+  const db2 = new GunDB();
+  await db2.ready(kvPath);
+  const got = await db2.get<{ value: number }>(id);
+  await db2.close();
+
+  if (!got) throw new Error("Expected value after restart");
+  assertEquals(got.value, 123);
+});
+
+Deno.test("vector clock increments on local puts", async () => {
+  const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+  const id = "vc:counter";
+  const db = new GunDB();
+  await db.ready(kvPath);
+  await db.put(id, { n: 1 });
+  await db.put(id, { n: 2 });
+  await db.put(id, { n: 3 });
+  await db.close();
+
+  // 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();
+  if (!node) throw new Error("Missing node for vector clock check");
+  const clockValues = Object.values(node.vectorClock);
+  assertEquals(clockValues.length, 1);
+  assertEquals(clockValues[0], 3);
+});
+
+Deno.test("CRDT merge: equal timestamps deterministic merge", () => {
+  const t = Date.now();
+  const local: NodeRecord = {
+    id: "n1",
+    data: { a: 1, shared: 1, nested: { x: 1, y: 1 }, toDelete: 1 },
+    vector: [0.1, 0.2],
+    type: "TypeA",
+    timestamp: t,
+    vectorClock: { peerA: 2 },
+  };
+  const incoming: NodeRecord = {
+    id: "n1",
+    data: { b: 2, shared: 2, nested: { y: 2, z: 3 }, toDelete: null },
+    // vector and type intentionally undefined to test fallback
+    timestamp: t,
+    vectorClock: { peerB: 3 },
+  } as unknown as NodeRecord;
+
+  const merged = mergeNodes(local, incoming);
+  assertEquals(merged.id, "n1");
+  assertEquals(merged.timestamp, t);
+  assertEquals(merged.data, {
+    a: 1,
+    shared: 2,
+    b: 2,
+    nested: { x: 1, y: 2, z: 3 },
+  });
+  assertEquals(merged.type, "TypeA");
+  assertEquals(merged.vector, [0.1, 0.2]);
+  assertEquals(merged.vectorClock.peerA, 2);
+  assertEquals(merged.vectorClock.peerB, 3);
+});
+
+Deno.test("CRDT merge: LWW on differing timestamps", () => {
+  const t1 = 1000;
+  const t2 = 2000;
+  const base: NodeRecord = {
+    id: "n2",
+    data: { a: 1 },
+    timestamp: t1,
+    vectorClock: { p1: 1 },
+  } as unknown as NodeRecord;
+  const newer: NodeRecord = {
+    id: "n2",
+    data: { a: 999, b: 2 },
+    timestamp: t2,
+    vectorClock: { p2: 1 },
+  } as unknown as NodeRecord;
+
+  const up = mergeNodes(base, newer);
+  assertEquals(up.data, { a: 999, b: 2 });
+  assertEquals(up.timestamp, t2);
+
+  const down = mergeNodes(newer, base);
+  assertEquals(down.data, { a: 999, b: 2 });
+  assertEquals(down.timestamp, t2);
+});
+
+Deno.test(
+  {
+    name: "off stops receiving events",
+    sanitizeOps: false,
+    sanitizeResources: false,
+  },
+  async () => {
+    const db = new GunDB();
+    try {
+      const kvPath = await Deno.makeTempFile({
+        prefix: "kv_",
+        suffix: ".sqlite",
+      });
+      await db.ready(kvPath);
+      let called = false;
+      const id = "user:dave";
+      const cb = () => {
+        called = true;
+      };
+      db.on(id, cb);
+      db.off(id, cb);
+      await db.put(id, { name: "Dave" });
+      await new Promise((r) => setTimeout(r, 200));
+      assertEquals(called, false);
+    } finally {
+      await db.close();
+    }
+  },
+);
+
+Deno.test("type system helpers: setType + instancesOf", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+    await db.put("t:1", { name: "Alice" });
+    await db.setType("t:1", "Person");
+    await db.put("t:2", { name: "Acme" });
+    await db.setType("t:2", "Company");
+    const people = await db.instancesOf("Person");
+    if (people.length !== 1 || people[0].id !== "t:1") {
+      throw new Error("Expected exactly one Person: t:1");
+    }
+  } finally {
+    await db.close();
+  }
+});

package/legacy/tests/fixtures/performance-data.json

@@ -0,0 +1,71 @@
+{
+  "load_test_scenarios": [
+    {
+      "name": "small_records",
+      "description": "Small records (100 bytes each)",
+      "record_size": 100,
+      "record_count": 1000,
+      "expected_ops_per_sec": 1000
+    },
+    {
+      "name": "medium_records",
+      "description": "Medium records (1KB each)",
+      "record_size": 1024,
+      "record_count": 1000,
+      "expected_ops_per_sec": 500
+    },
+    {
+      "name": "large_records",
+      "description": "Large records (10KB each)",
+      "record_size": 10240,
+      "record_count": 100,
+      "expected_ops_per_sec": 100
+    },
+    {
+      "name": "vector_data",
+      "description": "Vector data (100 dimensions)",
+      "vector_dimensions": 100,
+      "record_count": 500,
+      "expected_ops_per_sec": 200
+    }
+  ],
+  "memory_limits": {
+    "max_record_size": 10485760,
+    "max_subscriptions": 10000,
+    "max_memory_usage_mb": 100,
+    "memory_per_record_bytes": 5000
+  },
+  "performance_thresholds": {
+    "crud_operations_per_sec": 1000,
+    "vector_search_per_sec": 100,
+    "subscription_updates_per_sec": 500,
+    "network_connections_per_sec": 50,
+    "max_response_time_ms": 100
+  },
+  "security_test_cases": [
+    {
+      "name": "sql_injection",
+      "payloads": [
+        "'; DROP TABLE users; --",
+        "' OR '1'='1",
+        "'; INSERT INTO users VALUES ('hacker', 'password'); --"
+      ]
+    },
+    {
+      "name": "xss_attacks",
+      "payloads": [
+        "<script>alert('xss')</script>",
+        "javascript:alert('xss')",
+        "<img src=x onerror=alert('xss')>"
+      ]
+    },
+    {
+      "name": "path_traversal",
+      "payloads": [
+        "../../../etc/passwd",
+        "..\\..\\..\\windows\\system32\\drivers\\etc\\hosts",
+        "/etc/passwd"
+      ]
+    }
+  ]
+}

package/legacy/tests/fixtures/test-data.json

@@ -0,0 +1,129 @@
+{
+  "users": [
+    {
+      "id": "user:1",
+      "name": "Alice Johnson",
+      "email": "alice@example.com",
+      "age": 30,
+      "type": "Person",
+      "profile": {
+        "bio": "Software engineer passionate about machine learning",
+        "location": "San Francisco, CA",
+        "interests": ["AI", "ML", "Rust", "TypeScript"]
+      }
+    },
+    {
+      "id": "user:2",
+      "name": "Bob Smith",
+      "email": "bob@example.com",
+      "age": 25,
+      "type": "Person",
+      "profile": {
+        "bio": "Data scientist working on NLP applications",
+        "location": "New York, NY",
+        "interests": ["NLP", "Python", "Statistics", "Research"]
+      }
+    },
+    {
+      "id": "user:3",
+      "name": "Carol Davis",
+      "email": "carol@example.com",
+      "age": 35,
+      "type": "Person",
+      "profile": {
+        "bio": "Product manager with a focus on developer tools",
+        "location": "Seattle, WA",
+        "interests": [
+          "Product",
+          "Strategy",
+          "Developer Experience",
+          "Leadership"
+        ]
+      }
+    }
+  ],
+  "companies": [
+    {
+      "id": "company:1",
+      "name": "TechCorp Inc",
+      "type": "Company",
+      "industry": "Technology",
+      "employees": 500,
+      "location": "San Francisco, CA",
+      "description": "Leading provider of AI-powered solutions"
+    },
+    {
+      "id": "company:2",
+      "name": "DataFlow Systems",
+      "type": "Company",
+      "industry": "Data Analytics",
+      "employees": 150,
+      "location": "New York, NY",
+      "description": "Specialized in real-time data processing and analytics"
+    }
+  ],
+  "documents": [
+    {
+      "id": "doc:1",
+      "title": "Introduction to Machine Learning",
+      "text": "Machine learning is a subset of artificial intelligence that focuses on algorithms that can learn from data without being explicitly programmed.",
+      "content": "This comprehensive guide covers the fundamentals of machine learning, including supervised learning, unsupervised learning, and reinforcement learning techniques.",
+      "type": "Document",
+      "tags": ["machine learning", "AI", "tutorial", "beginner"],
+      "author": "user:1",
+      "created": "2024-01-15T10:00:00Z"
+    },
+    {
+      "id": "doc:2",
+      "title": "Advanced Neural Networks",
+      "text": "Deep learning neural networks have revolutionized the field of artificial intelligence with their ability to process complex patterns in data.",
+      "content": "This advanced tutorial explores deep learning architectures including CNNs, RNNs, and Transformers, with practical implementation examples.",
+      "type": "Document",
+      "tags": ["deep learning", "neural networks", "advanced", "tutorial"],
+      "author": "user:2",
+      "created": "2024-01-20T14:30:00Z"
+    },
+    {
+      "id": "doc:3",
+      "title": "Product Strategy for Developer Tools",
+      "text": "Building successful developer tools requires understanding the unique needs and workflows of software developers.",
+      "content": "This guide covers product strategy, user research, and go-to-market approaches specifically tailored for developer-focused products.",
+      "type": "Document",
+      "tags": ["product strategy", "developer tools", "business", "strategy"],
+      "author": "user:3",
+      "created": "2024-01-25T09:15:00Z"
+    }
+  ],
+  "projects": [
+    {
+      "id": "project:1",
+      "name": "PluresDB Database",
+      "type": "Project",
+      "description": "P2P graph database with SQLite compatibility",
+      "status": "active",
+      "technologies": ["Rust", "TypeScript", "Deno", "WebAssembly"],
+      "team": ["user:1", "user:2"],
+      "created": "2024-01-01T00:00:00Z"
+    },
+    {
+      "id": "project:2",
+      "name": "AI Research Platform",
+      "type": "Project",
+      "description": "Platform for collaborative AI research and experimentation",
+      "status": "planning",
+      "technologies": ["Python", "TensorFlow", "PyTorch", "Docker"],
+      "team": ["user:2", "user:3"],
+      "created": "2024-02-01T00:00:00Z"
+    }
+  ],
+  "vector_queries": [
+    "machine learning algorithms",
+    "artificial intelligence research",
+    "neural network architectures",
+    "deep learning applications",
+    "data science techniques",
+    "product management strategy",
+    "developer experience design",
+    "software engineering best practices"
+  ]
+}