@ductape/sdk 0.0.4-v51 → 0.0.4-v53

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

@@ -1,7 +1,9 @@
 "use strict";
 /**
- * Neo4j Graph Database Adapter
- * Implements the BaseGraphAdapter for Neo4j databases using the official neo4j-driver
+ * 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;
@@ -38,1824 +40,1129 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Neo4jAdapter = void 0;
-const neo4j_driver_1 = __importStar(require("neo4j-driver"));
+const enums_1 = require("../types/enums");
 const base_adapter_1 = require("./base.adapter");
-const graph_types_1 = require("../types/graph.types");
-const node_types_1 = require("../types/node.types");
-const relationship_types_1 = require("../types/relationship.types");
-const path_types_1 = require("../types/path.types");
+const graph_error_1 = require("../utils/graph-error");
 /**
- * Neo4j connection implementation
+ * Neo4j adapter implementation
  */
-class Neo4jConnection {
-    constructor(config, id) {
-        this.config = config;
-        this.type = graph_types_1.GraphDatabaseType.NEO4J;
-        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
-        this.queryLanguage = graph_types_1.GraphQueryLanguage.CYPHER;
+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;
-        this.id = id || `neo4j-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        this.createdAt = new Date();
     }
-    async connect() {
-        var _a;
-        if (this.status === graph_types_1.GraphConnectionStatus.CONNECTED) {
-            return;
-        }
-        this.status = graph_types_1.GraphConnectionStatus.CONNECTING;
+    // ==================== CONNECTION MANAGEMENT ====================
+    async connect(options) {
         try {
-            const authToken = neo4j_driver_1.default.auth.basic(this.config.username, this.config.password);
-            const driverConfig = {
-                maxConnectionPoolSize: this.config.maxConnectionPoolSize || this.config.poolSize || 50,
-                connectionAcquisitionTimeout: this.config.connectionAcquisitionTimeout || 60000,
-                connectionTimeout: this.config.connectionTimeout || 30000,
-            };
-            if (this.config.maxConnectionLifetime) {
-                driverConfig.maxConnectionLifetime = this.config.maxConnectionLifetime;
-            }
-            if (this.config.encrypted !== undefined) {
-                driverConfig.encrypted = this.config.encrypted;
-            }
-            if (this.config.trust) {
-                driverConfig.trust = this.config.trust;
-            }
-            if (this.config.trustedCertificates) {
-                driverConfig.trustedCertificates = this.config.trustedCertificates;
-            }
-            if ((_a = this.config.options) === null || _a === void 0 ? void 0 : _a.logging) {
-                driverConfig.logging = this.config.options.logging;
-            }
-            this.driver = neo4j_driver_1.default.driver(this.config.uri, authToken, driverConfig);
-            // Verify connectivity
+            const neo4j = await Promise.resolve().then(() => __importStar(require('neo4j-driver')));
+            this.driver = neo4j.driver(options.connectionUrl, neo4j.auth.basic('neo4j', 'password'), // TODO: Extract from URL or options
+            options.options);
+            // Verify connection
             await this.driver.verifyConnectivity();
-            this.status = graph_types_1.GraphConnectionStatus.CONNECTED;
-            this.lastUsedAt = new Date();
-        }
-        catch (error) {
-            this.status = graph_types_1.GraphConnectionStatus.ERROR;
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, `Failed to connect to Neo4j: ${error.message}`, error);
-        }
-    }
-    async disconnect() {
-        if (this.session) {
-            await this.session.close();
-            this.session = null;
-        }
-        if (this.driver) {
-            await this.driver.close();
-            this.driver = null;
-        }
-        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
-    }
-    isConnected() {
-        return this.status === graph_types_1.GraphConnectionStatus.CONNECTED && this.driver !== null;
-    }
-    getClient() {
-        if (!this.driver) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Neo4j driver not initialized. Call connect() first.');
-        }
-        return this.driver;
-    }
-    getSession() {
-        if (!this.driver) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Neo4j driver not initialized. Call connect() first.');
-        }
-        const sessionConfig = {};
-        if (this.config.database) {
-            sessionConfig.database = this.config.database;
-        }
-        this.session = this.driver.session(sessionConfig);
-        this.lastUsedAt = new Date();
-        return this.session;
-    }
-    getDatabase() {
-        return this.config.database || 'neo4j';
-    }
-}
-/**
- * Neo4j transaction implementation
- */
-class Neo4jTransaction {
-    constructor(connection, session, transaction) {
-        this.connection = connection;
-        this.session = session;
-        this.status = graph_types_1.GraphTransactionStatus.PENDING;
-        this.id = `tx-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        this.createdAt = new Date();
-        this.native = transaction;
-        this.status = graph_types_1.GraphTransactionStatus.ACTIVE;
-    }
-    async commit() {
-        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Cannot commit transaction in ${this.status} state`);
-        }
-        try {
-            await this.native.commit();
-            this.status = graph_types_1.GraphTransactionStatus.COMMITTED;
-        }
-        catch (error) {
-            this.status = graph_types_1.GraphTransactionStatus.FAILED;
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Failed to commit transaction: ${error.message}`, error);
-        }
-    }
-    async rollback() {
-        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
-            return;
-        }
-        try {
-            await this.native.rollback();
-            this.status = graph_types_1.GraphTransactionStatus.ROLLED_BACK;
+            this.connected = true;
+            this.connectionUrl = options.connectionUrl;
+            return {
+                connected: true,
+                type: enums_1.GraphType.NEO4J,
+                latency: 0,
+            };
         }
         catch (error) {
-            this.status = graph_types_1.GraphTransactionStatus.FAILED;
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Failed to rollback transaction: ${error.message}`, error);
+            this.connected = false;
+            throw graph_error_1.GraphError.connectionError(`Failed to connect to Neo4j: ${error.message}`, error);
         }
     }
-    isActive() {
-        return this.status === graph_types_1.GraphTransactionStatus.ACTIVE;
-    }
-}
-/**
- * Neo4j Graph Database Adapter
- */
-class Neo4jAdapter extends base_adapter_1.BaseGraphAdapter {
-    constructor() {
-        super(...arguments);
-        this.type = graph_types_1.GraphDatabaseType.NEO4J;
-        this.supportedLanguages = [graph_types_1.GraphQueryLanguage.CYPHER];
-        this.defaultLanguage = graph_types_1.GraphQueryLanguage.CYPHER;
-    }
-    // ==================== CONNECTION METHODS ====================
-    async connect(config) {
-        if (config.type !== graph_types_1.GraphDatabaseType.NEO4J) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `Invalid config type ${config.type}. Expected ${graph_types_1.GraphDatabaseType.NEO4J}`);
-        }
-        const connection = new Neo4jConnection(config);
-        await connection.connect();
-        return connection;
-    }
-    async disconnect(connection) {
-        await connection.disconnect();
-    }
-    async testConnection(connection) {
+    async testConnection(options) {
         var _a;
-        const startTime = Date.now();
         try {
-            const session = connection.getSession();
-            const result = await session.run('RETURN 1 AS test');
-            await session.close();
-            const driver = connection.getClient();
-            const serverInfo = await driver.getServerInfo();
+            const neo4j = await Promise.resolve().then(() => __importStar(require('neo4j-driver')));
+            const startTime = Date.now();
+            const testDriver = neo4j.driver(options.connectionUrl, neo4j.auth.basic('neo4j', 'password'), Object.assign(Object.assign({}, options.options), { connectionTimeout: 5000 }));
+            await testDriver.verifyConnectivity();
+            const serverInfo = await testDriver.getServerInfo();
+            await testDriver.close();
             return {
                 connected: true,
-                message: 'Connection successful',
-                databaseType: graph_types_1.GraphDatabaseType.NEO4J,
-                queryLanguage: graph_types_1.GraphQueryLanguage.CYPHER,
-                version: (_a = serverInfo.protocolVersion) === null || _a === void 0 ? void 0 : _a.toString(),
-                responseTime: Date.now() - startTime,
+                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,
-                message: 'Connection failed',
-                databaseType: graph_types_1.GraphDatabaseType.NEO4J,
-                queryLanguage: graph_types_1.GraphQueryLanguage.CYPHER,
-                responseTime: Date.now() - startTime,
+                type: enums_1.GraphType.NEO4J,
                 error: error.message,
             };
         }
     }
-    async getDatabaseInfo(connection) {
-        const session = connection.getSession();
-        try {
-            const result = await session.run('CALL dbms.components()');
-            const record = result.records[0];
-            return {
-                version: record.get('versions')[0],
-                edition: record.get('edition'),
-                features: [],
-            };
-        }
-        finally {
-            await session.close();
-        }
-    }
-    // ==================== TRANSACTION METHODS ====================
-    async beginTransaction(connection, options) {
-        const session = connection.getSession();
-        const txConfig = {};
-        if (options === null || options === void 0 ? void 0 : options.timeout) {
-            txConfig.timeout = (0, neo4j_driver_1.int)(options.timeout);
+    async disconnect() {
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
         }
-        if (options === null || options === void 0 ? void 0 : options.metadata) {
-            txConfig.metadata = options.metadata;
+        if (this.driver) {
+            await this.driver.close();
+            this.driver = null;
         }
-        const accessMode = (options === null || options === void 0 ? void 0 : options.accessMode) === 'READ'
-            ? neo4j_driver_1.default.session.READ
-            : neo4j_driver_1.default.session.WRITE;
-        const transaction = session.beginTransaction(txConfig);
-        return new Neo4jTransaction(connection, session, transaction);
+        this.connected = false;
     }
-    async commitTransaction(connection, transaction) {
-        await transaction.commit();
-    }
-    async rollbackTransaction(connection, transaction) {
-        await transaction.rollback();
-    }
-    // ==================== RAW QUERY METHODS ====================
-    async executeRaw(connection, options, transaction) {
-        const startTime = Date.now();
-        try {
-            let result;
-            if (transaction && transaction.isActive()) {
-                result = await transaction.native.run(options.query, options.params || {});
-            }
-            else {
-                const session = connection.getSession();
-                try {
-                    result = await session.run(options.query, options.params || {});
-                }
-                finally {
-                    await session.close();
-                }
-            }
-            const records = result.records.map((record) => {
-                const obj = {};
-                record.keys.forEach((key) => {
-                    obj[key] = this.convertNeo4jValue(record.get(key));
-                });
-                return obj;
-            });
-            return {
-                success: true,
-                executionTime: Date.now() - startTime,
-                data: records,
-                columns: result.records.length > 0 ? result.records[0].keys.map(k => String(k)) : [],
-                count: records.length,
-                statistics: this.parseStatistics(result.summary.counters),
-            };
+    getSession(transaction) {
+        if (transaction === null || transaction === void 0 ? void 0 : transaction.client) {
+            return transaction.client;
         }
-        catch (error) {
-            throw this.wrapError(error, graph_types_1.GraphErrorType.QUERY_ERROR, `Query execution failed: ${error.message}`, options.query, options.params);
+        if (!this.session) {
+            this.session = this.driver.session();
         }
+        return this.session;
     }
     // ==================== NODE OPERATIONS ====================
-    async createNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const labels = this.normalizeLabels(options.labels);
-        const labelStr = labels.map(l => this.escapeIdentifier(l)).join(':');
-        const { clause: propsClause, params } = this.buildPropertiesClause(options.properties);
-        const query = `CREATE (n:${labelStr} ${propsClause}) RETURN n`;
-        try {
-            const result = await this.executeRaw(connection, { query, params }, transaction);
-            const node = result.data.length > 0 ? this.parseNode(result.data[0].n) : undefined;
-            return {
-                success: true,
-                executionTime: Date.now() - startTime,
-                node,
-                created: true,
-                statistics: result.statistics,
-            };
-        }
-        catch (error) {
-            if (options.onConflict === 'ignore') {
-                return {
-                    success: true,
-                    executionTime: Date.now() - startTime,
-                    created: false,
-                };
-            }
-            throw error;
-        }
+    async createNode(options, transaction) {
+        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(connection, options, transaction) {
-        const startTime = Date.now();
-        const labels = options.labels ? this.normalizeLabels(options.labels) : [];
-        const labelStr = labels.length > 0 ? ':' + labels.map(l => this.escapeIdentifier(l)).join(':') : '';
-        let query = `MATCH (n${labelStr})`;
+    async findNodes(options, transaction) {
+        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 = {};
-        // Build WHERE clause
-        if (options.where || options.properties) {
-            const whereParts = [];
-            if (options.where) {
-                const { clause, params: whereParams } = this.buildWhereFromClause(options.where, 'n');
-                whereParts.push(clause);
-                Object.assign(params, whereParams);
-            }
-            if (options.properties) {
-                Object.entries(options.properties).forEach(([key, value], index) => {
-                    const paramName = `prop_${index}`;
-                    whereParts.push(`n.${this.escapeIdentifier(key)} = $${paramName}`);
-                    params[paramName] = value;
-                });
-            }
-            if (whereParts.length > 0) {
-                query += ` WHERE ${whereParts.join(' AND ')}`;
-            }
-        }
-        // Return specific properties or entire node
-        if (options.returnProperties && options.returnProperties.length > 0) {
-            const props = options.returnProperties.map(p => `n.${this.escapeIdentifier(p)} AS ${p}`).join(', ');
-            query += ` RETURN ${props}`;
-        }
-        else {
-            query += ` RETURN n`;
+        if (options.where) {
+            const { clause, params: whereParams } = this.buildWhereClause(options.where, 'n');
+            query += ` WHERE ${clause}`;
+            Object.assign(params, whereParams);
         }
-        // ORDER BY
-        if (options.orderBy && options.orderBy.length > 0) {
-            const orderParts = options.orderBy.map(o => `n.${this.escapeIdentifier(o.property)} ${o.direction}`);
-            query += ` ORDER BY ${orderParts.join(', ')}`;
+        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(', ')}`;
         }
