pluresdb 1.0.1

package/src/tests/integration/mesh-network.test.ts

@@ -0,0 +1,297 @@
+// @ts-nocheck
+import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+
+const shouldRunMeshTests =
+  (Deno.env.get("RUN_MESH_TESTS") ?? "").toLowerCase() === "true";
+const defaultTimeoutMs = Number(
+  Deno.env.get("RUN_MESH_TEST_TIMEOUT_MS") ?? "10000",
+);
+
+if (!shouldRunMeshTests) {
+  console.warn(
+    "[mesh-network.test] Skipping mesh networking integration tests. Set RUN_MESH_TESTS=true to enable.",
+  );
+}
+
+function withTimeout<T>(
+  promise: Promise<T>,
+  message: string,
+  timeoutMs = defaultTimeoutMs,
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(message));
+    }, timeoutMs);
+
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      },
+    );
+  });
+}
+
+function meshTest(name: string, fn: () => Promise<void>) {
+  Deno.test({
+    name,
+    ignore: !shouldRunMeshTests,
+    sanitizeOps: false,
+    sanitizeResources: false,
+    fn,
+  });
+}
+
+function randomPort(): number {
+  return 18000 + Math.floor(Math.random() * 10000);
+}
+
+meshTest("Mesh Network - Basic Connection and Sync", async () => {
+  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);
+
+    // Start server
+    await dbA.serve({ port });
+
+    // Add data to server
+    await dbA.put("mesh:test", {
+      text: "Hello from server A",
+      timestamp: Date.now(),
+    });
+
+    // Connect client and wait for sync
+    const receivedData = new Promise((resolve) => {
+      dbB.on("mesh:test", (node) => {
+        if (node && (node.data as any).text === "Hello from server A") {
+          resolve(true);
+        }
+      });
+    });
+
+    dbB.connect(serverUrl);
+    await withTimeout(receivedData as Promise<unknown>, "Timed out waiting for initial mesh sync");
+
+    // Verify data was received
+    const syncedData = await dbB.get("mesh:test");
+    assertExists(syncedData);
+    assertEquals((syncedData as any).text, "Hello from server A");
+  } finally {
+    await dbB.close();
+    await dbA.close();
+  }
+});
+
+meshTest("Mesh Network - Bidirectional Sync", async () => {
+  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 });
+
+    // Connect B to A
+    dbB.connect(serverUrl);
+    await withTimeout(
+      new Promise((resolve) => setTimeout(resolve, 100)),
+      "Timed out waiting for mesh connection",
+    );
+
+    // A sends data to B
+    await dbA.put("from:A", { message: "Hello from A" });
+
+    const receivedFromA = new Promise((resolve) => {
+      dbB.on("from:A", (node) => {
+        if (node && (node.data as any).message === "Hello from A") {
+          resolve(true);
+        }
+      });
+    });
+    await withTimeout(
+      receivedFromA as Promise<unknown>,
+      "Timed out waiting for data from node A",
+    );
+
+    // B sends data to A
+    await dbB.put("from:B", { message: "Hello from B" });
+
+    const receivedFromB = new Promise((resolve) => {
+      dbA.on("from:B", (node) => {
+        if (node && (node.data as any).message === "Hello from B") {
+          resolve(true);
+        }
+      });
+    });
+    await withTimeout(
+      receivedFromB as Promise<unknown>,
+      "Timed out waiting for data from node B",
+    );
+
+    // Verify both received data
+    const dataFromA = await dbB.get("from:A");
+    const dataFromB = await dbA.get("from:B");
+
+    assertExists(dataFromA);
+    assertExists(dataFromB);
+    assertEquals((dataFromA as any).message, "Hello from A");
+    assertEquals((dataFromB as any).message, "Hello from B");
+  } finally {
+    await dbB.close();
+    await dbA.close();
+  }
+});
+
+meshTest("Mesh Network - Conflict Resolution", async () => {
+  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 });
+
+    // Connect B to A
+    dbB.connect(serverUrl);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Both modify the same key simultaneously
+    const timestamp = Date.now();
+    await dbA.put("conflict:test", {
+      value: "from A",
+      timestamp: timestamp + 1000,
+    });
+    await dbB.put("conflict:test", {
+      value: "from B",
+      timestamp: timestamp + 2000,
+    });
+
+    // Wait for sync
+    await withTimeout(
+      new Promise((resolve) => setTimeout(resolve, 500)),
+      "Timed out waiting for conflict resolution",
+    );
+
+    // Check that both databases have the same final state
+    const finalA = await dbA.get("conflict:test");
+    const finalB = await dbB.get("conflict:test");
+
+    assertExists(finalA);
+    assertExists(finalB);
+
+    // Should have the newer timestamp (from B)
+    assertEquals((finalA as any).value, "from B");
+    assertEquals((finalB as any).value, "from B");
+  } finally {
+    await dbB.close();
+    await dbA.close();
+  }
+});
+
+meshTest("Mesh Network - Multiple Clients", async () => {
+  const port = randomPort();
+  const serverUrl = `ws://localhost:${port}`;
+
+  const dbA = new GunDB(); // Server
+  const dbB = new GunDB(); // Client 1
+  const dbC = new GunDB(); // Client 2
+
+  try {
+    const kvA = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    const kvB = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    const kvC = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+
+    await dbA.ready(kvA);
+    await dbB.ready(kvB);
+    await dbC.ready(kvC);
+    await dbA.serve({ port });
+
+    // Connect both clients
+    dbB.connect(serverUrl);
+    dbC.connect(serverUrl);
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // B sends data
+    await dbB.put("multi:test", { from: "B", message: "Hello from B" });
+
+    // Wait for both A and C to receive
+    const receivedOnA = new Promise((resolve) => {
+      dbA.on("multi:test", (node) => {
+        if (node && (node.data as any).from === "B") resolve(true);
+      });
+    });
+
+    const receivedOnC = new Promise((resolve) => {
+      dbC.on("multi:test", (node) => {
+        if (node && (node.data as any).from === "B") resolve(true);
+      });
+    });
+
+    await withTimeout(
+      Promise.all([receivedOnA, receivedOnC]),
+      "Timed out waiting for multi-client propagation",
+    );
+
+    // Verify all have the data
+    const dataA = await dbA.get("multi:test");
+    const dataB = await dbB.get("multi:test");
+    const dataC = await dbC.get("multi:test");
+
+    assertExists(dataA);
+    assertExists(dataB);
+    assertExists(dataC);
+    assertEquals((dataA as any).from, "B");
+    assertEquals((dataB as any).from, "B");
+    assertEquals((dataC as any).from, "B");
+  } finally {
+    await dbC.close();
+    await dbB.close();
+    await dbA.close();
+  }
+});
+
+meshTest("Mesh Network - Connection Error Handling", async () => {
+  const db = new GunDB();
+
+  try {
+    const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    await db.ready(kvPath);
+
+    // Try to connect to non-existent server
+    db.connect("ws://localhost:99999");
+
+    // Should not throw error, but connection should fail gracefully
+    await withTimeout(
+      new Promise((resolve) => setTimeout(resolve, 1000)),
+      "Timed out waiting for graceful connection failure",
+    );
+  } finally {
+    await db.close();
+  }
+});

