@plures/pluresdb 1.5.3 → 1.6.10

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

@@ -0,0 +1,388 @@
+// @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");
+});

package/legacy/util/debug.ts

@@ -1,6 +1,19 @@
 export const DEBUG_ENABLED: boolean = (() => {
   try {
-    const v = Deno.env.get("PLURESDB_DEBUG") ?? "";
+    let v = "";
+    // Check for Deno environment
+    if (typeof (globalThis as any).Deno !== "undefined") {
+      const Deno = (globalThis as any).Deno;
+      if (Deno.env && Deno.env.get) {
+        v = Deno.env.get("PLURESDB_DEBUG") ?? "";
+      }
+    } else {
+      // Check for Node.js environment
+      const globalProcess = (globalThis as any).process;
+      if (typeof globalProcess !== "undefined" && globalProcess?.env) {
+        v = globalProcess.env.PLURESDB_DEBUG ?? "";
+      }
+    }
     return v === "1" || v.toLowerCase() === "true";
   } catch {
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plures/pluresdb",
-  "version": "1.5.3",
+  "version": "1.6.10",
   "description": "P2P Graph Database with SQLite Compatibility - Local-first, offline-first database for modern applications",
   "main": "dist/node-index.js",
   "types": "dist/node-index.d.ts",
@@ -35,6 +35,11 @@
       "require": "./dist/types/node-types.js",
       "default": "./dist/types/node-types.js"
     },
+    "./local-first": {
+      "types": "./dist/local-first/unified-api.d.ts",
+      "require": "./dist/local-first/unified-api.js",
+      "default": "./dist/local-first/unified-api.js"
+    },
     "./package.json": "./package.json"
   },
   "bin": {
@@ -46,7 +51,7 @@
     "build:web": "cd web/svelte && npm install && npm run build",
     "dev": "deno run -A --unstable-kv --watch src/main.ts serve --port 34567",
     "start": "node dist/cli.js serve",
-    "test": "deno test -A --unstable-kv",
+    "test": "deno test -A --unstable-kv --sloppy-imports",
     "test:azure:relay": "deno test --allow-net --allow-env azure/tests/relay-tests.ts",
     "test:azure:full": "npm run test:azure:relay",
     "lint": "eslint . --ext .js,.ts,.tsx",
@@ -55,6 +60,7 @@
     "verify": "npm run build:lib && npm test",
     "prepare": "npm run build:lib",
     "prepublishOnly": "npm run verify && npm run build:web",
+    "validate-publish": "node scripts/validate-npm-publish.js",
     "postinstall": "node scripts/postinstall.js",
     "release-check": "node scripts/release-check.js",
     "update-changelog": "node scripts/update-changelog.js"

package/scripts/validate-npm-publish.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+/**
+ * Pre-publish Validation Script for NPM
+ * 
+ * This script validates that the package is ready to be published to npm.
+ * It checks:
+ * 1. TypeScript compilation succeeds
+ * 2. Deno type checking passes
+ * 3. All tests pass
+ * 4. Required files exist in dist/
+ * 5. package.json is valid
+ */
+
+const { execSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+
+// Configuration
+const MAX_PACKAGE_SIZE_MB = 10;
+
+function log(message, color = RESET) {
+  console.log(`${color}${message}${RESET}`);
+}
+
+function error(message) {
+  log(`✗ ${message}`, RED);
+}
+
+function success(message) {
+  log(`✓ ${message}`, GREEN);
+}
+
+function info(message) {
+  log(`ℹ ${message}`, YELLOW);
+}
+
+function title(message) {
+  log(`\n${BOLD}${message}${RESET}`);
+}
+
+function runCommand(command, description) {
+  try {
+    info(`Running: ${description}...`);
+    execSync(command, { stdio: "inherit", cwd: process.cwd() });
+    success(description);
+    return true;
+  } catch (err) {
+    error(`${description} failed`);
+    return false;
+  }
+}
+
+function checkFileExists(filePath, description) {
+  const fullPath = path.join(process.cwd(), filePath);
+  if (fs.existsSync(fullPath)) {
+    success(`${description}: ${filePath}`);
+    return true;
+  } else {
+    error(`${description} missing: ${filePath}`);
+    return false;
+  }
+}
+
+async function main() {
+  title("🚀 NPM Publish Validation");
+
+  let allChecksPassed = true;
+
+  // 1. Check package.json is valid
+  title("📦 Validating package.json...");
+  try {
+    const packageJson = JSON.parse(
+      fs.readFileSync(path.join(process.cwd(), "package.json"), "utf-8"),
+    );
+    if (!packageJson.name || !packageJson.version) {
+      error("package.json missing required fields (name or version)");
+      allChecksPassed = false;
+    } else {
+      success(
+        `Package: ${packageJson.name}@${packageJson.version}`,
+      );
+    }
+  } catch (err) {
+    error(`Invalid package.json: ${err.message}`);
+    allChecksPassed = false;
+  }
+
+  // 2. TypeScript compilation
+  title("🔨 Building TypeScript...");
+  if (!runCommand("npm run build:lib", "TypeScript compilation")) {
+    allChecksPassed = false;
+  }
+
+  // 3. Check required dist files exist
+  title("📁 Checking required files...");
+  const requiredFiles = [
+    "dist/node-index.js",
+    "dist/node-index.d.ts",
+    "dist/better-sqlite3.js",
+    "dist/better-sqlite3.d.ts",
+    "dist/cli.js",
+    "dist/cli.d.ts",
+    "dist/local-first/unified-api.js",
+    "dist/local-first/unified-api.d.ts",
+    "dist/vscode/extension.js",
+    "dist/vscode/extension.d.ts",
+    "dist/types/node-types.js",
+    "dist/types/node-types.d.ts",
+  ];
+
+  for (const file of requiredFiles) {
+    if (!checkFileExists(file, "Required file")) {
+      allChecksPassed = false;
+    }
+  }
+
+  // 4. Deno type checking
+  title("🦕 Deno type checking...");
+  const denoPath = process.env.DENO_PATH || "deno";
+  const denoCheckFiles = [
+    "legacy/local-first/unified-api.ts",
+    "legacy/node-index.ts",
+    "legacy/better-sqlite3.ts",
+    "legacy/cli.ts",
+    "legacy/vscode/extension.ts",
+  ];
+
+  // Check if Deno is available
+  let denoAvailable = false;
+  try {
+    execSync(`${denoPath} --version`, { stdio: "pipe" });
+    denoAvailable = true;
+  } catch (err) {
+    info("Deno not available - skipping Deno type checks");
+  }
+
+  if (denoAvailable) {
+    let denoChecksFailed = false;
+    for (const file of denoCheckFiles) {
+      if (
+        !runCommand(
+          `${denoPath} check --sloppy-imports ${file}`,
+          `Deno type check: ${file}`,
+        )
+      ) {
+        error(`Deno type check failed for ${file}`);
+        denoChecksFailed = true;
+        allChecksPassed = false;
+        // Continue checking other files to show all failures
+      }
+    }
+    if (!denoChecksFailed) {
+      success("All Deno type checks passed");
+    }
+  }
+
+  // 5. Run tests (if Deno is available)
+  title("🧪 Running tests...");
+  if (denoAvailable) {
+    // Set DENO_PATH environment variable so npm test can find deno
+    const testEnv = { ...process.env };
+    const denoPathEnv = process.env.DENO_PATH;
+    if (denoPathEnv && denoPathEnv.includes(path.sep)) {
+      // If DENO_PATH was provided as a path, make sure its directory is in PATH for npm test
+      const denoBinDir = path.dirname(denoPathEnv);
+      // Use path.delimiter for cross-platform compatibility (: on Unix, ; on Windows)
+      testEnv.PATH = `${denoBinDir}${path.delimiter}${process.env.PATH}`;
+    }
+    
+    try {
+      execSync("npm test", { stdio: "inherit", cwd: process.cwd(), env: testEnv });
+      success("Deno tests");
+    } catch (err) {
+      error("Tests failed");
+      allChecksPassed = false;
+    }
+  } else {
+    info("Deno tests skipped (Deno not available)");
+  }
+
+  // 6. Check package size
+  title("📊 Package size check...");
+  try {
+    const output = execSync("npm pack --dry-run 2>&1", { encoding: "utf-8" });
+    const sizeMatch = output.match(/package size:\s+(\d+\.?\d*)\s*(\w+)/i);
+    if (sizeMatch) {
+      const size = parseFloat(sizeMatch[1]);
+      const unit = sizeMatch[2];
+      success(`Package size: ${size} ${unit}`);
+
+      // Warn if package is larger than configured threshold
+      if (unit.toLowerCase() === "mb" && size > MAX_PACKAGE_SIZE_MB) {
+        info(
+          `Warning: Package size is quite large (${size} ${unit}). Consider excluding unnecessary files.`,
+        );
+      }
+    }
+  } catch (err) {
+    info("Could not determine package size");
+  }
+
+  // Summary
+  title("📋 Validation Summary");
+  if (allChecksPassed) {
+    success("All critical checks passed! ✨");
+    log(
+      "\nThe package is ready to be published to npm.",
+      GREEN,
+    );
+    process.exit(0);
+  } else {
+    error("Some checks failed. Please fix the issues before publishing.");
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  error(`Validation failed with error: ${err.message}`);
+  console.error(err);
+  process.exit(1);
+});