@plures/pluresdb 1.6.10 → 2.9.6

package/legacy/tests/unit/core.test.ts

@@ -1,226 +0,0 @@
-// @ts-nocheck
-import {
-  assertEquals,
-  assertExists,
-  assertRejects,
-} 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";
-
-Deno.test("Core Database - Basic CRUD Operations", async () => {
-  const db = new GunDB();
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    // Test put and get
-    const user = { name: "Alice", age: 30, email: "alice@example.com" };
-    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);
-    assertEquals(got?.email, "alice@example.com");
-
-    // Test update
-    await db.put("user:alice", { ...user, age: 31 });
-    const updated = await db.get<typeof user>("user:alice");
-    assertEquals(updated?.age, 31);
-
-    // Test delete
-    await db.delete("user:alice");
-    const deleted = await db.get<typeof user>("user:alice");
-    assertEquals(deleted, null);
-  } finally {
-    await db.close();
-  }
-});
-
-Deno.test("Core Database - Vector Clock Increments", async () => {
-  const db = new GunDB();
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    const id = "vc:test";
-    await db.put(id, { value: 1 });
-    await db.put(id, { value: 2 });
-    await db.put(id, { value: 3 });
-
-    // 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();
-
-    assertExists(node);
-    const clockValues = Object.values(node.vectorClock);
-    assertEquals(clockValues.length, 1);
-    assertEquals(clockValues[0], 3);
-  } finally {
-    await db.close();
-  }
-});
-
-Deno.test("Core Database - Type System", async () => {
-  const db = new GunDB();
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    // Test setType and instancesOf
-    await db.put("person:1", { name: "Alice" });
-    await db.setType("person:1", "Person");
-
-    await db.put("company:1", { name: "Acme Corp" });
-    await db.setType("company:1", "Company");
-
-    const people = await db.instancesOf("Person");
-    assertEquals(people.length, 1);
-    assertEquals(people[0].id, "person:1");
-
-    const companies = await db.instancesOf("Company");
-    assertEquals(companies.length, 1);
-    assertEquals(companies[0].id, "company:1");
-  } finally {
-    await db.close();
-  }
-});
-
-Deno.test("Core Database - Vector Search", async () => {
-  const db = new GunDB();
-  try {
-    const kvPath = await Deno.makeTempFile({
-      prefix: "kv_",
-      suffix: ".sqlite",
-    });
-    await db.ready(kvPath);
-
-    // Add documents with text content
-    await db.put("doc:1", {
-      text: "Machine learning and artificial intelligence",
-    });
-    await db.put("doc:2", { text: "Cooking recipes and food preparation" });
-    await db.put("doc:3", { text: "Deep learning neural networks" });
-
-    // Test vector search
-    const results = await db.vectorSearch("machine learning", 2);
-    assertExists(results);
-    assertEquals(results.length, 2);
-
-    // Should find the most relevant documents
-    const docIds = results.map((r) => r.id);
-    assertExists(docIds.includes("doc:1"));
-    assertExists(docIds.includes("doc:3"));
-  } finally {
-    await db.close();
-  }
-});
-
-Deno.test("CRDT Merge - Equal Timestamps", () => {
-  const timestamp = Date.now();
-  const local: NodeRecord = {
-    id: "test:1",
-    data: { a: 1, shared: 1, nested: { x: 1, y: 1 } },
-    vector: [0.1, 0.2],
-    type: "TestType",
-    timestamp,
-    vectorClock: { peerA: 2 },
-  };
-
-  const incoming: NodeRecord = {
-    id: "test:1",
-    data: { b: 2, shared: 2, nested: { y: 2, z: 3 } },
-    timestamp,
-    vectorClock: { peerB: 3 },
-  } as unknown as NodeRecord;
-
-  const merged = mergeNodes(local, incoming);
-
-  assertEquals(merged.id, "test:1");
-  assertEquals(merged.timestamp, timestamp);
-  assertEquals(merged.data, {
-    a: 1,
-    shared: 2,
-    b: 2,
-    nested: { x: 1, y: 2, z: 3 },
-  });
-  assertEquals(merged.type, "TestType");
-  assertEquals(merged.vector, [0.1, 0.2]);
-  assertEquals(merged.vectorClock.peerA, 2);
-  assertEquals(merged.vectorClock.peerB, 3);
-});
-
-Deno.test("CRDT Merge - LWW on Different Timestamps", () => {
-  const t1 = 1000;
-  const t2 = 2000;
-
-  const older: NodeRecord = {
-    id: "test:2",
-    data: { a: 1, b: 1 },
-    timestamp: t1,
-    vectorClock: { p1: 1 },
-  } as unknown as NodeRecord;
-
-  const newer: NodeRecord = {
-    id: "test:2",
-    data: { a: 999, b: 2, c: 3 },
-    timestamp: t2,
-    vectorClock: { p2: 1 },
-  } as unknown as NodeRecord;
-
-  const merged = mergeNodes(older, newer);
-
-  assertEquals(merged.data, { a: 999, b: 2, c: 3 });
-  assertEquals(merged.timestamp, t2);
-});
-
-Deno.test("Core Database - Error Handling", async () => {
-  const db = new GunDB();
-
-  // Test operations before ready
-  await assertRejects(
-    () => db.put("test", { value: 1 }),
-    Error,
-    "Database not ready",
-  );
-
-  await assertRejects(() => db.get("test"), Error, "Database not ready");
-
-  await assertRejects(() => db.delete("test"), Error, "Database not ready");
-});
-
-Deno.test("Core Database - Persistence Across Restarts", async () => {
-  const kvPath = await Deno.makeTempFile({
-    prefix: "kv_",
-    suffix: ".sqlite",
-  });
-  const id = "persist:test";
-
-  // First session
-  const db1 = new GunDB();
-  await db1.ready(kvPath);
-  await db1.put(id, { value: 123, text: "persistent data" });
-  await db1.close();
-
-  // Second session
-  const db2 = new GunDB();
-  await db2.ready(kvPath);
-  const got = await db2.get<{ value: number; text: string }>(id);
-  await db2.close();
-
-  assertExists(got);
-  assertEquals(got.value, 123);
-  assertEquals(got.text, "persistent data");
-});

