@plures/pluresdb 1.6.10 → 2.9.6

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();
-  }
-});

package/legacy/tests/vscode_extension_test.ts

@@ -1,281 +0,0 @@
-// @ts-nocheck
-import { assert, assertEquals, assertMatch } from "jsr:@std/assert@1.0.14";
-import {
-  createPluresExtension,
-  ExtensionContextLike,
-  PluresVSCodeExtension,
-  VSCodeAPI,
-} from "../vscode/extension.ts";
-
-interface RecordedDocument {
-  content: string;
-  language: string;
-}
-
-interface RecordedMessage {
-  type: "info" | "error";
-  text: string;
-}
-
-type CommandHandler = (...args: unknown[]) => unknown;
-
-type TestHarness = {
-  vscode: VSCodeAPI;
-  context: ExtensionContextLike;
-  commands: Map<string, CommandHandler>;
-  docs: RecordedDocument[];
-  messages: RecordedMessage[];
-  shownTargets: string[];
-  queueInputs: (...values: (string | undefined)[]) => void;
-};
-
-function createHarness(storageDir: string): TestHarness {
-  const commands = new Map<string, CommandHandler>();
-  const docs: RecordedDocument[] = [];
-  const messages: RecordedMessage[] = [];
-  const shownTargets: string[] = [];
-  const inputQueue: Array<string | undefined> = [];
-
-  const vscode: VSCodeAPI = {
-    commands: {
-      registerCommand(command, handler) {
-        commands.set(command, handler);
-        return {
-          dispose() {
-            commands.delete(command);
-          },
-        };
-      },
-    },
-    window: {
-      async showInformationMessage(message: string) {
-        messages.push({ type: "info", text: message });
-      },
-      async showErrorMessage(message: string) {
-        messages.push({ type: "error", text: message });
-      },
-      async showInputBox() {
-        return inputQueue.shift();
-      },
-      async showTextDocument(doc: unknown) {
-        if (
-          typeof doc === "object" && doc && "content" in doc &&
-          "language" in doc
-        ) {
-          const record = doc as RecordedDocument;
-          docs.push({ content: record.content, language: record.language });
-        }
-      },
-    },
-    workspace: {
-      async openTextDocument(init) {
-        docs.push(init as RecordedDocument);
-        return init;
-      },
-    },
-    env: {
-      async openExternal(target) {
-        shownTargets.push(
-          typeof target === "string" ? target : target.toString(),
-        );
-      },
-    },
-    Uri: {
-      parse(target: string) {
-        return target;
-      },
-    },
-  };
-
-  const context: ExtensionContextLike = {
-    subscriptions: [],
-    globalStorageUri: { fsPath: storageDir },
-  };
-
-  return {
-    vscode,
-    context,
-    commands,
-    docs,
-    messages,
-    shownTargets,
-    queueInputs: (...values: (string | undefined)[]) => {
-      inputQueue.push(...values);
-    },
-  };
-}
-
-async function getFreePort(): Promise<number> {
-  const listener = Deno.listen({ hostname: "127.0.0.1", port: 0 });
-  const { port } = listener.addr as Deno.NetAddr;
-  listener.close();
-  return port;
-}
-
-async function waitFor(
-  predicate: () => Promise<boolean>,
-  timeout = 10_000,
-  interval = 200,
-) {
-  const deadline = Date.now() + timeout;
-  while (Date.now() < deadline) {
-    if (await predicate()) return;
-    await new Promise((resolve) => setTimeout(resolve, interval));
-  }
-  throw new Error("Timed out waiting for condition");
-}
-
-async function removeDirWithRetry(target: string) {
-  const delays = [0, 200, 400, 800, 1600, 3200];
-  for (let i = 0; i < delays.length; i++) {
-    if (delays[i] > 0) {
-      await new Promise((resolve) => setTimeout(resolve, delays[i]));
-    }
-    try {
-      await Deno.remove(target, { recursive: true });
-      return;
-    } catch (error) {
-      const retryable = error instanceof Error &&
-        /used by another process/i.test(error.message);
-      if (!retryable || i === delays.length - 1) {
-        throw error;
-      }
-    }
-  }
-}
-
-Deno.test("VSCode integration dogfood workflow", async () => {
-  const storageDir = await Deno.makeTempDir({ prefix: "plures-vscode-" });
-  const apiPort = await getFreePort();
-  const webPort = await getFreePort();
-  const apiUrl = `http://127.0.0.1:${apiPort}`;
-
-  const harness = createHarness(storageDir);
-  const extension = createPluresExtension(harness.vscode, harness.context, {
-    config: {
-      host: "127.0.0.1",
-      port: apiPort,
-      webPort,
-    },
-  });
-
-  try {
-    try {
-      await extension.activate();
-    } catch (error) {
-      console.error("Activation failed", harness.messages);
-      throw error;
-    }
-
-    await waitFor(async () => {
-      try {
-        const res = await fetch(`${apiUrl}/api/list`);
-        return res.ok;
-      } catch {
-        return false;
-      }
-    });
-
-    const seed = await fetch(`${apiUrl}/api/put`, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({
-        id: "extension:vector-doc",
-        data: {
-          type: "VSCodeDocument",
-          title: "Integration Test",
-          tags: ["extension", "sqlite"],
-          vector: [0.12, 0.24, 0.48, 0.96],
-        },
-      }),
-    });
-    assert(seed.ok, "Failed to seed vector test data");
-
-    const openWebUICmd = harness.commands.get("pluresdb.openWebUI");
-    if (!openWebUICmd) {
-      throw new Error("openWebUI command should be registered");
-    }
-    await openWebUICmd();
-    assertEquals(harness.shownTargets.at(-1), `http://127.0.0.1:${webPort}`);
-
-    harness.queueInputs("SELECT name FROM pragma_table_info('settings')");
-    const execQuery = harness.commands.get("pluresdb.executeQuery");
-    if (!execQuery) {
-      throw new Error("executeQuery command should be registered");
-    }
-    await execQuery();
-    const schemaDoc = harness.docs.at(-1);
-    if (!schemaDoc) {
-      throw new Error("Expected schema document to open");
-    }
-    const schemaRows = JSON.parse(schemaDoc.content) as Array<
-      Record<string, unknown>
-    >;
-    const columnNames = schemaRows.map((row) => String(row.name));
-    assert(
-      columnNames.includes("key"),
-      "Settings table should expose key column",
-    );
-
-    harness.queueInputs(
-      "user:alpha",
-      '{"name":"Ada","vector":[0.2,0.1,0.3,0.4],"role":"builder"}',
-    );
-    const storeCommand = harness.commands.get("pluresdb.storeData");
-    if (!storeCommand) {
-      throw new Error("storeData command should be registered");
-    }
-    await storeCommand();
-    assertMatch(
-      harness.messages.at(-1)?.text ?? "",
-      /Stored data for key: user:alpha/,
-    );
-
-    harness.queueInputs("user:alpha");
-    const retrieveCommand = harness.commands.get("pluresdb.retrieveData");
-    if (!retrieveCommand) {
-      throw new Error("retrieveData command should be registered");
-    }
-    await retrieveCommand();
-    const retrievedDoc = harness.docs.at(-1);
-    if (!retrievedDoc) {
-      throw new Error("Expected retrieved document to open");
-    }
-    const retrieved = JSON.parse(retrievedDoc.content);
-    assertEquals(retrieved.name, "Ada");
-
-    harness.queueInputs("sqlite builder search");
-    const vectorCommand = harness.commands.get("pluresdb.vectorSearch");
-    if (!vectorCommand) {
-      throw new Error("vectorSearch command should be registered");
-    }
-    await vectorCommand();
-    const vectorDoc = harness.docs.at(-1);
-    if (!vectorDoc) {
-      throw new Error("Expected vector search document to open");
-    }
-    const vectorResults = JSON.parse(vectorDoc.content) as Array<
-      Record<string, unknown>
-    >;
-    assert(
-      vectorResults.length > 0,
-      "Vector search should return at least one result",
-    );
-
-    const settingsRows = await extension.executeSQL(
-      "SELECT name FROM pragma_table_info('documents')",
-    );
-    assert(Array.isArray(settingsRows));
-  } finally {
-    await extension.deactivate();
-    try {
-      await removeDirWithRetry(storageDir);
-    } catch (error) {
-      console.warn(
-        `⚠️  Failed to remove temp dir: ${
-          error instanceof Error ? error.message : String(error)
-        }`,
-      );
-    }
-  }
-});

