@plures/pluresdb 1.6.10 → 2.9.6

package/legacy/local-first/unified-api.ts

@@ -1,449 +0,0 @@
-/**
- * Unified Local-First API for PluresDB
- * 
- * Automatically selects the best integration method based on runtime environment:
- * - Browser (WASM): Direct in-process WebAssembly
- * - Tauri: Direct Rust crate linking via Tauri commands
- * - Native IPC: Shared memory inter-process communication
- * - Network: HTTP REST API (fallback for backward compatibility)
- * 
- * This provides a consistent API across all platforms while maximizing performance
- * and minimizing network overhead.
- */
-
-import { debugLog } from "../util/debug";
-
-export interface LocalFirstOptions {
-  /**
-   * Integration mode. If not specified, auto-detects the best mode.
-   * - "auto": Auto-detect runtime environment
-   * - "wasm": WebAssembly (browser)
-   * - "tauri": Tauri native integration
-   * - "ipc": Shared memory IPC
-   * - "network": HTTP REST API (backward compatibility)
-   */
-  mode?: "auto" | "wasm" | "tauri" | "ipc" | "network";
-
-  /**
-   * Database name (for WASM mode)
-   */
-  dbName?: string;
-
-  /**
-   * IPC channel name (for IPC mode)
-   */
-  channelName?: string;
-
-  /**
-   * Network URL (for network mode)
-   */
-  networkUrl?: string;
-
-  /**
-   * Network port (for network mode)
-   */
-  port?: number;
-}
-
-export interface LocalFirstBackend {
-  put(id: string, data: unknown): Promise<string>;
-  get(id: string): Promise<unknown>;
-  delete(id: string): Promise<void>;
-  list(): Promise<unknown[]>;
-  vectorSearch?(query: string, limit: number): Promise<unknown[]>;
-  close?(): Promise<void>;
-}
-
-/**
- * Runtime environment detection
- */
-class RuntimeDetector {
-  static isBrowser(): boolean {
-    return typeof globalThis !== "undefined" &&
-      typeof (globalThis as any).window !== "undefined" &&
-      typeof (globalThis as any).document !== "undefined" &&
-      typeof (globalThis as any).WebAssembly !== "undefined";
-  }
-
-  static isTauri(): boolean {
-    return typeof globalThis !== "undefined" &&
-      typeof (globalThis as any).window !== "undefined" &&
-      (globalThis as any).window?.__TAURI__ !== undefined;
-  }
-
-  static isNode(): boolean {
-    const globalProcess = (globalThis as any).process;
-    return typeof globalProcess !== "undefined" &&
-      globalProcess.versions?.node != null;
-  }
-
-  static isDeno(): boolean {
-    return typeof globalThis !== "undefined" &&
-      (globalThis as any).Deno !== undefined;
-  }
-
-  static hasIPCEnvironment(): boolean {
-    if (this.isNode()) {
-      return (globalThis as any).process?.env?.PLURESDB_IPC === "true";
-    }
-    if (this.isDeno()) {
-      const Deno = (globalThis as any).Deno;
-      return Deno?.env?.get?.("PLURESDB_IPC") === "true";
-    }
-    return false;
-  }
-
-  static detectBestMode(): "wasm" | "tauri" | "ipc" | "network" {
-    if (this.isTauri()) {
-      debugLog("Detected Tauri environment - using native integration");
-      return "tauri";
-    }
-
-    if (this.isBrowser()) {
-      debugLog("Detected browser environment - using WASM");
-      return "wasm";
-    }
-
-    if (this.hasIPCEnvironment()) {
-      debugLog("Detected IPC environment - using shared memory");
-      return "ipc";
-    }
-
-    debugLog("Using network mode (fallback)");
-    return "network";
-  }
-}
-
-/**
- * WASM Backend (Browser)
- * 
- * Uses WebAssembly for direct in-process database access.
- * Data is persisted in IndexedDB.
- */
-class WasmBackend implements LocalFirstBackend {
-  private db: unknown = null;
-  private dbName: string;
-
-  constructor(dbName: string = "pluresdb") {
-    this.dbName = dbName;
-  }
-
-  async initialize(): Promise<void> {
-    // Note: This is a placeholder. The actual WASM module will be implemented
-    // in Phase 1 of the roadmap (pluresdb-wasm crate).
-    throw new Error(
-      "WASM backend not yet implemented. Please see docs/LOCAL_FIRST_INTEGRATION.md for implementation status.",
-    );
-  }
-
-  async put(id: string, data: unknown): Promise<string> {
-    if (!this.db) await this.initialize();
-    return (this.db as any).put(id, data);
-  }
-
-  async get(id: string): Promise<unknown> {
-    if (!this.db) await this.initialize();
-    return (this.db as any).get(id);
-  }
-
-  async delete(id: string): Promise<void> {
-    if (!this.db) await this.initialize();
-    return (this.db as any).delete(id);
-  }
-
-  async list(): Promise<unknown[]> {
-    if (!this.db) await this.initialize();
-    return (this.db as any).list();
-  }
-
-  async vectorSearch(query: string, limit: number): Promise<unknown[]> {
-    if (!this.db) await this.initialize();
-    return (this.db as any).vectorSearch(query, limit);
-  }
-
-  async close(): Promise<void> {
-    if (this.db) {
-      await (this.db as any).close();
-      this.db = null;
-    }
-  }
-}
-
-/**
- * Tauri Backend
- * 
- * Uses Tauri commands to invoke Rust functions directly.
- * Provides native performance with no network overhead.
- */
-class TauriBackend implements LocalFirstBackend {
-  private invoke: any;
-
-  constructor() {
-    const win = typeof globalThis !== "undefined" ? (globalThis as any).window : undefined;
-    if (!win || !win.__TAURI__) {
-      throw new Error("Tauri backend requires Tauri environment");
-    }
-    this.invoke = win.__TAURI__.invoke;
-  }
-
-  async put(id: string, data: unknown): Promise<string> {
-    return await this.invoke("pluresdb_put", { id, data });
-  }
-
-  async get(id: string): Promise<unknown> {
-    return await this.invoke("pluresdb_get", { id });
-  }
-
-  async delete(id: string): Promise<void> {
-    await this.invoke("pluresdb_delete", { id });
-  }
-
-  async list(): Promise<unknown[]> {
-    return await this.invoke("pluresdb_list");
-  }
-
-  async vectorSearch(query: string, limit: number): Promise<unknown[]> {
-    return await this.invoke("pluresdb_vector_search", { query, limit });
-  }
-}
-
-/**
- * IPC Backend (Native Apps)
- * 
- * Uses shared memory and message passing for inter-process communication.
- * Provides low-latency access without network overhead.
- */
-class IPCBackend implements LocalFirstBackend {
-  private channelName: string;
-
-  constructor(channelName: string = "pluresdb") {
-    this.channelName = channelName;
-  }
-
-  async initialize(): Promise<void> {
-    // Note: This is a placeholder. The actual IPC implementation will be
-    // in Phase 3 of the roadmap (pluresdb-ipc crate).
-    throw new Error(
-      "IPC backend not yet implemented. Please see docs/LOCAL_FIRST_INTEGRATION.md for implementation status.",
-    );
-  }
-
-  async put(id: string, data: unknown): Promise<string> {
-    throw new Error("IPC backend not yet implemented");
-  }
-
-  async get(id: string): Promise<unknown> {
-    throw new Error("IPC backend not yet implemented");
-  }
-
-  async delete(id: string): Promise<void> {
-    throw new Error("IPC backend not yet implemented");
-  }
-
-  async list(): Promise<unknown[]> {
-    throw new Error("IPC backend not yet implemented");
-  }
-
-  async vectorSearch(query: string, limit: number): Promise<unknown[]> {
-    throw new Error("IPC backend not yet implemented");
-  }
-}
-
-/**
- * Network Backend (HTTP REST API)
- * 
- * Uses HTTP requests to communicate with a PluresDB server.
- * This is the fallback mode for backward compatibility.
- */
-class NetworkBackend implements LocalFirstBackend {
-  private baseUrl: string;
-
-  constructor(url?: string, port?: number) {
-    this.baseUrl = url || `http://localhost:${port || 34567}`;
-  }
-
-  async put(id: string, data: unknown): Promise<string> {
-    const response = await fetch(`${this.baseUrl}/api/put`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ id, data }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`PUT failed: ${response.statusText}`);
-    }
-
-    // API returns { ok: true }, return the id
-    await response.json();
-    return id;
-  }
-
-  async get(id: string): Promise<unknown> {
-    const response = await fetch(`${this.baseUrl}/api/get?id=${encodeURIComponent(id)}`);
-
-    if (!response.ok) {
-      if (response.status === 404) return null;
-      throw new Error(`GET failed: ${response.statusText}`);
-    }
-
-    // API returns the node data directly (can be null)
-    return await response.json();
-  }
-
-  async delete(id: string): Promise<void> {
-    const response = await fetch(`${this.baseUrl}/api/delete?id=${encodeURIComponent(id)}`, {
-      method: "DELETE",
-    });
-
-    if (!response.ok) {
-      throw new Error(`DELETE failed: ${response.statusText}`);
-    }
-  }
-
-  async list(): Promise<unknown[]> {
-    const response = await fetch(`${this.baseUrl}/api/list`);
-
-    if (!response.ok) {
-      throw new Error(`LIST failed: ${response.statusText}`);
-    }
-
-    // API returns array of { id, data }
-    const nodes = await response.json() as Array<{ id: string; data: unknown }>;
-    return nodes;
-  }
-
-  async vectorSearch(query: string, limit: number): Promise<unknown[]> {
-    const response = await fetch(`${this.baseUrl}/api/search`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ query, limit }),
-    });
-
-    if (!response.ok) {
-      throw new Error(`VECTOR_SEARCH failed: ${response.statusText}`);
-    }
-
-    // API returns array of { id, data }
-    const nodes = await response.json() as Array<{ id: string; data: unknown }>;
-    return nodes;
-  }
-}
-
-/**
- * PluresDB Local-First API
- * 
- * Unified interface that works across all platforms:
- * - Browser (WASM)
- * - Tauri (native)
- * - Native apps (IPC)
- * - Traditional apps (network)
- * 
- * Automatically selects the best integration method or allows manual override.
- * 
- * @example
- * ```typescript
- * // Auto-detect best mode
- * const db = new PluresDBLocalFirst();
- * 
- * // Manual mode selection
- * const db = new PluresDBLocalFirst({ mode: "wasm", dbName: "my-app" });
- * 
- * // Use the API (same across all modes)
- * await db.put("user:1", { name: "Alice", email: "alice@example.com" });
- * const user = await db.get("user:1");
- * const results = await db.vectorSearch("Find users named Alice", 10);
- * ```
- */
-export class PluresDBLocalFirst {
-  private backend: LocalFirstBackend;
-  private mode: string;
-
-  constructor(options: LocalFirstOptions = {}) {
-    const mode = options.mode || "auto";
-    const actualMode = mode === "auto" ? RuntimeDetector.detectBestMode() : mode;
-
-    this.mode = actualMode;
-
-    switch (actualMode) {
-      case "wasm":
-        this.backend = new WasmBackend(options.dbName);
-        break;
-
-      case "tauri":
-        this.backend = new TauriBackend();
-        break;
-
-      case "ipc":
-        this.backend = new IPCBackend(options.channelName);
-        break;
-
-      case "network":
-        this.backend = new NetworkBackend(options.networkUrl, options.port);
-        break;
-
-      default:
-        throw new Error(`Unknown mode: ${actualMode}`);
-    }
-
-    debugLog(`Initialized in ${this.mode} mode`);
-  }
-
-  /**
-   * Get the current integration mode
-   */
-  getMode(): string {
-    return this.mode;
-  }
-
-  /**
-   * Insert or update a node
-   */
-  async put(id: string, data: unknown): Promise<string> {
-    return this.backend.put(id, data);
-  }
-
-  /**
-   * Retrieve a node by ID
-   */
-  async get(id: string): Promise<unknown> {
-    return this.backend.get(id);
-  }
-
-  /**
-   * Delete a node by ID
-   */
-  async delete(id: string): Promise<void> {
-    return this.backend.delete(id);
-  }
-
-  /**
-   * List all nodes
-   */
-  async list(): Promise<unknown[]> {
-    return this.backend.list();
-  }
-
-  /**
-   * Vector search (semantic similarity)
-   */
-  async vectorSearch(query: string, limit: number = 10): Promise<unknown[]> {
-    if (!this.backend.vectorSearch) {
-      throw new Error("Vector search not supported in this mode");
-    }
-    return this.backend.vectorSearch(query, limit);
-  }
-
-  /**
-   * Close the database connection
-   */
-  async close(): Promise<void> {
-    if (this.backend.close) {
-      await this.backend.close();
-    }
-  }
-}
-
-/**
- * Legacy export for backward compatibility
- */
-export default PluresDBLocalFirst;

