@plures/pluresdb 1.4.0

package/dist/node-index.js

@@ -0,0 +1,665 @@
+"use strict";
+/**
+ * Node.js Entry Point for PluresDB
+ * This provides a clean API for VSCode extensions and other Node.js applications
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluresVSCodeExtension = exports.createPluresExtension = exports.default = exports.BetterSQLite3Database = exports.BetterSQLite3Statement = exports.SQLiteCompatibleAPI = exports.PluresNode = void 0;
+const node_events_1 = require("node:events");
+const node_child_process_1 = require("node:child_process");
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const node_process_1 = __importDefault(require("node:process"));
+const better_sqlite3_shared_1 = require("./better-sqlite3-shared");
+const packageRoot = typeof __dirname !== "undefined"
+    ? path.resolve(__dirname, "..")
+    : node_process_1.default.cwd();
+class PluresNode extends node_events_1.EventEmitter {
+    process = null;
+    config;
+    denoPath;
+    isRunning = false;
+    apiUrl = "";
+    constructor(options = {}) {
+        super();
+        this.config = {
+            port: 34567,
+            host: "localhost",
+            dataDir: path.join(os.homedir(), ".pluresdb"),
+            webPort: 34568,
+            logLevel: "info",
+            ...options.config,
+        };
+        this.denoPath = options.denoPath || this.findDenoPath();
+        if (options.autoStart !== false) {
+            this.start();
+        }
+    }
+    findDenoPath() {
+        // Try to find Deno in common locations
+        const possiblePaths = [
+            "deno", // In PATH
+            path.join(os.homedir(), ".deno", "bin", "deno"),
+            path.join(os.homedir(), ".local", "bin", "deno"),
+            "/usr/local/bin/deno",
+            "/opt/homebrew/bin/deno",
+            "C:\\Users\\" + os.userInfo().username + "\\.deno\\bin\\deno.exe",
+            "C:\\Program Files\\deno\\deno.exe",
+        ];
+        for (const denoPath of possiblePaths) {
+            try {
+                if (fs.existsSync(denoPath) || this.isCommandAvailable(denoPath)) {
+                    return denoPath;
+                }
+            }
+            catch {
+                // Continue to next path
+            }
+        }
+        throw new Error("Deno not found. Please install Deno from https://deno.land/");
+    }
+    isCommandAvailable(command) {
+        try {
+            require("child_process").execSync(`"${command}" --version`, {
+                stdio: "ignore",
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async start() {
+        if (this.isRunning) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                // Ensure data directory exists
+                if (!fs.existsSync(this.config.dataDir)) {
+                    fs.mkdirSync(this.config.dataDir, { recursive: true });
+                }
+                const kvPath = path.join(this.config.dataDir, "pluresdb.kv");
+                // Find the main.ts file
+                const mainTsPath = path.join(packageRoot, "src", "main.ts");
+                if (!fs.existsSync(mainTsPath)) {
+                    throw new Error("PluresDB main.ts not found. Please ensure the package is properly installed.");
+                }
+                // Start the Deno process
+                const args = [
+                    "run",
+                    "-A",
+                    "--unstable-kv",
+                    "--no-lock",
+                    mainTsPath,
+                    "serve",
+                    "--port",
+                    this.config.port.toString(),
+                    "--host",
+                    this.config.host,
+                    "--kv",
+                    kvPath,
+                ];
+                this.process = (0, node_child_process_1.spawn)(this.denoPath, args, {
+                    stdio: ["pipe", "pipe", "pipe"],
+                    cwd: packageRoot,
+                });
+                this.apiUrl = `http://${this.config.host}:${this.config.port}`;
+                // Handle process events
+                this.process.on("error", (error) => {
+                    this.emit("error", error);
+                    reject(error);
+                });
+                this.process.on("exit", (code) => {
+                    this.isRunning = false;
+                    this.emit("exit", code);
+                });
+                // Wait for server to start
+                this.waitForServer()
+                    .then(() => {
+                    this.isRunning = true;
+                    this.emit("started");
+                    resolve();
+                })
+                    .catch(reject);
+                // Handle stdout/stderr
+                this.process.stdout?.on("data", (data) => {
+                    const output = data.toString();
+                    this.emit("stdout", output);
+                });
+                this.process.stderr?.on("data", (data) => {
+                    const output = data.toString();
+                    this.emit("stderr", output);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async waitForServer(timeout = 20000) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < timeout) {
+            try {
+                const response = await fetch(`${this.apiUrl}/api/config`);
+                if (response.ok) {
+                    return;
+                }
+            }
+            catch {
+                // Server not ready yet
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        throw new Error("Server failed to start within timeout");
+    }
+    async stop() {
+        if (!this.isRunning || !this.process) {
+            return;
+        }
+        return new Promise((resolve) => {
+            this.process.kill("SIGTERM");
+            this.process.on("exit", () => {
+                this.isRunning = false;
+                this.emit("stopped");
+                resolve();
+            });
+            // Force kill after 5 seconds
+            setTimeout(() => {
+                if (this.process && this.isRunning) {
+                    this.process.kill("SIGKILL");
+                }
+                resolve();
+            }, 5000);
+        });
+    }
+    getApiUrl() {
+        return this.apiUrl;
+    }
+    getWebUrl() {
+        return `http://${this.config.host}:${this.config.webPort}`;
+    }
+    isServerRunning() {
+        return this.isRunning;
+    }
+    // SQLite-compatible API methods
+    async query(sql, params = []) {
+        const response = await fetch(`${this.apiUrl}/api/query`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ sql, params }),
+        });
+        if (!response.ok) {
+            throw new Error(`Query failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async put(key, value) {
+        const response = await fetch(`${this.apiUrl}/api/data`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ key, value }),
+        });
+        if (!response.ok) {
+            throw new Error(`Put failed: ${response.statusText}`);
+        }
+    }
+    async get(key) {
+        const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`);
+        if (!response.ok) {
+            if (response.status === 404) {
+                return null;
+            }
+            throw new Error(`Get failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async delete(key) {
+        const response = await fetch(`${this.apiUrl}/api/data/${encodeURIComponent(key)}`, {
+            method: "DELETE",
+        });
+        if (!response.ok) {
+            throw new Error(`Delete failed: ${response.statusText}`);
+        }
+    }
+    async vectorSearch(query, limit = 10) {
+        const response = await fetch(`${this.apiUrl}/api/vsearch`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ query, limit }),
+        });
+        if (!response.ok) {
+            throw new Error(`Vector search failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async list(prefix) {
+        const url = prefix
+            ? `${this.apiUrl}/api/list?prefix=${encodeURIComponent(prefix)}`
+            : `${this.apiUrl}/api/list`;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`List failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async getConfig() {
+        const response = await fetch(`${this.apiUrl}/api/config`);
+        if (!response.ok) {
+            throw new Error(`Get config failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async setConfig(config) {
+        const response = await fetch(`${this.apiUrl}/api/config`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(config),
+        });
+        if (!response.ok) {
+            throw new Error(`Set config failed: ${response.statusText}`);
+        }
+    }
+    // P2P API methods
+    async createIdentity(options) {
+        const response = await fetch(`${this.apiUrl}/api/identity`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(options),
+        });
+        if (!response.ok) {
+            throw new Error(`Create identity failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async searchPeers(query) {
+        const response = await fetch(`${this.apiUrl}/api/peers/search?q=${encodeURIComponent(query)}`);
+        if (!response.ok) {
+            throw new Error(`Search peers failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async shareNode(nodeId, targetPeerId, options) {
+        const response = await fetch(`${this.apiUrl}/api/share`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                nodeId,
+                targetPeerId,
+                accessLevel: options?.accessLevel || "read-only",
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Share node failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async acceptSharedNode(sharedNodeId) {
+        const response = await fetch(`${this.apiUrl}/api/share/accept`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ sharedNodeId }),
+        });
+        if (!response.ok) {
+            throw new Error(`Accept shared node failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async addDevice(device) {
+        const response = await fetch(`${this.apiUrl}/api/devices`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(device),
+        });
+        if (!response.ok) {
+            throw new Error(`Add device failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    async syncWithDevice(deviceId) {
+        const response = await fetch(`${this.apiUrl}/api/devices/sync`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ deviceId }),
+        });
+        if (!response.ok) {
+            throw new Error(`Sync with device failed: ${response.statusText}`);
+        }
+        return response.json();
+    }
+}
+exports.PluresNode = PluresNode;
+exports.default = PluresNode;
+// SQLite-compatible API for easy migration
+class SQLiteCompatibleAPI {
+    plures;
+    constructor(options) {
+        this.plures = new PluresNode(options);
+    }
+    async start() {
+        await this.plures.start();
+    }
+    async stop() {
+        await this.plures.stop();
+    }
+    // SQLite-compatible methods
+    async run(sql, params = []) {
+        return this.plures.query(sql, params);
+    }
+    async get(sql, params = []) {
+        const result = await this.plures.query(sql, params);
+        return result.rows?.[0] || null;
+    }
+    async all(sql, params = []) {
+        const result = await this.plures.query(sql, params);
+        return result.rows || [];
+    }
+    async exec(sql) {
+        return this.plures.query(sql);
+    }
+    // Additional PluresDB specific methods
+    async put(key, value) {
+        return this.plures.put(key, value);
+    }
+    async getValue(key) {
+        return this.plures.get(key);
+    }
+    async delete(key) {
+        return this.plures.delete(key);
+    }
+    async vectorSearch(query, limit = 10) {
+        return this.plures.vectorSearch(query, limit);
+    }
+    async list(prefix) {
+        return this.plures.list(prefix);
+    }
+    getApiUrl() {
+        return this.plures.getApiUrl();
+    }
+    getWebUrl() {
+        return this.plures.getWebUrl();
+    }
+    isRunning() {
+        return this.plures.isServerRunning();
+    }
+    // P2P API methods
+    async createIdentity(options) {
+        return this.plures.createIdentity(options);
+    }
+    async searchPeers(query) {
+        return this.plures.searchPeers(query);
+    }
+    async shareNode(nodeId, targetPeerId, options) {
+        return this.plures.shareNode(nodeId, targetPeerId, options);
+    }
+    async acceptSharedNode(sharedNodeId) {
+        return this.plures.acceptSharedNode(sharedNodeId);
+    }
+    async addDevice(device) {
+        return this.plures.addDevice(device);
+    }
+    async syncWithDevice(deviceId) {
+        return this.plures.syncWithDevice(deviceId);
+    }
+}
+exports.SQLiteCompatibleAPI = SQLiteCompatibleAPI;
+class BetterSQLite3Statement {
+    database;
+    sql;
+    boundParams;
+    rawMode = false;
+    pluckMode = false;
+    expandMode = false;
+    reader;
+    constructor(database, sql) {
+        this.database = database;
+        this.sql = sql;
+        this.reader = /^\s*select/i.test(sql);
+    }
+    get databaseInstance() {
+        return this.database;
+    }
+    bind(...params) {
+        this.boundParams = (0, better_sqlite3_shared_1.normalizeParameterInput)(params);
+        return this;
+    }
+    raw(toggle = true) {
+        this.rawMode = toggle;
+        if (toggle) {
+            this.pluckMode = false;
+        }
+        return this;
+    }
+    pluck(toggle = true) {
+        this.pluckMode = toggle;
+        if (toggle) {
+            this.expandMode = false;
+            this.rawMode = false;
+        }
+        return this;
+    }
+    expand(toggle = true) {
+        this.expandMode = toggle;
+        if (toggle) {
+            this.pluckMode = false;
+        }
+        return this;
+    }
+    safeIntegers() {
+        // No-op for compatibility with better-sqlite3 API
+        return this;
+    }
+    async run(...params) {
+        const result = await this.database.executeStatement(this.sql, this.resolveParams(params));
+        return {
+            changes: typeof result.changes === "number" ? result.changes : 0,
+            lastInsertRowid: typeof result.lastInsertRowId === "number"
+                ? result.lastInsertRowId
+                : null,
+            columns: result.columns,
+        };
+    }
+    async get(...params) {
+        const rows = await this.fetchRows(params);
+        return rows.length > 0 ? rows[0] : undefined;
+    }
+    async all(...params) {
+        return await this.fetchRows(params);
+    }
+    async *iterate(...params) {
+        const rows = await this.fetchRows(params);
+        for (const row of rows) {
+            yield row;
+        }
+    }
+    async columns() {
+        const result = await this.database.executeStatement(this.sql, this.boundParams ?? []);
+        return result.columns ?? [];
+    }
+    resolveParams(params) {
+        const normalized = (0, better_sqlite3_shared_1.normalizeParameterInput)(params);
+        if (normalized.length > 0) {
+            return normalized;
+        }
+        return this.boundParams ? [...this.boundParams] : [];
+    }
+    async fetchRows(params) {
+        const result = await this.database.executeStatement(this.sql, this.resolveParams(params));
+        return this.transformRows(result);
+    }
+    transformRows(result) {
+        return result.rows.map((row) => (0, better_sqlite3_shared_1.shapeRow)(row, result.columns, {
+            raw: this.rawMode,
+            pluck: this.pluckMode,
+            expand: this.expandMode,
+        }));
+    }
+}
+exports.BetterSQLite3Statement = BetterSQLite3Statement;
+class BetterSQLite3Database {
+    options;
+    plures;
+    filename;
+    verbose;
+    openPromise = null;
+    opened = false;
+    constructor(filenameOrOptions, maybeOptions) {
+        const { filename, options } = this.resolveOptions(filenameOrOptions, maybeOptions);
+        this.filename = filename;
+        this.options = options;
+        this.verbose = options.verbose;
+        const config = { ...options.config };
+        if (!config.dataDir) {
+            const baseDir = options.memory
+                ? path.join(os.tmpdir(), "pluresdb", "better-sqlite3-memory")
+                : path.join(os.homedir(), ".pluresdb", "better-sqlite3");
+            const safeName = (0, better_sqlite3_shared_1.sanitizeDataDirName)(filename === ":memory:" ? "memory" : filename);
+            config.dataDir = path.join(baseDir, safeName);
+        }
+        this.plures = new PluresNode({
+            config,
+            denoPath: options.denoPath,
+            autoStart: false,
+        });
+        if (options.autoStart !== false) {
+            void this.open();
+        }
+    }
+    get name() {
+        return this.filename;
+    }
+    get isOpen() {
+        return this.opened;
+    }
+    async open() {
+        await this.ensureOpen();
+        return this;
+    }
+    async close() {
+        if (!this.opened && !this.openPromise) {
+            return;
+        }
+        await this.plures.stop();
+        this.opened = false;
+        this.openPromise = null;
+    }
+    prepare(sql) {
+        if (!this.opened) {
+            throw new Error("Database is not open. Call await db.open() before preparing statements.");
+        }
+        return new BetterSQLite3Statement(this, sql);
+    }
+    async exec(sql) {
+        await this.ensureOpen();
+        for (const statement of (0, better_sqlite3_shared_1.splitSqlStatements)(sql)) {
+            await this.executeStatement(statement, []);
+        }
+        return this;
+    }
+    transaction(fn) {
+        return async (...args) => {
+            await this.ensureOpen();
+            await this.executeStatement("BEGIN", []);
+            try {
+                const result = await fn(...args);
+                await this.executeStatement("COMMIT", []);
+                return result;
+            }
+            catch (error) {
+                await this.executeStatement("ROLLBACK", []).catch(() => undefined);
+                throw error;
+            }
+        };
+    }
+    async pragma(statement) {
+        const sql = /^\s*pragma/i.test(statement)
+            ? statement
+            : `PRAGMA ${statement}`;
+        const result = await this.executeStatement(sql, []);
+        return result.rows;
+    }
+    defaultSafeIntegers() {
+        return this;
+    }
+    unsafeMode() {
+        return this;
+    }
+    async executeStatement(sql, params) {
+        await this.ensureOpen();
+        const normalizedParams = (0, better_sqlite3_shared_1.normalizeParameterInput)(params);
+        const raw = await this.plures.query(sql, normalizedParams);
+        return (0, better_sqlite3_shared_1.normalizeQueryResult)(raw);
+    }
+    async ensureOpen() {
+        if (this.opened) {
+            return;
+        }
+        if (!this.openPromise) {
+            this.openPromise = (async () => {
+                await this.plures.start();
+                this.opened = true;
+                if (this.verbose) {
+                    this.verbose(`PluresDB ready for better-sqlite3 compatibility (${this.filename})`);
+                }
+            })();
+        }
+        await this.openPromise;
+    }
+    resolveOptions(filenameOrOptions, maybeOptions) {
+        if (typeof filenameOrOptions === "string") {
+            return {
+                filename: filenameOrOptions,
+                options: { ...(maybeOptions ?? {}), filename: filenameOrOptions },
+            };
+        }
+        const options = filenameOrOptions ?? {};
+        const filename = options.filename ?? ":memory:";
+        return { filename, options: { ...options, filename } };
+    }
+}
+exports.BetterSQLite3Database = BetterSQLite3Database;
+__exportStar(require("./types/node-types"), exports);
+var extension_1 = require("./vscode/extension");
+Object.defineProperty(exports, "createPluresExtension", { enumerable: true, get: function () { return extension_1.createPluresExtension; } });
+Object.defineProperty(exports, "PluresVSCodeExtension", { enumerable: true, get: function () { return extension_1.PluresVSCodeExtension; } });
+//# sourceMappingURL=node-index.js.map