@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,1861 @@
+"use strict";
+/**
+ * Neo4j Graph Database Adapter
+ * Implements the BaseGraphAdapter for Neo4j databases using the official neo4j-driver
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Neo4jAdapter = void 0;
+const neo4j_driver_1 = __importStar(require("neo4j-driver"));
+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");
+/**
+ * Neo4j connection 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;
+        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;
+        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
+            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;
+        }
+        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);
+        }
+    }
+    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) {
+        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();
+            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,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                message: 'Connection failed',
+                databaseType: graph_types_1.GraphDatabaseType.NEO4J,
+                queryLanguage: graph_types_1.GraphQueryLanguage.CYPHER,
+                responseTime: Date.now() - startTime,
+                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);
+        }
+        if (options === null || options === void 0 ? void 0 : options.metadata) {
+            txConfig.metadata = options.metadata;
+        }
+        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);
+    }
+    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),
+            };
+        }
+        catch (error) {
+            throw this.wrapError(error, graph_types_1.GraphErrorType.QUERY_ERROR, `Query execution failed: ${error.message}`, options.query, options.params);
+        }
+    }
+    // ==================== 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 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})`;
+        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`;
+        }
+        // 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(', ')}`;
+        }
+        // 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 nodes = result.data.map(row => {
+            if (options.returnProperties) {
+                // Reconstruct node from properties
+                return {
+                    id: '',
+                    labels: [],
+                    properties: row,
+                };
+            }
+            return this.parseNode(row.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) {
+            return null;
+        }
+        return this.parseNode(result.data[0].n);
+    }
+    async updateNode(connection, 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(', ')}`;
+        }
+        if (removeParts.length > 0) {
+            query += ` REMOVE ${removeParts.join(', ')}`;
+        }
+        query += ' RETURN n';
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        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,
+        };
+    }
+    async deleteNode(connection, options, transaction) {
+        var _a, _b;
+        const startTime = Date.now();
+        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;
+        }
+        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);
+        }
+        const deleteCmd = options.detach ? 'DETACH DELETE' : 'DELETE';
+        const query = `${matchClause} ${deleteCmd} n`;
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        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,
+        };
+    }
+    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(':');
+        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;
+        });
+        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;
+        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,
+        };
+    }
+    // ==================== 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);
+        }
+        const query = `
+      MATCH ${fromMatch}, ${toMatch}
+      CREATE (from)-[r:${this.escapeIdentifier(options.type)}${propsClause}]->(to)
+      RETURN r, from, to
+    `;
+        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,
+        };
+    }
+    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';
+        }
+        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));
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            relationships,
+            count: relationships.length,
+            hasMore: options.limit !== undefined && relationships.length === options.limit,
+        };
+    }
+    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(', ')}`;
+        }
+        query += ' RETURN r';
+        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,
+            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,
+        };
+    }
+    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);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            deletedCount: ((_a = result.statistics) === null || _a === void 0 ? void 0 : _a.relationshipsDeleted) || 0,
+            statistics: result.statistics,
+        };
+    }
+    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)
+    `;
+        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;
+        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,
+        };
+    }
+    // ==================== PATH & TRAVERSAL OPERATIONS ====================
+    async traverse(connection, options, transaction) {
+        const startTime = Date.now();
+        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 ')}`;
+            }
+        }
+        // Return clause
+        const returnParts = [];
+        if (options.returnPaths) {
+            returnParts.push('path');
+        }
+        if (options.returnNodes) {
+            returnParts.push('COLLECT(DISTINCT end) AS nodes');
+        }
+        if (returnParts.length === 0) {
+            returnParts.push('path');
+        }
+        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);
+                });
+            }
+        });
+        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,
+        };
+    }
+    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
+      `;
+        }
+        else if (options.returnAllShortest) {
+            query = `
+        MATCH ${startNodeMatch}, ${endNodeMatch}
+        MATCH path = allShortestPaths((start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end))
+        RETURN path
+      `;
+        }
+        else {
+            query = `
+        MATCH ${startNodeMatch}, ${endNodeMatch}
+        MATCH path = shortestPath((start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end))
+        RETURN path
+      `;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        if (result.data.length === 0) {
+            return {
+                success: true,
+                executionTime: Date.now() - startTime,
+                found: false,
+            };
+        }
+        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: [] });
+            }
+            return parsedPath;
+        });
+        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,
+        };
+    }
+    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 ? '->' : '-';
+        let query = `
+      MATCH ${startNodeMatch}, ${endNodeMatch}
+      MATCH path = (start)${dirStart}[${relPattern}${depthPattern}]${dirEnd}(end)
+      RETURN path
+    `;
+        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));
+        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}`;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            matches: result.data,
+            count: result.data.length,
+            hasMore: options.limit !== undefined && result.data.length === options.limit,
+        };
+    }
+    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
+    `;
+        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)));
+            }
+        }
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            subgraph: {
+                nodes,
+                relationships,
+                nodeCount: nodes.length,
+                relationshipCount: relationships.length,
+            },
+        };
+    }
+    async getNeighborhood(connection, options, transaction) {
+        const startTime = Date.now();
+        const params = {};
+        const centerMatch = this.buildNodeSelectorMatch(options.node, 'center', params);
+        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
+    `;
+        // 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);
+                });
+            }
+            if (row.relationships) {
+                row.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
+            }
+        }
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            nodes,
+            relationships,
+            levels,
+        };
+    }
+    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
+        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
+    `;
+        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,
+        }));
+        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();
+        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 ')}`;
+        }
+        query += ' RETURN count(n) AS count';
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            count: this.toNumber(((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0),
+        };
+    }
+    async countRelationships(connection, type, where, transaction) {
+        var _a;
+        const startTime = Date.now();
+        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 ')}`;
+        }
+        query += ' RETURN count(r) AS count';
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            count: this.toNumber(((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 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] || {};
+        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 || {},
+        };
+    }
+    // ==================== SEARCH OPERATIONS ====================
+    async fullTextSearch(connection, options, transaction) {
+        const startTime = Date.now();
+        let query = `
+      CALL db.index.fulltext.queryNodes($indexName, $searchQuery)
+      YIELD node, score
+    `;
+        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,
+            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,
+        };
+    }
+    async vectorSearch(connection, options, transaction) {
+        const startTime = Date.now();
+        const query = `
+      CALL db.index.vector.queryNodes($indexName, $k, $vector)
+      YIELD node, score
+      ${options.minScore ? `WHERE score >= ${options.minScore}` : ''}
+      RETURN node, score
+    `;
+        const params = {
+            indexName: options.index,
+            k: options.topK,
+            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 })));
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            nodes,
+            count: nodes.length,
+        };
+    }
+    // ==================== SCHEMA OPERATIONS ====================
+    async createNodeConstraint(connection, constraint, transaction) {
+        const startTime = Date.now();
+        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`;
+                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`;
+                break;
+            default:
+                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `Unknown constraint type: ${constraint.type}`);
+        }
+        await this.executeRaw(connection, { query }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            name: constraint.name,
+            created: true,
+        };
+    }
+    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 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 listConstraints(connection, transaction) {
+        const startTime = Date.now();
+        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;
+            default:
+                query = `CREATE INDEX ${this.escapeIdentifier(index.name)} FOR (n:${this.escapeIdentifier(index.label)}) ON (${props})`;
+        }
+        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);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            name: index.name,
+            created: true,
+        };
+    }
+    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 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,
+        };
+    }
+    // ==================== 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') {
+        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;
+        });
+        return {
+            clause: parts.join(' AND '),
+            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)
+        return {
+            id: nativeNode.id || nativeNode.identity || '',
+            labels: nativeNode.labels || [],
+            properties: (nativeNode.properties || nativeNode),
+            elementId: nativeNode.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,
+            };
+        }
+        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,
+        };
+    }
+    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)));
+        }
+        return {
+            nodes,
+            relationships,
+            length: relationships.length,
+            start: nodes[0],
+            end: nodes[nodes.length - 1],
+        };
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    convertNeo4jValue(value) {
+        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 Path
+        if (value.segments !== undefined) {
+            return this.parsePath(value);
+        }
+        // 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;
+            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 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