@sochdb/sochdb 0.4.0

package/dist/esm/query.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * SochDB Query Builder
+ *
+ * Fluent query interface for SochDB.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+/**
+ * Fluent query builder for SochDB.
+ *
+ * @example
+ * ```typescript
+ * const results = await db.query('users/')
+ *   .limit(10)
+ *   .select(['name', 'email'])
+ *   .toList();
+ * ```
+ */
+class Query {
+    _client;
+    _pathPrefix;
+    _limit;
+    _offset;
+    _columns;
+    constructor(client, pathPrefix) {
+        this._client = client;
+        this._pathPrefix = pathPrefix;
+    }
+    /**
+     * Limit the number of results.
+     *
+     * @param n - Maximum number of results to return
+     * @returns This query builder for chaining
+     */
+    limit(n) {
+        this._limit = n;
+        return this;
+    }
+    /**
+     * Skip the first n results.
+     *
+     * @param n - Number of results to skip
+     * @returns This query builder for chaining
+     */
+    offset(n) {
+        this._offset = n;
+        return this;
+    }
+    /**
+     * Select specific columns to return.
+     *
+     * @param columns - Array of column names to select
+     * @returns This query builder for chaining
+     */
+    select(columns) {
+        this._columns = columns;
+        return this;
+    }
+    /**
+     * Execute the query and return results as TOON string.
+     *
+     * @returns TOON formatted string (e.g., "result[N]{cols}: row1; row2")
+     */
+    async execute() {
+        return this._client.query(this._pathPrefix, {
+            limit: this._limit,
+            offset: this._offset,
+            columns: this._columns,
+        });
+    }
+    /**
+     * Execute and parse results into a list of objects.
+     *
+     * @returns Array of result objects
+     */
+    async toList() {
+        const toonStr = await this.execute();
+        return this._parseToon(toonStr);
+    }
+    /**
+     * Execute and return the first result, or null if none.
+     *
+     * @returns First result or null
+     */
+    async first() {
+        const originalLimit = this._limit;
+        this._limit = 1;
+        const results = await this.toList();
+        this._limit = originalLimit;
+        return results.length > 0 ? results[0] : null;
+    }
+    /**
+     * Execute and return the count of results.
+     *
+     * @returns Number of matching results
+     */
+    async count() {
+        const results = await this.toList();
+        return results.length;
+    }
+    /**
+     * Simple TOON parser.
+     *
+     * Parses TOON format: "result[N]{col1,col2}: val1,val2; val3,val4"
+     */
+    _parseToon(toonStr) {
+        if (!toonStr || toonStr === 'result[0]{}:') {
+            return [];
+        }
+        // Parse header: result[N]{cols}:
+        const headerMatch = toonStr.match(/^result\[(\d+)\]\{([^}]*)\}:\s*/);
+        if (!headerMatch) {
+            // Try to parse as JSON if not TOON format
+            try {
+                return JSON.parse(toonStr);
+            }
+            catch {
+                return [];
+            }
+        }
+        const count = parseInt(headerMatch[1], 10);
+        if (count === 0) {
+            return [];
+        }
+        const columns = headerMatch[2].split(',').map((c) => c.trim());
+        const body = toonStr.substring(headerMatch[0].length);
+        // Split rows by semicolon
+        const rows = body.split(';').map((r) => r.trim()).filter((r) => r.length > 0);
+        return rows.map((row) => {
+            const values = row.split(',').map((v) => v.trim());
+            const result = {};
+            columns.forEach((col, idx) => {
+                if (col && idx < values.length) {
+                    // Try to parse as JSON/number
+                    let value = values[idx];
+                    if (value === 'null') {
+                        value = null;
+                    }
+                    else if (value === 'true') {
+                        value = true;
+                    }
+                    else if (value === 'false') {
+                        value = false;
+                    }
+                    else if (!isNaN(Number(value))) {
+                        value = Number(value);
+                    }
+                    result[col] = value;
+                }
+            });
+            return result;
+        });
+    }
+}
+exports.Query = Query;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"query.js","sourceRoot":"","sources":["../../src/query.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SochDB Query Builder\n *\n * Fluent query interface for SochDB.\n *\n * @packageDocumentation\n */\n\n// Copyright 2025 Sushanth (https://github.com/sushanthpy)\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n// You may obtain a copy of the License at\n//\n//     http://www.apache.org/licenses/LICENSE-2.0\n\nimport { IpcClient } from './ipc-client';\n\n/**\n * Query result row.\n */\nexport interface QueryResult {\n  [key: string]: unknown;\n}\n\n/**\n * Fluent query builder for SochDB.\n *\n * @example\n * ```typescript\n * const results = await db.query('users/')\n *   .limit(10)\n *   .select(['name', 'email'])\n *   .toList();\n * ```\n */\nexport class Query {\n  private _client: IpcClient;\n  private _pathPrefix: string;\n  private _limit?: number;\n  private _offset?: number;\n  private _columns?: string[];\n\n  constructor(client: IpcClient, pathPrefix: string) {\n    this._client = client;\n    this._pathPrefix = pathPrefix;\n  }\n\n  /**\n   * Limit the number of results.\n   *\n   * @param n - Maximum number of results to return\n   * @returns This query builder for chaining\n   */\n  limit(n: number): Query {\n    this._limit = n;\n    return this;\n  }\n\n  /**\n   * Skip the first n results.\n   *\n   * @param n - Number of results to skip\n   * @returns This query builder for chaining\n   */\n  offset(n: number): Query {\n    this._offset = n;\n    return this;\n  }\n\n  /**\n   * Select specific columns to return.\n   *\n   * @param columns - Array of column names to select\n   * @returns This query builder for chaining\n   */\n  select(columns: string[]): Query {\n    this._columns = columns;\n    return this;\n  }\n\n  /**\n   * Execute the query and return results as TOON string.\n   *\n   * @returns TOON formatted string (e.g., \"result[N]{cols}: row1; row2\")\n   */\n  async execute(): Promise<string> {\n    return this._client.query(this._pathPrefix, {\n      limit: this._limit,\n      offset: this._offset,\n      columns: this._columns,\n    });\n  }\n\n  /**\n   * Execute and parse results into a list of objects.\n   *\n   * @returns Array of result objects\n   */\n  async toList(): Promise<QueryResult[]> {\n    const toonStr = await this.execute();\n    return this._parseToon(toonStr);\n  }\n\n  /**\n   * Execute and return the first result, or null if none.\n   *\n   * @returns First result or null\n   */\n  async first(): Promise<QueryResult | null> {\n    const originalLimit = this._limit;\n    this._limit = 1;\n    const results = await this.toList();\n    this._limit = originalLimit;\n    return results.length > 0 ? results[0] : null;\n  }\n\n  /**\n   * Execute and return the count of results.\n   *\n   * @returns Number of matching results\n   */\n  async count(): Promise<number> {\n    const results = await this.toList();\n    return results.length;\n  }\n\n  /**\n   * Simple TOON parser.\n   *\n   * Parses TOON format: \"result[N]{col1,col2}: val1,val2; val3,val4\"\n   */\n  private _parseToon(toonStr: string): QueryResult[] {\n    if (!toonStr || toonStr === 'result[0]{}:') {\n      return [];\n    }\n\n    // Parse header: result[N]{cols}:\n    const headerMatch = toonStr.match(/^result\\[(\\d+)\\]\\{([^}]*)\\}:\\s*/);\n    if (!headerMatch) {\n      // Try to parse as JSON if not TOON format\n      try {\n        return JSON.parse(toonStr);\n      } catch {\n        return [];\n      }\n    }\n\n    const count = parseInt(headerMatch[1], 10);\n    if (count === 0) {\n      return [];\n    }\n\n    const columns = headerMatch[2].split(',').map((c) => c.trim());\n    const body = toonStr.substring(headerMatch[0].length);\n\n    // Split rows by semicolon\n    const rows = body.split(';').map((r) => r.trim()).filter((r) => r.length > 0);\n\n    return rows.map((row) => {\n      const values = row.split(',').map((v) => v.trim());\n      const result: QueryResult = {};\n\n      columns.forEach((col, idx) => {\n        if (col && idx < values.length) {\n          // Try to parse as JSON/number\n          let value: unknown = values[idx];\n          if (value === 'null') {\n            value = null;\n          } else if (value === 'true') {\n            value = true;\n          } else if (value === 'false') {\n            value = false;\n          } else if (!isNaN(Number(value))) {\n            value = Number(value);\n          }\n          result[col] = value;\n        }\n      });\n\n      return result;\n    });\n  }\n}\n"]}

