leangraph 1.0.0

package/dist/db.js

@@ -0,0 +1,720 @@
+// Database Wrapper for SQLite
+import Database from "better-sqlite3";
+// ============================================================================
+// Schema
+// ============================================================================
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS nodes (
+    id TEXT PRIMARY KEY,
+    label JSON NOT NULL,
+    properties JSON DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL,
+    source_id TEXT NOT NULL,
+    target_id TEXT NOT NULL,
+    properties JSON DEFAULT '{}',
+    FOREIGN KEY (source_id) REFERENCES nodes(id) ON DELETE CASCADE,
+    FOREIGN KEY (target_id) REFERENCES nodes(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_edges_type ON edges(type);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+`;
+// ============================================================================
+// Helpers
+// ============================================================================
+/**
+ * Convert a parameter value for SQLite binding.
+ * Large integers (outside JavaScript's safe integer range) are converted to BigInt
+ * to ensure SQLite treats them as INTEGER rather than REAL (which loses precision).
+ *
+ * Important: We convert via string representation to preserve the value that JavaScript
+ * would serialize (e.g., to JSON), rather than the internal floating-point representation
+ * which may differ for large integers.
+ */
+function convertParamForSqlite(value) {
+    if (typeof value === "number" && Number.isInteger(value) && !Number.isSafeInteger(value)) {
+        // Large integer: convert to BigInt via string to preserve the serialized representation
+        // This ensures consistency with JSON.stringify() behavior
+        return BigInt(String(value));
+    }
+    return value;
+}
+/**
+ * Convert all params in an array for SQLite binding.
+ */
+function convertParamsForSqlite(params) {
+    return params.map(convertParamForSqlite);
+}
+// ============================================================================
+// Database Class
+// ============================================================================
+// ============================================================================
+// Custom SQL Functions for Cypher Semantics
+// ============================================================================
+/**
+ * Deep equality comparison with Cypher's three-valued logic.
+ * Returns: 1 (true), 0 (false), or null (unknown when comparing with null)
+ */
+function deepCypherEquals(a, b) {
+    // Both null/undefined -> null (unknown if null equals null)
+    if (a === null && b === null)
+        return null;
+    // One null -> null (unknown)
+    if (a === null || b === null)
+        return null;
+    // Arrays
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return 0; // false
+        if (a.length === 0)
+            return 1; // true
+        let hasNull = false;
+        for (let i = 0; i < a.length; i++) {
+            const cmp = deepCypherEquals(a[i], b[i]);
+            if (cmp === null)
+                hasNull = true;
+            else if (cmp === 0)
+                return 0; // false
+        }
+        return hasNull ? null : 1;
+    }
+    // Objects (maps)
+    if (typeof a === "object" && typeof b === "object" && a !== null && b !== null && !Array.isArray(a) && !Array.isArray(b)) {
+        const keysA = Object.keys(a).sort();
+        const keysB = Object.keys(b).sort();
+        if (keysA.length !== keysB.length)
+            return 0;
+        if (keysA.join(",") !== keysB.join(","))
+            return 0;
+        let hasNull = false;
+        for (const k of keysA) {
+            const cmp = deepCypherEquals(a[k], b[k]);
+            if (cmp === null)
+                hasNull = true;
+            else if (cmp === 0)
+                return 0;
+        }
+        return hasNull ? null : 1;
+    }
+    // Primitives
+    return a === b ? 1 : 0;
+}
+/**
+ * Get the Cypher type category for ordering comparisons.
+ * Returns a type string for values that can be ordered, or null for non-orderable types.
+ *
+ * When using SQLite's -> operator for JSON extraction, values come as JSON-formatted strings:
+ * - 'true' / 'false' for booleans
+ * - '"string"' for strings (with quotes)
+ * - '123' or '3.14' for numbers (no quotes)
+ * - '[...]' for arrays
+ * - '{...}' for objects
+ */
+// Regex patterns for temporal types
+const TIME_PATTERN = /^\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+const LOCALTIME_PATTERN = /^\d{2}:\d{2}(:\d{2})?(\.\d+)?$/;
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const DATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?(Z|[+-]\d{2}:\d{2})?(\[.+\])?$/;
+const LOCALDATETIME_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2})?(\.\d+)?$/;
+function getCypherTypeForOrdering(value) {
+    if (value === null)
+        return null;
+    const jsType = typeof value;
+    // Numbers (integer and real) are in the same ordering category
+    if (jsType === "number" || jsType === "bigint")
+        return "number";
+    // Strings - could be raw strings OR JSON-formatted values from -> operator
+    if (jsType === "string") {
+        const s = value;
+        // Check for JSON boolean literals (from -> operator)
+        if (s === "true" || s === "false")
+            return "boolean";
+        // Check for JSON null
+        if (s === "null")
+            return null;
+        // Check for JSON array
+        if (s.startsWith("[") && s.endsWith("]")) {
+            try {
+                JSON.parse(s);
+                return "array"; // arrays are not orderable
+            }
+            catch {
+                // Not valid JSON, treat as string
+            }
+        }
+        // Check for JSON object  
+        if (s.startsWith("{") && s.endsWith("}")) {
+            try {
+                JSON.parse(s);
+                return "object"; // objects are not orderable
+            }
+            catch {
+                // Not valid JSON, treat as string
+            }
+        }
+        // Check for JSON string literal (starts and ends with quotes)
+        if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) {
+            return "string";
+        }
+        // Check for JSON number (no quotes, valid number)
+        if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(s)) {
+            return "number";
+        }
+        // Check for temporal types (times with timezone need special comparison)
+        if (TIME_PATTERN.test(s))
+            return "time";
+        if (DATETIME_PATTERN.test(s))
+            return "datetime";
+        if (DATE_PATTERN.test(s))
+            return "date";
+        if (LOCALTIME_PATTERN.test(s))
+            return "localtime";
+        if (LOCALDATETIME_PATTERN.test(s))
+            return "localdatetime";
+        // Otherwise treat as a plain string
+        return "string";
+    }
+    // Booleans - SQLite stores these as integers, but if we somehow get a JS boolean
+    if (jsType === "boolean")
+        return "boolean";
+    // Objects and arrays in JS form (shouldn't normally happen with SQLite)
+    if (Array.isArray(value))
+        return "array";
+    if (jsType === "object")
+        return "object";
+    return null;
+}
+/**
+ * Check if two Cypher types are compatible for ordering comparisons (<, <=, >, >=).
+ */
+function areCypherTypesOrderable(typeA, typeB) {
+    if (typeA === null || typeB === null)
+        return false;
+    // Arrays, objects, nodes, relationships are not orderable
+    if (typeA === "array" || typeB === "array")
+        return false;
+    if (typeA === "object" || typeB === "object")
+        return false;
+    // Same type is always orderable
+    if (typeA === typeB)
+        return true;
+    // Numbers (integer/real) are orderable with each other - already handled by "number" category
+    return false;
+}
+/**
+ * Parse timezone offset to minutes from UTC
+ */
+function parseTimezoneOffset(tz) {
+    if (tz === "Z" || tz === "+00:00")
+        return 0;
+    const sign = tz[0] === "-" ? -1 : 1;
+    const hours = parseInt(tz.slice(1, 3), 10);
+    const minutes = parseInt(tz.slice(4, 6), 10);
+    return sign * (hours * 60 + minutes);
+}
+/**
+ * Convert time string to nanoseconds from midnight UTC for comparison
+ */
+function timeToNanosUTC(timeStr) {
+    // Format: HH:MM or HH:MM:SS or HH:MM:SS.nnnnnnnnn followed by Z or +HH:MM or -HH:MM
+    // May also have [timezone] suffix - strip it
+    const withoutTzName = timeStr.replace(/\[.+\]$/, "");
+    // Find timezone part
+    let tzOffset = 0;
+    let timePart = withoutTzName;
+    if (withoutTzName.endsWith("Z")) {
+        timePart = withoutTzName.slice(0, -1);
+        tzOffset = 0;
+    }
+    else {
+        const tzMatch = withoutTzName.match(/([+-]\d{2}:\d{2})$/);
+        if (tzMatch) {
+            tzOffset = parseTimezoneOffset(tzMatch[1]);
+            timePart = withoutTzName.slice(0, -6);
+        }
+    }
+    // Parse time components
+    const parts = timePart.split(":");
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+    let seconds = 0;
+    let nanos = 0;
+    if (parts[2]) {
+        const secParts = parts[2].split(".");
+        seconds = parseInt(secParts[0], 10);
+        if (secParts[1]) {
+            // Pad or truncate to 9 digits
+            const fracStr = secParts[1].padEnd(9, "0").slice(0, 9);
+            nanos = parseInt(fracStr, 10);
+        }
+    }
+    // Convert to total nanoseconds from midnight, then adjust for timezone
+    const totalMinutes = hours * 60 + minutes - tzOffset;
+    const totalNanos = (totalMinutes * 60 + seconds) * 1_000_000_000 + nanos;
+    // Normalize to 24-hour range (handle negative from timezone adjustment)
+    const dayInNanos = 24 * 60 * 60 * 1_000_000_000;
+    return ((totalNanos % dayInNanos) + dayInNanos) % dayInNanos;
+}
+/**
+ * Convert a value to its comparable form.
+ * For JSON-formatted strings from -> operator, parse to get actual value.
+ * For temporal types, convert to a form suitable for comparison.
+ */
+function toComparableValue(value, type) {
+    if (typeof value === "string") {
+        if (type === "number") {
+            return parseFloat(value);
+        }
+        if (type === "boolean") {
+            return value === "true";
+        }
+        if (type === "string") {
+            // JSON string literal - remove outer quotes
+            if (value.startsWith('"') && value.endsWith('"')) {
+                return value.slice(1, -1);
+            }
+            return value;
+        }
+        if (type === "time") {
+            // Convert to nanoseconds from midnight UTC for comparison
+            return timeToNanosUTC(value);
+        }
+        if (type === "datetime") {
+            // Strip [timezone] suffix and compare lexically (ISO format is naturally sortable when in UTC or same TZ)
+            // For proper comparison, we'd need to convert to UTC, but for same-offset datetimes, lexical works
+            // TODO: Full timezone-aware datetime comparison
+            return value.replace(/\[.+\]$/, "");
+        }
+        // date, localtime, localdatetime can be compared lexically (ISO format is sortable)
+        if (type === "date" || type === "localtime" || type === "localdatetime") {
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Helper to convert SQLite boolean representation to JavaScript boolean.
+ * SQLite can represent booleans as: 1, 0, 'true', 'false'
+ */
+function toBoolValue(x) {
+    if (x === null || x === undefined)
+        return null;
+    if (x === 1 || x === true || x === 'true')
+        return true;
+    if (x === 0 || x === false || x === 'false')
+        return false;
+    return null;
+}
+/**
+ * Register custom SQL functions for Cypher semantics on a database instance.
+ */
+function registerCypherFunctions(db) {
+    // cypher_not: Proper boolean negation that works with both JSON booleans and integers
+    // Converts json('true')/1 -> 0, json('false')/0 -> 1, null -> null
+    // Returns integers for SQLite compatibility in WHERE clauses
+    db.function("cypher_not", { deterministic: true }, (x) => {
+        const b = toBoolValue(x);
+        if (b === null)
+            return null;
+        return b ? 0 : 1;
+    });
+    // cypher_and: Proper boolean AND that works with both JSON booleans and integers
+    // Returns integers for SQLite compatibility in WHERE clauses
+    db.function("cypher_and", { deterministic: true }, (a, b) => {
+        const boolA = toBoolValue(a);
+        const boolB = toBoolValue(b);
+        // Cypher AND with NULL: false AND NULL = false, true AND NULL = NULL
+        if (boolA === false || boolB === false)
+            return 0;
+        if (boolA === null || boolB === null)
+            return null;
+        return boolA && boolB ? 1 : 0;
+    });
+    // cypher_or: Proper boolean OR that works with both JSON booleans and integers
+    // Returns integers for SQLite compatibility in WHERE clauses
+    db.function("cypher_or", { deterministic: true }, (a, b) => {
+        const boolA = toBoolValue(a);
+        const boolB = toBoolValue(b);
+        // Cypher OR with NULL: true OR NULL = true, false OR NULL = NULL
+        if (boolA === true || boolB === true)
+            return 1;
+        if (boolA === null || boolB === null)
+            return null;
+        return boolA || boolB ? 1 : 0;
+    });
+    // cypher_compare: Type-aware comparison for ordering operators (<, <=, >, >=)
+    // Returns: 1 if condition is true, 0 if false, null if types are incompatible
+    db.function("cypher_lt", { deterministic: true }, (a, b) => {
+        if (a === null || a === undefined || b === null || b === undefined)
+            return null;
+        const typeA = getCypherTypeForOrdering(a);
+        const typeB = getCypherTypeForOrdering(b);
+        if (!areCypherTypesOrderable(typeA, typeB))
+            return null;
+        const valA = toComparableValue(a, typeA);
+        const valB = toComparableValue(b, typeB);
+        return valA < valB ? 1 : 0;
+    });
+    db.function("cypher_lte", { deterministic: true }, (a, b) => {
+        if (a === null || a === undefined || b === null || b === undefined)
+            return null;
+        const typeA = getCypherTypeForOrdering(a);
+        const typeB = getCypherTypeForOrdering(b);
+        if (!areCypherTypesOrderable(typeA, typeB))
+            return null;
+        const valA = toComparableValue(a, typeA);
+        const valB = toComparableValue(b, typeB);
+        return valA <= valB ? 1 : 0;
+    });
+    db.function("cypher_gt", { deterministic: true }, (a, b) => {
+        if (a === null || a === undefined || b === null || b === undefined)
+            return null;
+        const typeA = getCypherTypeForOrdering(a);
+        const typeB = getCypherTypeForOrdering(b);
+        if (!areCypherTypesOrderable(typeA, typeB))
+            return null;
+        const valA = toComparableValue(a, typeA);
+        const valB = toComparableValue(b, typeB);
+        return valA > valB ? 1 : 0;
+    });
+    db.function("cypher_gte", { deterministic: true }, (a, b) => {
+        if (a === null || a === undefined || b === null || b === undefined)
+            return null;
+        const typeA = getCypherTypeForOrdering(a);
+        const typeB = getCypherTypeForOrdering(b);
+        if (!areCypherTypesOrderable(typeA, typeB))
+            return null;
+        const valA = toComparableValue(a, typeA);
+        const valB = toComparableValue(b, typeB);
+        return valA >= valB ? 1 : 0;
+    });
+    // cypher_equals: Null-aware deep equality for lists and maps
+    db.function("cypher_equals", { deterministic: true }, (a, b) => {
+        // Handle SQL NULL
+        if (a === null && b === null)
+            return null;
+        if (a === null || b === null)
+            return null;
+        // Try to parse as JSON (for arrays/objects stored as JSON strings)
+        let parsedA, parsedB;
+        try {
+            parsedA = typeof a === "string" ? JSON.parse(a) : a;
+        }
+        catch {
+            parsedA = a;
+        }
+        try {
+            parsedB = typeof b === "string" ? JSON.parse(b) : b;
+        }
+        catch {
+            parsedB = b;
+        }
+        return deepCypherEquals(parsedA, parsedB);
+    });
+    // cypher_case_eq: Type-aware equality for CASE expressions
+    // Takes value+type pairs to preserve type information across SQLite's type coercion
+    // Returns: 1 if equal (same type and value), 0 if not equal
+    db.function("cypher_case_eq", { deterministic: true }, (val1, type1, val2, type2) => {
+        // NULL handling: if either is null, return null (unknown)
+        if (val1 === null || val2 === null)
+            return null;
+        if (type1 === "null" || type2 === "null")
+            return null;
+        // Helper to get runtime type from a value
+        const getRuntimeType = (val) => {
+            if (val === null)
+                return "null";
+            const jsType = typeof val;
+            if (jsType === "boolean" || val === 0 || val === 1) {
+                // SQLite stores booleans as 0/1, so we can't distinguish at runtime
+                // We rely on the compile-time type info for this
+                return "unknown_number_or_boolean";
+            }
+            if (jsType === "number" || jsType === "bigint")
+                return "number";
+            if (jsType === "string") {
+                // Check if it's a JSON array/object
+                const str = val;
+                if (str.startsWith("["))
+                    return "list";
+                if (str.startsWith("{"))
+                    return "map";
+                return "string";
+            }
+            return "unknown";
+        };
+        // Resolve "dynamic" types using runtime type detection
+        let resolvedType1 = type1;
+        let resolvedType2 = type2;
+        if (type1 === "dynamic") {
+            resolvedType1 = getRuntimeType(val1);
+        }
+        if (type2 === "dynamic") {
+            resolvedType2 = getRuntimeType(val2);
+        }
+        // Normalize numeric types: integer, float, and number are all comparable
+        const normalizeNumericType = (t) => {
+            if (t === "integer" || t === "float" || t === "number")
+                return "numeric";
+            return t;
+        };
+        const normType1 = normalizeNumericType(resolvedType1);
+        const normType2 = normalizeNumericType(resolvedType2);
+        // Different types are never equal in CASE expressions
+        // (except numeric types which are comparable)
+        if (normType1 !== normType2)
+            return 0;
+        // Same type - compare values
+        // For lists/maps, use deep comparison
+        if (normType1 === "list" || normType1 === "map") {
+            let parsed1, parsed2;
+            try {
+                parsed1 = typeof val1 === "string" ? JSON.parse(val1) : val1;
+            }
+            catch {
+                parsed1 = val1;
+            }
+            try {
+                parsed2 = typeof val2 === "string" ? JSON.parse(val2) : val2;
+            }
+            catch {
+                parsed2 = val2;
+            }
+            const result = deepCypherEquals(parsed1, parsed2);
+            return result === null ? null : result;
+        }
+        // For numeric types, compare as numbers
+        if (normType1 === "numeric") {
+            const num1 = Number(val1);
+            const num2 = Number(val2);
+            return num1 === num2 ? 1 : 0;
+        }
+        // For primitives (boolean, string), direct comparison
+        return val1 === val2 ? 1 : 0;
+    });
+}
+export class GraphDatabase {
+    db;
+    initialized = false;
+    constructor(path = ":memory:") {
+        this.db = new Database(path);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        // Register custom Cypher functions
+        registerCypherFunctions(this.db);
+    }
+    /**
+     * Initialize the database schema
+     */
+    initialize() {
+        if (this.initialized)
+            return;
+        this.db.exec(SCHEMA);
+        this.initialized = true;
+    }
+    /**
+     * Execute a SQL statement and return results
+     */
+    execute(sql, params = []) {
+        this.ensureInitialized();
+        // Convert large integers to BigInt for proper SQLite INTEGER binding
+        const convertedParams = convertParamsForSqlite(params);
+        const stmt = this.db.prepare(sql);
+        const trimmedSql = sql.trim().toUpperCase();
+        // Check if it's a query (SELECT or WITH for CTEs)
+        const isQuery = trimmedSql.startsWith("SELECT") || trimmedSql.startsWith("WITH");
+        if (isQuery) {
+            const rows = stmt.all(...convertedParams);
+            return { rows, changes: 0, lastInsertRowid: 0 };
+        }
+        else {
+            const result = stmt.run(...convertedParams);
+            return {
+                rows: [],
+                changes: result.changes,
+                lastInsertRowid: result.lastInsertRowid,
+            };
+        }
+    }
+    /**
+     * Execute multiple statements in a transaction
+     */
+    transaction(fn) {
+        this.ensureInitialized();
+        return this.db.transaction(fn)();
+    }
+    /**
+     * Insert a node
+     */
+    insertNode(id, label, properties = {}) {
+        // Normalize label to array format for storage
+        const labelArray = Array.isArray(label) ? label : [label];
+        this.execute("INSERT INTO nodes (id, label, properties) VALUES (?, ?, ?)", [id, JSON.stringify(labelArray), JSON.stringify(properties)]);
+    }
+    /**
+     * Insert an edge
+     */
+    insertEdge(id, type, sourceId, targetId, properties = {}) {
+        this.execute("INSERT INTO edges (id, type, source_id, target_id, properties) VALUES (?, ?, ?, ?, ?)", [id, type, sourceId, targetId, JSON.stringify(properties)]);
+    }
+    /**
+     * Get a node by ID
+     */
+    getNode(id) {
+        const result = this.execute("SELECT * FROM nodes WHERE id = ?", [id]);
+        if (result.rows.length === 0)
+            return null;
+        const row = result.rows[0];
+        const labelArray = JSON.parse(row.label);
+        return {
+            id: row.id,
+            label: labelArray,
+            properties: JSON.parse(row.properties),
+        };
+    }
+    /**
+     * Get an edge by ID
+     */
+    getEdge(id) {
+        const result = this.execute("SELECT * FROM edges WHERE id = ?", [id]);
+        if (result.rows.length === 0)
+            return null;
+        const row = result.rows[0];
+        return {
+            id: row.id,
+            type: row.type,
+            source_id: row.source_id,
+            target_id: row.target_id,
+            properties: JSON.parse(row.properties),
+        };
+    }
+    /**
+     * Get all nodes with a given label
+     */
+    getNodesByLabel(label) {
+        const result = this.execute("SELECT * FROM nodes WHERE EXISTS (SELECT 1 FROM json_each(label) WHERE value = ?)", [label]);
+        return result.rows.map((row) => {
+            const r = row;
+            const labelArray = JSON.parse(r.label);
+            return {
+                id: r.id,
+                label: labelArray,
+                properties: JSON.parse(r.properties),
+            };
+        });
+    }
+    /**
+     * Get all edges with a given type
+     */
+    getEdgesByType(type) {
+        const result = this.execute("SELECT * FROM edges WHERE type = ?", [type]);
+        return result.rows.map((row) => {
+            const r = row;
+            return {
+                id: r.id,
+                type: r.type,
+                source_id: r.source_id,
+                target_id: r.target_id,
+                properties: JSON.parse(r.properties),
+            };
+        });
+    }
+    /**
+     * Delete a node by ID
+     */
+    deleteNode(id) {
+        const result = this.execute("DELETE FROM nodes WHERE id = ?", [id]);
+        return result.changes > 0;
+    }
+    /**
+     * Delete an edge by ID
+     */
+    deleteEdge(id) {
+        const result = this.execute("DELETE FROM edges WHERE id = ?", [id]);
+        return result.changes > 0;
+    }
+    /**
+     * Update node properties
+     */
+    updateNodeProperties(id, properties) {
+        const result = this.execute("UPDATE nodes SET properties = ? WHERE id = ?", [JSON.stringify(properties), id]);
+        return result.changes > 0;
+    }
+    /**
+     * Count nodes
+     */
+    countNodes() {
+        const result = this.execute("SELECT COUNT(*) as count FROM nodes");
+        return result.rows[0].count;
+    }
+    /**
+     * Count edges
+     */
+    countEdges() {
+        const result = this.execute("SELECT COUNT(*) as count FROM edges");
+        return result.rows[0].count;
+    }
+    /**
+     * Close the database connection
+     */
+    close() {
+        this.db.close();
+    }
+    /**
+     * Get the underlying database instance (for advanced operations)
+     */
+    getRawDatabase() {
+        return this.db;
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            this.initialize();
+        }
+    }
+}
+// ============================================================================
+// Database Manager (for multi-project support)
+// ============================================================================
+export class DatabaseManager {
+    databases = new Map();
+    basePath;
+    constructor(basePath = ":memory:") {
+        this.basePath = basePath;
+    }
+    /**
+     * Get or create a database for a project/environment
+     */
+    getDatabase(project, env = "production") {
+        const key = `${env}/${project}`;
+        if (!this.databases.has(key)) {
+            const path = this.basePath === ":memory:"
+                ? ":memory:"
+                : `${this.basePath}/${env}/${project}.db`;
+            const db = new GraphDatabase(path);
+            db.initialize();
+            this.databases.set(key, db);
+        }
+        return this.databases.get(key);
+    }
+    /**
+     * Close all database connections
+     */
+    closeAll() {
+        for (const db of this.databases.values()) {
+            db.close();
+        }
+        this.databases.clear();
+    }
+    /**
+     * List all open databases
+     */
+    listDatabases() {
+        return Array.from(this.databases.keys());
+    }
+}
+//# sourceMappingURL=db.js.map