@plures/pluresdb 1.4.0

package/legacy/vscode/extension.ts

@@ -0,0 +1,387 @@
+import * as path from "node:path";
+import { PluresNode, SQLiteCompatibleAPI } from "../node-index";
+import type { PluresDBConfig } from "../types/node-types";
+
+type DisposableLike = { dispose(): void };
+
+type InputBoxOptions = {
+  prompt: string;
+  placeHolder?: string;
+};
+
+type TextDocumentInit = {
+  content: string;
+  language: string;
+};
+
+type UriLike = { toString(): string } | string;
+
+export type VSCodeWindow = {
+  showInformationMessage(message: string): void | Promise<unknown>;
+  showErrorMessage(message: string): void | Promise<unknown>;
+  showInputBox(options: InputBoxOptions): Promise<string | undefined>;
+  showTextDocument(document: unknown): Promise<unknown>;
+};
+
+export type VSCodeCommands = {
+  registerCommand(
+    command: string,
+    callback: (...args: unknown[]) => unknown,
+  ): DisposableLike;
+};
+
+export type VSCodeWorkspace = {
+  openTextDocument(init: TextDocumentInit): Promise<unknown>;
+};
+
+export type VSCodeEnv = {
+  openExternal(target: UriLike): Promise<unknown> | unknown;
+};
+
+export type VSCodeUri = {
+  parse(target: string): UriLike;
+};
+
+export type VSCodeAPI = {
+  window: VSCodeWindow;
+  commands: VSCodeCommands;
+  workspace: VSCodeWorkspace;
+  env: VSCodeEnv;
+  Uri: VSCodeUri;
+};
+
+export type ExtensionContextLike = {
+  subscriptions: DisposableLike[];
+  globalStorageUri: { fsPath: string };
+};
+
+export type ExtensionOptions = {
+  config?: PluresDBConfig;
+  commandPrefix?: string;
+  pluresInstance?: PluresNode;
+  sqliteInstance?: SQLiteCompatibleAPI;
+};
+
+type CommandFactory = () => Promise<void> | void;
+
+const DEFAULT_CONFIG: PluresDBConfig = {
+  port: 34567,
+  host: "localhost",
+  webPort: 34568,
+  logLevel: "info",
+};
+
+export class PluresVSCodeExtension {
+  private readonly vscode: VSCodeAPI;
+  private readonly context: ExtensionContextLike;
+  private readonly plures: PluresNode;
+  private readonly sqlite: SQLiteCompatibleAPI;
+  private readonly commandPrefix: string;
+  private readonly disposables: DisposableLike[] = [];
+  private activated = false;
+
+  constructor(
+    vscodeApi: VSCodeAPI,
+    context: ExtensionContextLike,
+    options: ExtensionOptions = {},
+  ) {
+    this.vscode = vscodeApi;
+    this.context = context;
+    this.commandPrefix = options.commandPrefix ?? "pluresdb";
+
+    const mergedConfig: PluresDBConfig = {
+      ...DEFAULT_CONFIG,
+      dataDir: path.join(context.globalStorageUri.fsPath, "pluresdb"),
+      ...options.config,
+    };
+
+    this.plures = options.pluresInstance ??
+      new PluresNode({ config: mergedConfig, autoStart: false });
+    this.sqlite = options.sqliteInstance ??
+      new SQLiteCompatibleAPI({ config: mergedConfig, autoStart: false });
+
+    this.setupEventHandlers();
+  }
+
+  async activate(): Promise<void> {
+    if (this.activated) {
+      return;
+    }
+
+    try {
+      await this.plures.start();
+      await this.sqlite.start();
+      this.registerCommands();
+      await this.setupDatabase();
+      this.activated = true;
+      await this.safeInfo("PluresDB extension activated");
+    } catch (error) {
+      await this.safeError(
+        `Failed to activate PluresDB: ${this.errorMessage(error)}`,
+      );
+      throw error;
+    }
+  }
+
+  async deactivate(): Promise<void> {
+    if (!this.activated) {
+      return;
+    }
+
+    try {
+      await this.sqlite.stop();
+      await this.plures.stop();
+    } finally {
+      this.disposeAll();
+      this.activated = false;
+    }
+  }
+
+  getWebUrl(): string {
+    return this.plures.getWebUrl();
+  }
+
+  async storeSetting(key: string, value: unknown) {
+    return this.sqlite.put(`settings:${key}`, value);
+  }
+
+  async getSetting(key: string) {
+    return this.sqlite.getValue(`settings:${key}`);
+  }
+
+  async storeDocument(
+    id: string,
+    content: string,
+    language: string,
+    filePath: string,
+  ) {
+    return this.sqlite.put(`documents:${id}`, {
+      content,
+      language,
+      filePath,
+      updatedAt: new Date().toISOString(),
+    });
+  }
+
+  async searchDocuments(query: string, limit = 20) {
+    return this.sqlite.vectorSearch(query, limit);
+  }
+
+  async executeSQL(sql: string, params: unknown[] = []) {
+    return this.sqlite.all(sql, params);
+  }
+
+  private setupEventHandlers() {
+    this.plures.on("started", () => {
+      this.safeInfo("PluresDB database started");
+    });
+
+    this.plures.on("stopped", () => {
+      this.safeInfo("PluresDB database stopped");
+    });
+
+    this.plures.on("error", (error: unknown) => {
+      this.safeError(`PluresDB error: ${this.errorMessage(error)}`);
+    });
+
+    this.plures.on("stderr", (output: string) => {
+      const trimmed = output.trim();
+      if (trimmed.length > 0) {
+        this.safeError(trimmed);
+      }
+    });
+
+    this.plures.on("stdout", (output: string) => {
+      const trimmed = output.trim();
+      if (trimmed.length > 0) {
+        this.safeInfo(trimmed);
+      }
+    });
+  }
+
+  private registerCommands() {
+    const register = (name: string, factory: CommandFactory) => {
+      const disposable = this.vscode.commands.registerCommand(
+        `${this.commandPrefix}.${name}`,
+        () => factory(),
+      );
+      this.context.subscriptions.push(disposable);
+      this.disposables.push(disposable);
+    };
+
+    register("openWebUI", async () => {
+      const webUrl = this.getWebUrl();
+      await this.vscode.env.openExternal(this.vscode.Uri.parse(webUrl));
+    });
+
+    register("executeQuery", async () => {
+      const sql = await this.vscode.window.showInputBox({
+        prompt: "Enter SQL query",
+        placeHolder: "SELECT * FROM users",
+      });
+
+      if (!sql) return;
+
+      try {
+        const result = await this.sqlite.all(sql);
+        const doc = await this.vscode.workspace.openTextDocument({
+          content: JSON.stringify(result, null, 2),
+          language: "json",
+        });
+        await this.vscode.window.showTextDocument(doc);
+      } catch (error) {
+        await this.safeError(`Query failed: ${this.errorMessage(error)}`);
+      }
+    });
+
+    register("vectorSearch", async () => {
+      const query = await this.vscode.window.showInputBox({
+        prompt: "Enter search query",
+        placeHolder: "machine learning",
+      });
+
+      if (!query) return;
+
+      try {
+        const results = await this.sqlite.vectorSearch(query, 10);
+        const doc = await this.vscode.workspace.openTextDocument({
+          content: JSON.stringify(results, null, 2),
+          language: "json",
+        });
+        await this.vscode.window.showTextDocument(doc);
+      } catch (error) {
+        await this.safeError(
+          `Vector search failed: ${this.errorMessage(error)}`,
+        );
+      }
+    });
+
+    register("storeData", async () => {
+      const key = await this.vscode.window.showInputBox({
+        prompt: "Enter key",
+        placeHolder: "user:123",
+      });
+
+      if (!key) return;
+
+      const json = await this.vscode.window.showInputBox({
+        prompt: "Enter value (JSON)",
+        placeHolder: '{"name": "Ada", "email": "ada@example.com"}',
+      });
+
+      if (!json) return;
+
+      try {
+        const value = JSON.parse(json);
+        await this.sqlite.put(key, value);
+        await this.safeInfo(`Stored data for key: ${key}`);
+      } catch (error) {
+        await this.safeError(
+          `Failed to store data: ${this.errorMessage(error)}`,
+        );
+      }
+    });
+
+    register("retrieveData", async () => {
+      const key = await this.vscode.window.showInputBox({
+        prompt: "Enter key to retrieve",
+        placeHolder: "user:123",
+      });
+
+      if (!key) return;
+
+      try {
+        const value = await this.sqlite.getValue(key);
+        if (value) {
+          const doc = await this.vscode.workspace.openTextDocument({
+            content: JSON.stringify(value, null, 2),
+            language: "json",
+          });
+          await this.vscode.window.showTextDocument(doc);
+        } else {
+          await this.safeInfo("Key not found");
+        }
+      } catch (error) {
+        await this.safeError(
+          `Failed to retrieve data: ${this.errorMessage(error)}`,
+        );
+      }
+    });
+  }
+
+  private async setupDatabase() {
+    const statements = [
+      `CREATE TABLE IF NOT EXISTS settings (
+        key TEXT PRIMARY KEY,
+        value TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )`,
+      `CREATE TABLE IF NOT EXISTS documents (
+        id TEXT PRIMARY KEY,
+        content TEXT,
+        language TEXT,
+        file_path TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )`,
+      `CREATE TABLE IF NOT EXISTS search_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        query TEXT,
+        results_count INTEGER,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+      )`,
+    ];
+
+    for (const sql of statements) {
+      try {
+        await this.sqlite.exec(sql);
+      } catch (error) {
+        await this.safeError(
+          `Failed to initialize database: ${this.errorMessage(error)}`,
+        );
+      }
+    }
+  }
+
+  private disposeAll() {
+    for (const disposable of this.disposables.splice(0)) {
+      try {
+        disposable.dispose();
+      } catch (_error) {
+        // ignore
+      }
+    }
+  }
+
+  private async safeInfo(message: string) {
+    try {
+      await this.vscode.window.showInformationMessage(message);
+    } catch (_error) {
+      // ignore message failures in headless tests
+    }
+  }
+
+  private async safeError(message: string) {
+    try {
+      await this.vscode.window.showErrorMessage(message);
+    } catch (_error) {
+      // ignore message failures in headless tests
+    }
+  }
+
+  private errorMessage(error: unknown): string {
+    if (error instanceof Error) {
+      return error.message;
+    }
+    return String(error);
+  }
+}
+
+export function createPluresExtension(
+  vscodeApi: VSCodeAPI,
+  context: ExtensionContextLike,
+  options: ExtensionOptions = {},
+) {
+  return new PluresVSCodeExtension(vscodeApi, context, options);
+}

