@ductape/sdk 0.0.4-v9 → 0.0.4-v91

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

@@ -0,0 +1,1452 @@
+"use strict";
+/**
+ * Memgraph Graph Database Adapter
+ *
+ * Implements the BaseGraphAdapter for Memgraph.
+ * Memgraph is a high-performance, in-memory graph database
+ * that is fully compatible with Neo4j's Bolt protocol and Cypher query language.
+ *
+ * Key features:
+ * - Cypher query language compatibility
+ * - Bolt protocol support
+ * - In-memory performance
+ * - Triggers and streams support
+ * - MAGE graph algorithms library
+ */
+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.MemgraphAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const enums_1 = require("../types/enums");
+const graph_error_1 = require("../utils/graph-error");
+/**
+ * Memgraph adapter - Cypher-compatible graph database
+ * Uses the neo4j-driver package as Memgraph supports the Bolt protocol
+ */
+class MemgraphAdapter extends base_adapter_1.BaseGraphAdapter {
+    constructor() {
+        super(...arguments);
+        this.graphType = enums_1.GraphType.MEMGRAPH;
+        this.supportedFeatures = new Set([
+            enums_1.GraphFeature.TRANSACTIONS,
+            enums_1.GraphFeature.SCHEMA_INDEXES,
+            enums_1.GraphFeature.TRIGGERS,
+            enums_1.GraphFeature.CHANGE_STREAMS,
+            enums_1.GraphFeature.GRAPH_ALGORITHMS,
+        ]);
+        this.driver = null;
+        this.session = null;
+    }
+    // ==================== CONNECTION MANAGEMENT ====================
+    async connect(options) {
+        var _a, _b;
+        try {
+            // Store connection options for reconnection
+            this.connectionOptions = options;
+            // Memgraph uses the Bolt protocol, compatible with neo4j-driver
+            const neo4j = await Promise.resolve().then(() => __importStar(require('neo4j-driver')));
+            const auth = options.auth
+                ? neo4j.auth.basic(options.auth.username, options.auth.password)
+                : neo4j.auth.basic('', ''); // Memgraph can run without auth
+            // Check if encryption is already specified in the URL scheme
+            // bolt+s:// and bolt+ssc:// indicate encryption is configured via URL
+            const urlHasEncryption = options.connectionUrl.startsWith('bolt+s://') ||
+                options.connectionUrl.startsWith('bolt+ssc://') ||
+                options.connectionUrl.startsWith('neo4j+s://') ||
+                options.connectionUrl.startsWith('neo4j+ssc://');
+            // Build driver config - only set encrypted if URL doesn't already specify it
+            const driverConfig = Object.assign({}, options.options);
+            if (!urlHasEncryption) {
+                // Only set encrypted option when URL doesn't already configure it
+                driverConfig.encrypted = (_b = (_a = options.options) === null || _a === void 0 ? void 0 : _a.encrypted) !== null && _b !== void 0 ? _b : false;
+            }
+            else {
+                // Remove any conflicting encryption settings when URL specifies encryption
+                delete driverConfig.encrypted;
+                delete driverConfig.trust;
+            }
+            this.driver = neo4j.driver(options.connectionUrl, auth, driverConfig);
+            // Verify connection
+            await this.driver.verifyConnectivity();
+            this.connected = true;
+            this.connectionUrl = options.connectionUrl;
+            return {
+                connected: true,
+                type: enums_1.GraphType.MEMGRAPH,
+                latency: 0,
+            };
+        }
+        catch (error) {
+            this.connected = false;
+            throw graph_error_1.GraphError.connectionError(`Failed to connect to Memgraph: ${error.message}`, error);
+        }
+    }
+    async testConnection(options) {
+        try {
+            const neo4j = await Promise.resolve().then(() => __importStar(require('neo4j-driver')));
+            const startTime = Date.now();
+            const auth = options.auth
+                ? neo4j.auth.basic(options.auth.username, options.auth.password)
+                : neo4j.auth.basic('', '');
+            // Check if encryption is already specified in the URL scheme
+            const urlHasEncryption = options.connectionUrl.startsWith('bolt+s://') ||
+                options.connectionUrl.startsWith('bolt+ssc://') ||
+                options.connectionUrl.startsWith('neo4j+s://') ||
+                options.connectionUrl.startsWith('neo4j+ssc://');
+            // Build driver config - avoid conflicting encryption settings
+            const driverConfig = Object.assign(Object.assign({}, options.options), { connectionTimeout: 5000 });
+            if (urlHasEncryption) {
+                delete driverConfig.encrypted;
+                delete driverConfig.trust;
+            }
+            const testDriver = neo4j.driver(options.connectionUrl, auth, driverConfig);
+            await testDriver.verifyConnectivity();
+            // Get Memgraph version
+            const session = testDriver.session();
+            const result = await session.run('CALL mg.info() YIELD key, value WHERE key = "version" RETURN value');
+            const version = result.records.length > 0 ? result.records[0].get('value') : 'unknown';
+            await session.close();
+            await testDriver.close();
+            return {
+                connected: true,
+                type: enums_1.GraphType.MEMGRAPH,
+                version,
+                latency: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                type: enums_1.GraphType.MEMGRAPH,
+                error: error.message,
+            };
+        }
+    }
+    async disconnect() {
+        if (this.session) {
+            await this.session.close();
+            this.session = null;
+        }
+        if (this.driver) {
+            await this.driver.close();
+            this.driver = null;
+        }
+        this.connected = false;
+    }
+    getSession(transaction) {
+        if (transaction === null || transaction === void 0 ? void 0 : transaction.client) {
+            return transaction.client;
+        }
+        if (!this.session) {
+            this.ensureConnected();
+            this.session = this.driver.session();
+        }
+        return this.session;
+    }
+    // ==================== NODE OPERATIONS ====================
+    async createNode(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const labels = options.labels.join(':');
+            const query = `CREATE (n:${labels} $props) RETURN n, id(n) as nodeId`;
+            const session = this.getSession(transaction);
+            const result = await session.run(query, { props: options.properties });
+            const record = result.records[0];
+            const node = record.get('n');
+            const nodeId = record.get('nodeId');
+            return {
+                node: this.mapMemgraphNode(node, nodeId),
+                created: true,
+            };
+        });
+    }
+    async findNodes(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a, _b;
+            const labels = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.join(':')) || '';
+            const labelClause = labels ? `:${labels}` : '';
+            let query = `MATCH (n${labelClause})`;
+            const params = {};
+            if (options.where) {
+                const { clause, params: whereParams } = this.buildWhereClause(options.where, 'n');
+                query += ` WHERE ${clause}`;
+                Object.assign(params, whereParams);
+            }
+            query += ' RETURN n, id(n) as nodeId';
+            if ((_b = options.orderBy) === null || _b === void 0 ? void 0 : _b.length) {
+                const orderClauses = options.orderBy.map(o => `n.${o.property} ${o.direction.toUpperCase()}`);
+                query += ` ORDER BY ${orderClauses.join(', ')}`;
+            }
+            if (options.skip) {
+                query += ` SKIP ${options.skip}`;
+            }
+            if (options.limit) {
+                query += ` LIMIT ${options.limit}`;
+            }
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const nodes = result.records.map((record) => this.mapMemgraphNode(record.get('n'), record.get('nodeId')));
+            return {
+                nodes,
+                count: nodes.length,
+            };
+        });
+    }
+    async findNodeById(id, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // Memgraph uses internal id() function
+            const query = `MATCH (n) WHERE id(n) = $id RETURN n, id(n) as nodeId`;
+            const session = this.getSession(transaction);
+            const result = await session.run(query, {
+                id: typeof id === 'number' ? id : parseInt(id, 10),
+            });
+            if (result.records.length === 0) {
+                return null;
+            }
+            return this.mapMemgraphNode(result.records[0].get('n'), result.records[0].get('nodeId'));
+        });
+    }
+    async updateNode(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            let query;
+            const params = { props: options.properties };
+            if (options.id) {
+                query = `MATCH (n) WHERE id(n) = $id SET n += $props RETURN n, id(n) as nodeId`;
+                params.id = typeof options.id === 'number' ? options.id : parseInt(options.id, 10);
+            }
+            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, id(n) as nodeId';
+            }
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const nodes = result.records.map((record) => this.mapMemgraphNode(record.get('n'), record.get('nodeId')));
+            return {
+                node: nodes.length === 1 ? nodes[0] : undefined,
+                nodes: nodes.length > 1 ? nodes : undefined,
+                updatedCount: nodes.length,
+                updated: nodes.length > 0,
+            };
+        });
+    }
+    async deleteNode(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            let query;
+            const params = {};
+            const detach = options.detach ? 'DETACH ' : '';
+            if (options.id) {
+                query = `MATCH (n) WHERE id(n) = $id ${detach}DELETE n`;
+                params.id = typeof options.id === 'number' ? options.id : parseInt(options.id, 10);
+            }
+            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`;
+            }
+            const session = this.getSession(transaction);
+            await session.run(query, params);
+            return {
+                deleted: true,
+                deletedCount: 1,
+            };
+        });
+    }
+    async mergeNode(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const labels = options.labels.join(':');
+            const matchProps = Object.entries(options.matchProperties)
+                .map(([key]) => `${key}: $match_${key}`)
+                .join(', ');
+            let query = `MERGE (n:${labels} {${matchProps}})`;
+            const params = {};
+            // Add match properties to params
+            Object.entries(options.matchProperties).forEach(([key, value]) => {
+                params[`match_${key}`] = value;
+            });
+            if (options.onCreate) {
+                query += ' ON CREATE SET n += $onCreateProps';
+                params.onCreateProps = options.onCreate;
+            }
+            if (options.onMatch) {
+                query += ' ON MATCH SET n += $onMatchProps';
+                params.onMatchProps = options.onMatch;
+            }
+            query += ' RETURN n, id(n) as nodeId';
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const record = result.records[0];
+            const node = this.mapMemgraphNode(record.get('n'), record.get('nodeId'));
+            return {
+                node,
+                created: true, // Memgraph doesn't easily tell us if it was created or matched
+                merged: true,
+            };
+        });
+    }
+    // ==================== LABEL MANAGEMENT ====================
+    async addLabels(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const labels = options.labels.map(l => `:\`${l}\``).join('');
+            const query = `
+        MATCH (n)
+        WHERE id(n) = $id
+        SET n${labels}
+        RETURN n, id(n) as nodeId
+      `;
+            const params = {
+                id: typeof options.id === 'number' ? options.id : parseInt(options.id, 10),
+            };
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            if (result.records.length === 0) {
+                throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
+            }
+            const record = result.records[0];
+            const node = this.mapMemgraphNode(record.get('n'), record.get('nodeId'));
+            return {
+                node,
+                addedLabels: options.labels,
+            };
+        });
+    }
+    async removeLabels(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const labels = options.labels.map(l => `:\`${l}\``).join('');
+            const query = `
+        MATCH (n)
+        WHERE id(n) = $id
+        REMOVE n${labels}
+        RETURN n, id(n) as nodeId
+      `;
+            const params = {
+                id: typeof options.id === 'number' ? options.id : parseInt(options.id, 10),
+            };
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            if (result.records.length === 0) {
+                throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
+            }
+            const record = result.records[0];
+            const node = this.mapMemgraphNode(record.get('n'), record.get('nodeId'));
+            return {
+                node,
+                removedLabels: options.labels,
+            };
+        });
+    }
+    async setLabels(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // First get current labels
+            const getQuery = `
+        MATCH (n)
+        WHERE id(n) = $id
+        RETURN labels(n) as currentLabels
+      `;
+            const params = {
+                id: typeof options.id === 'number' ? options.id : parseInt(options.id, 10),
+            };
+            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 id(n) = $id
+        REMOVE n${removeLabels}
+        SET n${addLabels}
+        RETURN n, id(n) as nodeId
+      `;
+            const result = await session.run(setQuery, params);
+            const node = this.mapMemgraphNode(result.records[0].get('n'), result.records[0].get('nodeId'));
+            return {
+                node,
+                previousLabels,
+                newLabels: options.labels,
+            };
+        });
+    }
+    // ==================== RELATIONSHIP OPERATIONS ====================
+    async createRelationship(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const query = `
+        MATCH (a), (b)
+        WHERE id(a) = $startId AND id(b) = $endId
+        CREATE (a)-[r:${options.type} $props]->(b)
+        RETURN r, id(r) as relId, id(a) as startId, id(b) as endId
+      `;
+            const params = {
+                startId: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10),
+                endId: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10),
+                props: options.properties || {},
+            };
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const record = result.records[0];
+            const rel = record.get('r');
+            return {
+                relationship: this.mapMemgraphRelationship(rel, record.get('relId'), record.get('startId'), record.get('endId')),
+                created: true,
+            };
+        });
+    }
+    async findRelationships(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const types = options.type
+                ? (Array.isArray(options.type) ? options.type.join('|') : options.type)
+                : (options.types ? options.types.join('|') : '');
+            const typeClause = types ? `:${types}` : '';
+            let query = `MATCH (a)-[r${typeClause}]->(b)`;
+            const params = {};
+            const conditions = [];
+            if (options.startNodeId) {
+                conditions.push('id(a) = $startId');
+                params.startId = typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10);
+            }
+            if (options.endNodeId) {
+                conditions.push('id(b) = $endId');
+                params.endId = typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10);
+            }
+            if (options.where) {
+                const { clause, params: whereParams } = this.buildWhereClause(options.where, 'r');
+                conditions.push(clause);
+                Object.assign(params, whereParams);
+            }
+            if (conditions.length > 0) {
+                query += ` WHERE ${conditions.join(' AND ')}`;
+            }
+            query += ' RETURN r, id(r) as relId, id(a) as startId, id(b) as endId';
+            if (options.skip) {
+                query += ` SKIP ${options.skip}`;
+            }
+            if (options.limit) {
+                query += ` LIMIT ${options.limit}`;
+            }
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const relationships = result.records.map((record) => this.mapMemgraphRelationship(record.get('r'), record.get('relId'), record.get('startId'), record.get('endId')));
+            return {
+                relationships,
+                count: relationships.length,
+            };
+        });
+    }
+    async findRelationshipById(id, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const query = `
+        MATCH (a)-[r]->(b)
+        WHERE id(r) = $id
+        RETURN r, id(r) as relId, id(a) as startId, id(b) as endId
+      `;
+            const session = this.getSession(transaction);
+            const result = await session.run(query, {
+                id: typeof id === 'number' ? id : parseInt(id, 10),
+            });
+            if (result.records.length === 0) {
+                return null;
+            }
+            const record = result.records[0];
+            return this.mapMemgraphRelationship(record.get('r'), record.get('relId'), record.get('startId'), record.get('endId'));
+        });
+    }
+    async updateRelationship(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            let query;
+            const params = { props: options.properties };
+            if (options.id) {
+                query = `
+          MATCH (a)-[r]->(b)
+          WHERE id(r) = $id
+          SET r += $props
+          RETURN r, id(r) as relId, id(a) as startId, id(b) as endId
+        `;
+                params.id = typeof options.id === 'number' ? options.id : parseInt(options.id, 10);
+            }
+            else {
+                const typeClause = options.type ? `:${options.type}` : '';
+                query = `MATCH (a)-[r${typeClause}]->(b)`;
+                if (options.where) {
+                    const { clause, params: whereParams } = this.buildWhereClause(options.where, 'r');
+                    query += ` WHERE ${clause}`;
+                    Object.assign(params, whereParams);
+                }
+                query += ' SET r += $props RETURN r, id(r) as relId, id(a) as startId, id(b) as endId';
+            }
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const relationships = result.records.map((record) => this.mapMemgraphRelationship(record.get('r'), record.get('relId'), record.get('startId'), record.get('endId')));
+            return {
+                relationship: relationships.length === 1 ? relationships[0] : undefined,
+                relationships: relationships.length > 1 ? relationships : undefined,
+                updatedCount: relationships.length,
+                updated: relationships.length > 0,
+            };
+        });
+    }
+    async deleteRelationship(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            let query;
+            const params = {};
+            if (options.id) {
+                query = `MATCH ()-[r]->() WHERE id(r) = $id DELETE r RETURN count(r) as count`;
+                params.id = typeof options.id === 'number' ? options.id : parseInt(options.id, 10);
+            }
+            else {
+                const typeClause = options.type ? `:${options.type}` : '';
+                query = `MATCH (a)-[r${typeClause}]->(b)`;
+                const conditions = [];
+                if (options.startNodeId) {
+                    conditions.push('id(a) = $startId');
+                    params.startId = typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10);
+                }
+                if (options.endNodeId) {
+                    conditions.push('id(b) = $endId');
+                    params.endId = typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10);
+                }
+                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 = this.toNumber((_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) || 0;
+            return {
+                deleted: count > 0,
+                deletedCount: count,
+            };
+        });
+    }
+    async mergeRelationship(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            let matchPropsClause = '';
+            const params = {
+                startId: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10),
+                endId: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10),
+            };
+            if (options.matchProperties) {
+                const matchProps = Object.entries(options.matchProperties)
+                    .map(([key]) => `${key}: $match_${key}`)
+                    .join(', ');
+                matchPropsClause = ` {${matchProps}}`;
+                Object.entries(options.matchProperties).forEach(([key, value]) => {
+                    params[`match_${key}`] = value;
+                });
+            }
+            let query = `
+        MATCH (a), (b)
+        WHERE id(a) = $startId AND id(b) = $endId
+        MERGE (a)-[r:${options.type}${matchPropsClause}]->(b)
+      `;
+            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, id(r) as relId, id(a) as startId, id(b) as endId';
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const record = result.records[0];
+            const relationship = this.mapMemgraphRelationship(record.get('r'), record.get('relId'), record.get('startId'), record.get('endId'));
+            return {
+                relationship,
+                created: true,
+                merged: true,
+            };
+        });
+    }
+    // ==================== TRAVERSAL OPERATIONS ====================
+    async traverse(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const direction = this.getDirectionArrow(options.direction);
+            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
+            const relClause = relTypes ? `:${relTypes}` : '';
+            const minDepth = options.minDepth || 1;
+            const maxDepth = options.maxDepth || 3;
+            const query = `
+        MATCH path = (start)${direction.left}[${relClause}*${minDepth}..${maxDepth}]${direction.right}(end)
+        WHERE id(start) = $startId
+        RETURN path
+        ${options.limit ? `LIMIT ${options.limit}` : ''}
+      `;
+            const params = {
+                startId: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10),
+            };
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const paths = result.records.map((record) => this.mapMemgraphPath(record.get('path')));
+            // Collect unique nodes and relationships
+            const nodesMap = new Map();
+            const relsMap = new Map();
+            paths.forEach(path => {
+                path.nodes.forEach(node => nodesMap.set(String(node.id), node));
+                path.relationships.forEach(rel => relsMap.set(String(rel.id), rel));
+            });
+            return {
+                paths,
+                nodes: Array.from(nodesMap.values()),
+                relationships: Array.from(relsMap.values()),
+                count: paths.length,
+            };
+        });
+    }
+    async shortestPath(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
+            const relClause = relTypes ? `:${relTypes}` : '';
+            const maxDepth = options.maxDepth || 15;
+            // Use BFS for shortest path in Memgraph
+            const query = `
+        MATCH (start), (end)
+        WHERE id(start) = $startId AND id(end) = $endId
+        MATCH path = shortestPath((start)-[${relClause}*..${maxDepth}]-(end))
+        RETURN path
+      `;
+            const params = {
+                startId: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10),
+                endId: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10),
+            };
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            if (result.records.length === 0) {
+                return { path: null, found: false };
+            }
+            const path = this.mapMemgraphPath(result.records[0].get('path'));
+            return {
+                path,
+                length: path.length,
+                found: true,
+                totalWeight: options.weightProperty
+                    ? path.relationships.reduce((sum, r) => sum + (r.properties[options.weightProperty] || 0), 0)
+                    : undefined,
+            };
+        });
+    }
+    async allPaths(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
+            const relClause = relTypes ? `:${relTypes}` : '';
+            const minDepth = options.minDepth || 1;
+            const maxDepth = options.maxDepth || 5;
+            const limit = options.limit || options.maxPaths;
+            const query = `
+        MATCH (start), (end)
+        WHERE id(start) = $startId AND id(end) = $endId
+        MATCH path = (start)-[${relClause}*${minDepth}..${maxDepth}]-(end)
+        RETURN path
+        ${limit ? `LIMIT ${limit}` : ''}
+      `;
+            const params = {
+                startId: typeof options.startNodeId === 'number' ? options.startNodeId : parseInt(options.startNodeId, 10),
+                endId: typeof options.endNodeId === 'number' ? options.endNodeId : parseInt(options.endNodeId, 10),
+            };
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            const paths = result.records.map((record) => this.mapMemgraphPath(record.get('path')));
+            return {
+                paths,
+                count: paths.length,
+                total: paths.length,
+            };
+        });
+    }
+    async getNeighborhood(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const direction = this.getDirectionArrow(options.direction);
+            const relTypes = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.join('|')) || '';
+            const relClause = relTypes ? `:${relTypes}` : '';
+            const depth = options.depth || 1;
+            const limit = options.limit;
+            const query = `
+        MATCH (start)
+        WHERE id(start) = $nodeId
+        MATCH path = (start)${direction.left}[r${relClause}*1..${depth}]${direction.right}(neighbor)
+        RETURN DISTINCT neighbor, id(neighbor) as neighborId, r
+        ${limit ? `LIMIT ${limit}` : ''}
+      `;
+            const params = {
+                nodeId: typeof options.nodeId === 'number' ? options.nodeId : parseInt(options.nodeId, 10),
+            };
+            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 neighborId = record.get('neighborId');
+                const nodeKey = String(this.toNumber(neighborId));
+                if (!nodesMap.has(nodeKey)) {
+                    nodesMap.set(nodeKey, this.mapMemgraphNode(neighbor, neighborId));
+                }
+                const rels = record.get('r');
+                if (Array.isArray(rels)) {
+                    rels.forEach((rel) => {
+                        relationshipsSet.push(this.mapMemgraphRelationship(rel, rel.identity, rel.start, rel.end));
+                    });
+                }
+            });
+            return {
+                nodes: Array.from(nodesMap.values()),
+                relationships: relationshipsSet,
+                depth,
+            };
+        });
+    }
+    async findConnectedComponents(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            // Memgraph has MAGE library for graph algorithms
+            // Use weakly connected components algorithm
+            const labels = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.join(':')) || '';
+            const labelClause = labels ? `:${labels}` : '';
+            try {
+                // Try using MAGE library first (if installed)
+                const query = `
+          CALL weakly_connected_components.get()
+          YIELD node, component_id
+          WITH component_id, collect(node) as nodes
+          RETURN nodes, size(nodes) as size, component_id
+          ORDER BY size DESC
+        `;
+                const session = this.getSession(transaction);
+                const result = await session.run(query, {});
+                const components = result.records.map((record) => ({
+                    nodes: record.get('nodes').map((n) => this.mapMemgraphNode(n, n.identity)),
+                    size: this.toNumber(record.get('size')),
+                }));
+                return {
+                    components,
+                    count: components.length,
+                };
+            }
+            catch (_b) {
+                // Fallback to basic Cypher implementation
+                const query = `
+          MATCH (n${labelClause})
+          WITH collect(n) as allNodes
+          UNWIND allNodes as node
+          MATCH path = (node)-[*]-(connected)
+          WITH node, collect(DISTINCT connected) + [node] as component
+          WITH collect(DISTINCT component) as allComponents
+          UNWIND allComponents as comp
+          WITH comp, size(comp) as compSize
+          RETURN comp as nodes, compSize as size
+          ORDER BY size DESC
+        `;
+                const session = this.getSession(transaction);
+                const result = await session.run(query, {});
+                const components = result.records.map((record) => ({
+                    nodes: record.get('nodes').map((n) => this.mapMemgraphNode(n, n.identity)),
+                    size: this.toNumber(record.get('size')),
+                }));
+                return {
+                    components,
+                    count: components.length,
+                };
+            }
+        });
+    }
+    // ==================== AGGREGATION OPERATIONS ====================
+    async countNodes(labels, where, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const labelClause = (labels === null || labels === void 0 ? void 0 : labels.length) ? `:${labels.join(':')}` : '';
+            let query = `MATCH (n${labelClause})`;
+            const params = {};
+            if (where) {
+                const { clause, params: whereParams } = this.buildWhereClause(where, 'n');
+                query += ` WHERE ${clause}`;
+                Object.assign(params, whereParams);
+            }
+            query += ' RETURN count(n) as count';
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            return {
+                count: this.toNumber((_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) || 0,
+            };
+        });
+    }
+    async countRelationships(types, where, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const typeClause = (types === null || types === void 0 ? void 0 : types.length) ? `:${types.join('|')}` : '';
+            let query = `MATCH ()-[r${typeClause}]->()`;
+            const params = {};
+            if (where) {
+                const { clause, params: whereParams } = this.buildWhereClause(where, 'r');
+                query += ` WHERE ${clause}`;
+                Object.assign(params, whereParams);
+            }
+            query += ' RETURN count(r) as count';
+            const session = this.getSession(transaction);
+            const result = await session.run(query, params);
+            return {
+                count: this.toNumber((_a = result.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) || 0,
+            };
+        });
+    }
+    async getStatistics(transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a, _b;
+            const session = this.getSession(transaction);
+            const nodeCountResult = await session.run('MATCH (n) RETURN count(n) as count');
+            const relCountResult = await session.run('MATCH ()-[r]->() RETURN count(r) as count');
+            return {
+                nodeCount: this.toNumber((_a = nodeCountResult.records[0]) === null || _a === void 0 ? void 0 : _a.get('count')) || 0,
+                relationshipCount: this.toNumber((_b = relCountResult.records[0]) === null || _b === void 0 ? void 0 : _b.get('count')) || 0,
+            };
+        });
+    }
+    // ==================== SEARCH OPERATIONS ====================
+    async fullTextSearch(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // Memgraph supports text search through MAGE text_search module
+            // Use the index name to search
+            const query = `
+        CALL text_search.search($indexName, $searchQuery, $limit)
+        YIELD node, score
+        RETURN node, id(node) as nodeId, score
+      `;
+            const session = this.getSession(transaction);
+            const result = await session.run(query, {
+                indexName: options.indexName,
+                searchQuery: options.query,
+                limit: options.limit || 100,
+            });
+            const nodes = result.records.map((r) => this.mapMemgraphNode(r.get('node'), r.get('nodeId')));
+            const scores = result.records.map((r) => r.get('score') || 1.0);
+            return {
+                nodes,
+                scores,
+            };
+        });
+    }
+    async vectorSearch(_options, _transaction) {
+        // Memgraph doesn't natively support vector search yet
+        // This would require a custom implementation or external service
+        throw graph_error_1.GraphError.unsupportedOperationError('Vector search is not natively supported in Memgraph. Consider using an external vector database.', this.graphType);
+    }
+    // ==================== RAW QUERY ====================
+    async query(options, transaction) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a, _b;
+            const session = this.getSession(transaction);
+            const result = await session.run(options.query, options.params || {});
+            return {
+                records: result.records.map((r) => r.toObject()),
+                summary: {
+                    resultAvailableAfter: this.toNumber((_a = result.summary) === null || _a === void 0 ? void 0 : _a.resultAvailableAfter),
+                    resultConsumedAfter: this.toNumber((_b = result.summary) === null || _b === void 0 ? void 0 : _b.resultConsumedAfter),
+                },
+            };
+        });
+    }
+    // ==================== SCHEMA OPERATIONS ====================
+    async createNodeIndex(options) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // Memgraph uses CREATE INDEX ON :Label(property)
+            const query = `CREATE INDEX ON :${options.label}(${options.properties.join(', ')})`;
+            const session = this.getSession();
+            await session.run(query);
+            return { created: true, name: options.name };
+        });
+    }
+    async createNodeConstraint(options) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            let query;
+            const property = options.property || (options.properties && options.properties[0]);
+            switch (options.type) {
+                case 'UNIQUE':
+                    // Memgraph uses CREATE CONSTRAINT ON (n:Label) ASSERT n.property IS UNIQUE
+                    query = `CREATE CONSTRAINT ON (n:${options.label}) ASSERT n.${property} IS UNIQUE`;
+                    break;
+                case 'EXISTS':
+                    query = `CREATE CONSTRAINT ON (n:${options.label}) ASSERT EXISTS (n.${property})`;
+                    break;
+                default:
+                    throw graph_error_1.GraphError.validationError(`Unsupported constraint type: ${options.type}`);
+            }
+            const session = this.getSession();
+            await session.run(query);
+            return { created: true, name: options.name };
+        });
+    }
+    async createRelationshipIndex(options) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // Memgraph relationship indexes
+            const query = `CREATE INDEX ON :${options.type}(${options.properties.join(', ')})`;
+            const session = this.getSession();
+            await session.run(query);
+            return { created: true, name: options.name };
+        });
+    }
+    async listIndexes() {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const query = 'SHOW INDEX INFO';
+            const session = this.getSession();
+            const result = await session.run(query);
+            const indexes = result.records.map((r) => ({
+                name: r.get('index name') || '',
+                labelOrType: r.get('label') || '',
+                properties: [r.get('property') || ''],
+                unique: false, // Memgraph doesn't distinguish in SHOW INDEX INFO
+                type: r.get('index type') || 'BTREE',
+                state: 'ONLINE',
+            }));
+            return { indexes };
+        });
+    }
+    async listConstraints() {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const query = 'SHOW CONSTRAINT INFO';
+            const session = this.getSession();
+            const result = await session.run(query);
+            const constraints = result.records.map((r) => ({
+                name: `constraint_${r.get('label')}_${r.get('property')}`,
+                label: r.get('label') || '',
+                property: r.get('property') || '',
+                type: r.get('constraint type') || 'UNIQUE',
+            }));
+            return { constraints };
+        });
+    }
+    async dropIndex(name) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // In Memgraph, we need label and property to drop index
+            // This is a simplified version
+            const query = `DROP INDEX ON :${name}`;
+            const session = this.getSession();
+            try {
+                await session.run(query);
+                return { dropped: true };
+            }
+            catch (_a) {
+                return { dropped: false };
+            }
+        });
+    }
+    async dropConstraint(name) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            // Memgraph requires the full constraint definition to drop
+            // This is a simplified version that might need adjustment
+            const query = `DROP CONSTRAINT ON (n:${name}) ASSERT n.id IS UNIQUE`;
+            const session = this.getSession();
+            try {
+                await session.run(query);
+                return { dropped: true };
+            }
+            catch (_a) {
+                return { dropped: false };
+            }
+        });
+    }
+    // ==================== SCHEMA INTROSPECTION ====================
+    async listLabels() {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a, _b, _c, _d;
+            const session = this.getSession();
+            // Get all labels using Memgraph's CALL mg.labels()
+            const labelsResult = await session.run('CALL mg.labels() YIELD label RETURN label');
+            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
+           RETURN DISTINCT key`);
+                const properties = propsResult.records.map((r) => ({
+                    name: r.get('key'),
+                    type: 'unknown',
+                }));
+                labels.push({
+                    name: labelName,
+                    count: typeof count === 'number' ? count : Number(count),
+                    properties,
+                });
+            }
+            return { labels };
+        });
+    }
+    async listRelationshipTypes() {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            var _a, _b, _c, _d;
+            const session = this.getSession();
+            // Get all relationship types using Memgraph's CALL mg.relationship_types()
+            const typesResult = await session.run('CALL mg.relationship_types() YIELD relationshipType RETURN relationshipType');
+            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 };
+        });
+    }
+    // ==================== TRANSACTION OPERATIONS ====================
+    async beginTransaction(_options) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const session = this.driver.session();
+            const tx = session.beginTransaction();
+            return {
+                id: `tx_${Date.now()}`,
+                status: enums_1.GraphTransactionStatus.ACTIVE,
+                client: tx,
+                nativeTransaction: tx,
+                startTime: new Date(),
+                commit: async () => {
+                    await tx.commit();
+                    await session.close();
+                },
+                rollback: async () => {
+                    await tx.rollback();
+                    await session.close();
+                },
+            };
+        });
+    }
+    async commitTransaction(transaction) {
+        if (transaction.commit) {
+            await transaction.commit();
+        }
+    }
+    async rollbackTransaction(transaction) {
+        if (transaction.rollback) {
+            await transaction.rollback();
+        }
+    }
+    // ==================== MEMGRAPH-SPECIFIC FEATURES ====================
+    /**
+     * Create a trigger in Memgraph
+     */
+    async createTrigger(name, event, target, procedure) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const eventClause = `${event === 'CREATE' ? 'CREATED' : event === 'UPDATE' ? 'UPDATED' : 'DELETED'}`;
+            const targetClause = target === 'NODE' ? 'VERTEX' : 'EDGE';
+            const query = `
+        CREATE TRIGGER ${name}
+        ON ${eventClause} ${targetClause}
+        EXECUTE ${procedure}
+      `;
+            const session = this.getSession();
+            await session.run(query);
+        });
+    }
+    /**
+     * Drop a trigger in Memgraph
+     */
+    async dropTrigger(name) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const query = `DROP TRIGGER ${name}`;
+            const session = this.getSession();
+            await session.run(query);
+        });
+    }
+    /**
+     * List all triggers in Memgraph
+     */
+    async listTriggers() {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const query = 'SHOW TRIGGERS';
+            const session = this.getSession();
+            const result = await session.run(query);
+            return result.records.map((r) => ({
+                name: r.get('trigger name'),
+                statement: r.get('statement'),
+            }));
+        });
+    }
+    /**
+     * Create a stream consumer in Memgraph
+     */
+    async createStream(name, type, topics, transformationProcedure, config) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const configStr = Object.entries(config)
+                .map(([k, v]) => `${k} = '${v}'`)
+                .join(', ');
+            const query = `
+        CREATE ${type} STREAM ${name}
+        TOPICS ${topics.join(', ')}
+        TRANSFORM ${transformationProcedure}
+        ${configStr ? `CONFIGS { ${configStr} }` : ''}
+      `;
+            const session = this.getSession();
+            await session.run(query);
+        });
+    }
+    /**
+     * Run a MAGE algorithm (if installed)
+     */
+    async runMageAlgorithm(algorithm, params = {}) {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            const paramsList = Object.entries(params)
+                .map(([k]) => `${k}: $${k}`)
+                .join(', ');
+            const query = `CALL ${algorithm}(${paramsList ? `{${paramsList}}` : ''}) YIELD *`;
+            const session = this.getSession();
+            const result = await session.run(query, params);
+            return result.records.map((r) => r.toObject());
+        });
+    }
+    // ==================== UTILITY METHODS ====================
+    buildWhereClause(where, alias = 'n') {
+        const conditions = [];
+        const params = {};
+        let paramIndex = 0;
+        const processCondition = (key, value, prefix = '') => {
+            const fullKey = prefix ? `${prefix}_${key}` : key;
+            const paramName = `param_${paramIndex++}`;
+            // Normalize key to lowercase for comparison
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                const subConditions = [];
+                if (Array.isArray(value)) {
+                    value.forEach((v) => {
+                        Object.entries(v).forEach(([k, val]) => {
+                            processCondition(k, val, fullKey);
+                            subConditions.push(conditions.pop());
+                        });
+                    });
+                }
+                else {
+                    Object.entries(value).forEach(([k, v]) => {
+                        processCondition(k, v, fullKey);
+                        subConditions.push(conditions.pop());
+                    });
+                }
+                conditions.push(`(${subConditions.join(' AND ')})`);
+                return;
+            }
+            if (normalizedKey === '$or') {
+                const subConditions = [];
+                if (Array.isArray(value)) {
+                    value.forEach((v) => {
+                        Object.entries(v).forEach(([k, val]) => {
+                            processCondition(k, val, fullKey);
+                            subConditions.push(conditions.pop());
+                        });
+                    });
+                }
+                else {
+                    Object.entries(value).forEach(([k, v]) => {
+                        processCondition(k, v, fullKey);
+                        subConditions.push(conditions.pop());
+                    });
+                }
+                conditions.push(`(${subConditions.join(' OR ')})`);
+                return;
+            }
+            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                Object.entries(value).forEach(([op, opValue]) => {
+                    const normalizedOp = op.toLowerCase();
+                    const opParamName = `${paramName}_${normalizedOp}`;
+                    switch (normalizedOp) {
+                        case '$gt':
+                            conditions.push(`${alias}.${key} > $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$gte':
+                            conditions.push(`${alias}.${key} >= $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$lt':
+                            conditions.push(`${alias}.${key} < $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$lte':
+                            conditions.push(`${alias}.${key} <= $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$ne':
+                            conditions.push(`${alias}.${key} <> $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$in':
+                            conditions.push(`${alias}.${key} IN $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$nin':
+                        case '$not_in':
+                            conditions.push(`NOT ${alias}.${key} IN $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$contains':
+                            conditions.push(`${alias}.${key} CONTAINS $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$startswith':
+                        case '$starts_with':
+                            conditions.push(`${alias}.${key} STARTS WITH $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$endswith':
+                        case '$ends_with':
+                            conditions.push(`${alias}.${key} ENDS WITH $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                        case '$exists':
+                            if (opValue) {
+                                conditions.push(`${alias}.${key} IS NOT NULL`);
+                            }
+                            else {
+                                conditions.push(`${alias}.${key} IS NULL`);
+                            }
+                            break;
+                        case '$regex':
+                            conditions.push(`${alias}.${key} =~ $${opParamName}`);
+                            params[opParamName] = opValue;
+                            break;
+                    }
+                });
+            }
+            else {
+                conditions.push(`${alias}.${key} = $${paramName}`);
+                params[paramName] = value;
+            }
+        };
+        Object.entries(where).forEach(([key, value]) => {
+            processCondition(key, value);
+        });
+        return {
+            clause: conditions.join(' AND ') || 'true',
+            params,
+        };
+    }
+    parseError(error) {
+        if (error instanceof graph_error_1.GraphError) {
+            return error;
+        }
+        return graph_error_1.GraphError.queryError(String(error));
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    mapMemgraphNode(node, nodeId) {
+        const id = nodeId !== undefined ? this.toNumber(nodeId) : this.toNumber(node.identity);
+        return {
+            id: String(id),
+            labels: node.labels || [],
+            properties: this.convertProperties(node.properties || {}),
+        };
+    }
+    mapMemgraphRelationship(rel, relId, startId, endId) {
+        const id = relId !== undefined ? this.toNumber(relId) : this.toNumber(rel.identity);
+        const start = startId !== undefined ? this.toNumber(startId) : this.toNumber(rel.start);
+        const end = endId !== undefined ? this.toNumber(endId) : this.toNumber(rel.end);
+        return {
+            id: String(id),
+            type: rel.type,
+            startNodeId: String(start),
+            endNodeId: String(end),
+            properties: this.convertProperties(rel.properties || {}),
+        };
+    }
+    mapMemgraphPath(path) {
+        const nodes = [];
+        const relationships = [];
+        if (path.segments) {
+            path.segments.forEach((segment, index) => {
+                if (index === 0) {
+                    nodes.push(this.mapMemgraphNode(segment.start, segment.start.identity));
+                }
+                nodes.push(this.mapMemgraphNode(segment.end, segment.end.identity));
+                relationships.push(this.mapMemgraphRelationship(segment.relationship, segment.relationship.identity, segment.start.identity, segment.end.identity));
+            });
+        }
+        return {
+            nodes,
+            relationships,
+            length: relationships.length,
+        };
+    }
+    convertProperties(props) {
+        const result = {};
+        for (const [key, value] of Object.entries(props)) {
+            result[key] = this.convertValue(value);
+        }
+        return result;
+    }
+    convertValue(value) {
+        var _a, _b, _c;
+        if (value === null || value === undefined) {
+            return value;
+        }
+        // Handle Integer type (from neo4j-driver)
+        if (typeof value === 'object' && ((_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Integer') {
+            return this.toNumber(value);
+        }
+        // Handle Date types
+        if (typeof value === 'object' && (((_b = value.constructor) === null || _b === void 0 ? void 0 : _b.name) === 'Date' || ((_c = value.constructor) === null || _c === void 0 ? void 0 : _c.name) === 'DateTime')) {
+            return new Date(value.toString());
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.convertValue(v));
+        }
+        return value;
+    }
+    toNumber(value) {
+        if (value === null || value === undefined) {
+            return 0;
+        }
+        if (typeof value === 'number') {
+            return value;
+        }
+        if (typeof value === 'object' && typeof value.toNumber === 'function') {
+            return value.toNumber();
+        }
+        if (typeof value === 'object' && typeof value.toInt === 'function') {
+            return value.toInt();
+        }
+        return parseInt(String(value), 10) || 0;
+    }
+    getDirectionArrow(direction) {
+        switch (direction) {
+            case enums_1.TraversalDirection.OUTGOING:
+            case 'OUTGOING':
+                return { left: '-', right: '->' };
+            case enums_1.TraversalDirection.INCOMING:
+            case 'INCOMING':
+                return { left: '<-', right: '-' };
+            case enums_1.TraversalDirection.BOTH:
+            case 'BOTH':
+            default:
+                return { left: '-', right: '-' };
+        }
+    }
+}
+exports.MemgraphAdapter = MemgraphAdapter;
+//# sourceMappingURL=memgraph.adapter.js.map