package/legacy/types/index.ts

@@ -1,32 +0,0 @@
-export interface VectorClock {
-  [peerId: string]: number;
-}
-
-export interface NodeRecord {
-  id: string;
-  data: Record<string, unknown>;
-  vector?: number[];
-  type?: string;
-  timestamp: number;
-  state?: Record<string, number>;
-  vectorClock: VectorClock;
-}
-
-export interface PutMessage {
-  type: "put";
-  originId?: string;
-  node: NodeRecord;
-}
-
-export interface DeleteMessage {
-  type: "delete";
-  originId?: string;
-  id: string;
-}
-
-export interface SyncRequestMessage {
-  type: "sync_request";
-  originId?: string;
-}
-
-export type MeshMessage = PutMessage | DeleteMessage | SyncRequestMessage;

package/legacy/types/node-types.ts

@@ -1,80 +0,0 @@
-/**
- * Node.js-specific types for PluresDB
- */
-
-export interface PluresDBConfig {
-  port?: number;
-  host?: string;
-  dataDir?: string;
-  webPort?: number;
-  logLevel?: "debug" | "info" | "warn" | "error";
-}
-
-export interface PluresDBOptions {
-  config?: PluresDBConfig;
-  autoStart?: boolean;
-  denoPath?: string;
-}
-
-export interface QueryResult {
-  rows: any[];
-  columns: string[];
-  changes: number;
-  lastInsertRowId: number;
-}
-
-export interface BetterSQLite3Options extends PluresDBOptions {
-  filename?: string;
-  memory?: boolean;
-  readonly?: boolean;
-  fileMustExist?: boolean;
-  verbose?: (...args: unknown[]) => void;
-}
-
-export interface BetterSQLite3RunResult {
-  changes: number;
-  lastInsertRowid: number | null;
-  columns?: string[];
-}
-
-export interface VectorSearchResult {
-  id: string;
-  content: string;
-  score: number;
-  metadata?: any;
-}
-
-export interface Peer {
-  id: string;
-  name: string;
-  email: string;
-  publicKey: string;
-  lastSeen: Date;
-  status: "online" | "offline" | "connecting";
-}
-
-export interface SharedNode {
-  id: string;
-  nodeId: string;
-  peerId: string;
-  accessLevel: "read-only" | "read-write" | "admin";
-  encrypted: boolean;
-  createdAt: Date;
-  expiresAt?: Date;
-}
-
-export interface Device {
-  id: string;
-  name: string;
-  type: "laptop" | "phone" | "server" | "desktop";
-  lastSync: Date;
-  status: "online" | "offline" | "syncing";
-}
-
-export interface SyncStatus {
-  isOnline: boolean;
-  lastSync: Date | null;
-  pendingChanges: number;
-  connectedPeers: number;
-  syncProgress: number;
-}