pluresdb 1.0.1

package/src/tests/core.test.ts

@@ -0,0 +1,281 @@
+// @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/src/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/src/tests/fixtures/test-data.json

@@ -0,0 +1,124 @@
+{
+  "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"
+  ]
+}

package/src/tests/integration/api-server.test.ts

@@ -0,0 +1,232 @@
+// @ts-nocheck
+import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+import { startApiServer, type ApiServerHandle } from "../../http/api-server.ts";
+
+function randomPort(): number {
+  return 18000 + Math.floor(Math.random() * 10000);
+}
+
+Deno.test("API Server - HTTP Endpoints", async () => {
+  const db = new GunDB();
+  let api: ApiServerHandle | null = null;
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = randomPort();
+    const apiPort = port + 1;
+    db.serve({ port });
+    api = startApiServer({ port: apiPort, db });
+
+    const baseUrl = `http://localhost:${apiPort}`;
+
+    // Test PUT endpoint
+    const putResponse = await fetch(`${baseUrl}/api/nodes/test:1`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "Test Node", value: 123 }),
+    });
+    assertEquals(putResponse.status, 200);
+    await putResponse.body?.cancel();
+
+    // Test GET endpoint
+    const getResponse = await fetch(`${baseUrl}/api/nodes/test:1`);
+    assertEquals(getResponse.status, 200);
+    const data = await getResponse.json();
+    assertEquals(data.name, "Test Node");
+    assertEquals(data.value, 123);
+
+    // Test DELETE endpoint
+    const deleteResponse = await fetch(`${baseUrl}/api/nodes/test:1`, {
+      method: "DELETE",
+    });
+    assertEquals(deleteResponse.status, 200);
+    await deleteResponse.body?.cancel();
+
+    // Verify deletion
+    const getAfterDelete = await fetch(`${baseUrl}/api/nodes/test:1`);
+    assertEquals(getAfterDelete.status, 404);
+    await getAfterDelete.body?.cancel();
+  } finally {
+    api?.close();
+    await db.close();
+  }
+});
+
+Deno.test("API Server - Vector Search Endpoint", async () => {
+  const db = new GunDB();
+  let api: ApiServerHandle | null = null;
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Add test data
+    await db.put("doc:1", { text: "Machine learning algorithms" });
+    await db.put("doc:2", { text: "Cooking recipes and food" });
+
+    const port = randomPort();
+    const apiPort = port + 1;
+    db.serve({ port });
+    api = startApiServer({ port: apiPort, db });
+
+    const baseUrl = `http://localhost:${apiPort}`;
+
+    // Test vector search endpoint
+    const searchResponse = await fetch(`${baseUrl}/api/search`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        query: "machine learning",
+        limit: 5,
+      }),
+    });
+
+  assertEquals(searchResponse.status, 200);
+  const results = await searchResponse.json();
+    assertExists(results);
+    assertEquals(Array.isArray(results), true);
+  } finally {
+    api?.close();
+    await db.close();
+  }
+});
+
+Deno.test("API Server - WebSocket Connection", async () => {
+  const db = new GunDB();
+  let api: ApiServerHandle | null = null;
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = randomPort();
+    const apiPort = port + 1;
+    db.serve({ port });
+    api = startApiServer({ port: apiPort, db });
+
+    const wsUrl = `ws://localhost:${port}/ws`;
+
+    // Test WebSocket connection
+    const ws = new WebSocket(wsUrl);
+
+    const connectionPromise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error("Connection timeout")), 5000);
+      ws.onopen = () => {
+        clearTimeout(timer);
+        resolve(true);
+      };
+      ws.onerror = (error) => {
+        clearTimeout(timer);
+        reject(error);
+      };
+    });
+
+    await connectionPromise;
+
+    // Test sending data via WebSocket
+    const messagePromise = new Promise((resolve) => {
+      ws.onmessage = (event) => {
+        const data = JSON.parse(event.data);
+        if (data.type === "put") {
+          resolve(data);
+        }
+      };
+    });
+
+    // Send a message
+    ws.send(
+      JSON.stringify({
+        type: "put",
+        id: "ws:test",
+        data: { message: "Hello WebSocket" },
+      }),
+    );
+
+    await messagePromise;
+    ws.close();
+  } finally {
+    api?.close();
+    await db.close();
+  }
+});
+
+Deno.test("API Server - Error Handling", async () => {
+  const db = new GunDB();
+  let api: ApiServerHandle | null = null;
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = randomPort();
+    const apiPort = port + 1;
+    db.serve({ port });
+    api = startApiServer({ port: apiPort, db });
+
+    const baseUrl = `http://localhost:${apiPort}`;
+
+    // Test 404 for non-existent node
+    const notFoundResponse = await fetch(`${baseUrl}/api/nodes/nonexistent`);
+    assertEquals(notFoundResponse.status, 404);
+    await notFoundResponse.body?.cancel();
+
+    // Test 400 for invalid JSON
+    const invalidJsonResponse = await fetch(`${baseUrl}/api/nodes/test`, {
+      method: "PUT",
+      headers: { "Content-Type": "application/json" },
+      body: "invalid json",
+    });
+    assertEquals(invalidJsonResponse.status, 400);
+    await invalidJsonResponse.body?.cancel();
+  } finally {
+    api?.close();
+    await db.close();
+  }
+});
+
+Deno.test("API Server - CORS Headers", async () => {
+  const db = new GunDB();
+  let api: ApiServerHandle | null = null;
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const port = randomPort();
+    const apiPort = port + 1;
+    db.serve({ port });
+    api = startApiServer({ port: apiPort, db });
+
+    const baseUrl = `http://localhost:${apiPort}`;
+
+    // Test OPTIONS request for CORS
+    const optionsResponse = await fetch(`${baseUrl}/api/nodes/test`, {
+      method: "OPTIONS",
+      headers: {
+        Origin: "http://localhost:3000",
+        "Access-Control-Request-Method": "PUT",
+      },
+    });
+
+  assertEquals(optionsResponse.status, 200);
+  assertExists(optionsResponse.headers.get("Access-Control-Allow-Origin"));
+  assertExists(optionsResponse.headers.get("Access-Control-Allow-Methods"));
+  await optionsResponse.body?.cancel();
+  } finally {
+    api?.close();
+    await db.close();
+  }
+});