package/legacy/logic/rules.ts

@@ -1,46 +0,0 @@
-import type { NodeRecord } from "../types/index.ts";
-
-// Minimal DB interface to avoid circular imports
-export interface DatabaseLike {
-  put(id: string, data: Record<string, unknown>): Promise<void>;
-  get<T = Record<string, unknown>>(
-    id: string,
-  ): Promise<(T & { id: string }) | null>;
-}
-
-export interface RuleContext {
-  db: DatabaseLike;
-}
-
-export type RulePredicate = (node: NodeRecord) => boolean | Promise<boolean>;
-export type RuleAction = (ctx: RuleContext, node: NodeRecord) => Promise<void>;
-
-export interface Rule {
-  name: string;
-  whenType?: string;
-  predicate?: RulePredicate;
-  action: RuleAction;
-}
-
-export class RuleEngine {
-  private readonly rules: Map<string, Rule> = new Map();
-
-  addRule(rule: Rule): void {
-    this.rules.set(rule.name, rule);
-  }
-
-  removeRule(name: string): void {
-    this.rules.delete(name);
-  }
-
-  async evaluateNode(node: NodeRecord, ctx: RuleContext): Promise<void> {
-    for (const rule of this.rules.values()) {
-      if (rule.whenType && node.type !== rule.whenType) continue;
-      if (rule.predicate) {
-        const ok = await rule.predicate(node);
-        if (!ok) continue;
-      }
-      await rule.action(ctx, node);
-    }
-  }
-}

