pluresdb 1.0.1

package/scripts/dogfood.ts

@@ -0,0 +1,258 @@
+#!/usr/bin/env -S deno run -A --unstable-kv
+
+import { GunDB } from "../src/core/database.ts";
+import { startApiServer } from "../src/http/api-server.ts";
+
+declare const Deno: any;
+
+interface StepResult {
+  name: string;
+  ok: boolean;
+  details?: string;
+}
+
+async function main() {
+  const results: StepResult[] = [];
+  const kvDir = await Deno.makeTempDir({ prefix: "pluresdb-dogfood-" });
+  const kvPath = `${kvDir}/kv`;
+  const wsPort = 4600 + Math.floor(Math.random() * 5000);
+  const apiPort = wsPort + 1;
+  const apiUrl = `http://localhost:${apiPort}`;
+
+  const db = new GunDB();
+  await db.ready(kvPath);
+  db.serve({ port: wsPort });
+  const api = startApiServer({ port: apiPort, db });
+
+  const cleanupTasks: Array<() => Promise<void> | void> = [
+    async () => {
+      try {
+        api.close();
+      } catch (_) {
+        /* ignore */
+      }
+    },
+    async () => {
+      try {
+        await db.close();
+      } catch (_) {
+        /* ignore */
+      }
+    },
+    async () => {
+      try {
+        await Deno.remove(kvDir, { recursive: true });
+      } catch (_) {
+        /* ignore */
+      }
+    },
+  ];
+
+  const finalize = async () => {
+    for (const task of cleanupTasks) {
+      await Promise.resolve(task());
+    }
+  };
+
+  const assert = (cond: boolean, message: string) => {
+    if (!cond) {
+      throw new Error(message);
+    }
+  };
+
+  const record = (name: string, ok: boolean, details?: string) => {
+    const entry: StepResult = { name, ok, details };
+    results.push(entry);
+    const icon = ok ? "✅" : "❌";
+    console.log(`${icon} ${name}${details ? ` — ${details}` : ""}`);
+  };
+
+  try {
+    console.log("🚀 Starting PluresDB dogfooding run");
+    console.log(`🗂️  KV path: ${kvPath}`);
+    console.log(`🔌 Mesh port: ${wsPort}`);
+    console.log(`🌐 API port: ${apiPort}`);
+
+    await waitFor(
+      async () => {
+        try {
+          const res = await fetch(`${apiUrl}/api/list`);
+          return res.ok;
+        } catch (_) {
+          return false;
+        }
+      },
+      { timeoutMs: 10_000, intervalMs: 250 },
+    );
+    record("Server readiness", true);
+
+    const nodeId = "dogfood:api";
+    const initialPayload = {
+      type: "DogfoodTest",
+      text: "Hello from the dogfooding script",
+      vector: Array.from({ length: 4 }, (_, i) => i + 1),
+    };
+    const putRes = await fetch(`${apiUrl}/api/put`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ id: nodeId, data: initialPayload }),
+    });
+    assert(putRes.ok, `API put failed (${putRes.status})`);
+    record("API put", true);
+
+    const getRes = await fetch(`${apiUrl}/api/get?id=${encodeURIComponent(nodeId)}`);
+    assert(getRes.ok, "API get failed");
+    const getJson = await getRes.json();
+    assert(getJson.text === initialPayload.text, "Unexpected API get payload");
+    record("API get", true);
+
+    const listRes = await fetch(`${apiUrl}/api/list`);
+    assert(listRes.ok, "API list failed");
+    const listJson = await listRes.json();
+    assert(
+      Array.isArray(listJson) && listJson.some((n: any) => n.id === nodeId),
+      "Node missing from API list",
+    );
+    record("API list", true);
+
+    const searchRes = await fetch(
+      `${apiUrl}/api/search?q=${encodeURIComponent("dogfood script test")}&k=5`,
+    );
+    assert(searchRes.ok, "API search failed");
+    const searchJson = await searchRes.json();
+    assert(Array.isArray(searchJson) && searchJson.length > 0, "Vector search returned no results");
+    record("API vector search", true);
+
+    const updatePayload = {
+      type: "DogfoodTest",
+      text: "Hello from the updated dogfooding script",
+    };
+    const putUpdate = await fetch(`${apiUrl}/api/put`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ id: nodeId, data: updatePayload }),
+    });
+    assert(putUpdate.ok, "API put update failed");
+    record("API update", true);
+
+    const historyRes = await fetch(`${apiUrl}/api/history?id=${encodeURIComponent(nodeId)}`);
+    assert(historyRes.ok, "API history failed");
+    const historyJson = await historyRes.json();
+    assert(Array.isArray(historyJson) && historyJson.length >= 2, "API history missing versions");
+    record("API history", true, `${historyJson.length} versions`);
+
+    const restoreTimestamp =
+      historyJson.at(-1)?.timestamp ?? historyJson[historyJson.length - 1]?.timestamp;
+    assert(typeof restoreTimestamp === "number", "Failed to locate restore timestamp");
+    const restoreRes = await fetch(
+      `${apiUrl}/api/restore?id=${encodeURIComponent(nodeId)}&timestamp=${restoreTimestamp}`,
+    );
+    assert(restoreRes.ok, "API restore failed");
+    record("API restore", true);
+
+    const restored = await (
+      await fetch(`${apiUrl}/api/get?id=${encodeURIComponent(nodeId)}`)
+    ).json();
+    assert(restored.text === initialPayload.text, "Restore did not revert payload");
+    record("API post-restore verification", true);
+
+    const instancesRes = await fetch(
+      `${apiUrl}/api/instances?type=${encodeURIComponent("DogfoodTest")}`,
+    );
+    assert(instancesRes.ok, "API instances failed");
+    const instancesJson = await instancesRes.json();
+    assert(
+      Array.isArray(instancesJson) && instancesJson.some((n: any) => n.id === nodeId),
+      "Instances endpoint missing node",
+    );
+    record("API type instances", true);
+
+    const webRes = await fetch(`${apiUrl}/`);
+    assert(webRes.ok, "Web UI endpoint failed");
+    const webHtml = await webRes.text();
+    record("Web UI fetch", true, `${webHtml.length} chars`);
+
+    const cliId = "dogfood:cli";
+    const cliPut = await runCli([
+      "put",
+      cliId,
+      JSON.stringify({ type: "DogfoodTest", text: "CLI write" }),
+      "--kv",
+      kvPath,
+    ]);
+    assert(cliPut.code === 0, `CLI put failed: ${cliPut.stderr}`);
+    record("CLI put", true);
+
+    const cliGet = await runCli(["get", cliId, "--kv", kvPath]);
+    assert(cliGet.code === 0, `CLI get failed: ${cliGet.stderr}`);
+    const cliGetJson = JSON.parse(cliGet.stdout.trim() || "null");
+    assert(cliGetJson?.text === "CLI write", "CLI get returned wrong payload");
+    record("CLI get", true);
+
+    const cliList = await runCli(["list", "--kv", kvPath]);
+    assert(cliList.code === 0, `CLI list failed: ${cliList.stderr}`);
+    const cliListJson = JSON.parse(cliList.stdout.trim() || "[]");
+    assert(Array.isArray(cliListJson) && cliListJson.length >= 2, "CLI list missing entries");
+    record("CLI list", true);
+
+    const cliSearch = await runCli(["vsearch", "dogfooding", "5", "--kv", kvPath]);
+    assert(cliSearch.code === 0, `CLI vsearch failed: ${cliSearch.stderr}`);
+    const cliSearchJson = JSON.parse(cliSearch.stdout.trim() || "[]");
+    assert(
+      Array.isArray(cliSearchJson) && cliSearchJson.length > 0,
+      "CLI vsearch returned no results",
+    );
+    record("CLI vector search", true);
+
+    console.log("\n🎉 Dogfooding run succeeded!");
+  } catch (error) {
+    record("Dogfooding run", false, error instanceof Error ? error.message : String(error));
+    await finalize();
+    console.log("\n❌ Dogfooding run failed");
+    console.log(error);
+    Deno.exit(1);
+  }
+
+  await finalize();
+}
+
+async function runCli(args: string[]) {
+  const command = new Deno.Command("deno", {
+    args: ["run", "-A", "--unstable-kv", "--no-lock", "src/main.ts", ...args],
+    stdout: "piped",
+    stderr: "piped",
+  });
+  const { code, stdout, stderr } = await command.output();
+  return {
+    code,
+    stdout: new TextDecoder().decode(stdout),
+    stderr: new TextDecoder().decode(stderr),
+  };
+}
+
+async function waitFor(
+  fn: () => Promise<boolean>,
+  opts: { timeoutMs: number; intervalMs: number },
+) {
+  const deadline = Date.now() + opts.timeoutMs;
+  while (Date.now() < deadline) {
+    if (await fn()) return;
+    await sleep(opts.intervalMs);
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+function sleep(ms: number): Promise<void>;
+function sleep<T>(ms: number, value: T): Promise<T>;
+function sleep(ms: number, value?: unknown) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      clearTimeout(timer);
+      resolve(value);
+    }, ms);
+  });
+}
+
+if ((import.meta as any).main) {
+  await main();
+}

