@plures/pluresdb 1.6.10 → 2.9.6

package/scripts/dogfood.ts

@@ -1,297 +0,0 @@
-#!/usr/bin/env -S deno run -A --unstable-kv
-
-import { GunDB } from "../legacy/core/database.ts";
-import { startApiServer } from "../legacy/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",
-      "legacy/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

@@ -1,156 +0,0 @@
-/**
- * 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 {
-        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}`);
-    Deno.exit(1);
-  }
-}
-
-// Run the setup
-main();

package/scripts/publish-crates.sh

@@ -1,95 +0,0 @@
-#!/bin/bash
-# Publish all PluresDB crates to crates.io
-# Usage: ./scripts/publish-crates.sh
-
-set -e
-
-echo "=========================================="
-echo "Publishing PluresDB Crates to crates.io"
-echo "=========================================="
-echo ""
-
-# Check if logged in
-if ! cargo login --check 2>/dev/null; then
-    echo "Error: Not logged in to crates.io"
-    echo "Run: cargo login <your-api-token>"
-    exit 1
-fi
-
-# Colors for output
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-RED='\033[0;31m'
-NC='\033[0m' # No Color
-
-# Function to publish a crate
-publish_crate() {
-    local crate_name=$1
-    local crate_path=$2
-    
-    echo -e "${YELLOW}Publishing ${crate_name}...${NC}"
-    cd "$crate_path"
-    
-    # Verify it builds
-    echo "  Building..."
-    if ! cargo build --release > /dev/null 2>&1; then
-        echo -e "${RED}  ✗ Build failed${NC}"
-        return 1
-    fi
-    
-    # Run tests
-    echo "  Running tests..."
-    if ! cargo test > /dev/null 2>&1; then
-        echo -e "${RED}  ✗ Tests failed${NC}"
-        return 1
-    fi
-    
-    # Check package
-    echo "  Checking package..."
-    if ! cargo package > /dev/null 2>&1; then
-        echo -e "${RED}  ✗ Package check failed${NC}"
-        return 1
-    fi
-    
-    # Publish
-    echo "  Publishing to crates.io..."
-    if cargo publish; then
-        echo -e "${GREEN}  ✓ ${crate_name} published successfully${NC}"
-        cd - > /dev/null
-        return 0
-    else
-        echo -e "${RED}  ✗ Publishing failed${NC}"
-        cd - > /dev/null
-        return 1
-    fi
-}
-
-# Publish in dependency order
-echo "Publishing crates in dependency order..."
-echo ""
-
-# Note: pluresdb-core and pluresdb-sync are already published
-# Uncomment if you need to republish them:
-# publish_crate "pluresdb-core" "crates/pluresdb-core"
-# publish_crate "pluresdb-sync" "crates/pluresdb-sync"
-
-# Publish storage (depends on core)
-publish_crate "pluresdb-storage" "crates/pluresdb-storage"
-echo ""
-
-# Publish unified main crate (depends on core, storage, sync)
-publish_crate "pluresdb" "crates/pluresdb"
-echo ""
-
-# Publish CLI (depends on core, storage, sync)
-publish_crate "pluresdb-cli" "crates/pluresdb-cli"
-echo ""
-
-echo "=========================================="
-echo -e "${GREEN}All crates published successfully!${NC}"
-echo "=========================================="
-echo ""
-echo "Note: pluresdb-node and pluresdb-deno are published separately:"
-echo "  - pluresdb-node: npm publish (in crates/pluresdb-node)"
-echo "  - pluresdb-deno: deno publish (in crates/pluresdb-deno)"
-