package/legacy/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello, world!");
-}

package/legacy/main.ts

@@ -1,197 +0,0 @@
-import { GunDB } from "./core/database.ts";
-import { debugLog as _debugLog } from "./util/debug.ts";
-import { startApiServer } from "./http/api-server.ts";
-import { loadConfig, saveConfig } from "./config.ts";
-
-function printUsage() {
-  console.log(
-    [
-      "Usage:",
-      "  deno run -A src/main.ts serve [--port <port>] [--kv <path>] [ws://peer ...]",
-      "  deno run -A src/main.ts put <id> <json> [--kv <path>]",
-      "  deno run -A src/main.ts get <id> [--kv <path>]",
-      "  deno run -A src/main.ts delete <id> [--kv <path>]",
-      "  deno run -A src/main.ts vsearch <query> <k> [--kv <path>]",
-      "  deno run -A src/main.ts type <id> <TypeName> [--kv <path>]",
-      "  deno run -A src/main.ts instances <TypeName> [--kv <path>]",
-      "  deno run -A src/main.ts list [--kv <path>]",
-      "",
-    ].join("\n"),
-  );
-}
-
-if (import.meta.main) {
-  const [cmd, ...rest] = Deno.args;
-  switch (cmd) {
-    case "serve": {
-      const cfg = await loadConfig();
-      let port = cfg.port ?? 8080;
-      let kvPath: string | undefined = cfg.kvPath;
-      const pi = rest.indexOf("--port");
-      if (pi >= 0 && rest[pi + 1]) {
-        const n = Number(rest[pi + 1]);
-        if (Number.isFinite(n)) port = n;
-      }
-      const ki = rest.indexOf("--kv");
-      if (ki >= 0 && rest[ki + 1]) kvPath = rest[ki + 1];
-      const peers = (cfg.peers ?? []).concat(
-        rest.filter((v) => v.startsWith("ws://") || v.startsWith("wss://")),
-      );
-
-      const db = new GunDB();
-      await db.ready(kvPath);
-      db.serve({ port });
-      for (const p of peers) db.connect(p);
-
-      const api = startApiServer({ port: port + (cfg.apiPortOffset ?? 1), db });
-      console.log(`PluresDB node serving on ws://localhost:${port}`);
-      console.log(`HTTP API/UI on ${api.url}`);
-      if (peers.length) console.log("Connected to peers:", peers.join(", "));
-
-      // Keep process alive
-      await new Promise(() => {});
-      break;
-    }
-    case "put": {
-      const [id, json, ...flags] = rest;
-      if (!id || !json) {
-        printUsage();
-        Deno.exit(1);
-      }
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      const obj = JSON.parse(json);
-      await db.put(id, obj);
-      console.log("ok");
-      await db.close();
-      break;
-    }
-    case "get": {
-      const [id, ...flags] = rest;
-      if (!id) {
-        printUsage();
-        Deno.exit(1);
-      }
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      const val = await db.get<Record<string, unknown>>(id);
-      console.log(JSON.stringify(val));
-      await db.close();
-      break;
-    }
-    case "delete": {
-      const [id, ...flags] = rest;
-      if (!id) {
-        printUsage();
-        Deno.exit(1);
-      }
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      await db.delete(id);
-      console.log("ok");
-      await db.close();
-      break;
-    }
-    case "vsearch": {
-      const [query, kRaw, ...flags] = rest;
-      if (!query || !kRaw) {
-        printUsage();
-        Deno.exit(1);
-      }
-      const k = Number(kRaw);
-      if (!Number.isFinite(k)) {
-        printUsage();
-        Deno.exit(1);
-      }
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      const results = await db.vectorSearch(query, k);
-      console.log(
-        JSON.stringify(results.map((n) => ({ id: n.id, data: n.data }))),
-      );
-      await db.close();
-      break;
-    }
-    case "type": {
-      const [id, typeName, ...flags] = rest;
-      if (!id || !typeName) {
-        printUsage();
-        Deno.exit(1);
-      }
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      await db.setType(id, typeName);
-      console.log("ok");
-      await db.close();
-      break;
-    }
-    case "instances": {
-      const [typeName, ...flags] = rest;
-      if (!typeName) {
-        printUsage();
-        Deno.exit(1);
-      }
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      const rows = await db.instancesOf(typeName);
-      console.log(
-        JSON.stringify(rows.map((n) => ({ id: n.id, data: n.data }))),
-      );
-      await db.close();
-      break;
-    }
-    case "list": {
-      const flags = rest;
-      let kvPath: string | undefined;
-      const ki = flags.indexOf("--kv");
-      if (ki >= 0 && flags[ki + 1]) kvPath = flags[ki + 1];
-      const db = new GunDB();
-      await db.ready(kvPath);
-      const nodes = await db.getAll();
-      const out = nodes.map((node) => ({
-        id: node.id,
-        data: node.data as Record<string, unknown>,
-      }));
-      console.log(JSON.stringify(out));
-      await db.close();
-      break;
-    }
-    case "config": {
-      const cfg = await loadConfig();
-      console.log(JSON.stringify(cfg, null, 2));
-      break;
-    }
-    case "config:set": {
-      const [key, value] = rest;
-      if (!key || value === undefined) {
-        printUsage();
-        Deno.exit(1);
-      }
-      const cfg = await loadConfig();
-      (cfg as any)[key] = /^[0-9]+$/.test(value) ? Number(value) : value;
-      await saveConfig(cfg);
-      console.log("ok");
-      break;
-    }
-    default:
-      printUsage();
-  }
-}