package/scripts/postinstall.js

@@ -0,0 +1,155 @@
+/**
+ * Post-install script for PluresDB npm package
+ * This script ensures Deno is available and sets up the environment
+ */
+
+const { spawn, exec } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const DENO_VERSION = "1.40.0";
+
+function log(message) {
+  console.log(`[pluresdb] ${message}`);
+}
+
+function logError(message) {
+  console.error(`[pluresdb] ERROR: ${message}`);
+}
+
+function isDenoInstalled() {
+  return new Promise((resolve) => {
+    exec("deno --version", (error) => {
+      resolve(!error);
+    });
+  });
+}
+
+function installDeno() {
+  return new Promise((resolve, reject) => {
+    const platform = os.platform();
+    const arch = os.arch();
+
+    log("Installing Deno...");
+
+    let installCommand;
+
+    if (platform === "win32") {
+      // Windows - use PowerShell
+      installCommand = `powershell -c "iwr https://deno.land/install.ps1 -useb | iex"`;
+    } else if (platform === "darwin") {
+      // macOS - use Homebrew or curl
+      installCommand = "curl -fsSL https://deno.land/install.sh | sh";
+    } else {
+      // Linux - use curl
+      installCommand = "curl -fsSL https://deno.land/install.sh | sh";
+    }
+
+    exec(installCommand, (error, stdout, stderr) => {
+      if (error) {
+        logError(`Failed to install Deno: ${error.message}`);
+        logError("Please install Deno manually from https://deno.land/");
+        reject(error);
+      } else {
+        log("Deno installed successfully");
+        resolve();
+      }
+    });
+  });
+}
+
+function createStartScript() {
+  const scriptContent = `#!/bin/bash
+# PluresDB start script
+export DENO_INSTALL="$HOME/.deno"
+export PATH="$DENO_INSTALL/bin:$PATH"
+
+# Start PluresDB
+deno run -A "${path.join(__dirname, "../src/main.ts")}" serve "$@"
+`;
+
+  const scriptPath = path.join(__dirname, "../bin/pluresdb.sh");
+  const scriptDir = path.dirname(scriptPath);
+
+  if (!fs.existsSync(scriptDir)) {
+    fs.mkdirSync(scriptDir, { recursive: true });
+  }
+
+  fs.writeFileSync(scriptPath, scriptContent);
+  fs.chmodSync(scriptPath, "755");
+
+  log("Created start script");
+}
+
+function createWindowsStartScript() {
+  const scriptContent = `@echo off
+REM PluresDB start script for Windows
+set DENO_INSTALL=%USERPROFILE%\\.deno
+set PATH=%DENO_INSTALL%\\bin;%PATH%
+
+REM Start PluresDB
+deno run -A "${path.join(__dirname, "../src/main.ts")}" serve %*
+`;
+
+  const scriptPath = path.join(__dirname, "../bin/pluresdb.bat");
+  const scriptDir = path.dirname(scriptPath);
+
+  if (!fs.existsSync(scriptDir)) {
+    fs.mkdirSync(scriptDir, { recursive: true });
+  }
+
+  fs.writeFileSync(scriptPath, scriptContent);
+
+  log("Created Windows start script");
+}
+
+async function main() {
+  try {
+    log("Setting up PluresDB...");
+
+    // Check if Deno is installed
+    const denoInstalled = await isDenoInstalled();
+
+    if (!denoInstalled) {
+      log("Deno not found, attempting to install...");
+      try {
+        await installDeno();
+      } catch (error) {
+        logError("Failed to install Deno automatically");
+        logError("Please install Deno manually:");
+        logError("  Windows: iwr https://deno.land/install.ps1 -useb | iex");
+        logError("  macOS/Linux: curl -fsSL https://deno.land/install.sh | sh");
+        logError("  Or visit: https://deno.land/");
+        return;
+      }
+    } else {
+      log("Deno is already installed");
+    }
+
+    // Create start scripts
+    createStartScript();
+    if (os.platform() === "win32") {
+      createWindowsStartScript();
+    }
+
+    // Create data directory
+    const dataDir = path.join(os.homedir(), ".pluresdb");
+    if (!fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+      log(`Created data directory: ${dataDir}`);
+    }
+
+    log("Setup complete!");
+    log("Usage:");
+    log("  npx pluresdb serve");
+    log("  or");
+    log("  node node_modules/pluresdb/dist/cli.js serve");
+  } catch (error) {
+    logError(`Setup failed: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// Run the setup
+main();

package/scripts/run-tests.ts

@@ -0,0 +1,175 @@
+#!/usr/bin/env -S deno run -A --unstable-kv
+
+// @ts-nocheck
+
+interface TestSuite {
+  name: string;
+  command: string;
+  description: string;
+  timeout?: number;
+}
+
+interface TestResults {
+  suite: string;
+  passed: boolean;
+  duration: number;
+  output: string;
+  error?: string;
+}
+
+class TestRunner {
+  private results: TestResults[] = [];
+
+  async runTestSuite(suite: TestSuite): Promise<TestResults> {
+    console.log(`\n🧪 Running ${suite.name}...`);
+    console.log(`   ${suite.description}`);
+
+    const startTime = performance.now();
+
+    try {
+      const command = new Deno.Command("deno", {
+        args: suite.command.split(" "),
+        stdout: "piped",
+        stderr: "piped",
+      });
+
+      const { code, stdout, stderr } = await command.output();
+      const duration = performance.now() - startTime;
+
+      const output = new TextDecoder().decode(stdout);
+      const error = new TextDecoder().decode(stderr);
+
+      const result: TestResults = {
+        suite: suite.name,
+        passed: code === 0,
+        duration,
+        output,
+        error: code !== 0 ? error : undefined,
+      };
+
+      this.results.push(result);
+
+      if (result.passed) {
+        console.log(`   ✅ Passed (${duration.toFixed(2)}ms)`);
+      } else {
+        console.log(`   ❌ Failed (${duration.toFixed(2)}ms)`);
+        console.log(`   Error: ${result.error}`);
+      }
+
+      return result;
+    } catch (error) {
+      const duration = performance.now() - startTime;
+
+      const result: TestResults = {
+        suite: suite.name,
+        passed: false,
+        duration,
+        output: "",
+        error: error.message,
+      };
+
+      this.results.push(result);
+
+      console.log(`   ❌ Failed (${duration.toFixed(2)}ms)`);
+      console.log(`   Error: ${error.message}`);
+
+      return result;
+    }
+  }
+
+  printSummary() {
+    console.log("\n" + "=".repeat(80));
+    console.log("TEST SUMMARY");
+    console.log("=".repeat(80));
+
+    const passed = this.results.filter((r) => r.passed).length;
+    const total = this.results.length;
+    const totalDuration = this.results.reduce((sum, r) => sum + r.duration, 0);
+
+    console.log(`Total Tests: ${total}`);
+    console.log(`Passed: ${passed}`);
+    console.log(`Failed: ${total - passed}`);
+    console.log(`Total Duration: ${totalDuration.toFixed(2)}ms`);
+    console.log(`Success Rate: ${((passed / total) * 100).toFixed(1)}%`);
+
+    console.log("\nDetailed Results:");
+    this.results.forEach((result) => {
+      const status = result.passed ? "✅" : "❌";
+      console.log(`  ${status} ${result.suite} (${result.duration.toFixed(2)}ms)`);
+    });
+
+    if (passed < total) {
+      console.log("\nFailed Tests:");
+      this.results
+        .filter((r) => !r.passed)
+        .forEach((result) => {
+          console.log(`\n❌ ${result.suite}:`);
+          console.log(`   Error: ${result.error}`);
+        });
+    }
+  }
+}
+
+async function main() {
+  console.log("🚀 PluresDB Test Suite Runner");
+  console.log("===============================");
+
+  const testSuites: TestSuite[] = [
+    {
+      name: "Unit Tests",
+      command: "test -A --unstable-kv --parallel src/tests/unit/",
+      description: "Core functionality tests (CRUD, subscriptions, vector search)",
+      timeout: 30000,
+    },
+    {
+      name: "Integration Tests",
+      command: "test -A --unstable-kv --parallel src/tests/integration/",
+      description: "Mesh networking and API server tests",
+      timeout: 60000,
+    },
+    {
+      name: "Performance Tests",
+      command: "test -A --unstable-kv --parallel src/tests/performance/",
+      description: "Load testing and performance validation",
+      timeout: 120000,
+    },
+    {
+      name: "Security Tests",
+      command: "test -A --unstable-kv --parallel src/tests/security/",
+      description: "Input validation and security testing",
+      timeout: 30000,
+    },
+    {
+      name: "Code Quality",
+      command: "lint src/",
+      description: "Code linting and style checks",
+      timeout: 10000,
+    },
+    {
+      name: "Type Checking",
+      command: "check src/main.ts",
+      description: "TypeScript type checking",
+      timeout: 15000,
+    },
+  ];
+
+  const runner = new TestRunner();
+
+  for (const suite of testSuites) {
+    await runner.runTestSuite(suite);
+  }
+
+  runner.printSummary();
+
+  const failedTests = runner.results.filter((r) => !r.passed).length;
+  if (failedTests > 0) {
+    console.log(`\n❌ ${failedTests} test suite(s) failed!`);
+    Deno.exit(1);
+  } else {
+    console.log("\n🎉 All tests passed!");
+  }
+}
+
+if (import.meta.main) {
+  await main();
+}