package/dist/esm/server-manager.js

@@ -0,0 +1,295 @@
+"use strict";
+/**
+ * SochDB Embedded Server Manager
+ *
+ * Manages the lifecycle of the SochDB server process for embedded mode.
+ * Automatically starts the server when needed and stops it on cleanup.
+ *
+ * @packageDocumentation
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startEmbeddedServer = startEmbeddedServer;
+exports.stopEmbeddedServer = stopEmbeddedServer;
+exports.stopAllEmbeddedServers = stopAllEmbeddedServers;
+exports.isServerRunning = isServerRunning;
+// Copyright 2025 Sushanth (https://github.com/sushanthpy)
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const child_process_1 = require("child_process");
+const errors_1 = require("./errors");
+/**
+ * Find the sochdb-server binary (provides IPC interface)
+ *
+ * Note: sochdb-server uses Unix domain sockets, not available on Windows.
+ * On Windows, use the gRPC client instead for cross-platform compatibility.
+ */
+function findServerBinary() {
+    const platform = process.platform;
+    const arch = process.arch;
+    // Windows doesn't support Unix sockets, sochdb-server is not available
+    if (platform === 'win32') {
+        throw new errors_1.DatabaseError('sochdb-server is not available on Windows (requires Unix domain sockets). ' +
+            'Use the gRPC client for cross-platform support: ' +
+            'const client = await GrpcClient.connect("localhost:50051")');
+    }
+    let target;
+    if (platform === 'darwin') {
+        target = arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+    }
+    else {
+        target = arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';
+    }
+    const binaryName = 'sochdb-server';
+    // Search paths - prioritize bundled binaries
+    const searchPaths = [
+        // Bundled in package (installed via npm) - from dist/cjs or dist/esm
+        path.join(__dirname, '..', '_bin', target, binaryName),
+        path.join(__dirname, '..', '..', '_bin', target, binaryName),
+        path.join(__dirname, '..', '..', '..', '_bin', target, binaryName),
+        // When running from source (src/) during development/testing
+        path.resolve(__dirname, '..', '_bin', target, binaryName),
+        // Development paths - from project root
+        path.join(__dirname, '..', '..', 'target', 'release', binaryName),
+        path.join(__dirname, '..', '..', 'target', 'debug', binaryName),
+        path.join(__dirname, '..', '..', '..', 'target', 'release', binaryName),
+        path.join(__dirname, '..', '..', '..', 'target', 'debug', binaryName),
+        // Absolute paths for sochdb workspace
+        path.resolve(process.cwd(), '_bin', target, binaryName),
+        path.resolve(process.cwd(), 'target', 'release', binaryName),
+        path.resolve(process.cwd(), '..', 'target', 'release', binaryName),
+    ];
+    for (const p of searchPaths) {
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    // Try PATH
+    const pathDirs = (process.env.PATH || '').split(path.delimiter);
+    for (const dir of pathDirs) {
+        const p = path.join(dir, binaryName);
+        if (fs.existsSync(p)) {
+            return p;
+        }
+    }
+    throw new errors_1.DatabaseError(`Could not find ${binaryName}. ` +
+        `The pre-built binary may not be available for your platform (${platform}/${arch}). ` +
+        `Install via: cargo build --release -p sochdb-tools`);
+}
+/**
+ * Wait for a Unix socket to become available
+ */
+async function waitForSocket(socketPath, timeoutMs = 10000) {
+    const startTime = Date.now();
+    const checkInterval = 100;
+    while (Date.now() - startTime < timeoutMs) {
+        if (fs.existsSync(socketPath)) {
+            // Try to connect to verify it's actually listening
+            try {
+                await new Promise((resolve, reject) => {
+                    const socket = net.createConnection({ path: socketPath }, () => {
+                        socket.destroy();
+                        resolve();
+                    });
+                    socket.on('error', reject);
+                    socket.setTimeout(1000);
+                });
+                return;
+            }
+            catch {
+                // Socket exists but not ready yet
+            }
+        }
+        await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+    throw new errors_1.ConnectionError(`Timeout waiting for server socket at ${socketPath} after ${timeoutMs}ms`);
+}
+// Track running server instances
+const runningServers = new Map();
+/**
+ * Start an embedded SochDB server for the given database path.
+ * If a server is already running for this path, return the existing instance.
+ *
+ * @param dbPath - Path to the database directory
+ * @returns The socket path for connecting
+ */
+async function startEmbeddedServer(dbPath) {
+    const absolutePath = path.resolve(dbPath);
+    const socketPath = path.join(absolutePath, 'sochdb.sock');
+    // Check if server already running for this path
+    const existing = runningServers.get(absolutePath);
+    if (existing && existing.process.exitCode === null) {
+        // Server still running
+        return socketPath;
+    }
+    // Check if another process already has a server running
+    if (fs.existsSync(socketPath)) {
+        try {
+            // Try to connect - if successful, server is running
+            await waitForSocket(socketPath, 1000);
+            return socketPath;
+        }
+        catch {
+            // Socket exists but dead - clean it up
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch {
+                // Ignore
+            }
+        }
+    }
+    // Ensure database directory exists
+    if (!fs.existsSync(absolutePath)) {
+        fs.mkdirSync(absolutePath, { recursive: true });
+    }
+    // Find and spawn server
+    const serverBinary = findServerBinary();
+    const serverProcess = (0, child_process_1.spawn)(serverBinary, ['--db', absolutePath, '--socket', socketPath], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: false,
+    });
+    // Collect stderr for error reporting
+    let stderrOutput = '';
+    serverProcess.stderr?.on('data', (data) => {
+        stderrOutput += data.toString();
+    });
+    // Handle process exit
+    serverProcess.on('exit', (code, signal) => {
+        runningServers.delete(absolutePath);
+        if (code !== 0 && code !== null) {
+            console.error(`SochDB server exited with code ${code}: ${stderrOutput}`);
+        }
+    });
+    serverProcess.on('error', (err) => {
+        runningServers.delete(absolutePath);
+        console.error(`Failed to start SochDB server: ${err.message}`);
+    });
+    // Store instance
+    runningServers.set(absolutePath, {
+        process: serverProcess,
+        socketPath,
+        dbPath: absolutePath,
+    });
+    // Wait for server to be ready
+    try {
+        await waitForSocket(socketPath, 10000);
+    }
+    catch (err) {
+        // Kill the process if it didn't start properly
+        serverProcess.kill();
+        runningServers.delete(absolutePath);
+        throw new errors_1.DatabaseError(`Failed to start embedded server: ${stderrOutput || err.message}`);
+    }
+    return socketPath;
+}
+/**
+ * Stop the embedded server for a specific database path
+ */
+async function stopEmbeddedServer(dbPath) {
+    const absolutePath = path.resolve(dbPath);
+    const instance = runningServers.get(absolutePath);
+    if (!instance) {
+        return;
+    }
+    // Send SIGTERM and wait for graceful shutdown
+    instance.process.kill('SIGTERM');
+    // Wait for process to exit (max 5 seconds)
+    await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            // Force kill if still running
+            if (instance.process.exitCode === null) {
+                instance.process.kill('SIGKILL');
+            }
+            resolve();
+        }, 5000);
+        instance.process.on('exit', () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+    });
+    runningServers.delete(absolutePath);
+    // Clean up socket file
+    try {
+        if (fs.existsSync(instance.socketPath)) {
+            fs.unlinkSync(instance.socketPath);
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Stop all running embedded servers
+ */
+async function stopAllEmbeddedServers() {
+    const stopPromises = [];
+    for (const [dbPath] of runningServers) {
+        stopPromises.push(stopEmbeddedServer(dbPath));
+    }
+    await Promise.all(stopPromises);
+}
+/**
+ * Check if an embedded server is running for a database path
+ */
+function isServerRunning(dbPath) {
+    const absolutePath = path.resolve(dbPath);
+    const instance = runningServers.get(absolutePath);
+    return instance !== undefined && instance.process.exitCode === null;
+}
+// Cleanup on process exit
+process.on('exit', () => {
+    for (const instance of runningServers.values()) {
+        try {
+            instance.process.kill('SIGKILL');
+        }
+        catch {
+            // Ignore
+        }
+    }
+});
+process.on('SIGINT', async () => {
+    await stopAllEmbeddedServers();
+    process.exit(0);
+});
+process.on('SIGTERM', async () => {
+    await stopAllEmbeddedServers();
+    process.exit(0);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"server-manager.js","sourceRoot":"","sources":["../../src/server-manager.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqIH,kDA+EC;AAKD,gDAqCC;AAKD,wDAMC;AAKD,0CAIC;AAhRD,0DAA0D;AAC1D,EAAE;AACF,kEAAkE;AAClE,mEAAmE;AAEnE,uCAAyB;AACzB,2CAA6B;AAC7B,yCAA2B;AAC3B,iDAAoD;AACpD,qCAA0D;AAE1D;;;;;GAKG;AACH,SAAS,gBAAgB;IACvB,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAE1B,uEAAuE;IACvE,IAAI,QAAQ,KAAK,OAAO,EAAE,CAAC;QACzB,MAAM,IAAI,sBAAa,CACrB,4EAA4E;YAC5E,kDAAkD;YAClD,4DAA4D,CAC7D,CAAC;IACJ,CAAC;IAED,IAAI,MAAc,CAAC;IACnB,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,qBAAqB,CAAC;IAC7E,CAAC;SAAM,CAAC;QACN,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,2BAA2B,CAAC,CAAC,CAAC,0BAA0B,CAAC;IACvF,CAAC;IAED,MAAM,UAAU,GAAG,eAAe,CAAC;IAEnC,6CAA6C;IAC7C,MAAM,WAAW,GAAG;QAClB,qEAAqE;QACrE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC;QACtD,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC;QAC5D,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC;QAClE,6DAA6D;QAC7D,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC;QACzD,wCAAwC;QACxC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;QACjE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC;QAC/D,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;QACvE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,UAAU,CAAC;QACrE,sCAAsC;QACtC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC;QACvD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;QAC5D,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,CAAC;KACnE,CAAC;IAEF,KAAK,MAAM,CAAC,IAAI,WAAW,EAAE,CAAC;QAC5B,IAAI,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAED,WAAW;IACX,MAAM,QAAQ,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChE,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;QAC3B,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;QACrC,IAAI,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;IAED,MAAM,IAAI,sBAAa,CACrB,kBAAkB,UAAU,IAAI;QAChC,gEAAgE,QAAQ,IAAI,IAAI,KAAK;QACrF,oDAAoD,CACrD,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,aAAa,CAAC,UAAkB,EAAE,YAAoB,KAAK;IACxE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,aAAa,GAAG,GAAG,CAAC;IAE1B,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,SAAS,EAAE,CAAC;QAC1C,IAAI,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;YAC9B,mDAAmD;YACnD,IAAI,CAAC;gBACH,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;oBAC1C,MAAM,MAAM,GAAG,GAAG,CAAC,gBAAgB,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE,GAAG,EAAE;wBAC7D,MAAM,CAAC,OAAO,EAAE,CAAC;wBACjB,OAAO,EAAE,CAAC;oBACZ,CAAC,CAAC,CAAC;oBACH,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;oBAC3B,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;gBAC1B,CAAC,CAAC,CAAC;gBACH,OAAO;YACT,CAAC;YAAC,MAAM,CAAC;gBACP,kCAAkC;YACpC,CAAC;QACH,CAAC;QACD,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC;IACnE,CAAC;IAED,MAAM,IAAI,wBAAe,CACvB,wCAAwC,UAAU,UAAU,SAAS,IAAI,CAC1E,CAAC;AACJ,CAAC;AAWD,iCAAiC;AACjC,MAAM,cAAc,GAAgC,IAAI,GAAG,EAAE,CAAC;AAE9D;;;;;;GAMG;AACI,KAAK,UAAU,mBAAmB,CAAC,MAAc;IACtD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,CAAC;IAE1D,gDAAgD;IAChD,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAClD,IAAI,QAAQ,IAAI,QAAQ,CAAC,OAAO,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;QACnD,uBAAuB;QACvB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,wDAAwD;IACxD,IAAI,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QAC9B,IAAI,CAAC;YACH,oDAAoD;YACpD,MAAM,aAAa,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;YACtC,OAAO,UAAU,CAAC;QACpB,CAAC;QAAC,MAAM,CAAC;YACP,uCAAuC;YACvC,IAAI,CAAC;gBACH,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;YAC5B,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS;YACX,CAAC;QACH,CAAC;IACH,CAAC;IAED,mCAAmC;IACnC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QACjC,EAAE,CAAC,SAAS,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IAClD,CAAC;IAED,wBAAwB;IACxB,MAAM,YAAY,GAAG,gBAAgB,EAAE,CAAC;IAExC,MAAM,aAAa,GAAG,IAAA,qBAAK,EAAC,YAAY,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE;QACxF,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC;QACjC,QAAQ,EAAE,KAAK;KAChB,CAAC,CAAC;IAEH,qCAAqC;IACrC,IAAI,YAAY,GAAG,EAAE,CAAC;IACtB,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE;QACxC,YAAY,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,sBAAsB;IACtB,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE;QACxC,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACpC,IAAI,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;YAChC,OAAO,CAAC,KAAK,CAAC,kCAAkC,IAAI,KAAK,YAAY,EAAE,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE;QAChC,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACpC,OAAO,CAAC,KAAK,CAAC,kCAAkC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IACjE,CAAC,CAAC,CAAC;IAEH,iBAAiB;IACjB,cAAc,CAAC,GAAG,CAAC,YAAY,EAAE;QAC/B,OAAO,EAAE,aAAa;QACtB,UAAU;QACV,MAAM,EAAE,YAAY;KACrB,CAAC,CAAC;IAEH,8BAA8B;IAC9B,IAAI,CAAC;QACH,MAAM,aAAa,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,+CAA+C;QAC/C,aAAa,CAAC,IAAI,EAAE,CAAC;QACrB,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QACpC,MAAM,IAAI,sBAAa,CACrB,oCAAoC,YAAY,IAAK,GAAa,CAAC,OAAO,EAAE,CAC7E,CAAC;IACJ,CAAC;IAED,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,kBAAkB,CAAC,MAAc;IACrD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAElD,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO;IACT,CAAC;IAED,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAEjC,2CAA2C;IAC3C,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;QAClC,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;YAC9B,8BAA8B;YAC9B,IAAI,QAAQ,CAAC,OAAO,CAAC,QAAQ,KAAK,IAAI,EAAE,CAAC;gBACvC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACnC,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC,EAAE,IAAI,CAAC,CAAC;QAET,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;YAC/B,YAAY,CAAC,OAAO,CAAC,CAAC;YACtB,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;IAEH,cAAc,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;IAEpC,uBAAuB;IACvB,IAAI,CAAC;QACH,IAAI,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACvC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAAC,MAAM,CAAC;QACP,wBAAwB;IAC1B,CAAC;AACH,CAAC;AAED;;GAEG;AACI,KAAK,UAAU,sBAAsB;IAC1C,MAAM,YAAY,GAAoB,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,cAAc,EAAE,CAAC;QACtC,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,CAAC;IACD,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;AAClC,CAAC;AAED;;GAEG;AACH,SAAgB,eAAe,CAAC,MAAc;IAC5C,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAClD,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC;AACtE,CAAC;AAED,0BAA0B;AAC1B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;IACtB,KAAK,MAAM,QAAQ,IAAI,cAAc,CAAC,MAAM,EAAE,EAAE,CAAC;QAC/C,IAAI,CAAC;YACH,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACnC,CAAC;QAAC,MAAM,CAAC;YACP,SAAS;QACX,CAAC;IACH,CAAC;AACH,CAAC,CAAC,CAAC;AAEH,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,KAAK,IAAI,EAAE;IAC9B,MAAM,sBAAsB,EAAE,CAAC;IAC/B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC;AAEH,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,KAAK,IAAI,EAAE;IAC/B,MAAM,sBAAsB,EAAE,CAAC;IAC/B,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC","sourcesContent":["/**\n * SochDB Embedded Server Manager\n *\n * Manages the lifecycle of the SochDB server process for embedded mode.\n * Automatically starts the server when needed and stops it on cleanup.\n *\n * @packageDocumentation\n */\n\n// Copyright 2025 Sushanth (https://github.com/sushanthpy)\n//\n// Licensed under the Apache License, Version 2.0 (the \"License\");\n// you may not use this file except in compliance with the License.\n\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as net from 'net';\nimport { spawn, ChildProcess } from 'child_process';\nimport { ConnectionError, DatabaseError } from './errors';\n\n/**\n * Find the sochdb-server binary (provides IPC interface)\n * \n * Note: sochdb-server uses Unix domain sockets, not available on Windows.\n * On Windows, use the gRPC client instead for cross-platform compatibility.\n */\nfunction findServerBinary(): string {\n  const platform = process.platform;\n  const arch = process.arch;\n\n  // Windows doesn't support Unix sockets, sochdb-server is not available\n  if (platform === 'win32') {\n    throw new DatabaseError(\n      'sochdb-server is not available on Windows (requires Unix domain sockets). ' +\n      'Use the gRPC client for cross-platform support: ' +\n      'const client = await GrpcClient.connect(\"localhost:50051\")'\n    );\n  }\n\n  let target: string;\n  if (platform === 'darwin') {\n    target = arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';\n  } else {\n    target = arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';\n  }\n\n  const binaryName = 'sochdb-server';\n\n  // Search paths - prioritize bundled binaries\n  const searchPaths = [\n    // Bundled in package (installed via npm) - from dist/cjs or dist/esm\n    path.join(__dirname, '..', '_bin', target, binaryName),\n    path.join(__dirname, '..', '..', '_bin', target, binaryName),\n    path.join(__dirname, '..', '..', '..', '_bin', target, binaryName),\n    // When running from source (src/) during development/testing\n    path.resolve(__dirname, '..', '_bin', target, binaryName),\n    // Development paths - from project root\n    path.join(__dirname, '..', '..', 'target', 'release', binaryName),\n    path.join(__dirname, '..', '..', 'target', 'debug', binaryName),\n    path.join(__dirname, '..', '..', '..', 'target', 'release', binaryName),\n    path.join(__dirname, '..', '..', '..', 'target', 'debug', binaryName),\n    // Absolute paths for sochdb workspace\n    path.resolve(process.cwd(), '_bin', target, binaryName),\n    path.resolve(process.cwd(), 'target', 'release', binaryName),\n    path.resolve(process.cwd(), '..', 'target', 'release', binaryName),\n  ];\n\n  for (const p of searchPaths) {\n    if (fs.existsSync(p)) {\n      return p;\n    }\n  }\n\n  // Try PATH\n  const pathDirs = (process.env.PATH || '').split(path.delimiter);\n  for (const dir of pathDirs) {\n    const p = path.join(dir, binaryName);\n    if (fs.existsSync(p)) {\n      return p;\n    }\n  }\n\n  throw new DatabaseError(\n    `Could not find ${binaryName}. ` +\n    `The pre-built binary may not be available for your platform (${platform}/${arch}). ` +\n    `Install via: cargo build --release -p sochdb-tools`\n  );\n}\n\n/**\n * Wait for a Unix socket to become available\n */\nasync function waitForSocket(socketPath: string, timeoutMs: number = 10000): Promise<void> {\n  const startTime = Date.now();\n  const checkInterval = 100;\n\n  while (Date.now() - startTime < timeoutMs) {\n    if (fs.existsSync(socketPath)) {\n      // Try to connect to verify it's actually listening\n      try {\n        await new Promise<void>((resolve, reject) => {\n          const socket = net.createConnection({ path: socketPath }, () => {\n            socket.destroy();\n            resolve();\n          });\n          socket.on('error', reject);\n          socket.setTimeout(1000);\n        });\n        return;\n      } catch {\n        // Socket exists but not ready yet\n      }\n    }\n    await new Promise(resolve => setTimeout(resolve, checkInterval));\n  }\n\n  throw new ConnectionError(\n    `Timeout waiting for server socket at ${socketPath} after ${timeoutMs}ms`\n  );\n}\n\n/**\n * Embedded server instance\n */\ninterface ServerInstance {\n  process: ChildProcess;\n  socketPath: string;\n  dbPath: string;\n}\n\n// Track running server instances\nconst runningServers: Map<string, ServerInstance> = new Map();\n\n/**\n * Start an embedded SochDB server for the given database path.\n * If a server is already running for this path, return the existing instance.\n *\n * @param dbPath - Path to the database directory\n * @returns The socket path for connecting\n */\nexport async function startEmbeddedServer(dbPath: string): Promise<string> {\n  const absolutePath = path.resolve(dbPath);\n  const socketPath = path.join(absolutePath, 'sochdb.sock');\n\n  // Check if server already running for this path\n  const existing = runningServers.get(absolutePath);\n  if (existing && existing.process.exitCode === null) {\n    // Server still running\n    return socketPath;\n  }\n\n  // Check if another process already has a server running\n  if (fs.existsSync(socketPath)) {\n    try {\n      // Try to connect - if successful, server is running\n      await waitForSocket(socketPath, 1000);\n      return socketPath;\n    } catch {\n      // Socket exists but dead - clean it up\n      try {\n        fs.unlinkSync(socketPath);\n      } catch {\n        // Ignore\n      }\n    }\n  }\n\n  // Ensure database directory exists\n  if (!fs.existsSync(absolutePath)) {\n    fs.mkdirSync(absolutePath, { recursive: true });\n  }\n\n  // Find and spawn server\n  const serverBinary = findServerBinary();\n  \n  const serverProcess = spawn(serverBinary, ['--db', absolutePath, '--socket', socketPath], {\n    stdio: ['ignore', 'pipe', 'pipe'],\n    detached: false,\n  });\n\n  // Collect stderr for error reporting\n  let stderrOutput = '';\n  serverProcess.stderr?.on('data', (data) => {\n    stderrOutput += data.toString();\n  });\n\n  // Handle process exit\n  serverProcess.on('exit', (code, signal) => {\n    runningServers.delete(absolutePath);\n    if (code !== 0 && code !== null) {\n      console.error(`SochDB server exited with code ${code}: ${stderrOutput}`);\n    }\n  });\n\n  serverProcess.on('error', (err) => {\n    runningServers.delete(absolutePath);\n    console.error(`Failed to start SochDB server: ${err.message}`);\n  });\n\n  // Store instance\n  runningServers.set(absolutePath, {\n    process: serverProcess,\n    socketPath,\n    dbPath: absolutePath,\n  });\n\n  // Wait for server to be ready\n  try {\n    await waitForSocket(socketPath, 10000);\n  } catch (err) {\n    // Kill the process if it didn't start properly\n    serverProcess.kill();\n    runningServers.delete(absolutePath);\n    throw new DatabaseError(\n      `Failed to start embedded server: ${stderrOutput || (err as Error).message}`\n    );\n  }\n\n  return socketPath;\n}\n\n/**\n * Stop the embedded server for a specific database path\n */\nexport async function stopEmbeddedServer(dbPath: string): Promise<void> {\n  const absolutePath = path.resolve(dbPath);\n  const instance = runningServers.get(absolutePath);\n\n  if (!instance) {\n    return;\n  }\n\n  // Send SIGTERM and wait for graceful shutdown\n  instance.process.kill('SIGTERM');\n\n  // Wait for process to exit (max 5 seconds)\n  await new Promise<void>((resolve) => {\n    const timeout = setTimeout(() => {\n      // Force kill if still running\n      if (instance.process.exitCode === null) {\n        instance.process.kill('SIGKILL');\n      }\n      resolve();\n    }, 5000);\n\n    instance.process.on('exit', () => {\n      clearTimeout(timeout);\n      resolve();\n    });\n  });\n\n  runningServers.delete(absolutePath);\n\n  // Clean up socket file\n  try {\n    if (fs.existsSync(instance.socketPath)) {\n      fs.unlinkSync(instance.socketPath);\n    }\n  } catch {\n    // Ignore cleanup errors\n  }\n}\n\n/**\n * Stop all running embedded servers\n */\nexport async function stopAllEmbeddedServers(): Promise<void> {\n  const stopPromises: Promise<void>[] = [];\n  for (const [dbPath] of runningServers) {\n    stopPromises.push(stopEmbeddedServer(dbPath));\n  }\n  await Promise.all(stopPromises);\n}\n\n/**\n * Check if an embedded server is running for a database path\n */\nexport function isServerRunning(dbPath: string): boolean {\n  const absolutePath = path.resolve(dbPath);\n  const instance = runningServers.get(absolutePath);\n  return instance !== undefined && instance.process.exitCode === null;\n}\n\n// Cleanup on process exit\nprocess.on('exit', () => {\n  for (const instance of runningServers.values()) {\n    try {\n      instance.process.kill('SIGKILL');\n    } catch {\n      // Ignore\n    }\n  }\n});\n\nprocess.on('SIGINT', async () => {\n  await stopAllEmbeddedServers();\n  process.exit(0);\n});\n\nprocess.on('SIGTERM', async () => {\n  await stopAllEmbeddedServers();\n  process.exit(0);\n});\n"]}