@plures/pluresdb 1.5.3 → 2.9.6

package/dist/node-index.js

@@ -1,665 +0,0 @@
-"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