@ductape/sdk 0.1.6 → 0.1.8

package/dist/graph/adapters/neo4j.adapter.js

@@ -1,1317 +0,0 @@
-"use strict";
-/**
- * Neo4j Graph Adapter
- *
- * Adapter implementation for Neo4j graph database
- * Uses the official neo4j-driver package
- */
-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.Neo4jAdapter = void 0;
-const enums_1 = require("../types/enums");
-const base_adapter_1 = require("./base.adapter");
-const graph_error_1 = require("../utils/graph-error");
-/**
- * Neo4j adapter implementation
- */
-class Neo4jAdapter extends base_adapter_1.BaseGraphAdapter {
-    constructor() {
-        super(...arguments);
-        this.graphType = enums_1.GraphType.NEO4J;
-        this.supportedFeatures = new Set([
-            enums_1.GraphFeature.TRANSACTIONS,
-            enums_1.GraphFeature.SCHEMA_INDEXES,
-            enums_1.GraphFeature.FULL_TEXT_SEARCH,
-            enums_1.GraphFeature.GRAPH_ALGORITHMS,
-            enums_1.GraphFeature.GEOSPATIAL,
-        ]);
-        this.driver = null;
-        this.session = null;
-    }
-    // ==================== CONNECTION MANAGEMENT ====================
-    async connect(options) {
-        try {
-            const neo4j = await Promise.resolve().then(() => __importStar(require('neo4j-driver')));
-            // Store connection options for reconnection
-            this.connectionOptions = options;
-            // Use auth credentials from options, fallback to defaults for backwards compatibility
-            const auth = options.auth
-                ? neo4j.auth.basic(options.auth.username, options.auth.password)
-                : neo4j.auth.basic('neo4j', 'neo4j');
-            this.driver = neo4j.driver(options.connectionUrl, auth, options.options);
-            // Verify connection
-            await this.driver.verifyConnectivity();
-            this.connected = true;
-            this.connectionUrl = options.connectionUrl;
-            return {
-                connected: true,
-                type: enums_1.GraphType.NEO4J,
-                latency: 0,
-            };
-        }
-        catch (error) {
-            this.connected = false;
-            throw graph_error_1.GraphError.connectionError(`Failed to connect to Neo4j: ${error.message}`, error);
-        }
-    }
-    async testConnection(options) {
-        var _a;
-        try {
-            const neo4j = await Promise.resolve().then(() => __importStar(require('neo4j-driver')));
-            const startTime = Date.now();
-            // Use auth credentials from options, fallback to defaults for backwards compatibility
-            const auth = options.auth
-                ? neo4j.auth.basic(options.auth.username, options.auth.password)
-                : neo4j.auth.basic('neo4j', 'neo4j');
-            const testDriver = neo4j.driver(options.connectionUrl, auth, Object.assign(Object.assign({}, options.options), { connectionTimeout: 5000 }));
-            await testDriver.verifyConnectivity();
-            const serverInfo = await testDriver.getServerInfo();
-            await testDriver.close();
-            return {
-                connected: true,
-                type: enums_1.GraphType.NEO4J,
-                version: (_a = serverInfo === null || serverInfo === void 0 ? void 0 : serverInfo.protocolVersion) === null || _a === void 0 ? void 0 : _a.toString(),
-                latency: Date.now() - startTime,
-            };
-        }
-        catch (error) {
-            return {
-                connected: false,
-                type: enums_1.GraphType.NEO4J,
-                error: error.message,
-            };
-        }
-    }
-    async disconnect() {
-        if (this.session) {
-            await this.session.close();
-            this.session = null;
-        }
-        if (this.driver) {
-            await this.driver.close();
-            this.driver = null;
-        }
-        this.connected = false;
-    }
-    getSession(transaction) {
-        if (transaction === null || transaction === void 0 ? void 0 : transaction.client) {
-            return transaction.client;
-        }
-        // Always create a new session to avoid conflicts with concurrent requests
-        // Sessions are lightweight and designed to be created per-operation
-        return this.driver.session();
-    }
-    // ==================== NODE OPERATIONS ====================
-    async createNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const labels = options.labels.join(':');
-            const query = `CREATE (n:${labels} $props) RETURN n`;
-            const session = this.getSession(transaction);
-            const result = await session.run(query, { props: options.properties });
-            const record = result.records[0];
-            const node = record.get('n');
-            return {
-                node: this.mapNeo4jNode(node),
-                created: true,
-            };
-        });
-    }
-    async findNodes(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            const labels = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.join(':')) || '';
-            const labelClause = labels ? `:${labels}` : '';
-            let query = `MATCH (n${labelClause})`;
-            const params = {};
-            if (options.where) {
-                const { clause, params: whereParams } = this.buildWhereClause(options.where, 'n');
-                query += ` WHERE ${clause}`;
-                Object.assign(params, whereParams);
-            }
-            query += ' RETURN n';
-            if ((_b = options.orderBy) === null || _b === void 0 ? void 0 : _b.length) {
-                const orderClauses = options.orderBy.map(o => `n.${o.property} ${o.direction.toUpperCase()}`);
-                query += ` ORDER BY ${orderClauses.join(', ')}`;
-            }
-            if (options.offset) {
-                query += ` SKIP ${options.offset}`;
-            }
-            if (options.limit) {
-                query += ` LIMIT ${options.limit}`;
-            }
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const nodes = result.records.map((record) => this.mapNeo4jNode(record.get('n')));
-            return {
-                nodes,
-                count: nodes.length,
-            };
-        });
-    }
-    async findNodeById(id, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = `MATCH (n) WHERE elementId(n) = $id OR id(n) = $idNum RETURN n`;
-            const session = this.getSession(transaction);
-            const result = await session.run(query, {
-                id: String(id),
-                idNum: typeof id === 'number' ? id : parseInt(id, 10) || -1
-            });
-            if (result.records.length === 0) {
-                return null;
-            }
-            return this.mapNeo4jNode(result.records[0].get('n'));
-        });
-    }
-    async updateNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            let query;
-            const params = { props: options.properties };
-            if (options.id) {
-                query = `MATCH (n) WHERE elementId(n) = $id OR id(n) = $idNum SET n += $props RETURN n`;
-                params.id = String(options.id);
-                params.idNum = typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1;
-            }
-            else {
-                const labels = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.join(':')) || '';
-                const labelClause = labels ? `:${labels}` : '';
-                query = `MATCH (n${labelClause})`;
-                if (options.where) {
-                    const { clause, params: whereParams } = this.buildWhereClause(options.where, 'n');
-                    query += ` WHERE ${clause}`;
-                    Object.assign(params, whereParams);
-                }
-                query += ' SET n += $props RETURN n';
-            }
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const nodes = result.records.map((record) => this.mapNeo4jNode(record.get('n')));
-            return {
-                node: nodes.length === 1 ? nodes[0] : undefined,
-                nodes: nodes.length > 1 ? nodes : undefined,
-                updatedCount: nodes.length,
-            };
-        });
-    }
-    async deleteNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c;
-            let query;
-            const params = {};
-            const detach = options.detach ? 'DETACH ' : '';
-            if (options.id) {
-                query = `MATCH (n) WHERE elementId(n) = $id OR id(n) = $idNum ${detach}DELETE n RETURN count(n) as count`;
-                params.id = String(options.id);
-                params.idNum = typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1;
-            }
-            else {
-                const labels = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.join(':')) || '';
-                const labelClause = labels ? `:${labels}` : '';
-                query = `MATCH (n${labelClause})`;
-                if (options.where) {
-                    const { clause, params: whereParams } = this.buildWhereClause(options.where, 'n');
-                    query += ` WHERE ${clause}`;
-                    Object.assign(params, whereParams);
-                }
-                query += ` ${detach}DELETE n RETURN count(n) as count`;
-            }
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const count = ((_c = (_b = result.records[0]) === null || _b === void 0 ? void 0 : _b.get('count')) === null || _c === void 0 ? void 0 : _c.toNumber()) || 0;
-            return {
-                deleted: count > 0,
-                deletedCount: count,
-            };
-        });
-    }
-    async mergeNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const labels = options.labels.join(':');
-            const matchProps = Object.entries(options.matchProperties)
-                .map(([key]) => `${key}: $match_${key}`)
-                .join(', ');
-            let query = `MERGE (n:${labels} {${matchProps}})`;
-            const params = {};
-            // Add match properties to params
-            Object.entries(options.matchProperties).forEach(([key, value]) => {
-                params[`match_${key}`] = value;
-            });
-            if (options.onCreate) {
-                query += ' ON CREATE SET n += $onCreateProps';
-                params.onCreateProps = options.onCreate;
-            }
-            if (options.onMatch) {
-                query += ' ON MATCH SET n += $onMatchProps';
-                params.onMatchProps = options.onMatch;
-            }
-            query += ' RETURN n, EXISTS((n)--()) as existed';
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const record = result.records[0];
-            const node = this.mapNeo4jNode(record.get('n'));
-            return {
-                node,
-                created: !record.get('existed'),
-            };
-        });
-    }
-    // ==================== LABEL MANAGEMENT ====================
-    async addLabels(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const labels = options.labels.map(l => `:\`${l}\``).join('');
-            const query = `
-        MATCH (n)
-        WHERE elementId(n) = $id OR id(n) = $idNum
-        SET n${labels}
-        RETURN n, labels(n) as newLabels
-      `;
-            const params = {
-                id: String(options.id),
-                idNum: typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            if (result.records.length === 0) {
-                throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
-            }
-            const record = result.records[0];
-            const node = this.mapNeo4jNode(record.get('n'));
-            return {
-                node,
-                addedLabels: options.labels,
-            };
-        });
-    }
-    async removeLabels(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const labels = options.labels.map(l => `:\`${l}\``).join('');
-            const query = `
-        MATCH (n)
-        WHERE elementId(n) = $id OR id(n) = $idNum
-        REMOVE n${labels}
-        RETURN n, labels(n) as newLabels
-      `;
-            const params = {
-                id: String(options.id),
-                idNum: typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            if (result.records.length === 0) {
-                throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
-            }
-            const record = result.records[0];
-            const node = this.mapNeo4jNode(record.get('n'));
-            return {
-                node,
-                removedLabels: options.labels,
-            };
-        });
-    }
-    async setLabels(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            // First get current labels
-            const getQuery = `
-        MATCH (n)
-        WHERE elementId(n) = $id OR id(n) = $idNum
-        RETURN labels(n) as currentLabels
-      `;
-            const params = {
-                id: String(options.id),
-                idNum: typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const getResult = await session.run(getQuery, params);
-            if (getResult.records.length === 0) {
-                throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
-            }
-            const previousLabels = getResult.records[0].get('currentLabels');
-            // Remove all existing labels and add new ones
-            const removeLabels = previousLabels.map(l => `:\`${l}\``).join('');
-            const addLabels = options.labels.map(l => `:\`${l}\``).join('');
-            const setQuery = `
-        MATCH (n)
-        WHERE elementId(n) = $id OR id(n) = $idNum
-        REMOVE n${removeLabels}
-        SET n${addLabels}
-        RETURN n
-      `;
-            const result = await session.run(setQuery, params);
-            const node = this.mapNeo4jNode(result.records[0].get('n'));
-            return {
-                node,
-                previousLabels,
-                newLabels: options.labels,
-            };
-        });
-    }
-    // ==================== RELATIONSHIP OPERATIONS ====================
-    async createRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = `
-        MATCH (a), (b)
-        WHERE (elementId(a) = $startId OR id(a) = $startIdNum)
-          AND (elementId(b) = $endId OR id(b) = $endIdNum)
-        CREATE (a)-[r:${options.type} $props]->(b)
-        RETURN r, elementId(a) as startId, elementId(b) as endId
-      `;
-            const params = {
-                startId: String(options.startNodeId),
-                startIdNum: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1,
-                endId: String(options.endNodeId),
-                endIdNum: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10) || -1,
-                props: options.properties || {},
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const record = result.records[0];
-            const rel = record.get('r');
-            return {
-                relationship: this.mapNeo4jRelationship(rel, record.get('startId'), record.get('endId')),
-                created: true,
-            };
-        });
-    }
-    async findRelationships(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const types = options.type
-                ? (Array.isArray(options.type) ? options.type.join('|') : options.type)
-                : '';
-            const typeClause = types ? `:${types}` : '';
-            let query = `MATCH (a)-[r${typeClause}]->(b)`;
-            const params = {};
-            const conditions = [];
-            if (options.startNodeId) {
-                conditions.push('(elementId(a) = $startId OR id(a) = $startIdNum)');
-                params.startId = String(options.startNodeId);
-                params.startIdNum = typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1;
-            }
-            if (options.endNodeId) {
-                conditions.push('(elementId(b) = $endId OR id(b) = $endIdNum)');
-                params.endId = String(options.endNodeId);
-                params.endIdNum = typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10) || -1;
-            }
-            if (options.where) {
-                const { clause, params: whereParams } = this.buildWhereClause(options.where, 'r');
-                conditions.push(clause);
-                Object.assign(params, whereParams);
-            }
-            if (conditions.length > 0) {
-                query += ` WHERE ${conditions.join(' AND ')}`;
-            }
-            query += ' RETURN r, elementId(a) as startId, elementId(b) as endId';
-            if (options.offset) {
-                query += ` SKIP ${options.offset}`;
-            }
-            if (options.limit) {
-                query += ` LIMIT ${options.limit}`;
-            }
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const relationships = result.records.map((record) => this.mapNeo4jRelationship(record.get('r'), record.get('startId'), record.get('endId')));
-            return {
-                relationships,
-                count: relationships.length,
-            };
-        });
-    }
-    async findRelationshipById(id, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = `
-        MATCH (a)-[r]->(b)
-        WHERE elementId(r) = $id OR id(r) = $idNum
-        RETURN r, elementId(a) as startId, elementId(b) as endId
-      `;
-            const session = this.getSession(transaction);
-            const result = await session.run(query, {
-                id: String(id),
-                idNum: typeof id === 'number' ? id : parseInt(id, 10) || -1,
-            });
-            if (result.records.length === 0) {
-                return null;
-            }
-            const record = result.records[0];
-            return this.mapNeo4jRelationship(record.get('r'), record.get('startId'), record.get('endId'));
-        });
-    }
-    async updateRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            let query;
-            const params = { props: options.properties };
-            if (options.id) {
-                query = `
-          MATCH (a)-[r]->(b)
-          WHERE elementId(r) = $id OR id(r) = $idNum
-          SET r += $props
-          RETURN r, elementId(a) as startId, elementId(b) as endId
-        `;
-                params.id = String(options.id);
-                params.idNum = typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1;
-            }
-            else {
-                const typeClause = options.type ? `:${options.type}` : '';
-                query = `MATCH (a)-[r${typeClause}]->(b)`;
-                if (options.where) {
-                    const { clause, params: whereParams } = this.buildWhereClause(options.where, 'r');
-                    query += ` WHERE ${clause}`;
-                    Object.assign(params, whereParams);
-                }
-                query += ' SET r += $props RETURN r, elementId(a) as startId, elementId(b) as endId';
-            }
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const relationships = result.records.map((record) => this.mapNeo4jRelationship(record.get('r'), record.get('startId'), record.get('endId')));
-            return {
-                relationship: relationships.length === 1 ? relationships[0] : undefined,
-                relationships: relationships.length > 1 ? relationships : undefined,
-                updatedCount: relationships.length,
-            };
-        });
-    }
-    async deleteRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            let query;
-            const params = {};
-            if (options.id) {
-                query = `MATCH ()-[r]->() WHERE elementId(r) = $id OR id(r) = $idNum DELETE r RETURN count(r) as count`;
-                params.id = String(options.id);
-                params.idNum = typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1;
-            }
-            else {
-                const typeClause = options.type ? `:${options.type}` : '';
-                query = `MATCH (a)-[r${typeClause}]->(b)`;
-                const conditions = [];
-                if (options.startNodeId) {
-                    conditions.push('(elementId(a) = $startId OR id(a) = $startIdNum)');
-                    params.startId = String(options.startNodeId);
-                    params.startIdNum = typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1;
-                }
-                if (options.endNodeId) {
-                    conditions.push('(elementId(b) = $endId OR id(b) = $endIdNum)');
-                    params.endId = String(options.endNodeId);
-                    params.endIdNum = typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10) || -1;
-                }
-                if (options.where) {
-                    const { clause, params: whereParams } = this.buildWhereClause(options.where, 'r');
-                    conditions.push(clause);
-                    Object.assign(params, whereParams);
-                }
-                if (conditions.length > 0) {
-                    query += ` WHERE ${conditions.join(' AND ')}`;
-                }
-                query += ' DELETE r RETURN count(r) as count';
-            }
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const count = ((_b = (_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) === null || _b === void 0 ? void 0 : _b.toNumber()) || 0;
-            return {
-                deleted: count > 0,
-                deletedCount: count,
-            };
-        });
-    }
-    async mergeRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            let query = `
-        MATCH (a), (b)
-        WHERE (elementId(a) = $startId OR id(a) = $startIdNum)
-          AND (elementId(b) = $endId OR id(b) = $endIdNum)
-        MERGE (a)-[r:${options.type}]->(b)
-      `;
-            const params = {
-                startId: String(options.startNodeId),
-                startIdNum: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1,
-                endId: String(options.endNodeId),
-                endIdNum: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10) || -1,
-            };
-            if (options.onCreate) {
-                query += ' ON CREATE SET r += $onCreateProps';
-                params.onCreateProps = options.onCreate;
-            }
-            if (options.onMatch) {
-                query += ' ON MATCH SET r += $onMatchProps';
-                params.onMatchProps = options.onMatch;
-            }
-            query += ' RETURN r, elementId(a) as startId, elementId(b) as endId';
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const record = result.records[0];
-            const relationship = this.mapNeo4jRelationship(record.get('r'), record.get('startId'), record.get('endId'));
-            // Check if relationship was created (no properties existed before)
-            const created = Object.keys(record.get('r').properties || {}).length === 0;
-            return {
-                relationship,
-                created,
-            };
-        });
-    }
-    // ==================== TRAVERSAL OPERATIONS ====================
-    async traverse(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            const direction = this.getDirectionArrow(options.direction);
-            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
-            const relClause = relTypes ? `:${relTypes}` : '';
-            const depthClause = `*1..${options.maxDepth || 3}`;
-            const query = `
-        MATCH path = (start)${direction.left}[${relClause}${depthClause}]${direction.right}(end)
-        WHERE elementId(start) = $startId OR id(start) = $startIdNum
-        RETURN path
-        ${options.limit ? `LIMIT ${options.limit}` : ''}
-      `;
-            const params = {
-                startId: String(options.startNodeId),
-                startIdNum: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const paths = result.records.map((record) => this.mapNeo4jPath(record.get('path')));
-            return {
-                paths,
-                count: paths.length,
-            };
-        });
-    }
-    async shortestPath(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
-            const relClause = relTypes ? `:${relTypes}` : '';
-            const maxDepth = options.maxDepth || 15;
-            const query = `
-        MATCH (start), (end)
-        WHERE (elementId(start) = $startId OR id(start) = $startIdNum)
-          AND (elementId(end) = $endId OR id(end) = $endIdNum)
-        MATCH path = shortestPath((start)-[${relClause}*..${maxDepth}]-(end))
-        RETURN path
-      `;
-            const params = {
-                startId: String(options.startNodeId),
-                startIdNum: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1,
-                endId: String(options.endNodeId),
-                endIdNum: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            if (result.records.length === 0) {
-                return { path: null };
-            }
-            const path = this.mapNeo4jPath(result.records[0].get('path'));
-            return {
-                path,
-                totalWeight: options.weightProperty
-                    ? path.relationships.reduce((sum, r) => sum + (r.properties[options.weightProperty] || 0), 0)
-                    : undefined,
-            };
-        });
-    }
-    async allPaths(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
-            const relClause = relTypes ? `:${relTypes}` : '';
-            const minDepth = options.minDepth || 1;
-            const maxDepth = options.maxDepth || 5;
-            const query = `
-        MATCH (start), (end)
-        WHERE (elementId(start) = $startId OR id(start) = $startIdNum)
-          AND (elementId(end) = $endId OR id(end) = $endIdNum)
-        MATCH path = (start)-[${relClause}*${minDepth}..${maxDepth}]-(end)
-        RETURN path
-        ${options.limit ? `LIMIT ${options.limit}` : ''}
-      `;
-            const params = {
-                startId: String(options.startNodeId),
-                startIdNum: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10) || -1,
-                endId: String(options.endNodeId),
-                endIdNum: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const paths = result.records.map((record) => this.mapNeo4jPath(record.get('path')));
-            return {
-                paths,
-                count: paths.length,
-            };
-        });
-    }
-    async getNeighborhood(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            const direction = this.getDirectionArrow(options.direction);
-            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
-            const relClause = relTypes ? `:${relTypes}` : '';
-            const depth = options.depth || 1;
-            const query = `
-        MATCH (start)
-        WHERE elementId(start) = $nodeId OR id(start) = $nodeIdNum
-        MATCH path = (start)${direction.left}[r${relClause}*1..${depth}]${direction.right}(neighbor)
-        RETURN DISTINCT neighbor, r
-      `;
-            const params = {
-                nodeId: String(options.nodeId),
-                nodeIdNum: typeof options.nodeId === 'number' ? options.nodeId : parseInt(options.nodeId, 10) || -1,
-            };
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            const nodesMap = new Map();
-            const relationshipsSet = [];
-            result.records.forEach((record) => {
-                const neighbor = record.get('neighbor');
-                const nodeId = neighbor.elementId || neighbor.identity.toString();
-                if (!nodesMap.has(nodeId)) {
-                    nodesMap.set(nodeId, this.mapNeo4jNode(neighbor));
-                }
-                const rels = record.get('r');
-                if (Array.isArray(rels)) {
-                    rels.forEach((rel) => {
-                        relationshipsSet.push(this.mapNeo4jRelationship(rel, rel.startNodeElementId || rel.start.toString(), rel.endNodeElementId || rel.end.toString()));
-                    });
-                }
-            });
-            return {
-                nodes: Array.from(nodesMap.values()),
-                relationships: relationshipsSet,
-            };
-        });
-    }
-    async findConnectedComponents(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            // Note: This requires APOC or GDS library for efficient implementation
-            // Basic implementation using Cypher
-            const labels = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.join(':')) || '';
-            const labelClause = labels ? `:${labels}` : '';
-            const relTypes = ((_b = options.relationshipTypes) === null || _b === void 0 ? void 0 : _b.join('|')) || '';
-            const relClause = relTypes ? `:${relTypes}` : '';
-            const query = `
-        MATCH (n${labelClause})
-        WITH collect(n) as nodes
-        UNWIND nodes as node
-        MATCH path = (node)-[${relClause}*]-(connected)
-        WITH node, collect(DISTINCT connected) as component
-        RETURN component
-      `;
-            const session = this.getSession(transaction);
-            const result = await session.run(query, {});
-            const components = result.records.map((record) => ({
-                nodes: record.get('component').map((n) => this.mapNeo4jNode(n)),
-                size: record.get('component').length,
-            }));
-            return {
-                components,
-                count: components.length,
-            };
-        });
-    }
-    // ==================== AGGREGATION OPERATIONS ====================
-    async countNodes(labels, where, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            const labelClause = (labels === null || labels === void 0 ? void 0 : labels.length) ? `:${labels.join(':')}` : '';
-            let query = `MATCH (n${labelClause})`;
-            const params = {};
-            if (where) {
-                const { clause, params: whereParams } = this.buildWhereClause(where, 'n');
-                query += ` WHERE ${clause}`;
-                Object.assign(params, whereParams);
-            }
-            query += ' RETURN count(n) as count';
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            return {
-                count: ((_b = (_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) === null || _b === void 0 ? void 0 : _b.toNumber()) || 0,
-            };
-        });
-    }
-    async countRelationships(types, where, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            const typeClause = (types === null || types === void 0 ? void 0 : types.length) ? `:${types.join('|')}` : '';
-            let query = `MATCH ()-[r${typeClause}]->()`;
-            const params = {};
-            if (where) {
-                const { clause, params: whereParams } = this.buildWhereClause(where, 'r');
-                query += ` WHERE ${clause}`;
-                Object.assign(params, whereParams);
-            }
-            query += ' RETURN count(r) as count';
-            const session = this.getSession(transaction);
-            const result = await session.run(query, params);
-            return {
-                count: ((_b = (_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) === null || _b === void 0 ? void 0 : _b.toNumber()) || 0,
-            };
-        });
-    }
-    async getStatistics(transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c, _d;
-            const session = this.getSession(transaction);
-            const nodeCountResult = await session.run('MATCH (n) RETURN count(n) as count');
-            const relCountResult = await session.run('MATCH ()-[r]->() RETURN count(r) as count');
-            return {
-                nodeCount: ((_b = (_a = nodeCountResult.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) === null || _b === void 0 ? void 0 : _b.toNumber()) || 0,
-                relationshipCount: ((_d = (_c = relCountResult.records[0]) === null || _c === void 0 ? void 0 : _c.get('count')) === null || _d === void 0 ? void 0 : _d.toNumber()) || 0,
-            };
-        });
-    }
-    // ==================== SEARCH OPERATIONS ====================
-    async fullTextSearch(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = `
-        CALL db.index.fulltext.queryNodes($indexName, $searchQuery)
-        YIELD node, score
-        RETURN node, score
-        ${options.limit ? `LIMIT ${options.limit}` : ''}
-      `;
-            const session = this.getSession(transaction);
-            const result = await session.run(query, {
-                indexName: options.indexName,
-                searchQuery: options.query,
-            });
-            const nodes = result.records.map((r) => this.mapNeo4jNode(r.get('node')));
-            const scores = result.records.map((r) => r.get('score'));
-            return { nodes, scores };
-        });
-    }
-    async vectorSearch(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            // Vector search requires Neo4j 5.13+ with vector index
-            const query = `
-        CALL db.index.vector.queryNodes($indexName, $topK, $vector)
-        YIELD node, score
-        RETURN node, score
-      `;
-            const session = this.getSession(transaction);
-            const result = await session.run(query, {
-                indexName: options.indexName,
-                topK: options.topK || 10,
-                vector: options.vector,
-            });
-            const nodes = result.records.map((r) => this.mapNeo4jNode(r.get('node')));
-            const scores = result.records.map((r) => r.get('score'));
-            return { nodes, scores };
-        });
-    }
-    // ==================== RAW QUERY ====================
-    async query(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c, _d, _e, _f;
-            const session = this.getSession(transaction);
-            const result = await session.run(options.query, options.params || {});
-            return {
-                records: result.records.map((r) => r.toObject()),
-                summary: {
-                    resultAvailableAfter: (_b = (_a = result.summary) === null || _a === void 0 ? void 0 : _a.resultAvailableAfter) === null || _b === void 0 ? void 0 : _b.toNumber(),
-                    resultConsumedAfter: (_d = (_c = result.summary) === null || _c === void 0 ? void 0 : _c.resultConsumedAfter) === null || _d === void 0 ? void 0 : _d.toNumber(),
-                    database: (_f = (_e = result.summary) === null || _e === void 0 ? void 0 : _e.database) === null || _f === void 0 ? void 0 : _f.name,
-                },
-            };
-        });
-    }
-    // ==================== SCHEMA OPERATIONS ====================
-    async createNodeIndex(options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const properties = options.properties.map(p => `n.${p}`).join(', ');
-            const unique = options.unique ? 'UNIQUE' : '';
-            const query = `CREATE ${unique} INDEX ${options.name} IF NOT EXISTS FOR (n:${options.label}) ON (${properties})`;
-            const session = this.getSession();
-            await session.run(query);
-            return { created: true, name: options.name };
-        });
-    }
-    async createNodeConstraint(options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            let query;
-            switch (options.type) {
-                case 'UNIQUE':
-                    query = `CREATE CONSTRAINT ${options.name} IF NOT EXISTS FOR (n:${options.label}) REQUIRE n.${options.property} IS UNIQUE`;
-                    break;
-                case 'EXISTS':
-                    query = `CREATE CONSTRAINT ${options.name} IF NOT EXISTS FOR (n:${options.label}) REQUIRE n.${options.property} IS NOT NULL`;
-                    break;
-                default:
-                    throw graph_error_1.GraphError.validationError(`Unsupported constraint type: ${options.type}`);
-            }
-            const session = this.getSession();
-            await session.run(query);
-            return { created: true, name: options.name };
-        });
-    }
-    async createRelationshipIndex(options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const properties = options.properties.map(p => `r.${p}`).join(', ');
-            const query = `CREATE INDEX ${options.name} IF NOT EXISTS FOR ()-[r:${options.type}]-() ON (${properties})`;
-            const session = this.getSession();
-            await session.run(query);
-            return { created: true, name: options.name };
-        });
-    }
-    async listIndexes() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = 'SHOW INDEXES';
-            const session = this.getSession();
-            const result = await session.run(query);
-            const indexes = result.records.map((r) => {
-                var _a;
-                const indexType = r.get('type') || '';
-                // In Neo4j 5.x, unique indexes have an owningConstraint or type contains UNIQUE
-                const isUnique = indexType.toUpperCase().includes('UNIQUE') ||
-                    r.get('owningConstraint') != null;
-                return {
-                    name: r.get('name'),
-                    labelOrType: ((_a = r.get('labelsOrTypes')) === null || _a === void 0 ? void 0 : _a[0]) || '',
-                    properties: r.get('properties') || [],
-                    unique: isUnique,
-                    type: indexType,
-                    state: r.get('state'),
-                };
-            });
-            return { indexes };
-        });
-    }
-    async listConstraints() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = 'SHOW CONSTRAINTS';
-            const session = this.getSession();
-            const result = await session.run(query);
-            const constraints = result.records.map((r) => {
-                var _a, _b;
-                return ({
-                    name: r.get('name'),
-                    label: ((_a = r.get('labelsOrTypes')) === null || _a === void 0 ? void 0 : _a[0]) || '',
-                    property: ((_b = r.get('properties')) === null || _b === void 0 ? void 0 : _b[0]) || '',
-                    type: r.get('type'),
-                });
-            });
-            return { constraints };
-        });
-    }
-    async dropIndex(name) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = `DROP INDEX ${name} IF EXISTS`;
-            const session = this.getSession();
-            await session.run(query);
-            return { dropped: true };
-        });
-    }
-    async dropConstraint(name) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const query = `DROP CONSTRAINT ${name} IF EXISTS`;
-            const session = this.getSession();
-            await session.run(query);
-            return { dropped: true };
-        });
-    }
-    // ==================== SCHEMA INTROSPECTION ====================
-    async listLabels() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c, _d;
-            const session = this.getSession();
-            // Get all labels
-            const labelsResult = await session.run('CALL db.labels()');
-            const labelNames = labelsResult.records.map((r) => r.get('label'));
-            const labels = [];
-            for (const labelName of labelNames) {
-                // Get count for each label
-                const countResult = await session.run(`MATCH (n:\`${labelName}\`) RETURN count(n) as count`);
-                const count = ((_c = (_b = (_a = countResult.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) === null || _b === void 0 ? void 0 : _b.toNumber) === null || _c === void 0 ? void 0 : _c.call(_b)) ||
-                    ((_d = countResult.records[0]) === null || _d === void 0 ? void 0 : _d.get('count')) || 0;
-                // Get properties for a sample of nodes with this label
-                const propsResult = await session.run(`MATCH (n:\`${labelName}\`) WITH n LIMIT 100
-           UNWIND keys(n) as key
-           WITH DISTINCT key, n[key] as value
-           RETURN key,
-                  CASE toUpper(valueType(value))
-                    WHEN 'NULL' THEN 'unknown'
-                    WHEN 'INTEGER' THEN 'number'
-                    WHEN 'FLOAT' THEN 'number'
-                    WHEN 'STRING' THEN 'string'
-                    WHEN 'BOOLEAN' THEN 'boolean'
-                    WHEN 'DATE' THEN 'date'
-                    WHEN 'DATETIME' THEN 'datetime'
-                    WHEN 'LOCAL DATETIME' THEN 'datetime'
-                    WHEN 'ZONED DATETIME' THEN 'datetime'
-                    WHEN 'TIME' THEN 'time'
-                    WHEN 'LOCAL TIME' THEN 'time'
-                    WHEN 'ZONED TIME' THEN 'time'
-                    WHEN 'DURATION' THEN 'duration'
-                    WHEN 'POINT' THEN 'point'
-                    WHEN 'LIST OF ANY?' THEN 'array'
-                    ELSE 'unknown'
-                  END as type`);
-                const properties = propsResult.records.map((r) => ({
-                    name: r.get('key'),
-                    type: this.mapNeo4jTypeToPropertyType(r.get('type')),
-                }));
-                labels.push({
-                    name: labelName,
-                    count: typeof count === 'number' ? count : Number(count),
-                    properties,
-                });
-            }
-            return { labels };
-        });
-    }
-    async listRelationshipTypes() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c, _d;
-            const session = this.getSession();
-            // Get all relationship types
-            const typesResult = await session.run('CALL db.relationshipTypes()');
-            const typeNames = typesResult.records.map((r) => r.get('relationshipType'));
-            const types = [];
-            for (const typeName of typeNames) {
-                // Get count for each type
-                const countResult = await session.run(`MATCH ()-[r:\`${typeName}\`]->() RETURN count(r) as count`);
-                const count = ((_c = (_b = (_a = countResult.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) === null || _b === void 0 ? void 0 : _b.toNumber) === null || _c === void 0 ? void 0 : _c.call(_b)) ||
-                    ((_d = countResult.records[0]) === null || _d === void 0 ? void 0 : _d.get('count')) || 0;
-                // Get source and target label information
-                const endpointsResult = await session.run(`MATCH (a)-[r:\`${typeName}\`]->(b)
-           WITH labels(a) as fromLabels, labels(b) as toLabels
-           RETURN DISTINCT fromLabels[0] as fromLabel, toLabels[0] as toLabel
-           LIMIT 10`);
-                const fromLabelsArray = endpointsResult.records
-                    .map((r) => r.get('fromLabel'))
-                    .filter((l) => Boolean(l));
-                const fromLabels = [...new Set(fromLabelsArray)];
-                const toLabelsArray = endpointsResult.records
-                    .map((r) => r.get('toLabel'))
-                    .filter((l) => Boolean(l));
-                const toLabels = [...new Set(toLabelsArray)];
-                // Get properties for relationships of this type
-                const propsResult = await session.run(`MATCH ()-[r:\`${typeName}\`]->() WITH r LIMIT 100
-           UNWIND keys(r) as key
-           RETURN DISTINCT key`);
-                const properties = propsResult.records.map((r) => ({
-                    name: r.get('key'),
-                    type: 'unknown',
-                }));
-                types.push({
-                    type: typeName,
-                    count: typeof count === 'number' ? count : Number(count),
-                    fromLabels,
-                    toLabels,
-                    properties: properties.length > 0 ? properties : undefined,
-                });
-            }
-            return { types };
-        });
-    }
-    /**
-     * Map Neo4j type string to GraphPropertyType
-     */
-    mapNeo4jTypeToPropertyType(typeStr) {
-        switch (typeStr === null || typeStr === void 0 ? void 0 : typeStr.toLowerCase()) {
-            case 'number':
-            case 'integer':
-            case 'float':
-                return 'number';
-            case 'string':
-                return 'string';
-            case 'boolean':
-                return 'boolean';
-            case 'date':
-                return 'date';
-            case 'datetime':
-                return 'datetime';
-            case 'point':
-                return 'point';
-            case 'array':
-            case 'list':
-                return 'array';
-            default:
-                return 'unknown';
-        }
-    }
-    // ==================== TRANSACTION OPERATIONS ====================
-    async beginTransaction(_options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const session = this.driver.session();
-            const tx = session.beginTransaction();
-            return {
-                id: `tx_${Date.now()}`,
-                status: enums_1.GraphTransactionStatus.ACTIVE,
-                client: tx,
-                commit: async () => {
-                    await tx.commit();
-                    await session.close();
-                },
-                rollback: async () => {
-                    await tx.rollback();
-                    await session.close();
-                },
-            };
-        });
-    }
-    async commitTransaction(transaction) {
-        await transaction.commit();
-    }
-    async rollbackTransaction(transaction) {
-        await transaction.rollback();
-    }
-    // ==================== UTILITY METHODS ====================
-    buildWhereClause(where, alias = 'n') {
-        const conditions = [];
-        const params = {};
-        let paramIndex = 0;
-        const processCondition = (key, value, prefix = '') => {
-            const fullKey = prefix ? `${prefix}_${key}` : key;
-            const paramName = `param_${paramIndex++}`;
-            // Normalize key to lowercase for logical operators (support both cases for backwards compatibility)
-            const normalizedKey = key.toLowerCase();
-            if (normalizedKey === '$and') {
-                const entries = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
-                const subConditions = entries.map((entry) => {
-                    if (typeof entry === 'object' && !Array.isArray(entry)) {
-                        Object.entries(entry).forEach(([k, v]) => processCondition(k, v, fullKey));
-                    }
-                    return conditions.pop();
-                });
-                conditions.push(`(${subConditions.join(' AND ')})`);
-                return;
-            }
-            if (normalizedKey === '$or') {
-                const entries = Array.isArray(value) ? value : Object.entries(value).map(([k, v]) => ({ [k]: v }));
-                const subConditions = entries.map((entry) => {
-                    if (typeof entry === 'object' && !Array.isArray(entry)) {
-                        Object.entries(entry).forEach(([k, v]) => processCondition(k, v, fullKey));
-                    }
-                    return conditions.pop();
-                });
-                conditions.push(`(${subConditions.join(' OR ')})`);
-                return;
-            }
-            if (normalizedKey === '$not') {
-                Object.entries(value).forEach(([k, v]) => processCondition(k, v, fullKey));
-                const innerCondition = conditions.pop();
-                conditions.push(`NOT (${innerCondition})`);
-                return;
-            }
-            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                Object.entries(value).forEach(([op, opValue]) => {
-                    const opParamName = `${paramName}_${op.toLowerCase()}`;
-                    // Normalize operator to lowercase (support both cases for backwards compatibility)
-                    const normalizedOp = op.toLowerCase();
-                    switch (normalizedOp) {
-                        case '$gt':
-                            conditions.push(`${alias}.${key} > $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$gte':
-                            conditions.push(`${alias}.${key} >= $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$lt':
-                            conditions.push(`${alias}.${key} < $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$lte':
-                            conditions.push(`${alias}.${key} <= $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$ne':
-                            conditions.push(`${alias}.${key} <> $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$in':
-                            conditions.push(`${alias}.${key} IN $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$nin':
-                        case '$not_in':
-                            conditions.push(`NOT ${alias}.${key} IN $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$contains':
-                            conditions.push(`${alias}.${key} CONTAINS $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$startswith':
-                        case '$starts_with':
-                            conditions.push(`${alias}.${key} STARTS WITH $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$endswith':
-                        case '$ends_with':
-                            conditions.push(`${alias}.${key} ENDS WITH $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                        case '$exists':
-                            if (opValue) {
-                                conditions.push(`${alias}.${key} IS NOT NULL`);
-                            }
-                            else {
-                                conditions.push(`${alias}.${key} IS NULL`);
-                            }
-                            break;
-                        case '$regex':
-                            conditions.push(`${alias}.${key} =~ $${opParamName}`);
-                            params[opParamName] = opValue;
-                            break;
-                    }
-                });
-            }
-            else {
-                conditions.push(`${alias}.${key} = $${paramName}`);
-                params[paramName] = value;
-            }
-        };
-        Object.entries(where).forEach(([key, value]) => {
-            processCondition(key, value);
-        });
-        return {
-            clause: conditions.join(' AND ') || 'true',
-            params,
-        };
-    }
-    parseError(error) {
-        return graph_error_1.GraphError.wrap(error);
-    }
-    // ==================== PRIVATE HELPER METHODS ====================
-    mapNeo4jNode(node) {
-        var _a;
-        return {
-            id: node.elementId || ((_a = node.identity) === null || _a === void 0 ? void 0 : _a.toString()) || '',
-            labels: node.labels || [],
-            properties: this.convertNeo4jProperties(node.properties || {}),
-            elementId: node.elementId,
-        };
-    }
-    mapNeo4jRelationship(rel, startId, endId) {
-        var _a;
-        return {
-            id: rel.elementId || ((_a = rel.identity) === null || _a === void 0 ? void 0 : _a.toString()) || '',
-            type: rel.type,
-            startNodeId: startId,
-            endNodeId: endId,
-            properties: this.convertNeo4jProperties(rel.properties || {}),
-            elementId: rel.elementId,
-        };
-    }
-    mapNeo4jPath(path) {
-        const nodes = path.segments.reduce((acc, segment, index) => {
-            if (index === 0) {
-                acc.push(this.mapNeo4jNode(segment.start));
-            }
-            acc.push(this.mapNeo4jNode(segment.end));
-            return acc;
-        }, []);
-        const relationships = path.segments.map((segment) => this.mapNeo4jRelationship(segment.relationship, segment.start.elementId || segment.start.identity.toString(), segment.end.elementId || segment.end.identity.toString()));
-        return {
-            nodes,
-            relationships,
-            length: relationships.length,
-        };
-    }
-    convertNeo4jProperties(props) {
-        const result = {};
-        for (const [key, value] of Object.entries(props)) {
-            result[key] = this.convertNeo4jValue(value);
-        }
-        return result;
-    }
-    convertNeo4jValue(value) {
-        var _a, _b;
-        if (value === null || value === undefined) {
-            return value;
-        }
-        // Handle Neo4j Integer type
-        if (typeof value === 'object' && ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Integer') {
-            return value.toNumber();
-        }
-        // Handle Neo4j Date types
-        if (typeof value === 'object' && ((_b = value.constructor) === null || _b === void 0 ? void 0 : _b.name) === 'Date') {
-            return new Date(value.toString());
-        }
-        if (Array.isArray(value)) {
-            return value.map(v => this.convertNeo4jValue(v));
-        }
-        return value;
-    }
-    getDirectionArrow(direction) {
-        switch (direction) {
-            case enums_1.TraversalDirection.OUTGOING:
-            case 'OUTGOING':
-                return { left: '-', right: '->' };
-            case enums_1.TraversalDirection.INCOMING:
-            case 'INCOMING':
-                return { left: '<-', right: '-' };
-            case enums_1.TraversalDirection.BOTH:
-            case 'BOTH':
-            default:
-                return { left: '-', right: '-' };
-        }
-    }
-}
-exports.Neo4jAdapter = Neo4jAdapter;
-//# sourceMappingURL=neo4j.adapter.js.map