package/legacy/tests/unit/local-first-api.test.ts

@@ -1,65 +0,0 @@
-/**
- * Tests for Local-First Unified API
- */
-
-import { assertEquals, assertExists } from "jsr:@std/assert@1.0.14";
-import { PluresDBLocalFirst } from "../../local-first/unified-api.ts";
-
-Deno.test("PluresDBLocalFirst - Runtime detection", () => {
-  // Should detect "network" mode in Deno test environment
-  const db = new PluresDBLocalFirst({ mode: "auto" });
-  const mode = db.getMode();
-  
-  assertEquals(mode, "network", "Should default to network mode in Deno");
-});
-
-Deno.test("PluresDBLocalFirst - Manual mode selection", () => {
-  // Should allow manual mode selection
-  const db = new PluresDBLocalFirst({ mode: "network", port: 34567 });
-  const mode = db.getMode();
-  
-  assertEquals(mode, "network", "Should use network mode when explicitly set");
-});
-
-Deno.test("PluresDBLocalFirst - WASM mode throws not implemented", async () => {
-  const db = new PluresDBLocalFirst({ mode: "wasm", dbName: "test-db" });
-  
-  try {
-    await db.put("test:1", { value: "test" });
-    throw new Error("Should have thrown not implemented error");
-  } catch (error) {
-    assertEquals(
-      error instanceof Error && error.message.includes("not yet implemented"),
-      true,
-      "Should throw not implemented error for WASM mode"
-    );
-  }
-});
-
-Deno.test("PluresDBLocalFirst - IPC mode throws not implemented", async () => {
-  const db = new PluresDBLocalFirst({ mode: "ipc", channelName: "test-channel" });
-  
-  try {
-    await db.put("test:1", { value: "test" });
-    throw new Error("Should have thrown not implemented error");
-  } catch (error) {
-    assertEquals(
-      error instanceof Error && error.message.includes("not yet implemented"),
-      true,
-      "Should throw not implemented error for IPC mode"
-    );
-  }
-});
-
-Deno.test("PluresDBLocalFirst - Network mode API surface", () => {
-  const db = new PluresDBLocalFirst({ mode: "network", port: 34567 });
-  
-  // Check that all required methods exist
-  assertExists(db.put, "Should have put method");
-  assertExists(db.get, "Should have get method");
-  assertExists(db.delete, "Should have delete method");
-  assertExists(db.list, "Should have list method");
-  assertExists(db.vectorSearch, "Should have vectorSearch method");
-  assertExists(db.close, "Should have close method");
-  assertExists(db.getMode, "Should have getMode method");
-});