package/src/tests/logic.test.ts

@@ -0,0 +1,30 @@
+import { GunDB } from "../core/database.ts";
+import type { Rule } from "../logic/rules.ts";
+
+Deno.test("rule engine classification: Person.age >= 18 -> adult = true", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+    await db.ready(kvPath);
+
+    const rule: Rule = {
+      name: "adultClassifier",
+      whenType: "Person",
+      predicate: (node) =>
+        typeof (node.data as any).age === "number" && (node.data as any).age >= 18,
+      action: async (ctx, node) => {
+        const data = { ...(node.data as Record<string, unknown>), adult: true };
+        await ctx.db.put(node.id, data);
+      },
+    };
+    db.addRule(rule);
+
+    await db.put("p:alice", { name: "Alice", age: 20, type: "Person" });
+    const got = await db.get<{ adult?: boolean }>("p:alice");
+    if (!got || got.adult !== true) {
+      throw new Error("Expected adult flag set by rule");
+    }
+  } finally {
+    await db.close();
+  }
+});

package/src/tests/performance/load.test.ts

@@ -0,0 +1,288 @@
+// @ts-nocheck
+import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
+import { GunDB } from "../../core/database.ts";
+
+interface PerformanceMetrics {
+  operation: string;
+  count: number;
+  totalTime: number;
+  averageTime: number;
+  operationsPerSecond: number;
+}
+
+function measureOperation(
+  operation: () => Promise<void>,
+  count: number,
+): Promise<PerformanceMetrics> {
+  return new Promise(async (resolve) => {
+    const startTime = performance.now();
+
+    for (let i = 0; i < count; i++) {
+      await operation();
+    }
+
+    const endTime = performance.now();
+    const totalTime = endTime - startTime;
+    const averageTime = totalTime / count;
+    const operationsPerSecond = (count / totalTime) * 1000;
+
+    resolve({
+      operation: "unknown",
+      count,
+      totalTime,
+      averageTime,
+      operationsPerSecond,
+    });
+  });
+}
+
+Deno.test("Performance - Bulk Insert Operations", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const count = 1000;
+    let currentCount = 0;
+
+    const metrics = await measureOperation(async () => {
+      await db.put(`perf:${currentCount++}`, {
+        id: currentCount,
+        data: `Performance test data ${currentCount}`,
+        timestamp: Date.now(),
+      });
+    }, count);
+
+    console.log(`Bulk Insert Performance:`, metrics);
+
+    // Verify all data was inserted
+    const allNodes = await db.getAll();
+    assertEquals(allNodes.length, count);
+
+    // Performance assertions
+    assertEquals(metrics.operationsPerSecond > 100, true); // At least 100 ops/sec
+    assertEquals(metrics.averageTime < 10, true); // Less than 10ms per operation
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Performance - Bulk Read Operations", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Pre-populate with data
+    const count = 1000;
+    for (let i = 0; i < count; i++) {
+      await db.put(`read:${i}`, {
+        id: i,
+        data: `Read test data ${i}`,
+        timestamp: Date.now(),
+      });
+    }
+
+    let currentCount = 0;
+    const metrics = await measureOperation(async () => {
+      const data = await db.get(`read:${currentCount++}`);
+      assertExists(data);
+    }, count);
+
+    console.log(`Bulk Read Performance:`, metrics);
+
+    // Performance assertions
+    assertEquals(metrics.operationsPerSecond > 500, true); // At least 500 ops/sec
+    assertEquals(metrics.averageTime < 2, true); // Less than 2ms per operation
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Performance - Vector Search Operations", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    // Pre-populate with documents for vector search
+    const count = 500;
+    for (let i = 0; i < count; i++) {
+      await db.put(`doc:${i}`, {
+        text: `Document ${i} about machine learning and artificial intelligence`,
+        content: `This is document number ${i} containing information about AI and ML algorithms`,
+      });
+    }
+
+    const searchQueries = [
+      "machine learning algorithms",
+      "artificial intelligence",
+      "neural networks",
+      "deep learning",
+      "data science",
+    ];
+
+    let queryCount = 0;
+    const metrics = await measureOperation(async () => {
+      const query = searchQueries[queryCount % searchQueries.length];
+      const results = await db.vectorSearch(query, 10);
+      assertExists(results);
+      queryCount++;
+    }, 100);
+
+    console.log(`Vector Search Performance:`, metrics);
+
+    // Performance assertions
+    assertEquals(metrics.operationsPerSecond > 50, true); // At least 50 ops/sec
+    assertEquals(metrics.averageTime < 20, true); // Less than 20ms per operation
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Performance - Concurrent Operations", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const concurrentCount = 100;
+    const operationsPerWorker = 10;
+
+    const startTime = performance.now();
+
+    // Run concurrent operations
+    const promises = Array.from({ length: concurrentCount }, async (_, i) => {
+      for (let j = 0; j < operationsPerWorker; j++) {
+        await db.put(`concurrent:${i}:${j}`, {
+          worker: i,
+          operation: j,
+          timestamp: Date.now(),
+        });
+      }
+    });
+
+    await Promise.all(promises);
+
+    const endTime = performance.now();
+    const totalTime = endTime - startTime;
+    const totalOperations = concurrentCount * operationsPerWorker;
+    const operationsPerSecond = (totalOperations / totalTime) * 1000;
+
+    console.log(`Concurrent Operations Performance:`, {
+      totalOperations,
+      totalTime,
+      operationsPerSecond,
+    });
+
+    // Verify all operations completed
+    const allNodes = await db.getAll();
+    assertEquals(allNodes.length, totalOperations);
+
+    // Performance assertions
+    assertEquals(operationsPerSecond > 200, true); // At least 200 ops/sec
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Performance - Memory Usage", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const initialMemory = (performance as any).memory?.usedJSHeapSize || 0;
+
+    // Insert large amount of data
+    const count = 10000;
+    for (let i = 0; i < count; i++) {
+      await db.put(`memory:${i}`, {
+        id: i,
+        largeData: "x".repeat(1000), // 1KB per record
+        timestamp: Date.now(),
+      });
+    }
+
+    const afterInsertMemory = (performance as any).memory?.usedJSHeapSize || 0;
+    const memoryIncrease = afterInsertMemory - initialMemory;
+
+    console.log(`Memory Usage:`, {
+      initialMemory,
+      afterInsertMemory,
+      memoryIncrease,
+      memoryPerRecord: memoryIncrease / count,
+    });
+
+    // Memory efficiency assertions
+    assertEquals(memoryIncrease < 50 * 1024 * 1024, true); // Less than 50MB increase
+    assertEquals(memoryIncrease / count < 5000, true); // Less than 5KB per record
+  } finally {
+    await db.close();
+  }
+});
+
+Deno.test("Performance - Subscription Performance", async () => {
+  const db = new GunDB();
+  try {
+    const kvPath = await Deno.makeTempFile({
+      prefix: "kv_",
+      suffix: ".sqlite",
+    });
+    await db.ready(kvPath);
+
+    const subscriptionCount = 1000;
+    const updateCount = 100;
+
+    // Set up many subscriptions
+    const subscriptions: Array<() => void> = [];
+    for (let i = 0; i < subscriptionCount; i++) {
+      const unsubscribe = db.on(`sub:${i}`, () => {});
+      subscriptions.push(unsubscribe);
+    }
+
+    const startTime = performance.now();
+
+    // Trigger updates
+    for (let i = 0; i < updateCount; i++) {
+      await db.put(`sub:${i % subscriptionCount}`, {
+        update: i,
+        timestamp: Date.now(),
+      });
+    }
+
+    const endTime = performance.now();
+    const totalTime = endTime - startTime;
+    const updatesPerSecond = (updateCount / totalTime) * 1000;
+
+    console.log(`Subscription Performance:`, {
+      subscriptionCount,
+      updateCount,
+      totalTime,
+      updatesPerSecond,
+    });
+
+    // Clean up subscriptions
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+
+    // Performance assertions
+    assertEquals(updatesPerSecond > 50, true); // At least 50 updates/sec
+  } finally {
+    await db.close();
+  }
+});