-        // SKIP and LIMIT
-        if (options.skip !== undefined) {
-            query += ` SKIP ${options.skip}`;
+        if (options.offset) {
+            query += ` SKIP ${options.offset}`;
         }
-        if (options.limit !== undefined) {
+        if (options.limit) {
             query += ` LIMIT ${options.limit}`;
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = result.data.map(row => {
-            if (options.returnProperties) {
-                // Reconstruct node from properties
-                return {
-                    id: '',
-                    labels: [],
-                    properties: row,
-                };
-            }
-            return this.parseNode(row.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 {
-            success: true,
-            executionTime: Date.now() - startTime,
             nodes,
             count: nodes.length,
-            hasMore: options.limit !== undefined && nodes.length === options.limit,
         };
     }
-    async findNodeById(connection, id, transaction) {
-        const query = typeof id === 'string'
-            ? `MATCH (n) WHERE elementId(n) = $id RETURN n`
-            : `MATCH (n) WHERE id(n) = $id RETURN n`;
-        const result = await this.executeRaw(connection, { query, params: { id } }, transaction);
-        if (result.data.length === 0) {
+    async findNodeById(id, transaction) {
+        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.parseNode(result.data[0].n);
+        return this.mapNeo4jNode(result.records[0].get('n'));
     }
-    async updateNode(connection, options, transaction) {
+    async updateNode(options, transaction) {
         var _a;
-        const startTime = Date.now();
-        const params = {};
-        let matchClause = 'MATCH (n)';
-        // Build match by ID or labels
-        if (options.id !== undefined) {
-            if (typeof options.id === 'string') {
-                matchClause = 'MATCH (n) WHERE elementId(n) = $nodeId';
-            }
-            else {
-                matchClause = 'MATCH (n) WHERE id(n) = $nodeId';
-            }
-            params.nodeId = options.id;
-        }
-        else if (options.labels) {
-            const labels = this.normalizeLabels(options.labels);
-            matchClause = `MATCH (n:${labels.map(l => this.escapeIdentifier(l)).join(':')})`;
-        }
-        // Add WHERE clause
-        if (options.where) {
-            const { clause, params: whereParams } = this.buildWhereFromClause(options.where, 'n');
-            matchClause += options.id === undefined && !options.labels ? ` WHERE ${clause}` : ` AND ${clause}`;
-            Object.assign(params, whereParams);
-        }
-        const setParts = [];
-        const removeParts = [];
-        // SET properties
-        if (options.set) {
-            Object.entries(options.set).forEach(([key, value], index) => {
-                const paramName = `set_${index}`;
-                setParts.push(`n.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-        }
-        // Add labels
-        if (options.addLabels && options.addLabels.length > 0) {
-            setParts.push(`n:${options.addLabels.map(l => this.escapeIdentifier(l)).join(':')}`);
-        }
-        // REMOVE properties
-        if (options.remove && options.remove.length > 0) {
-            options.remove.forEach(prop => {
-                removeParts.push(`n.${this.escapeIdentifier(prop)}`);
-            });
-        }
-        // Remove labels
-        if (options.removeLabels && options.removeLabels.length > 0) {
-            removeParts.push(`n:${options.removeLabels.map(l => this.escapeIdentifier(l)).join(':')}`);
-        }
-        let query = matchClause;
-        if (setParts.length > 0) {
-            query += ` SET ${setParts.join(', ')}`;
+        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;
         }
-        if (removeParts.length > 0) {
-            query += ` REMOVE ${removeParts.join(', ')}`;
+        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';
         }
-        query += ' RETURN n';
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const session = this.getSession(transaction);
+        const result = await session.run(query, params);
+        const nodes = result.records.map((record) => this.mapNeo4jNode(record.get('n')));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(result.data[0].n) : undefined,
-            updated: result.data.length > 0,
-            matchedCount: result.data.length,
-            modifiedCount: ((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.propertiesSet) || 0,
-            statistics: result.statistics,
+            node: nodes.length === 1 ? nodes[0] : undefined,
+            nodes: nodes.length > 1 ? nodes : undefined,
+            updatedCount: nodes.length,
         };
     }
-    async deleteNode(connection, options, transaction) {
-        var _a, _b;
-        const startTime = Date.now();
+    async deleteNode(options, transaction) {
+        var _a, _b, _c;
+        let query;
         const params = {};
-        let matchClause = 'MATCH (n)';
-        if (options.id !== undefined) {
-            if (typeof options.id === 'string') {
-                matchClause = 'MATCH (n) WHERE elementId(n) = $nodeId';
-            }
-            else {
-                matchClause = 'MATCH (n) WHERE id(n) = $nodeId';
-            }
-            params.nodeId = options.id;
+        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 if (options.labels) {
-            const labels = this.normalizeLabels(options.labels);
-            matchClause = `MATCH (n:${labels.map(l => this.escapeIdentifier(l)).join(':')})`;
-        }
-        if (options.where) {
-            const { clause, params: whereParams } = this.buildWhereFromClause(options.where, 'n');
-            matchClause += options.id === undefined && !options.labels ? ` WHERE ${clause}` : ` AND ${clause}`;
-            Object.assign(params, whereParams);
+        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 deleteCmd = options.detach ? 'DETACH DELETE' : 'DELETE';
-        const query = `${matchClause} ${deleteCmd} n`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            deletedCount: ((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.nodesDeleted) || 0,
-            deletedRelationshipsCount: ((_b = result.statistics) === null || _b === void 0 ? void 0 : _b.relationshipsDeleted) || 0,
-            statistics: result.statistics,
+            deleted: count > 0,
+            deletedCount: count,
         };
     }
-    async mergeNode(connection, options, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const labels = this.normalizeLabels(options.labels);
-        const labelStr = labels.map(l => this.escapeIdentifier(l)).join(':');
+    async mergeNode(options, transaction) {
+        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 = {};
-        const matchProps = [];
-        Object.entries(options.matchProperties).forEach(([key, value], index) => {
-            const paramName = `match_${index}`;
-            matchProps.push(`${this.escapeIdentifier(key)}: $${paramName}`);
-            params[paramName] = value;
+        // Add match properties to params
+        Object.entries(options.matchProperties).forEach(([key, value]) => {
+            params[`match_${key}`] = value;
         });
-        let query = `MERGE (n:${labelStr} {${matchProps.join(', ')}})`;
-        if (options.onCreate && Object.keys(options.onCreate).length > 0) {
-            const createProps = [];
-            Object.entries(options.onCreate).forEach(([key, value], index) => {
-                const paramName = `create_${index}`;
-                createProps.push(`n.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` ON CREATE SET ${createProps.join(', ')}`;
-        }
-        if (options.onMatch && Object.keys(options.onMatch).length > 0) {
-            const matchSetProps = [];
-            Object.entries(options.onMatch).forEach(([key, value], index) => {
-                const paramName = `match_set_${index}`;
-                matchSetProps.push(`n.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` ON MATCH SET ${matchSetProps.join(', ')}`;
-        }
-        query += ' RETURN n';
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const created = (((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.nodesCreated) || 0) > 0;
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(result.data[0].n) : undefined,
-            created,
-            matched: !created,
-            statistics: result.statistics,
+            node,
+            created: !record.get('existed'),
         };
     }
-    // ==================== RELATIONSHIP OPERATIONS ====================
-    async createRelationship(connection, options, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const params = {};
-        const fromMatch = this.buildNodeReference(options.fromNode, 'from', params);
-        const toMatch = this.buildNodeReference(options.toNode, 'to', params);
-        let propsClause = '';
-        if (options.properties && Object.keys(options.properties).length > 0) {
-            const { clause, params: propParams } = this.buildPropertiesClause(options.properties, 'rel_');
-            propsClause = ` ${clause}`;
-            Object.assign(params, propParams);
-        }
+    // ==================== LABEL MANAGEMENT ====================
+    async addLabels(options, transaction) {
+        const labels = options.labels.map(l => `:\`${l}\``).join('');
         const query = `
-      MATCH ${fromMatch}, ${toMatch}
-      CREATE (from)-[r:${this.escapeIdentifier(options.type)}${propsClause}]->(to)
-      RETURN r, from, to
+      MATCH (n)
+      WHERE elementId(n) = $id OR id(n) = $idNum
+      SET n${labels}
+      RETURN n, labels(n) as newLabels
     `;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(result.data[0].r) : undefined,
-            created: (((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.relationshipsCreated) || 0) > 0,
-            statistics: result.statistics,
+        const params = {
+            id: String(options.id),
+            idNum: typeof options.id === 'number' ? options.id : parseInt(options.id, 10) || -1,
         };
-    }
-    async findRelationships(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        // Build relationship type pattern
-        let typePattern = '';
-        if (options.type) {
-            const types = Array.isArray(options.type) ? options.type : [options.type];
-            typePattern = ':' + types.map(t => this.escapeIdentifier(t)).join('|');
-        }
-        // Build direction pattern
-        const directionStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-        const directionEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-        let query = `MATCH (from)${directionStart}[r${typePattern}]${directionEnd}(to)`;
-        const whereParts = [];
-        // From node filter
-        if (options.fromNode) {
-            const fromWhere = this.buildNodeReferenceWhere(options.fromNode, 'from', params, 'from_');
-            if (fromWhere)
-                whereParts.push(fromWhere);
-        }
-        // To node filter
-        if (options.toNode) {
-            const toWhere = this.buildNodeReferenceWhere(options.toNode, 'to', params, 'to_');
-            if (toWhere)
-                whereParts.push(toWhere);
-        }
-        // Relationship properties filter
-        if (options.where) {
-            const { clause, params: whereParams } = this.buildRelationshipWhereClause(options.where, 'r');
-            whereParts.push(clause);
-            Object.assign(params, whereParams);
-        }
-        if (options.properties) {
-            Object.entries(options.properties).forEach(([key, value], index) => {
-                const paramName = `rel_prop_${index}`;
-                whereParts.push(`r.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-        }
-        if (whereParts.length > 0) {
-            query += ` WHERE ${whereParts.join(' AND ')}`;
-        }
-        // Return clause
-        if (options.includeNodes) {
-            query += ' RETURN r, from, to';
+        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`);
         }
-        else {
-            query += ' RETURN r';
-        }
-        // ORDER BY
-        if (options.orderBy && options.orderBy.length > 0) {
-            const orderParts = options.orderBy.map(o => `r.${this.escapeIdentifier(o.property)} ${o.direction}`);
-            query += ` ORDER BY ${orderParts.join(', ')}`;
-        }
-        // SKIP and LIMIT
-        if (options.skip !== undefined) {
-            query += ` SKIP ${options.skip}`;
-        }
-        if (options.limit !== undefined) {
-            query += ` LIMIT ${options.limit}`;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const relationships = result.data.map(row => this.parseRelationship(row.r));
+        const record = result.records[0];
+        const node = this.mapNeo4jNode(record.get('n'));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationships,
-            count: relationships.length,
-            hasMore: options.limit !== undefined && relationships.length === options.limit,
+            node,
+            addedLabels: options.labels,
         };
     }
-    async findRelationshipById(connection, id, transaction) {
-        const query = typeof id === 'string'
-            ? `MATCH ()-[r]->() WHERE elementId(r) = $id RETURN r`
-            : `MATCH ()-[r]->() WHERE id(r) = $id RETURN r`;
-        const result = await this.executeRaw(connection, { query, params: { id } }, transaction);
-        if (result.data.length === 0) {
-            return null;
-        }
-        return this.parseRelationship(result.data[0].r);
-    }
-    async updateRelationship(connection, options, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const params = {};
-        let matchClause = 'MATCH ()-[r]->()';
-        if (options.id !== undefined) {
-            if (typeof options.id === 'string') {
-                matchClause = 'MATCH ()-[r]->() WHERE elementId(r) = $relId';
-            }
-            else {
-                matchClause = 'MATCH ()-[r]->() WHERE id(r) = $relId';
-            }
-            params.relId = options.id;
-        }
-        else if (options.type) {
-            matchClause = `MATCH ()-[r:${this.escapeIdentifier(options.type)}]->()`;
-        }
-        if (options.where) {
-            const { clause, params: whereParams } = this.buildRelationshipWhereClause(options.where, 'r');
-            matchClause += options.id === undefined && !options.type ? ` WHERE ${clause}` : ` AND ${clause}`;
-            Object.assign(params, whereParams);
-        }
-        const setParts = [];
-        const removeParts = [];
-        if (options.set) {
-            Object.entries(options.set).forEach(([key, value], index) => {
-                const paramName = `set_${index}`;
-                setParts.push(`r.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-        }
-        if (options.remove && options.remove.length > 0) {
-            options.remove.forEach(prop => {
-                removeParts.push(`r.${this.escapeIdentifier(prop)}`);
-            });
-        }
-        let query = matchClause;
-        if (setParts.length > 0) {
-            query += ` SET ${setParts.join(', ')}`;
-        }
-        if (removeParts.length > 0) {
-            query += ` REMOVE ${removeParts.join(', ')}`;
+    async removeLabels(options, transaction) {
+        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`);
         }
-        query += ' RETURN r';
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const record = result.records[0];
+        const node = this.mapNeo4jNode(record.get('n'));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(result.data[0].r) : undefined,
-            updated: result.data.length > 0,
-            matchedCount: result.data.length,
-            modifiedCount: ((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.propertiesSet) || 0,
-            statistics: result.statistics,
+            node,
+            removedLabels: options.labels,
         };
     }
-    async deleteRelationship(connection, options, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const params = {};
-        let matchClause = 'MATCH ()-[r]->()';
-        if (options.id !== undefined) {
-            if (typeof options.id === 'string') {
-                matchClause = 'MATCH ()-[r]->() WHERE elementId(r) = $relId';
-            }
-            else {
-                matchClause = 'MATCH ()-[r]->() WHERE id(r) = $relId';
-            }
-            params.relId = options.id;
-        }
-        else if (options.type) {
-            const types = Array.isArray(options.type) ? options.type : [options.type];
-            matchClause = `MATCH ()-[r:${types.map(t => this.escapeIdentifier(t)).join('|')}]->()`;
-        }
-        if (options.where) {
-            const { clause, params: whereParams } = this.buildRelationshipWhereClause(options.where, 'r');
-            matchClause += options.id === undefined && !options.type ? ` WHERE ${clause}` : ` AND ${clause}`;
-            Object.assign(params, whereParams);
-        }
-        const query = `${matchClause} DELETE r`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+    async setLabels(options, transaction) {
+        // 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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            deletedCount: ((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.relationshipsDeleted) || 0,
-            statistics: result.statistics,
+            node,
+            previousLabels,
+            newLabels: options.labels,
         };
     }
-    async mergeRelationship(connection, options, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const params = {};
-        const fromMatch = this.buildNodeReference(options.fromNode, 'from', params);
-        const toMatch = this.buildNodeReference(options.toNode, 'to', params);
-        let matchPropsClause = '';
-        if (options.matchProperties && Object.keys(options.matchProperties).length > 0) {
-            const { clause, params: matchParams } = this.buildPropertiesClause(options.matchProperties, 'match_');
-            matchPropsClause = ` ${clause}`;
-            Object.assign(params, matchParams);
-        }
-        let query = `
-      MATCH ${fromMatch}, ${toMatch}
-      MERGE (from)-[r:${this.escapeIdentifier(options.type)}${matchPropsClause}]->(to)
+    // ==================== RELATIONSHIP OPERATIONS ====================
+    async createRelationship(options, transaction) {
+        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
     `;
-        if (options.onCreate && Object.keys(options.onCreate).length > 0) {
-            const createProps = [];
-            Object.entries(options.onCreate).forEach(([key, value], index) => {
-                const paramName = `create_${index}`;
-                createProps.push(`r.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` ON CREATE SET ${createProps.join(', ')}`;
-        }
-        if (options.onMatch && Object.keys(options.onMatch).length > 0) {
-            const matchSetProps = [];
-            Object.entries(options.onMatch).forEach(([key, value], index) => {
-                const paramName = `match_set_${index}`;
-                matchSetProps.push(`r.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` ON MATCH SET ${matchSetProps.join(', ')}`;
-        }
-        query += ' RETURN r';
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const created = (((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.relationshipsCreated) || 0) > 0;
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(result.data[0].r) : undefined,
-            created,
-            matched: !created,
-            statistics: result.statistics,
+            relationship: this.mapNeo4jRelationship(rel, record.get('startId'), record.get('endId')),
+            created: true,
         };
     }
-    // ==================== PATH & TRAVERSAL OPERATIONS ====================
-    async traverse(connection, options, transaction) {
-        const startTime = Date.now();
+    async findRelationships(options, transaction) {
+        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 startNodeMatch = this.buildNodeSelectorMatch(options.startNode, 'start', params);
-        // Build relationship pattern
-        const minDepth = options.minDepth || 1;
-        const maxDepth = options.maxDepth || 10;
-        const relPattern = this.buildTraversalRelPattern(options);
-        const depthPattern = minDepth === maxDepth ? `*${minDepth}` : `*${minDepth}..${maxDepth}`;
-        // Build direction
-        const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-        const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-        let query = `
-      MATCH ${startNodeMatch}
-      MATCH path = (start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end)
-    `;
-        // Add filters
-        if (options.filters) {
-            const filterParts = [];
-            if (options.filters.nodeLabels && options.filters.nodeLabels.length > 0) {
-                const labelConditions = options.filters.nodeLabels
-                    .map(l => `'${l}' IN labels(end)`)
-                    .join(' OR ');
-                filterParts.push(`(${labelConditions})`);
-            }
-            if (options.filters.stopAtLabels && options.filters.stopAtLabels.length > 0) {
-                const stopConditions = options.filters.stopAtLabels
-                    .map(l => `NOT '${l}' IN labels(end)`)
-                    .join(' AND ');
-                filterParts.push(`(${stopConditions})`);
-            }
-            if (filterParts.length > 0) {
-                query += ` WHERE ${filterParts.join(' AND ')}`;
-            }
+        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;
         }
-        // Return clause
-        const returnParts = [];
-        if (options.returnPaths) {
-            returnParts.push('path');
+        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.returnNodes) {
-            returnParts.push('COLLECT(DISTINCT end) AS nodes');
+        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 ')}`;
         }
-        if (returnParts.length === 0) {
-            returnParts.push('path');
+        query += ' RETURN r, elementId(a) as startId, elementId(b) as endId';
+        if (options.offset) {
+            query += ` SKIP ${options.offset}`;
         }
-        query += ` RETURN ${returnParts.join(', ')}`;
         if (options.limit) {
             query += ` LIMIT ${options.limit}`;
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const paths = [];
-        const nodesSet = new Map();
-        const relsSet = new Map();
-        result.data.forEach(row => {
-            if (row.path) {
-                const parsedPath = this.parsePath(row.path);
-                paths.push(parsedPath);
-                parsedPath.nodes.forEach(n => nodesSet.set(String(n.id), n));
-                parsedPath.relationships.forEach(r => relsSet.set(String(r.id), r));
-            }
-            if (row.nodes) {
-                row.nodes.forEach((n) => {
-                    const parsed = this.parseNode(n);
-                    nodesSet.set(String(parsed.id), parsed);
-                });
-            }
-        });
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            paths: options.returnPaths ? paths : undefined,
-            nodes: options.returnNodes ? Array.from(nodesSet.values()) : undefined,
-            relationships: Array.from(relsSet.values()),
-            count: paths.length,
+            relationships,
+            count: relationships.length,
         };
     }
-    async shortestPath(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        const startNodeMatch = this.buildNodeSelectorMatch(options.startNode, 'start', params);
-        const endNodeMatch = this.buildNodeSelectorMatch(options.endNode, 'end', params, 'end_');
-        const relPattern = this.buildTraversalRelPattern(options);
-        const maxDepth = options.maxDepth || '';
-        const depthPattern = maxDepth ? `*..${maxDepth}` : '*';
-        const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-        const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-        let query;
-        if (options.weightProperty && options.algorithm === path_types_1.PathAlgorithm.DIJKSTRA) {
-            // Use APOC for weighted shortest path
-            query = `
-        MATCH ${startNodeMatch}, ${endNodeMatch}
-        CALL apoc.algo.dijkstra(start, end, '${relPattern}', '${options.weightProperty}')
-        YIELD path, weight
-        RETURN path, weight
-      `;
+    async findRelationshipById(id, transaction) {
+        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;
         }
-        else if (options.returnAllShortest) {
+        const record = result.records[0];
+        return this.mapNeo4jRelationship(record.get('r'), record.get('startId'), record.get('endId'));
+    }
+    async updateRelationship(options, transaction) {
+        let query;
+        const params = { props: options.properties };
+        if (options.id) {
             query = `
-        MATCH ${startNodeMatch}, ${endNodeMatch}
-        MATCH path = allShortestPaths((start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end))
-        RETURN path
+        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 {
-            query = `
-        MATCH ${startNodeMatch}, ${endNodeMatch}
-        MATCH path = shortestPath((start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end))
-        RETURN path
-      `;
+            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 result = await this.executeRaw(connection, { query, params }, transaction);
-        if (result.data.length === 0) {
-            return {
-                success: true,
-                executionTime: Date.now() - startTime,
-                found: false,
-            };
+        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) {
+        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;
         }
-        const paths = result.data.map(row => {
-            const parsedPath = this.parsePath(row.path);
-            if (row.weight !== undefined) {
-                return Object.assign(Object.assign({}, parsedPath), { totalWeight: row.weight, weights: [] });
+        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;
             }
-            return parsedPath;
-        });
+            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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            path: options.returnAllShortest ? undefined : paths[0],
-            paths: options.returnAllShortest ? paths : undefined,
-            found: true,
-            length: paths[0].length,
-            totalWeight: paths[0].totalWeight,
+            deleted: count > 0,
+            deletedCount: count,
         };
     }
-    async allPaths(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        const startNodeMatch = this.buildNodeSelectorMatch(options.startNode, 'start', params);
-        const endNodeMatch = this.buildNodeSelectorMatch(options.endNode, 'end', params, 'end_');
-        const relPattern = this.buildTraversalRelPattern(options);
-        const minDepth = options.minDepth || 1;
-        const maxDepth = options.maxDepth || 10;
-        const depthPattern = `*${minDepth}..${maxDepth}`;
-        const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-        const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
+    async mergeRelationship(options, transaction) {
         let query = `
-      MATCH ${startNodeMatch}, ${endNodeMatch}
-      MATCH path = (start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end)
+      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) {
+        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}` : ''}
     `;
-        if (options.limit) {
-            query += ` LIMIT ${options.limit}`;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const paths = result.data.map(row => this.parsePath(row.path));
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
             paths,
             count: paths.length,
         };
     }
-    async matchPattern(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        const { pattern } = options;
-        // Build node patterns
-        const nodePatterns = [];
-        pattern.nodes.forEach(node => {
-            const labels = node.labels
-                ? ':' + (Array.isArray(node.labels) ? node.labels : [node.labels])
-                    .map(l => this.escapeIdentifier(l)).join(':')
-                : '';
-            let props = '';
-            if (node.properties && Object.keys(node.properties).length > 0) {
-                const { clause, params: nodeParams } = this.buildPropertiesClause(node.properties, `${node.variable}_`);
-                props = ` ${clause}`;
-                Object.assign(params, nodeParams);
-            }
-            nodePatterns.push(`(${node.variable}${labels}${props})`);
-        });
-        // Build relationship patterns
-        const matchClauses = [];
-        if (pattern.relationships.length === 0) {
-            // Just match nodes
-            matchClauses.push(`MATCH ${nodePatterns.join(', ')}`);
-        }
-        else {
-            pattern.relationships.forEach(rel => {
-                const startVar = rel.startNode;
-                const endVar = rel.endNode;
-                const relVar = rel.variable || '';
-                const types = rel.type
-                    ? ':' + (Array.isArray(rel.type) ? rel.type : [rel.type])
-                        .map(t => this.escapeIdentifier(t)).join('|')
-                    : '';
-                const dirStart = rel.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-                const dirEnd = rel.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-                    rel.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-                let hops = '';
-                if (rel.minHops !== undefined || rel.maxHops !== undefined) {
-                    const min = rel.minHops || '';
-                    const max = rel.maxHops || '';
-                    hops = `*${min}..${max}`;
-                }
-                matchClauses.push(`MATCH (${startVar})${dirStart}[${relVar}${types}${hops}]${dirEnd}(${endVar})`);
-            });
-        }
-        let query = matchClauses.join(' ');
-        // WHERE clause
-        if (pattern.where) {
-            const conditions = pattern.where.conditions
-                .map(c => c.expression)
-                .join(pattern.where.operator === 'OR' ? ' OR ' : ' AND ');
-            query += ` WHERE ${conditions}`;
-        }
-        // RETURN clause
-        const returnVars = options.return || pattern.nodes.map(n => n.variable);
-        query += ` RETURN ${returnVars.join(', ')}`;
-        // ORDER BY
-        if (options.orderBy && options.orderBy.length > 0) {
-            const orderParts = options.orderBy.map(o => `${o.expression} ${o.direction}`);
-            query += ` ORDER BY ${orderParts.join(', ')}`;
-        }
-        // SKIP and LIMIT
-        if (options.skip !== undefined) {
-            query += ` SKIP ${options.skip}`;
-        }
-        if (options.limit !== undefined) {
-            query += ` LIMIT ${options.limit}`;
+    async shortestPath(options, transaction) {
+        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 result = await this.executeRaw(connection, { query, params }, transaction);
+        const path = this.mapNeo4jPath(result.records[0].get('path'));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            matches: result.data,
-            count: result.data.length,
-            hasMore: options.limit !== undefined && result.data.length === options.limit,
+            path,
+            totalWeight: options.weightProperty
+                ? path.relationships.reduce((sum, r) => sum + (r.properties[options.weightProperty] || 0), 0)
+                : undefined,
         };
     }
-    async extractSubgraph(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        const startNodes = Array.isArray(options.startNodes) ? options.startNodes : [options.startNodes];
-        const startMatches = startNodes.map((node, idx) => this.buildNodeSelectorMatch(node, `start${idx}`, params, `start${idx}_`));
-        const maxDepth = options.maxDepth || 3;
-        const relPattern = this.buildTraversalRelPattern(options);
-        const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-        const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-        const startVars = startNodes.map((_, idx) => `start${idx}`).join(', ');
-        const matchPaths = startNodes.map((_, idx) => `(start${idx})${dirStart}[${relPattern}*0..${maxDepth}]${dirEnd}(n)`).join(' OR ');
-        let query = `
-      MATCH ${startMatches.join(', ')}
-      WITH ${startVars}
-      MATCH path = ${matchPaths.length > 0 ? matchPaths.replace(' OR ', '), (') : `(start0)${dirStart}[${relPattern}*0..${maxDepth}]${dirEnd}(n)`}
-      WITH COLLECT(DISTINCT n) AS nodes, COLLECT(DISTINCT relationships(path)) AS rels
-      UNWIND rels AS relList
-      UNWIND relList AS r
-      RETURN nodes, COLLECT(DISTINCT r) AS relationships
+    async allPaths(options, transaction) {
+        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 result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = [];
-        const relationships = [];
-        if (result.data.length > 0) {
-            const row = result.data[0];
-            if (row.nodes) {
-                row.nodes.forEach((n) => nodes.push(this.parseNode(n)));
-            }
-            if (row.relationships) {
-                row.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
-            }
-        }
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            subgraph: {
-                nodes,
-                relationships,
-                nodeCount: nodes.length,
-                relationshipCount: relationships.length,
-            },
+            paths,
+            count: paths.length,
         };
     }
-    async getNeighborhood(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        const centerMatch = this.buildNodeSelectorMatch(options.node, 'center', params);
+    async getNeighborhood(options, transaction) {
+        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;
-        let relTypes = '';
-        if (options.relationshipTypes && options.relationshipTypes.length > 0) {
-            relTypes = ':' + options.relationshipTypes.map(t => this.escapeIdentifier(t)).join('|');
-        }
-        const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-        const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
         const query = `
-      MATCH ${centerMatch}
-      CALL apoc.path.subgraphAll(center, {
-        relationshipFilter: '${relTypes.replace(':', '')}',
-        minLevel: ${options.includeCenter ? 0 : 1},
-        maxLevel: ${depth}
-      })
-      YIELD nodes, relationships
-      RETURN nodes, relationships
+      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
     `;
-        // Fallback query without APOC
-        const fallbackQuery = `
-      MATCH ${centerMatch}
-      MATCH path = (center)${dirStart}[${relTypes}*0..${depth}]${dirEnd}(n)
-      WITH COLLECT(DISTINCT n) AS nodes, COLLECT(DISTINCT relationships(path)) AS rels
-      UNWIND rels AS relList
-      UNWIND relList AS r
-      RETURN nodes, COLLECT(DISTINCT r) AS relationships
-    `;
-        let result;
-        try {
-            result = await this.executeRaw(connection, { query, params }, transaction);
-        }
-        catch (_a) {
-            // Fall back to non-APOC query
-            result = await this.executeRaw(connection, { query: fallbackQuery, params }, transaction);
-        }
-        const nodes = [];
-        const relationships = [];
-        const levels = new Map();
-        if (result.data.length > 0) {
-            const row = result.data[0];
-            if (row.nodes) {
-                row.nodes.forEach((n) => {
-                    const parsed = this.parseNode(n);
-                    nodes.push(parsed);
-                });
+        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));
             }
-            if (row.relationships) {
-                row.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
+            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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes,
-            relationships,
-            levels,
+            nodes: Array.from(nodesMap.values()),
+            relationships: relationshipsSet,
         };
     }
-    async findConnectedComponents(connection, options, transaction) {
-        const startTime = Date.now();
-        // Build label filter
-        let labelFilter = '';
-        if (options.labels && options.labels.length > 0) {
-            labelFilter = ':' + options.labels.map(l => this.escapeIdentifier(l)).join(':');
-        }
-        // Build relationship type filter
-        let relFilter = '';
-        if (options.relationshipTypes && options.relationshipTypes.length > 0) {
-            relFilter = ':' + options.relationshipTypes.map(t => this.escapeIdentifier(t)).join('|');
-        }
-        // Use GDS (Graph Data Science) library for connected components
+    async findConnectedComponents(options, transaction) {
+        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 = `
-      CALL gds.wcc.stream({
-        nodeQuery: 'MATCH (n${labelFilter}) RETURN id(n) AS id',
-        relationshipQuery: 'MATCH (n${labelFilter})-[r${relFilter}]-(m${labelFilter}) RETURN id(n) AS source, id(m) AS target'
-      })
-      YIELD nodeId, componentId
-      WITH componentId, COLLECT(nodeId) AS nodeIds
-      ${options.minSize ? `WHERE size(nodeIds) >= ${options.minSize}` : ''}
-      RETURN componentId, nodeIds
-      ORDER BY size(nodeIds) DESC
-    `;
-        // Fallback query without GDS
-        const fallbackQuery = `
-      MATCH (n${labelFilter})
-      WITH COLLECT(n) AS allNodes
-      UNWIND allNodes AS node
-      MATCH path = (node)-[${relFilter}*]-(connected)
-      WITH node, COLLECT(DISTINCT connected) + node AS component
-      WITH COLLECT(DISTINCT component) AS allComponents
-      UNWIND range(0, size(allComponents)-1) AS idx
-      WITH idx AS componentId, allComponents[idx] AS component
-      ${options.minSize ? `WHERE size(component) >= ${options.minSize}` : ''}
-      RETURN componentId, component AS nodes
+      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
     `;
-        let result;
-        try {
-            result = await this.executeRaw(connection, { query }, transaction);
-        }
-        catch (_a) {
-            result = await this.executeRaw(connection, { query: fallbackQuery }, transaction);
-        }
-        const components = result.data.map((row, idx) => ({
-            id: row.componentId || idx,
-            nodes: (row.nodes || []).map((n) => this.parseNode(n)),
-            size: row.nodeIds ? row.nodeIds.length : (row.nodes || []).length,
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
             components,
             count: components.length,
         };
     }
     // ==================== AGGREGATION OPERATIONS ====================
-    async countNodes(connection, labels, where, transaction) {
-        var _a;
-        const startTime = Date.now();
+    async countNodes(labels, where, transaction) {
+        var _a, _b;
+        const labelClause = (labels === null || labels === void 0 ? void 0 : labels.length) ? `:${labels.join(':')}` : '';
+        let query = `MATCH (n${labelClause})`;
         const params = {};
-        let labelStr = '';
-        if (labels) {
-            const labelArr = Array.isArray(labels) ? labels : [labels];
-            labelStr = ':' + labelArr.map(l => this.escapeIdentifier(l)).join(':');
-        }
-        let query = `MATCH (n${labelStr})`;
-        if (where && Object.keys(where).length > 0) {
-            const whereParts = [];
-            Object.entries(where).forEach(([key, value], index) => {
-                const paramName = `where_${index}`;
-                whereParts.push(`n.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` WHERE ${whereParts.join(' AND ')}`;
+        if (where) {
+            const { clause, params: whereParams } = this.buildWhereClause(where, 'n');
+            query += ` WHERE ${clause}`;
+            Object.assign(params, whereParams);
         }
-        query += ' RETURN count(n) AS count';
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        query += ' RETURN count(n) as count';
+        const session = this.getSession(transaction);
+        const result = await session.run(query, params);
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            count: this.toNumber(((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0),
+            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(connection, type, where, transaction) {
-        var _a;
-        const startTime = Date.now();
+    async countRelationships(types, where, transaction) {
+        var _a, _b;
+        const typeClause = (types === null || types === void 0 ? void 0 : types.length) ? `:${types.join('|')}` : '';
+        let query = `MATCH ()-[r${typeClause}]->()`;
         const params = {};
-        let typeStr = '';
-        if (type) {
-            const typeArr = Array.isArray(type) ? type : [type];
-            typeStr = ':' + typeArr.map(t => this.escapeIdentifier(t)).join('|');
-        }
-        let query = `MATCH ()-[r${typeStr}]->()`;
-        if (where && Object.keys(where).length > 0) {
-            const whereParts = [];
-            Object.entries(where).forEach(([key, value], index) => {
-                const paramName = `where_${index}`;
-                whereParts.push(`r.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` WHERE ${whereParts.join(' AND ')}`;
+        if (where) {
+            const { clause, params: whereParams } = this.buildWhereClause(where, 'r');
+            query += ` WHERE ${clause}`;
+            Object.assign(params, whereParams);
         }
-        query += ' RETURN count(r) AS count';
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        query += ' RETURN count(r) as count';
+        const session = this.getSession(transaction);
+        const result = await session.run(query, params);
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            count: this.toNumber(((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0),
+            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(connection, transaction) {
-        const startTime = Date.now();
-        const query = `
-      CALL apoc.meta.stats() YIELD labels, relTypesCount, nodeCount, relCount
-      RETURN labels, relTypesCount, nodeCount, relCount
-    `;
-        // Fallback without APOC
-        const fallbackQuery = `
-      MATCH (n)
-      WITH count(n) AS nodeCount
-      MATCH ()-[r]->()
-      WITH nodeCount, count(r) AS relCount
-      RETURN nodeCount, relCount
-    `;
-        let result;
-        try {
-            result = await this.executeRaw(connection, { query }, transaction);
-        }
-        catch (_a) {
-            result = await this.executeRaw(connection, { query: fallbackQuery }, transaction);
-        }
-        const row = result.data[0] || {};
+    async getStatistics(transaction) {
+        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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodeCount: this.toNumber(row.nodeCount || 0),
-            relationshipCount: this.toNumber(row.relCount || 0),
-            labelCounts: row.labels || {},
-            relationshipTypeCounts: row.relTypesCount || {},
+            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(connection, options, transaction) {
-        const startTime = Date.now();
-        let query = `
+    async fullTextSearch(options, transaction) {
+        const query = `
       CALL db.index.fulltext.queryNodes($indexName, $searchQuery)
       YIELD node, score
+      RETURN node, score
+      ${options.limit ? `LIMIT ${options.limit}` : ''}
     `;
-        if (options.labels && options.labels.length > 0) {
-            const labelConditions = options.labels.map(l => `'${l}' IN labels(node)`).join(' OR ');
-            query += ` WHERE ${labelConditions}`;
-        }
-        query += ' RETURN node';
-        if (options.score) {
-            query += ', score';
-        }
-        if (options.limit) {
-            query += ` LIMIT ${options.limit}`;
-        }
-        const params = {
-            indexName: options.index,
+        const session = this.getSession(transaction);
+        const result = await session.run(query, {
+            indexName: options.indexName,
             searchQuery: options.query,
-        };
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = result.data.map(row => {
-            const node = this.parseNode(row.node);
-            if (options.score && row.score !== undefined) {
-                return Object.assign(Object.assign({}, node), { score: row.score });
-            }
-            return node;
         });
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes,
-            count: nodes.length,
-        };
+        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(connection, options, transaction) {
-        const startTime = Date.now();
+    async vectorSearch(options, transaction) {
+        // Vector search requires Neo4j 5.13+ with vector index
         const query = `
-      CALL db.index.vector.queryNodes($indexName, $k, $vector)
+      CALL db.index.vector.queryNodes($indexName, $topK, $vector)
       YIELD node, score
-      ${options.minScore ? `WHERE score >= ${options.minScore}` : ''}
       RETURN node, score
     `;
-        const params = {
-            indexName: options.index,
-            k: options.topK,
+        const session = this.getSession(transaction);
+        const result = await session.run(query, {
+            indexName: options.indexName,
+            topK: options.topK || 10,
             vector: options.vector,
-        };
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = result.data.map(row => (Object.assign(Object.assign({}, this.parseNode(row.node)), { similarity: row.score })));
+        });
+        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) {
+        var _a, _b, _c, _d, _e, _f;
+        const session = this.getSession(transaction);
+        const result = await session.run(options.query, options.params || {});
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes,
-            count: nodes.length,
+            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 createNodeConstraint(connection, constraint, transaction) {
-        const startTime = Date.now();
+    async createNodeIndex(options) {
+        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) {
         let query;
-        const props = constraint.properties.map(p => `n.${this.escapeIdentifier(p)}`).join(', ');
-        switch (constraint.type) {
-            case node_types_1.NodeConstraintType.UNIQUE:
-                query = `CREATE CONSTRAINT ${this.escapeIdentifier(constraint.name)} FOR (n:${this.escapeIdentifier(constraint.label)}) REQUIRE (${props}) IS UNIQUE`;
-                break;
-            case node_types_1.NodeConstraintType.EXISTS:
-                query = `CREATE CONSTRAINT ${this.escapeIdentifier(constraint.name)} FOR (n:${this.escapeIdentifier(constraint.label)}) REQUIRE ${props} IS NOT NULL`;
+        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 node_types_1.NodeConstraintType.NODE_KEY:
-                query = `CREATE CONSTRAINT ${this.escapeIdentifier(constraint.name)} FOR (n:${this.escapeIdentifier(constraint.label)}) REQUIRE (${props}) IS NODE KEY`;
+            case 'EXISTS':
+                query = `CREATE CONSTRAINT ${options.name} IF NOT EXISTS FOR (n:${options.label}) REQUIRE n.${options.property} IS NOT NULL`;
                 break;
             default:
-                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `Unknown constraint type: ${constraint.type}`);
+                throw graph_error_1.GraphError.validationError(`Unsupported constraint type: ${options.type}`);
         }
-        await this.executeRaw(connection, { query }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: constraint.name,
-            created: true,
-        };
+        const session = this.getSession();
+        await session.run(query);
+        return { created: true, name: options.name };
     }
-    async createRelationshipConstraint(connection, constraint, transaction) {
-        const startTime = Date.now();
-        const props = constraint.properties.map(p => `r.${this.escapeIdentifier(p)}`).join(', ');
-        const query = `CREATE CONSTRAINT ${this.escapeIdentifier(constraint.name)} FOR ()-[r:${this.escapeIdentifier(constraint.relationshipType)}]-() REQUIRE ${props} IS NOT NULL`;
-        await this.executeRaw(connection, { query }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: constraint.name,
-            created: true,
-        };
+    async createRelationshipIndex(options) {
+        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 dropConstraint(connection, name, transaction) {
-        const startTime = Date.now();
-        const query = `DROP CONSTRAINT ${this.escapeIdentifier(name)}`;
-        await this.executeRaw(connection, { query }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name,
-            dropped: true,
-        };
+    async listIndexes() {
+        const query = 'SHOW INDEXES';
+        const session = this.getSession();
+        const result = await session.run(query);
+        const indexes = result.records.map((r) => {
+            var _a;
+            return ({
+                name: r.get('name'),
+                labelOrType: ((_a = r.get('labelsOrTypes')) === null || _a === void 0 ? void 0 : _a[0]) || '',
+                properties: r.get('properties') || [],
+                unique: r.get('uniqueness') === 'UNIQUE',
+                type: r.get('type'),
+                state: r.get('state'),
+            });
+        });
+        return { indexes };
     }
-    async listConstraints(connection, transaction) {
-        const startTime = Date.now();
+    async listConstraints() {
         const query = 'SHOW CONSTRAINTS';
-        const result = await this.executeRaw(connection, { query }, transaction);
-        const constraints = result.data.map(row => ({
-            name: row.name,
-            type: row.type,
-            entityType: row.entityType,
-            labelsOrTypes: row.labelsOrTypes || [],
-            properties: row.properties || [],
-            ownedIndex: row.ownedIndex,
-        }));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            constraints,
-        };
-    }
-    async createNodeIndex(connection, index, transaction) {
-        const startTime = Date.now();
-        const props = index.properties.map(p => `n.${this.escapeIdentifier(p)}`).join(', ');
-        let query;
-        switch (index.type) {
-            case node_types_1.NodeIndexType.BTREE:
-            case node_types_1.NodeIndexType.RANGE:
-                query = `CREATE INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON (${props})`;
-                break;
-            case node_types_1.NodeIndexType.FULLTEXT:
-                query = `CREATE FULLTEXT INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON EACH [${props}]`;
-                break;
-            case node_types_1.NodeIndexType.POINT:
-                query = `CREATE POINT INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON (${props})`;
-                break;
-            case node_types_1.NodeIndexType.TEXT:
-                query = `CREATE TEXT INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON (${props})`;
-                break;
-            case node_types_1.NodeIndexType.VECTOR:
-                const vectorOptions = index.options || {};
-                query = `CREATE VECTOR INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON (${props}) OPTIONS {indexConfig: {vector.dimensions: ${vectorOptions.dimensions || 256}, vector.similarity_function: '${vectorOptions.similarityFunction || 'cosine'}'}}`;
-                break;
+        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) {
+        const query = `DROP INDEX ${name} IF EXISTS`;
+        const session = this.getSession();
+        await session.run(query);
+        return { dropped: true };
+    }
+    async dropConstraint(name) {
+        const query = `DROP CONSTRAINT ${name} IF EXISTS`;
+        const session = this.getSession();
+        await session.run(query);
+        return { dropped: true };
+    }
+    // ==================== SCHEMA INTROSPECTION ====================
+    async listLabels() {
+        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 key, n[key] as value
+         RETURN DISTINCT key,
+                CASE
+                  WHEN value IS NULL THEN 'unknown'
+                  WHEN toInteger(value) IS NOT NULL THEN 'number'
+                  WHEN toFloat(value) IS NOT NULL THEN 'number'
+                  WHEN value =~ '.*' THEN 'string'
+                  WHEN value = true OR value = false THEN 'boolean'
+                  WHEN date(value) IS NOT NULL THEN 'date'
+                  WHEN datetime(value) IS NOT NULL THEN 'datetime'
+                  WHEN point(value) IS NOT NULL THEN 'point'
+                  WHEN value IS :: LIST 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() {
+        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:
-                query = `CREATE INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON (${props})`;
+                return 'unknown';
         }
-        await this.executeRaw(connection, { query }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: index.name,
-            created: true,
-        };
     }
-    async createRelationshipIndex(connection, index, transaction) {
-        const startTime = Date.now();
-        const props = index.properties.map(p => `r.${this.escapeIdentifier(p)}`).join(', ');
-        const query = `CREATE INDEX ${this.escapeIdentifier(index.name)} FOR ()-[r:${this.escapeIdentifier(index.relationshipType)}]-() ON (${props})`;
-        await this.executeRaw(connection, { query }, transaction);
+    // ==================== TRANSACTION OPERATIONS ====================
+    async beginTransaction(options) {
+        const session = this.driver.session();
+        const tx = session.beginTransaction();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: index.name,
-            created: true,
+            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 dropIndex(connection, name, transaction) {
-        const startTime = Date.now();
-        const query = `DROP INDEX ${this.escapeIdentifier(name)}`;
-        await this.executeRaw(connection, { query }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name,
-            dropped: true,
-        };
+    async commitTransaction(transaction) {
+        await transaction.commit();
     }
-    async listIndexes(connection, transaction) {
-        const startTime = Date.now();
-        const query = 'SHOW INDEXES';
-        const result = await this.executeRaw(connection, { query }, transaction);
-        const indexes = result.data.map(row => ({
-            name: row.name,
-            type: row.type,
-            entityType: row.entityType,
-            labelsOrTypes: row.labelsOrTypes || [],
-            properties: row.properties || [],
-            state: row.state,
-            uniqueness: row.uniqueness,
-            provider: row.provider,
-        }));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            indexes,
-        };
+    async rollbackTransaction(transaction) {
+        await transaction.rollback();
     }
     // ==================== UTILITY METHODS ====================
-    escapeIdentifier(identifier) {
-        // Neo4j identifiers can be backtick-escaped
-        if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
-            return identifier;
-        }
-        return `\`${identifier.replace(/`/g, '``')}\``;
-    }
-    escapeValue(value) {
-        if (value === null)
-            return 'null';
-        if (typeof value === 'string')
-            return `'${value.replace(/'/g, "\\'")}'`;
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'boolean')
-            return value ? 'true' : 'false';
-        if (value instanceof Date)
-            return `datetime('${value.toISOString()}')`;
-        if (Array.isArray(value))
-            return `[${value.map(v => this.escapeValue(v)).join(', ')}]`;
-        if (typeof value === 'object')
-            return `{${Object.entries(value).map(([k, v]) => `${k}: ${this.escapeValue(v)}`).join(', ')}}`;
-        return String(value);
-    }
-    buildWhereClause(where, variableName = 'n') {
+    buildWhereClause(where, alias = 'n') {
+        const conditions = [];
         const params = {};
-        const parts = [];
-        Object.entries(where).forEach(([key, value], index) => {
-            const paramName = `where_${index}`;
-            parts.push(`${variableName}.${this.escapeIdentifier(key)} = $${paramName}`);
-            params[paramName] = value;
+        let paramIndex = 0;
+        const processCondition = (key, value, prefix = '') => {
+            const fullKey = prefix ? `${prefix}_${key}` : key;
+            const paramName = `param_${paramIndex++}`;
+            if (key === '$AND') {
+                const subConditions = Object.entries(value).map(([k, v]) => {
+                    processCondition(k, v, fullKey);
+                    return conditions.pop();
+                });
+                conditions.push(`(${subConditions.join(' AND ')})`);
+                return;
+            }
+            if (key === '$OR') {
+                const subConditions = Object.entries(value).map(([k, v]) => {
+                    processCondition(k, v, fullKey);
+                    return conditions.pop();
+                });
+                conditions.push(`(${subConditions.join(' OR ')})`);
+                return;
+            }
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                Object.entries(value).forEach(([op, opValue]) => {
+                    const opParamName = `${paramName}_${op.toLowerCase()}`;
+                    switch (op) {
+                        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 '$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 '$STARTS_WITH':
+                            conditions.push(`${alias}.${key} STARTS WITH $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        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;
+                    }
+                });
+            }
+            else {
+                conditions.push(`${alias}.${key} = $${paramName}`);
+                params[paramName] = value;
+            }
+        };
+        Object.entries(where).forEach(([key, value]) => {
+            processCondition(key, value);
         });
         return {
-            clause: parts.join(' AND '),
+            clause: conditions.join(' AND ') || 'true',
             params,
         };
     }
-    // ==================== PROTECTED PARSER METHODS ====================
-    parseNode(nativeNode) {
-        if (!nativeNode) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.NODE_ERROR, 'Cannot parse null node');
-        }
-        // Handle Neo4j Node object
-        if (nativeNode.identity !== undefined) {
-            return {
-                id: this.toNumber(nativeNode.identity),
-                labels: nativeNode.labels || [],
-                properties: this.convertProperties(nativeNode.properties),
-                elementId: nativeNode.elementId,
-            };
-        }
-        // Handle plain object (from raw query results)
+    parseError(error) {
+        return graph_error_1.GraphError.wrap(error);
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    mapNeo4jNode(node) {
+        var _a;
         return {
-            id: nativeNode.id || nativeNode.identity || '',
-            labels: nativeNode.labels || [],
-            properties: (nativeNode.properties || nativeNode),
-            elementId: nativeNode.elementId,
+            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,
         };
     }
-    parseRelationship(nativeRelationship) {
-        if (!nativeRelationship) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.RELATIONSHIP_ERROR, 'Cannot parse null relationship');
-        }
-        // Handle Neo4j Relationship object
-        if (nativeRelationship.identity !== undefined) {
-            return {
-                id: this.toNumber(nativeRelationship.identity),
-                type: nativeRelationship.type,
-                startNodeId: this.toNumber(nativeRelationship.start),
-                endNodeId: this.toNumber(nativeRelationship.end),
-                properties: this.convertProperties(nativeRelationship.properties),
-                elementId: nativeRelationship.elementId,
-                startNodeElementId: nativeRelationship.startNodeElementId,
-                endNodeElementId: nativeRelationship.endNodeElementId,
-            };
-        }
+    mapNeo4jRelationship(rel, startId, endId) {
+        var _a;
         return {
-            id: nativeRelationship.id || nativeRelationship.identity || '',
-            type: nativeRelationship.type || '',
-            startNodeId: nativeRelationship.startNodeId || nativeRelationship.start || '',
-            endNodeId: nativeRelationship.endNodeId || nativeRelationship.end || '',
-            properties: (nativeRelationship.properties || nativeRelationship),
-            elementId: nativeRelationship.elementId,
+            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,
         };
     }
-    parsePath(nativePath) {
-        if (!nativePath) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.PATH_ERROR, 'Cannot parse null path');
-        }
-        // Handle Neo4j Path object
-        const nodes = [];
-        const relationships = [];
-        if (nativePath.segments) {
-            nativePath.segments.forEach((segment) => {
-                if (nodes.length === 0) {
-                    nodes.push(this.parseNode(segment.start));
-                }
-                relationships.push(this.parseRelationship(segment.relationship));
-                nodes.push(this.parseNode(segment.end));
-            });
-        }
-        else if (nativePath.nodes && nativePath.relationships) {
-            nativePath.nodes.forEach((n) => nodes.push(this.parseNode(n)));
-            nativePath.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
-        }
+    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,
-            start: nodes[0],
-            end: nodes[nodes.length - 1],
         };
     }
-    // ==================== PRIVATE HELPER METHODS ====================
+    convertNeo4jProperties(props) {
+        const result = {};
+        for (const [key, value] of Object.entries(props)) {
+            result[key] = this.convertNeo4jValue(value);
+        }
+        return result;
+    }
     convertNeo4jValue(value) {
-        if (value === null || value === undefined)
+        var _a, _b;
+        if (value === null || value === undefined) {
             return value;
-        // Handle Neo4j Integer
-        if (neo4j_driver_1.default.isInt(value)) {
-            return this.toNumber(value);
         }
-        // Handle Neo4j Node
-        if (value.labels !== undefined && value.properties !== undefined) {
-            return this.parseNode(value);
-        }
-        // Handle Neo4j Relationship
-        if (value.type !== undefined && value.start !== undefined && value.end !== undefined) {
-            return this.parseRelationship(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 Path
-        if (value.segments !== undefined) {
-            return this.parsePath(value);
+        // 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());
         }
-        // Handle arrays
         if (Array.isArray(value)) {
             return value.map(v => this.convertNeo4jValue(v));
         }
-        // Handle objects
-        if (typeof value === 'object') {
-            const converted = {};
-            Object.entries(value).forEach(([key, val]) => {
-                converted[key] = this.convertNeo4jValue(val);
-            });
-            return converted;
-        }
         return value;
     }
-    convertProperties(properties) {
-        if (!properties)
-            return {};
-        const converted = {};
-        Object.entries(properties).forEach(([key, value]) => {
-            converted[key] = this.convertNeo4jValue(value);
-        });
-        return converted;
-    }
-    toNumber(value) {
-        if (neo4j_driver_1.default.isInt(value)) {
-            return value.toNumber();
-        }
-        if (typeof value === 'number') {
-            return value;
-        }
-        return parseInt(value, 10) || 0;
-    }
-    normalizeLabels(labels) {
-        return Array.isArray(labels) ? labels : [labels];
-    }
-    buildPropertiesClause(properties, prefix = '') {
-        const params = {};
-        const propParts = [];
-        Object.entries(properties).forEach(([key, value], index) => {
-            const paramName = `${prefix}prop_${index}`;
-            propParts.push(`${this.escapeIdentifier(key)}: $${paramName}`);
-            params[paramName] = value;
-        });
-        return {
-            clause: `{${propParts.join(', ')}}`,
-            params,
-        };
-    }
-    buildNodeReference(ref, alias, params, prefix = '') {
-        let pattern = `(${alias}`;
-        if (ref.labels) {
-            const labels = this.normalizeLabels(ref.labels);
-            pattern += ':' + labels.map(l => this.escapeIdentifier(l)).join(':');
-        }
-        if (ref.id !== undefined) {
-            const paramName = `${prefix}id`;
-            params[paramName] = ref.id;
-            pattern += ` {id: $${paramName}}`;
-        }
-        else if (ref.properties && Object.keys(ref.properties).length > 0) {
-            const { clause, params: propParams } = this.buildPropertiesClause(ref.properties, prefix);
-            pattern += ` ${clause}`;
-            Object.assign(params, propParams);
-        }
-        pattern += ')';
-        return pattern;
-    }
-    buildNodeReferenceWhere(ref, alias, params, prefix = '') {
-        const parts = [];
-        if (ref.id !== undefined) {
-            const paramName = `${prefix}id`;
-            params[paramName] = ref.id;
-            if (typeof ref.id === 'string') {
-                parts.push(`elementId(${alias}) = $${paramName}`);
-            }
-            else {
-                parts.push(`id(${alias}) = $${paramName}`);
-            }
-        }
-        if (ref.labels) {
-            const labels = this.normalizeLabels(ref.labels);
-            labels.forEach(label => {
-                parts.push(`'${label}' IN labels(${alias})`);
-            });
-        }
-        if (ref.properties) {
-            Object.entries(ref.properties).forEach(([key, value], index) => {
-                const paramName = `${prefix}prop_${index}`;
-                parts.push(`${alias}.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-        }
-        return parts.join(' AND ');
-    }
-    buildWhereFromClause(where, alias, prefix = '') {
-        const params = {};
-        const clause = this.buildWhereCondition(where, alias, params, prefix);
-        return { clause, params };
-    }
-    buildWhereCondition(where, alias, params, prefix, index = 0) {
-        const paramName = `${prefix}where_${index}`;
-        let condition;
-        switch (where.operator) {
-            case node_types_1.NodeComparisonOperator.IS_NULL:
-                condition = `${alias}.${this.escapeIdentifier(where.property)} IS NULL`;
-                break;
-            case node_types_1.NodeComparisonOperator.IS_NOT_NULL:
-                condition = `${alias}.${this.escapeIdentifier(where.property)} IS NOT NULL`;
-                break;
-            case node_types_1.NodeComparisonOperator.IN:
-            case node_types_1.NodeComparisonOperator.NOT_IN:
-                params[paramName] = where.value;
-                condition = `${alias}.${this.escapeIdentifier(where.property)} ${where.operator} $${paramName}`;
-                break;
-            case node_types_1.NodeComparisonOperator.CONTAINS:
-                params[paramName] = where.value;
-                condition = `${alias}.${this.escapeIdentifier(where.property)} CONTAINS $${paramName}`;
-                break;
-            case node_types_1.NodeComparisonOperator.STARTS_WITH:
-                params[paramName] = where.value;
-                condition = `${alias}.${this.escapeIdentifier(where.property)} STARTS WITH $${paramName}`;
-                break;
-            case node_types_1.NodeComparisonOperator.ENDS_WITH:
-                params[paramName] = where.value;
-                condition = `${alias}.${this.escapeIdentifier(where.property)} ENDS WITH $${paramName}`;
-                break;
-            case node_types_1.NodeComparisonOperator.REGEX:
-                params[paramName] = where.value;
-                condition = `${alias}.${this.escapeIdentifier(where.property)} =~ $${paramName}`;
-                break;
+    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:
-                params[paramName] = where.value;
-                condition = `${alias}.${this.escapeIdentifier(where.property)} ${where.operator} $${paramName}`;
-        }
-        // Handle AND conditions
-        if (where.and && where.and.length > 0) {
-            const andClauses = where.and.map((w, i) => this.buildWhereCondition(w, alias, params, prefix, index + i + 1));
-            condition = `(${condition} AND ${andClauses.join(' AND ')})`;
-        }
-        // Handle OR conditions
-        if (where.or && where.or.length > 0) {
-            const orClauses = where.or.map((w, i) => this.buildWhereCondition(w, alias, params, prefix, index + i + 100));
-            condition = `(${condition} OR ${orClauses.join(' OR ')})`;
-        }
-        return condition;
-    }
-    buildRelationshipWhereClause(where, alias, prefix = '') {
-        const params = {};
-        const clause = this.buildRelationshipWhereCondition(where, alias, params, prefix);
-        return { clause, params };
-    }
-    buildRelationshipWhereCondition(where, alias, params, prefix, index = 0) {
-        const paramName = `${prefix}relwhere_${index}`;
-        params[paramName] = where.value;
-        let condition = `${alias}.${this.escapeIdentifier(where.property)} ${where.operator} $${paramName}`;
-        if (where.and && where.and.length > 0) {
-            const andClauses = where.and.map((w, i) => this.buildRelationshipWhereCondition(w, alias, params, prefix, index + i + 1));
-            condition = `(${condition} AND ${andClauses.join(' AND ')})`;
-        }
-        if (where.or && where.or.length > 0) {
-            const orClauses = where.or.map((w, i) => this.buildRelationshipWhereCondition(w, alias, params, prefix, index + i + 100));
-            condition = `(${condition} OR ${orClauses.join(' OR ')})`;
+                return { left: '-', right: '-' };
         }
-        return condition;
-    }
-    buildNodeSelectorMatch(selector, alias, params, prefix = '') {
-        let pattern = `(${alias}`;
-        if (selector.labels) {
-            const labels = this.normalizeLabels(selector.labels);
-            pattern += ':' + labels.map((l) => this.escapeIdentifier(l)).join(':');
-        }
-        pattern += ')';
-        const whereParts = [];
-        if (selector.id !== undefined) {
-            const paramName = `${prefix}id`;
-            params[paramName] = selector.id;
-            if (typeof selector.id === 'string') {
-                whereParts.push(`elementId(${alias}) = $${paramName}`);
-            }
-            else {
-                whereParts.push(`id(${alias}) = $${paramName}`);
-            }
-        }
-        if (selector.properties && Object.keys(selector.properties).length > 0) {
-            Object.entries(selector.properties).forEach(([key, value], index) => {
-                const paramName = `${prefix}prop_${index}`;
-                whereParts.push(`${alias}.${this.escapeIdentifier(key)} = $${paramName}`);
-                params[paramName] = value;
-            });
-        }
-        if (selector.where) {
-            const { clause, params: whereParams } = this.buildWhereFromClause(selector.where, alias, prefix);
-            whereParts.push(clause);
-            Object.assign(params, whereParams);
-        }
-        if (whereParts.length > 0) {
-            return `${pattern} WHERE ${whereParts.join(' AND ')}`;
-        }
-        return pattern;
-    }
-    buildTraversalRelPattern(options) {
-        if (!options.relationships)
-            return '';
-        const patterns = Array.isArray(options.relationships)
-            ? options.relationships
-            : [options.relationships];
-        const types = patterns
-            .filter((p) => p.type)
-            .map((p) => {
-            const types = Array.isArray(p.type) ? p.type : [p.type];
-            return types.map((t) => this.escapeIdentifier(t));
-        })
-            .flat();
-        return types.length > 0 ? ':' + types.join('|') : '';
-    }
-    parseStatistics(counters) {
-        if (!counters)
-            return undefined;
-        return {
-            nodesCreated: counters.nodesCreated ? counters.nodesCreated() : 0,
-            nodesDeleted: counters.nodesDeleted ? counters.nodesDeleted() : 0,
-            relationshipsCreated: counters.relationshipsCreated ? counters.relationshipsCreated() : 0,
-            relationshipsDeleted: counters.relationshipsDeleted ? counters.relationshipsDeleted() : 0,
-            propertiesSet: counters.propertiesSet ? counters.propertiesSet() : 0,
-            labelsAdded: counters.labelsAdded ? counters.labelsAdded() : 0,
-            labelsRemoved: counters.labelsRemoved ? counters.labelsRemoved() : 0,
-            indexesAdded: counters.indexesAdded ? counters.indexesAdded() : 0,
-            indexesRemoved: counters.indexesRemoved ? counters.indexesRemoved() : 0,
-            constraintsAdded: counters.constraintsAdded ? counters.constraintsAdded() : 0,
-            constraintsRemoved: counters.constraintsRemoved ? counters.constraintsRemoved() : 0,
-            containsUpdates: counters.containsUpdates ? counters.containsUpdates() : false,
-        };
     }
 }
 exports.Neo4jAdapter = Neo4jAdapter;
-exports.default = Neo4jAdapter;
 //# sourceMappingURL=neo4j.adapter.js.map