package/legacy/tests/unit/plugin-system.test.ts

@@ -1,388 +0,0 @@
-// @ts-nocheck
-import {
-  assertEquals,
-  assertExists,
-  assertRejects,
-  assert,
-} from "jsr:@std/assert@1.0.14";
-import {
-  pluginManager,
-  type Plugin,
-  type EmbeddingProvider,
-  type UIPanel,
-  type QueryTransformer,
-  type DataValidator,
-} from "../../plugins/plugin-system.ts";
-
-// Test helpers
-class TestEmbeddingProvider implements EmbeddingProvider {
-  name = "test-embeddings";
-  dimensions = 128;
-
-  async embed(text: string): Promise<number[]> {
-    return new Array(this.dimensions).fill(0.1);
-  }
-}
-
-class TestQueryTransformer implements QueryTransformer {
-  id = "test-transformer";
-
-  async transform(query: any): Promise<any> {
-    return { ...query, transformed: true };
-  }
-}
-
-class TestDataValidator implements DataValidator {
-  id = "test-validator";
-
-  async validate(data: Record<string, unknown>): Promise<{
-    valid: boolean;
-    errors?: string[];
-  }> {
-    if (!data.required) {
-      return { valid: false, errors: ["Missing required field"] };
-    }
-    return { valid: true };
-  }
-}
-
-Deno.test("Plugin System - Plugin Registration", async () => {
-  const plugin: Plugin = {
-    id: "test-plugin-1",
-    name: "Test Plugin",
-    version: "1.0.0",
-    description: "A test plugin",
-  };
-
-  await pluginManager.register(plugin);
-
-  const plugins = pluginManager.getPlugins();
-  const registered = plugins.find((p) => p.id === "test-plugin-1");
-
-  assertExists(registered);
-  assertEquals(registered.name, "Test Plugin");
-  assertEquals(registered.version, "1.0.0");
-
-  // Cleanup
-  await pluginManager.unregister("test-plugin-1");
-});
-
-Deno.test("Plugin System - Prevent Duplicate Plugin IDs", async () => {
-  const plugin1: Plugin = {
-    id: "duplicate-test",
-    name: "First Plugin",
-    version: "1.0.0",
-  };
-
-  const plugin2: Plugin = {
-    id: "duplicate-test",
-    name: "Second Plugin",
-    version: "2.0.0",
-  };
-
-  await pluginManager.register(plugin1);
-
-  // Attempting to register a plugin with duplicate ID should throw
-  await assertRejects(
-    async () => {
-      await pluginManager.register(plugin2);
-    },
-    Error,
-    "already registered",
-  );
-
-  // Cleanup
-  await pluginManager.unregister("duplicate-test");
-});
-
-Deno.test("Plugin System - Embedding Provider Registration", async () => {
-  const provider = new TestEmbeddingProvider();
-  const plugin: Plugin = {
-    id: "embedding-test",
-    name: "Embedding Test",
-    version: "1.0.0",
-    embeddingProviders: [provider],
-  };
-
-  await pluginManager.register(plugin);
-
-  const registeredProvider = pluginManager.getEmbeddingProvider(
-    "test-embeddings",
-  );
-  assertExists(registeredProvider);
-  assertEquals(registeredProvider.dimensions, 128);
-
-  const embedding = await registeredProvider.embed("test");
-  assertEquals(embedding.length, 128);
-  assertEquals(embedding[0], 0.1);
-
-  // Cleanup
-  await pluginManager.unregister("embedding-test");
-});
-
-Deno.test("Plugin System - Query Transformer Registration", async () => {
-  const transformer = new TestQueryTransformer();
-  const plugin: Plugin = {
-    id: "transformer-test",
-    name: "Transformer Test",
-    version: "1.0.0",
-    queryTransformers: [transformer],
-  };
-
-  await pluginManager.register(plugin);
-
-  const registeredTransformer = pluginManager.getQueryTransformer(
-    "test-transformer",
-  );
-  assertExists(registeredTransformer);
-
-  const query = { field: "value" };
-  const transformed = await registeredTransformer.transform(query);
-  assertEquals(transformed.field, "value");
-  assertEquals(transformed.transformed, true);
-
-  // Cleanup
-  await pluginManager.unregister("transformer-test");
-});
-
-Deno.test("Plugin System - Data Validator Registration", async () => {
-  const validator = new TestDataValidator();
-  const plugin: Plugin = {
-    id: "validator-test",
-    name: "Validator Test",
-    version: "1.0.0",
-    dataValidators: [validator],
-  };
-
-  await pluginManager.register(plugin);
-
-  const registeredValidator = pluginManager.getDataValidator("test-validator");
-  assertExists(registeredValidator);
-
-  // Test valid data
-  const validResult = await registeredValidator.validate({ required: true });
-  assertEquals(validResult.valid, true);
-
-  // Test invalid data
-  const invalidResult = await registeredValidator.validate({});
-  assertEquals(invalidResult.valid, false);
-  assertExists(invalidResult.errors);
-  assertEquals(invalidResult.errors.length, 1);
-
-  // Cleanup
-  await pluginManager.unregister("validator-test");
-});
-
-Deno.test("Plugin System - Plugin Lifecycle (init/destroy)", async () => {
-  let initCalled = false;
-  let destroyCalled = false;
-
-  const plugin: Plugin = {
-    id: "lifecycle-test",
-    name: "Lifecycle Test",
-    version: "1.0.0",
-    async init() {
-      initCalled = true;
-    },
-    async destroy() {
-      destroyCalled = true;
-    },
-  };
-
-  await pluginManager.register(plugin);
-  assertEquals(initCalled, true);
-
-  await pluginManager.unregister("lifecycle-test");
-  assertEquals(destroyCalled, true);
-});
-
-Deno.test("Plugin System - Transform Query with Multiple Transformers", async () => {
-  const transformer1: QueryTransformer = {
-    id: "transformer-1",
-    async transform(query: any) {
-      return { ...query, step1: true };
-    },
-  };
-
-  const transformer2: QueryTransformer = {
-    id: "transformer-2",
-    async transform(query: any) {
-      return { ...query, step2: true };
-    },
-  };
-
-  const plugin: Plugin = {
-    id: "multi-transformer-test",
-    name: "Multi Transformer Test",
-    version: "1.0.0",
-    queryTransformers: [transformer1, transformer2],
-  };
-
-  await pluginManager.register(plugin);
-
-  const query = { original: true };
-  const transformed = await pluginManager.transformQuery(query);
-
-  assertEquals(transformed.original, true);
-  assertEquals(transformed.step1, true);
-  assertEquals(transformed.step2, true);
-
-  // Cleanup
-  await pluginManager.unregister("multi-transformer-test");
-});
-
-Deno.test("Plugin System - Validate Data with Multiple Validators", async () => {
-  const validator1: DataValidator = {
-    id: "validator-1",
-    async validate(data: Record<string, unknown>) {
-      if (!data.field1) {
-        return { valid: false, errors: ["Missing field1"] };
-      }
-      return { valid: true };
-    },
-  };
-
-  const validator2: DataValidator = {
-    id: "validator-2",
-    async validate(data: Record<string, unknown>) {
-      if (!data.field2) {
-        return { valid: false, errors: ["Missing field2"] };
-      }
-      return { valid: true };
-    },
-  };
-
-  const plugin: Plugin = {
-    id: "multi-validator-test",
-    name: "Multi Validator Test",
-    version: "1.0.0",
-    dataValidators: [validator1, validator2],
-  };
-
-  await pluginManager.register(plugin);
-
-  // Test with all fields valid
-  const validResult = await pluginManager.validateData({
-    field1: true,
-    field2: true,
-  });
-  assertEquals(validResult.valid, true);
-  assertEquals(validResult.errors.length, 0);
-
-  // Test with missing fields
-  const invalidResult = await pluginManager.validateData({});
-  assertEquals(invalidResult.valid, false);
-  assertEquals(invalidResult.errors.length, 2);
-  assert(invalidResult.errors.includes("Missing field1"));
-  assert(invalidResult.errors.includes("Missing field2"));
-
-  // Cleanup
-  await pluginManager.unregister("multi-validator-test");
-});
-
-Deno.test("Plugin System - Unregister Non-Existent Plugin", async () => {
-  // Should not throw error when unregistering non-existent plugin
-  await pluginManager.unregister("non-existent-plugin");
-  // If we get here without error, test passes
-  assert(true);
-});
-
-Deno.test("Plugin System - Get All Providers After Registration", async () => {
-  const provider1 = new TestEmbeddingProvider();
-  provider1.name = "provider-1";
-
-  const provider2 = new TestEmbeddingProvider();
-  provider2.name = "provider-2";
-
-  const plugin: Plugin = {
-    id: "multi-provider-test",
-    name: "Multi Provider Test",
-    version: "1.0.0",
-    embeddingProviders: [provider1, provider2],
-  };
-
-  await pluginManager.register(plugin);
-
-  const providers = pluginManager.getEmbeddingProviders();
-  const testProviders = providers.filter((p) =>
-    p.name === "provider-1" || p.name === "provider-2"
-  );
-
-  assertEquals(testProviders.length, 2);
-
-  // Cleanup
-  await pluginManager.unregister("multi-provider-test");
-});
-
-Deno.test("Plugin System - UI Panel Registration", async () => {
-  const panel: UIPanel = {
-    id: "test-panel",
-    name: "Test Panel",
-    icon: "🧪",
-    component: {} as any, // Mock component
-    order: 100,
-  };
-
-  const plugin: Plugin = {
-    id: "panel-test",
-    name: "Panel Test",
-    version: "1.0.0",
-    uiPanels: [panel],
-  };
-
-  await pluginManager.register(plugin);
-
-  const registeredPanel = pluginManager.getUIPanel("test-panel");
-  assertExists(registeredPanel);
-  assertEquals(registeredPanel.name, "Test Panel");
-  assertEquals(registeredPanel.icon, "🧪");
-  assertEquals(registeredPanel.order, 100);
-
-  // Cleanup
-  await pluginManager.unregister("panel-test");
-});
-
-Deno.test("Plugin System - UI Panels Sorted by Order", async () => {
-  const panel1: UIPanel = {
-    id: "panel-1",
-    name: "Panel 1",
-    component: {} as any,
-    order: 30,
-  };
-
-  const panel2: UIPanel = {
-    id: "panel-2",
-    name: "Panel 2",
-    component: {} as any,
-    order: 10,
-  };
-
-  const panel3: UIPanel = {
-    id: "panel-3",
-    name: "Panel 3",
-    component: {} as any,
-    order: 20,
-  };
-
-  const plugin: Plugin = {
-    id: "sorted-panels-test",
-    name: "Sorted Panels Test",
-    version: "1.0.0",
-    uiPanels: [panel1, panel2, panel3],
-  };
-
-  await pluginManager.register(plugin);
-
-  const panels = pluginManager.getUIPanels();
-  const testPanels = panels.filter((p) =>
-    ["panel-1", "panel-2", "panel-3"].includes(p.id)
-  );
-
-  // Should be sorted by order: panel-2 (10), panel-3 (20), panel-1 (30)
-  assertEquals(testPanels[0].id, "panel-2");
-  assertEquals(testPanels[1].id, "panel-3");
-  assertEquals(testPanels[2].id, "panel-1");
-
-  // Cleanup
-  await pluginManager.unregister("sorted-panels-test");
-});