@plures/pluresdb 1.6.10 → 2.9.6

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

@@ -1,334 +0,0 @@
-// @ts-nocheck
-import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
-import { GunDB } from "../../core/database.ts";
-import { type ApiServerHandle, startApiServer } 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();
-  }
-});
-
-Deno.test("API Server - P2P API 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 createIdentity endpoint
-    const identityResponse = await fetch(`${baseUrl}/api/identity`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ name: "John Doe", email: "john@example.com" }),
-    });
-    assertEquals(identityResponse.status, 200);
-    const identity = await identityResponse.json();
-    assertExists(identity.id);
-    assertExists(identity.publicKey);
-    assertEquals(identity.name, "John Doe");
-    assertEquals(identity.email, "john@example.com");
-
-    // Test searchPeers endpoint
-    const peersResponse = await fetch(`${baseUrl}/api/peers/search?q=developer`);
-    assertEquals(peersResponse.status, 200);
-    const peers = await peersResponse.json();
-    assertEquals(Array.isArray(peers), true);
-
-    // Test shareNode endpoint
-    const shareResponse = await fetch(`${baseUrl}/api/share`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        nodeId: "node:123",
-        targetPeerId: "peer:456",
-        accessLevel: "read-only",
-      }),
-    });
-    assertEquals(shareResponse.status, 200);
-    const shareData = await shareResponse.json();
-    assertExists(shareData.sharedNodeId);
-    assertEquals(shareData.nodeId, "node:123");
-    assertEquals(shareData.targetPeerId, "peer:456");
-    assertEquals(shareData.accessLevel, "read-only");
-
-    // Test acceptSharedNode endpoint
-    const acceptResponse = await fetch(`${baseUrl}/api/share/accept`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ sharedNodeId: "shared:789" }),
-    });
-    assertEquals(acceptResponse.status, 200);
-    const acceptData = await acceptResponse.json();
-    assertEquals(acceptData.success, true);
-    assertEquals(acceptData.sharedNodeId, "shared:789");
-
-    // Test addDevice endpoint
-    const deviceResponse = await fetch(`${baseUrl}/api/devices`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ name: "My Laptop", type: "laptop" }),
-    });
-    assertEquals(deviceResponse.status, 200);
-    const device = await deviceResponse.json();
-    assertExists(device.id);
-    assertEquals(device.name, "My Laptop");
-    assertEquals(device.type, "laptop");
-    assertEquals(device.status, "online");
-
-    // Test syncWithDevice endpoint
-    const syncResponse = await fetch(`${baseUrl}/api/devices/sync`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ deviceId: "device:123" }),
-    });
-    assertEquals(syncResponse.status, 200);
-    const syncData = await syncResponse.json();
-    assertEquals(syncData.success, true);
-    assertEquals(syncData.deviceId, "device:123");
-
-    // Test GET devices list
-    const devicesListResponse = await fetch(`${baseUrl}/api/devices`);
-    assertEquals(devicesListResponse.status, 200);
-    const devicesList = await devicesListResponse.json();
-    assertEquals(Array.isArray(devicesList), true);
-  } finally {
-    api?.close();
-    await db.close();
-  }
-});

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

@@ -1,303 +0,0 @@
-// @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/legacy/tests/logic.test.ts

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