package/package.json

@@ -0,0 +1,127 @@
+{
+  "name": "@plures/pluresdb",
+  "version": "1.4.0",
+  "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",
+  "exports": {
+    ".": {
+      "types": "./dist/node-index.d.ts",
+      "require": "./dist/node-index.js",
+      "default": "./dist/node-index.js"
+    },
+    "./node": {
+      "types": "./dist/node-index.d.ts",
+      "require": "./dist/node-index.js",
+      "default": "./dist/node-index.js"
+    },
+    "./better-sqlite3": {
+      "types": "./dist/better-sqlite3.d.ts",
+      "require": "./dist/better-sqlite3.js",
+      "default": "./dist/better-sqlite3.js"
+    },
+    "./vscode": {
+      "types": "./dist/vscode/extension.d.ts",
+      "require": "./dist/vscode/extension.js",
+      "default": "./dist/vscode/extension.js"
+    },
+    "./cli": {
+      "types": "./dist/cli.d.ts",
+      "require": "./dist/cli.js",
+      "default": "./dist/cli.js"
+    },
+    "./types": {
+      "types": "./dist/types/node-types.d.ts",
+      "require": "./dist/types/node-types.js",
+      "default": "./dist/types/node-types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "pluresdb": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "npm run build:lib && npm run build:web",
+    "build:lib": "tsc -p tsconfig.json",
+    "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: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",
+    "fmt:check": "prettier --check .",
+    "fmt": "prettier --write .",
+    "verify": "npm run build:lib && npm test",
+    "prepare": "npm run build:lib",
+    "prepublishOnly": "npm run verify && npm run build:web",
+    "postinstall": "node scripts/postinstall.js",
+    "release-check": "node scripts/release-check.js",
+    "update-changelog": "node scripts/update-changelog.js"
+  },
+  "keywords": [
+    "database",
+    "graph-database",
+    "p2p",
+    "sqlite",
+    "local-first",
+    "offline-first",
+    "crdt",
+    "vector-search",
+    "deno",
+    "typescript",
+    "vscode",
+    "extension",
+    "embedded",
+    "sync",
+    "encryption"
+  ],
+  "author": "Plures Organization",
+  "license": "AGPL-3.0",
+  "homepage": "https://github.com/plures/pluresdb#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plures/pluresdb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/plures/pluresdb/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=8.0.0"
+  },
+  "files": [
+    "dist/",
+    "web/svelte/dist/",
+    "legacy/",
+    "examples/",
+    "scripts/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "dependencies": {
+    "cors": "^2.8.5",
+    "express": "^5.1.0",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.0",
+    "@types/vscode": "^1.104.0",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.46.4",
+    "@typescript-eslint/parser": "^8.46.4",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import": "^2.32.0",
+    "prettier": "^3.6.2",
+    "prettier-plugin-svelte": "^3.4.0",
+    "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}

package/scripts/compiled-crud-verify.ts

@@ -0,0 +1,30 @@
+import { GunDB } from "../src/core/database.ts";
+
+const serverUrl = Deno.env.get("SERVER_URL") ?? "ws://localhost:34567";
+
+const clientA = new GunDB();
+const clientB = new GunDB();
+
+const kvA = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+const kvB = await Deno.makeTempFile({ prefix: "kv_", suffix: ".sqlite" });
+
+await clientA.ready(kvA);
+await clientB.ready(kvB);
+
+clientA.connect(serverUrl);
+clientB.connect(serverUrl);
+
+const id = `bin:crud:${crypto.randomUUID()}`;
+
+const receivedOnB = new Promise<void>((resolve) =>
+  clientB.on(id, (n) => n && resolve())
+);
+
+await clientA.put(id, { text: "compiled works" } as Record<string, unknown>);
+
+await receivedOnB;
+
+await clientA.close();
+await clientB.close();
+
+console.log("COMPILED-CRUD-OK", id);