@ductape/sdk 0.1.7 → 0.1.8

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

@@ -1,1588 +0,0 @@
-"use strict";
-/**
- * ArangoDB Graph Database Adapter
- *
- * Implements the BaseGraphAdapter for ArangoDB.
- * ArangoDB is a multi-model database that supports documents, graphs, and key-value.
- * Uses AQL (ArangoDB Query Language) for graph operations.
- */
-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.ArangoDBAdapter = void 0;
-const base_adapter_1 = require("./base.adapter");
-const enums_1 = require("../types/enums");
-const graph_error_1 = require("../utils/graph-error");
-/**
- * ArangoDB adapter using arangojs
- */
-class ArangoDBAdapter extends base_adapter_1.BaseGraphAdapter {
-    constructor() {
-        super(...arguments);
-        this.graphType = enums_1.GraphType.ARANGODB;
-        this.supportedFeatures = new Set([
-            enums_1.GraphFeature.TRANSACTIONS,
-            enums_1.GraphFeature.SCHEMA_INDEXES,
-            enums_1.GraphFeature.FULL_TEXT_SEARCH,
-            enums_1.GraphFeature.MULTI_TENANCY,
-        ]);
-        this.db = null;
-        this.graph = null;
-        this.graphName = '';
-        this.vertexCollections = [];
-        this.edgeCollections = [];
-    }
-    /**
-     * Connect to ArangoDB
-     */
-    async connect(options) {
-        var _a;
-        try {
-            // Store connection options for reconnection
-            this.connectionOptions = options;
-            // Dynamically import arangojs
-            const arangojs = await Promise.resolve().then(() => __importStar(require('arangojs')));
-            const { Database } = arangojs;
-            this.db = new Database({
-                url: options.connectionUrl,
-                databaseName: options.database || '_system',
-            });
-            // If graph name is provided, get the graph
-            if (options.graphName) {
-                this.graphName = options.graphName;
-                this.graph = this.db.graph(options.graphName);
-                // Get graph info
-                const graphInfo = await this.graph.get();
-                this.vertexCollections = graphInfo.orphanCollections || [];
-                this.edgeCollections = ((_a = graphInfo.edgeDefinitions) === null || _a === void 0 ? void 0 : _a.map((ed) => ed.collection)) || [];
-                // Add vertex collections from edge definitions
-                for (const ed of graphInfo.edgeDefinitions || []) {
-                    this.vertexCollections.push(...ed.from, ...ed.to);
-                }
-                this.vertexCollections = [...new Set(this.vertexCollections)];
-            }
-            this.client = this.db;
-            this.connected = true;
-            return {
-                connected: true,
-                type: this.graphType,
-                version: await this.getVersion(),
-            };
-        }
-        catch (error) {
-            this.connected = false;
-            throw graph_error_1.GraphError.connectionError(`Failed to connect to ArangoDB: ${error.message}`);
-        }
-    }
-    async getVersion() {
-        try {
-            const info = await this.db.version();
-            return info.version;
-        }
-        catch (_a) {
-            return 'unknown';
-        }
-    }
-    /**
-     * Disconnect from ArangoDB
-     */
-    async disconnect() {
-        if (this.db) {
-            this.db = null;
-            this.graph = null;
-            this.client = null;
-            this.connected = false;
-        }
-    }
-    /**
-     * Test ArangoDB connection
-     */
-    async testConnection(options) {
-        try {
-            await this.connect(options);
-            const startTime = Date.now();
-            const version = await this.getVersion();
-            const latency = Date.now() - startTime;
-            await this.disconnect();
-            return {
-                connected: true,
-                type: this.graphType,
-                version,
-                latency,
-                features: ['aql', 'multi-model', 'transactions'],
-            };
-        }
-        catch (error) {
-            return {
-                connected: false,
-                type: this.graphType,
-                error: error.message,
-            };
-        }
-    }
-    // ==================== NODE OPERATIONS ====================
-    async createNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const collectionName = options.labels[0];
-                const collection = this.db.collection(collectionName);
-                const doc = Object.assign(Object.assign({}, options.properties), { _labels: options.labels });
-                const result = await collection.save(doc, { returnNew: true });
-                const node = {
-                    id: result._key,
-                    labels: options.labels,
-                    properties: result.new,
-                    elementId: result._id,
-                };
-                return { node, created: true };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to create node: ${error.message}`);
-            }
-        });
-    }
-    async findNodes(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c, _d, _e;
-            try {
-                let aql = 'FOR doc IN @@collection';
-                const bindVars = {};
-                const collectionName = ((_a = options.labels) === null || _a === void 0 ? void 0 : _a[0]) || this.vertexCollections[0];
-                bindVars['@collection'] = collectionName;
-                if (options.where) {
-                    const { filterStr, filterVars } = this.buildArangoWhereClause(options.where, 'doc');
-                    if (filterStr) {
-                        aql += ` FILTER ${filterStr}`;
-                        Object.assign(bindVars, filterVars);
-                    }
-                }
-                if ((_b = options.orderBy) === null || _b === void 0 ? void 0 : _b.length) {
-                    const sortParts = options.orderBy.map((o) => `doc.${o.property} ${o.direction || 'ASC'}`);
-                    aql += ` SORT ${sortParts.join(', ')}`;
-                }
-                const skipValue = (_d = (_c = options.skip) !== null && _c !== void 0 ? _c : options.offset) !== null && _d !== void 0 ? _d : 0;
-                const limitValue = (_e = options.limit) !== null && _e !== void 0 ? _e : 100;
-                aql += ` LIMIT ${skipValue}, ${limitValue}`;
-                aql += ' RETURN doc';
-                const cursor = await this.db.query(aql, bindVars);
-                const docs = await cursor.all();
-                const nodes = docs.map((doc) => ({
-                    id: doc._key,
-                    labels: doc._labels || [collectionName],
-                    properties: this.cleanArangoProps(doc),
-                    elementId: doc._id,
-                }));
-                const countAql = `RETURN LENGTH(FOR doc IN @@collection ${options.where ? `FILTER ${this.buildArangoWhereClause(options.where, 'doc').filterStr}` : ''} RETURN 1)`;
-                const countCursor = await this.db.query(countAql, { '@collection': collectionName });
-                const [total] = await countCursor.all();
-                return { nodes, total };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to find nodes: ${error.message}`);
-            }
-        });
-    }
-    async findNodeById(id, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(id).includes('/') ? id : null;
-                if (!docId) {
-                    for (const collName of this.vertexCollections) {
-                        try {
-                            const collection = this.db.collection(collName);
-                            const doc = await collection.document(id);
-                            return {
-                                id: doc._key,
-                                labels: doc._labels || [collName],
-                                properties: this.cleanArangoProps(doc),
-                                elementId: doc._id,
-                            };
-                        }
-                        catch (_a) {
-                            continue;
-                        }
-                    }
-                    return null;
-                }
-                const [collName] = String(docId).split('/');
-                const collection = this.db.collection(collName);
-                const doc = await collection.document(docId);
-                return {
-                    id: doc._key,
-                    labels: doc._labels || [collName],
-                    properties: this.cleanArangoProps(doc),
-                    elementId: doc._id,
-                };
-            }
-            catch (error) {
-                if (error.code === 404) {
-                    return null;
-                }
-                throw graph_error_1.GraphError.queryError(`Failed to find node by ID: ${error.message}`);
-            }
-        });
-    }
-    async updateNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(options.id);
-                const [collName] = docId.includes('/') ? docId.split('/') : [this.vertexCollections[0]];
-                const collection = this.db.collection(collName);
-                const key = docId.includes('/') ? docId.split('/')[1] : docId;
-                let updateData = {};
-                if (options.properties) {
-                    if ('$SET' in options.properties) {
-                        updateData = Object.assign(Object.assign({}, updateData), options.properties.$SET);
-                    }
-                    if ('$UNSET' in options.properties) {
-                        for (const prop of options.properties.$UNSET || []) {
-                            updateData[prop] = null;
-                        }
-                    }
-                    if ('$INCREMENT' in options.properties) {
-                        for (const [prop, value] of Object.entries(options.properties.$INCREMENT || {})) {
-                            const current = await collection.document(key);
-                            updateData[prop] = (current[prop] || 0) + value;
-                        }
-                    }
-                    if ('$APPEND' in options.properties) {
-                        for (const [prop, value] of Object.entries(options.properties.$APPEND || {})) {
-                            const current = await collection.document(key);
-                            updateData[prop] = [...(current[prop] || []), value];
-                        }
-                    }
-                }
-                const result = await collection.update(key, updateData, { returnNew: true });
-                const node = {
-                    id: result._key,
-                    labels: result.new._labels || [collName],
-                    properties: this.cleanArangoProps(result.new),
-                    elementId: result._id,
-                };
-                return { node, updated: true };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to update node: ${error.message}`);
-            }
-        });
-    }
-    async deleteNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(options.id);
-                const [collName] = docId.includes('/') ? docId.split('/') : [this.vertexCollections[0]];
-                const collection = this.db.collection(collName);
-                const key = docId.includes('/') ? docId.split('/')[1] : docId;
-                if (options.detach) {
-                    const fullId = docId.includes('/') ? docId : `${collName}/${key}`;
-                    for (const edgeCollName of this.edgeCollections) {
-                        await this.db.query(`FOR e IN @@collection FILTER e._from == @id OR e._to == @id REMOVE e IN @@collection`, { '@collection': edgeCollName, id: fullId });
-                    }
-                }
-                await collection.remove(key);
-                return { deleted: true, id: options.id };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to delete node: ${error.message}`);
-            }
-        });
-    }
-    async mergeNode(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const collectionName = options.labels[0];
-                const collection = this.db.collection(collectionName);
-                const { filterStr, filterVars } = this.buildArangoWhereClause(options.matchProperties, 'doc');
-                const findAql = `FOR doc IN @@collection FILTER ${filterStr} LIMIT 1 RETURN doc`;
-                const cursor = await this.db.query(findAql, Object.assign({ '@collection': collectionName }, filterVars));
-                const existing = await cursor.all();
-                if (existing.length > 0) {
-                    const doc = existing[0];
-                    const updateData = options.onMatch || {};
-                    const result = await collection.update(doc._key, updateData, { returnNew: true });
-                    return {
-                        node: {
-                            id: result._key,
-                            labels: options.labels,
-                            properties: this.cleanArangoProps(result.new),
-                            elementId: result._id,
-                        },
-                        created: false,
-                        merged: true,
-                    };
-                }
-                else {
-                    const createData = Object.assign(Object.assign(Object.assign({}, options.matchProperties), (options.onCreate || {})), { _labels: options.labels });
-                    const result = await collection.save(createData, { returnNew: true });
-                    return {
-                        node: {
-                            id: result._key,
-                            labels: options.labels,
-                            properties: this.cleanArangoProps(result.new),
-                            elementId: result._id,
-                        },
-                        created: true,
-                        merged: true,
-                    };
-                }
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to merge node: ${error.message}`);
-            }
-        });
-    }
-    // ==================== LABEL MANAGEMENT ====================
-    async addLabels(options, _transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                // In ArangoDB, we store labels in a _labels array property
-                // First, find the document
-                const docId = String(options.id);
-                const isFullId = docId.includes('/');
-                let doc;
-                if (isFullId) {
-                    const [collectionName, key] = docId.split('/');
-                    const collection = this.db.collection(collectionName);
-                    doc = await collection.document(key);
-                }
-                else {
-                    // Search across vertex collections
-                    for (const collectionName of this.vertexCollections) {
-                        try {
-                            const collection = this.db.collection(collectionName);
-                            doc = await collection.document(docId);
-                            break;
-                        }
-                        catch (_a) {
-                            continue;
-                        }
-                    }
-                }
-                if (!doc) {
-                    throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
-                }
-                const existingLabels = doc._labels || [];
-                const newLabels = [...new Set([...existingLabels, ...options.labels])];
-                const [collectionName] = doc._id.split('/');
-                const collection = this.db.collection(collectionName);
-                const result = await collection.update(doc._key, { _labels: newLabels }, { returnNew: true });
-                return {
-                    node: {
-                        id: result._key,
-                        labels: newLabels,
-                        properties: this.cleanArangoProps(result.new),
-                        elementId: result._id,
-                    },
-                    addedLabels: options.labels,
-                };
-            }
-            catch (error) {
-                if (error instanceof graph_error_1.GraphError)
-                    throw error;
-                throw graph_error_1.GraphError.queryError(`Failed to add labels: ${error.message}`);
-            }
-        });
-    }
-    async removeLabels(options, _transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(options.id);
-                const isFullId = docId.includes('/');
-                let doc;
-                if (isFullId) {
-                    const [collectionName, key] = docId.split('/');
-                    const collection = this.db.collection(collectionName);
-                    doc = await collection.document(key);
-                }
-                else {
-                    for (const collectionName of this.vertexCollections) {
-                        try {
-                            const collection = this.db.collection(collectionName);
-                            doc = await collection.document(docId);
-                            break;
-                        }
-                        catch (_a) {
-                            continue;
-                        }
-                    }
-                }
-                if (!doc) {
-                    throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
-                }
-                const existingLabels = doc._labels || [];
-                const newLabels = existingLabels.filter(l => !options.labels.includes(l));
-                const [collectionName] = doc._id.split('/');
-                const collection = this.db.collection(collectionName);
-                const result = await collection.update(doc._key, { _labels: newLabels }, { returnNew: true });
-                return {
-                    node: {
-                        id: result._key,
-                        labels: newLabels,
-                        properties: this.cleanArangoProps(result.new),
-                        elementId: result._id,
-                    },
-                    removedLabels: options.labels,
-                };
-            }
-            catch (error) {
-                if (error instanceof graph_error_1.GraphError)
-                    throw error;
-                throw graph_error_1.GraphError.queryError(`Failed to remove labels: ${error.message}`);
-            }
-        });
-    }
-    async setLabels(options, _transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(options.id);
-                const isFullId = docId.includes('/');
-                let doc;
-                if (isFullId) {
-                    const [collectionName, key] = docId.split('/');
-                    const collection = this.db.collection(collectionName);
-                    doc = await collection.document(key);
-                }
-                else {
-                    for (const collectionName of this.vertexCollections) {
-                        try {
-                            const collection = this.db.collection(collectionName);
-                            doc = await collection.document(docId);
-                            break;
-                        }
-                        catch (_a) {
-                            continue;
-                        }
-                    }
-                }
-                if (!doc) {
-                    throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
-                }
-                const previousLabels = doc._labels || [];
-                const [collectionName] = doc._id.split('/');
-                const collection = this.db.collection(collectionName);
-                const result = await collection.update(doc._key, { _labels: options.labels }, { returnNew: true });
-                return {
-                    node: {
-                        id: result._key,
-                        labels: options.labels,
-                        properties: this.cleanArangoProps(result.new),
-                        elementId: result._id,
-                    },
-                    previousLabels,
-                    newLabels: options.labels,
-                };
-            }
-            catch (error) {
-                if (error instanceof graph_error_1.GraphError)
-                    throw error;
-                throw graph_error_1.GraphError.queryError(`Failed to set labels: ${error.message}`);
-            }
-        });
-    }
-    // ==================== RELATIONSHIP OPERATIONS ====================
-    async createRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const edgeCollectionName = options.type;
-                const edgeCollection = this.db.collection(edgeCollectionName);
-                const fromId = String(options.startNodeId).includes('/')
-                    ? options.startNodeId
-                    : await this.resolveNodeId(options.startNodeId);
-                const toId = String(options.endNodeId).includes('/')
-                    ? options.endNodeId
-                    : await this.resolveNodeId(options.endNodeId);
-                const edgeDoc = Object.assign({ _from: fromId, _to: toId }, options.properties);
-                const result = await edgeCollection.save(edgeDoc, { returnNew: true });
-                const relationship = {
-                    id: result._key,
-                    type: options.type,
-                    startNodeId: fromId,
-                    endNodeId: toId,
-                    properties: this.cleanArangoProps(result.new),
-                    elementId: result._id,
-                };
-                return { relationship, created: true };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to create relationship: ${error.message}`);
-            }
-        });
-    }
-    async findRelationships(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b, _c, _d;
-            try {
-                const edgeCollectionName = ((_a = options.types) === null || _a === void 0 ? void 0 : _a[0]) || (Array.isArray(options.type) ? options.type[0] : options.type) || this.edgeCollections[0];
-                let aql = 'FOR edge IN @@collection';
-                const bindVars = { '@collection': edgeCollectionName };
-                if (options.where) {
-                    const { filterStr, filterVars } = this.buildArangoWhereClause(options.where, 'edge');
-                    if (filterStr) {
-                        aql += ` FILTER ${filterStr}`;
-                        Object.assign(bindVars, filterVars);
-                    }
-                }
-                const skipValue = (_c = (_b = options.skip) !== null && _b !== void 0 ? _b : options.offset) !== null && _c !== void 0 ? _c : 0;
-                const limitValue = (_d = options.limit) !== null && _d !== void 0 ? _d : 100;
-                aql += ` LIMIT ${skipValue}, ${limitValue}`;
-                aql += ' RETURN edge';
-                const cursor = await this.db.query(aql, bindVars);
-                const edges = await cursor.all();
-                const relationships = edges.map((edge) => ({
-                    id: edge._key,
-                    type: edgeCollectionName,
-                    startNodeId: edge._from,
-                    endNodeId: edge._to,
-                    properties: this.cleanArangoProps(edge),
-                    elementId: edge._id,
-                }));
-                return { relationships, total: relationships.length };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to find relationships: ${error.message}`);
-            }
-        });
-    }
-    async findRelationshipById(id, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(id);
-                if (!docId.includes('/')) {
-                    for (const collName of this.edgeCollections) {
-                        try {
-                            const collection = this.db.collection(collName);
-                            const edge = await collection.document(id);
-                            return {
-                                id: edge._key,
-                                type: collName,
-                                startNodeId: edge._from,
-                                endNodeId: edge._to,
-                                properties: this.cleanArangoProps(edge),
-                                elementId: edge._id,
-                            };
-                        }
-                        catch (_a) {
-                            continue;
-                        }
-                    }
-                    return null;
-                }
-                const [collName] = docId.split('/');
-                const collection = this.db.collection(collName);
-                const edge = await collection.document(docId);
-                return {
-                    id: edge._key,
-                    type: collName,
-                    startNodeId: edge._from,
-                    endNodeId: edge._to,
-                    properties: this.cleanArangoProps(edge),
-                    elementId: edge._id,
-                };
-            }
-            catch (error) {
-                if (error.code === 404) {
-                    return null;
-                }
-                throw graph_error_1.GraphError.queryError(`Failed to find relationship by ID: ${error.message}`);
-            }
-        });
-    }
-    async updateRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(options.id);
-                const [collName] = docId.includes('/') ? docId.split('/') : [this.edgeCollections[0]];
-                const collection = this.db.collection(collName);
-                const key = docId.includes('/') ? docId.split('/')[1] : docId;
-                let updateData = {};
-                if (options.properties) {
-                    if ('$SET' in options.properties) {
-                        updateData = Object.assign(Object.assign({}, updateData), options.properties.$SET);
-                    }
-                }
-                const result = await collection.update(key, updateData, { returnNew: true });
-                const relationship = {
-                    id: result._key,
-                    type: collName,
-                    startNodeId: result.new._from,
-                    endNodeId: result.new._to,
-                    properties: this.cleanArangoProps(result.new),
-                    elementId: result._id,
-                };
-                return { relationship, updated: true };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to update relationship: ${error.message}`);
-            }
-        });
-    }
-    async deleteRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const docId = String(options.id);
-                const [collName] = docId.includes('/') ? docId.split('/') : [this.edgeCollections[0]];
-                const collection = this.db.collection(collName);
-                const key = docId.includes('/') ? docId.split('/')[1] : docId;
-                await collection.remove(key);
-                return { deleted: true, id: options.id };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to delete relationship: ${error.message}`);
-            }
-        });
-    }
-    async mergeRelationship(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const edgeCollectionName = options.type;
-                const fromId = String(options.startNodeId).includes('/')
-                    ? options.startNodeId
-                    : await this.resolveNodeId(options.startNodeId);
-                const toId = String(options.endNodeId).includes('/')
-                    ? options.endNodeId
-                    : await this.resolveNodeId(options.endNodeId);
-                let filterStr = 'edge._from == @from AND edge._to == @to';
-                const bindVars = {
-                    '@collection': edgeCollectionName,
-                    from: fromId,
-                    to: toId,
-                };
-                if (options.matchProperties) {
-                    const { filterStr: matchFilter, filterVars } = this.buildArangoWhereClause(options.matchProperties, 'edge');
-                    if (matchFilter) {
-                        filterStr += ` AND ${matchFilter}`;
-                        Object.assign(bindVars, filterVars);
-                    }
-                }
-                const findAql = `FOR edge IN @@collection FILTER ${filterStr} LIMIT 1 RETURN edge`;
-                const cursor = await this.db.query(findAql, bindVars);
-                const existing = await cursor.all();
-                if (existing.length > 0) {
-                    const edge = existing[0];
-                    const collection = this.db.collection(edgeCollectionName);
-                    const updateData = options.onMatch || {};
-                    const result = await collection.update(edge._key, updateData, { returnNew: true });
-                    return {
-                        relationship: {
-                            id: result._key,
-                            type: options.type,
-                            startNodeId: result.new._from,
-                            endNodeId: result.new._to,
-                            properties: this.cleanArangoProps(result.new),
-                            elementId: result._id,
-                        },
-                        created: false,
-                        merged: true,
-                    };
-                }
-                else {
-                    const createProps = Object.assign(Object.assign({}, options.matchProperties), (options.onCreate || {}));
-                    const result = await this.createRelationship({
-                        type: options.type,
-                        startNodeId: options.startNodeId,
-                        endNodeId: options.endNodeId,
-                        properties: createProps,
-                    });
-                    return { relationship: result.relationship, created: true, merged: true };
-                }
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to merge relationship: ${error.message}`);
-            }
-        });
-    }
-    // ==================== TRAVERSAL OPERATIONS ====================
-    async traverse(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            try {
-                const startId = String(options.startNodeId).includes('/')
-                    ? options.startNodeId
-                    : await this.resolveNodeId(options.startNodeId);
-                const direction = this.mapDirection(options.direction);
-                const maxDepth = options.maxDepth || 3;
-                const minDepth = 1;
-                const edgeCollections = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length)
-                    ? options.relationshipTypes.join(', ')
-                    : this.edgeCollections.join(', ');
-                const aql = `
-          FOR v, e, p IN ${minDepth}..${maxDepth} ${direction} @startVertex
-          ${edgeCollections}
-          OPTIONS { bfs: true, uniqueVertices: 'global' }
-          RETURN { vertex: v, edge: e, path: p }
-        `;
-                const cursor = await this.db.query(aql, { startVertex: startId });
-                const results = await cursor.all();
-                const nodesMap = new Map();
-                const relationshipsMap = new Map();
-                for (const result of results) {
-                    if (result.vertex) {
-                        const v = result.vertex;
-                        nodesMap.set(v._id, {
-                            id: v._key,
-                            labels: v._labels || [v._id.split('/')[0]],
-                            properties: this.cleanArangoProps(v),
-                            elementId: v._id,
-                        });
-                    }
-                    if (result.edge) {
-                        const e = result.edge;
-                        relationshipsMap.set(e._id, {
-                            id: e._key,
-                            type: e._id.split('/')[0],
-                            startNodeId: e._from,
-                            endNodeId: e._to,
-                            properties: this.cleanArangoProps(e),
-                            elementId: e._id,
-                        });
-                    }
-                }
-                return {
-                    nodes: Array.from(nodesMap.values()),
-                    relationships: Array.from(relationshipsMap.values()),
-                    paths: [],
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to traverse: ${error.message}`);
-            }
-        });
-    }
-    async shortestPath(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            try {
-                const startId = String(options.startNodeId).includes('/')
-                    ? options.startNodeId
-                    : await this.resolveNodeId(options.startNodeId);
-                const endId = String(options.endNodeId).includes('/')
-                    ? options.endNodeId
-                    : await this.resolveNodeId(options.endNodeId);
-                const edgeCollections = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length)
-                    ? options.relationshipTypes.join(', ')
-                    : this.edgeCollections.join(', ');
-                let aql;
-                if (options.weightProperty) {
-                    aql = `
-            FOR v, e IN OUTBOUND SHORTEST_PATH @start TO @end
-            ${edgeCollections}
-            OPTIONS { weightAttribute: @weight }
-            RETURN { vertex: v, edge: e }
-          `;
-                }
-                else {
-                    aql = `
-            FOR v, e IN OUTBOUND SHORTEST_PATH @start TO @end
-            ${edgeCollections}
-            RETURN { vertex: v, edge: e }
-          `;
-                }
-                const cursor = await this.db.query(aql, {
-                    start: startId,
-                    end: endId,
-                    weight: options.weightProperty,
-                });
-                const results = await cursor.all();
-                if (results.length === 0) {
-                    return { path: null, length: -1, found: false };
-                }
-                const nodes = [];
-                const relationships = [];
-                for (const result of results) {
-                    if (result.vertex) {
-                        nodes.push({
-                            id: result.vertex._key,
-                            labels: result.vertex._labels || [result.vertex._id.split('/')[0]],
-                            properties: this.cleanArangoProps(result.vertex),
-                            elementId: result.vertex._id,
-                        });
-                    }
-                    if (result.edge) {
-                        relationships.push({
-                            id: result.edge._key,
-                            type: result.edge._id.split('/')[0],
-                            startNodeId: result.edge._from,
-                            endNodeId: result.edge._to,
-                            properties: this.cleanArangoProps(result.edge),
-                            elementId: result.edge._id,
-                        });
-                    }
-                }
-                return {
-                    path: {
-                        nodes,
-                        relationships,
-                        length: relationships.length,
-                    },
-                    length: relationships.length,
-                    found: true,
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to find shortest path: ${error.message}`);
-            }
-        });
-    }
-    async allPaths(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            try {
-                const startId = String(options.startNodeId).includes('/')
-                    ? options.startNodeId
-                    : await this.resolveNodeId(options.startNodeId);
-                const endId = String(options.endNodeId).includes('/')
-                    ? options.endNodeId
-                    : await this.resolveNodeId(options.endNodeId);
-                const maxDepth = options.maxDepth || 5;
-                const maxPaths = options.maxPaths || options.limit || 10;
-                const edgeCollections = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length)
-                    ? options.relationshipTypes.join(', ')
-                    : this.edgeCollections.join(', ');
-                const aql = `
-          FOR p IN 1..@maxDepth OUTBOUND @start
-          ${edgeCollections}
-          PRUNE p.vertices[-1]._id == @end
-          OPTIONS { bfs: false }
-          FILTER p.vertices[-1]._id == @end
-          LIMIT @maxPaths
-          RETURN p
-        `;
-                const cursor = await this.db.query(aql, {
-                    start: startId,
-                    end: endId,
-                    maxDepth,
-                    maxPaths,
-                });
-                const pathResults = await cursor.all();
-                const paths = pathResults.map((p) => {
-                    const nodes = p.vertices.map((v) => ({
-                        id: v._key,
-                        labels: v._labels || [v._id.split('/')[0]],
-                        properties: this.cleanArangoProps(v),
-                        elementId: v._id,
-                    }));
-                    const relationships = p.edges.map((e) => ({
-                        id: e._key,
-                        type: e._id.split('/')[0],
-                        startNodeId: e._from,
-                        endNodeId: e._to,
-                        properties: this.cleanArangoProps(e),
-                        elementId: e._id,
-                    }));
-                    return { nodes, relationships, length: relationships.length };
-                });
-                return { paths, total: paths.length };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to find all paths: ${error.message}`);
-            }
-        });
-    }
-    async getNeighborhood(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a;
-            try {
-                const nodeId = String(options.nodeId).includes('/')
-                    ? options.nodeId
-                    : await this.resolveNodeId(options.nodeId);
-                const direction = this.mapDirection(options.direction);
-                const depth = options.depth || 1;
-                const edgeCollections = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length)
-                    ? options.relationshipTypes.join(', ')
-                    : this.edgeCollections.join(', ');
-                let aql = `
-          FOR v, e IN 1..@depth ${direction} @start
-          ${edgeCollections}
-          OPTIONS { uniqueVertices: 'global' }
-        `;
-                if (options.limit) {
-                    aql += ` LIMIT @limit`;
-                }
-                aql += ` RETURN { vertex: v, edge: e }`;
-                const cursor = await this.db.query(aql, {
-                    start: nodeId,
-                    depth,
-                    limit: options.limit,
-                });
-                const results = await cursor.all();
-                const nodesMap = new Map();
-                const relationshipsMap = new Map();
-                for (const result of results) {
-                    if (result.vertex) {
-                        nodesMap.set(result.vertex._id, {
-                            id: result.vertex._key,
-                            labels: result.vertex._labels || [result.vertex._id.split('/')[0]],
-                            properties: this.cleanArangoProps(result.vertex),
-                            elementId: result.vertex._id,
-                        });
-                    }
-                    if (result.edge) {
-                        relationshipsMap.set(result.edge._id, {
-                            id: result.edge._key,
-                            type: result.edge._id.split('/')[0],
-                            startNodeId: result.edge._from,
-                            endNodeId: result.edge._to,
-                            properties: this.cleanArangoProps(result.edge),
-                            elementId: result.edge._id,
-                        });
-                    }
-                }
-                return {
-                    nodes: Array.from(nodesMap.values()),
-                    relationships: Array.from(relationshipsMap.values()),
-                    depth,
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to get neighborhood: ${error.message}`);
-            }
-        });
-    }
-    async findConnectedComponents(options, transaction) {
-        throw graph_error_1.GraphError.unsupportedOperationError('Connected components', 'ArangoDB (requires Pregel or SmartGraphs)');
-    }
-    // ==================== AGGREGATION ====================
-    async countNodes(labels, where, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const collectionName = (labels === null || labels === void 0 ? void 0 : labels[0]) || this.vertexCollections[0];
-                let aql = 'RETURN LENGTH(FOR doc IN @@collection';
-                const bindVars = { '@collection': collectionName };
-                if (where) {
-                    const { filterStr, filterVars } = this.buildArangoWhereClause(where, 'doc');
-                    if (filterStr) {
-                        aql += ` FILTER ${filterStr}`;
-                        Object.assign(bindVars, filterVars);
-                    }
-                }
-                aql += ' RETURN 1)';
-                const cursor = await this.db.query(aql, bindVars);
-                const [count] = await cursor.all();
-                return { count };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to count nodes: ${error.message}`);
-            }
-        });
-    }
-    async countRelationships(types, where, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const collectionName = (types === null || types === void 0 ? void 0 : types[0]) || this.edgeCollections[0];
-                let aql = 'RETURN LENGTH(FOR edge IN @@collection';
-                const bindVars = { '@collection': collectionName };
-                if (where) {
-                    const { filterStr, filterVars } = this.buildArangoWhereClause(where, 'edge');
-                    if (filterStr) {
-                        aql += ` FILTER ${filterStr}`;
-                        Object.assign(bindVars, filterVars);
-                    }
-                }
-                aql += ' RETURN 1)';
-                const cursor = await this.db.query(aql, bindVars);
-                const [count] = await cursor.all();
-                return { count };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to count relationships: ${error.message}`);
-            }
-        });
-    }
-    async getStatistics(transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                let nodeCount = 0;
-                let relationshipCount = 0;
-                const nodesByLabel = {};
-                const relationshipsByType = {};
-                for (const collName of this.vertexCollections) {
-                    const cursor = await this.db.query('RETURN LENGTH(FOR doc IN @@collection RETURN 1)', { '@collection': collName });
-                    const [count] = await cursor.all();
-                    nodesByLabel[collName] = count;
-                    nodeCount += count;
-                }
-                for (const collName of this.edgeCollections) {
-                    const cursor = await this.db.query('RETURN LENGTH(FOR edge IN @@collection RETURN 1)', { '@collection': collName });
-                    const [count] = await cursor.all();
-                    relationshipsByType[collName] = count;
-                    relationshipCount += count;
-                }
-                return {
-                    nodeCount,
-                    relationshipCount,
-                    nodesByLabel,
-                    relationshipsByType,
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to get statistics: ${error.message}`);
-            }
-        });
-    }
-    // ==================== SEARCH ====================
-    async fullTextSearch(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const aql = `
-          FOR doc IN ${options.indexName}
-          SEARCH ANALYZER(doc.content IN TOKENS(@query, 'text_en'), 'text_en')
-          SORT BM25(doc) DESC
-          LIMIT @limit
-          RETURN doc
-        `;
-                const cursor = await this.db.query(aql, {
-                    query: options.query,
-                    limit: options.limit || 10,
-                });
-                const results = await cursor.all();
-                return {
-                    nodes: results.map((doc) => ({
-                        id: doc._key,
-                        labels: doc._labels || [doc._id.split('/')[0]],
-                        properties: this.cleanArangoProps(doc),
-                        elementId: doc._id,
-                    })),
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to perform full-text search: ${error.message}`);
-            }
-        });
-    }
-    async vectorSearch(options, transaction) {
-        throw graph_error_1.GraphError.unsupportedOperationError('Vector search', 'ArangoDB');
-    }
-    // ==================== RAW QUERY ====================
-    async query(options, transaction) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const cursor = await this.db.query(options.query, options.params || {});
-                const records = await cursor.all();
-                return {
-                    records: records,
-                    summary: {
-                        database: this.db.name,
-                    },
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to execute query: ${error.message}`);
-            }
-        });
-    }
-    // ==================== SCHEMA ====================
-    async createNodeIndex(options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            var _a, _b;
-            try {
-                const collection = this.db.collection(options.label);
-                const indexOptions = {
-                    type: this.mapIndexType(options.type),
-                    fields: options.properties,
-                    name: options.name,
-                };
-                if (((_a = options.options) === null || _a === void 0 ? void 0 : _a.sparse) !== undefined) {
-                    indexOptions.sparse = options.options.sparse;
-                }
-                if (((_b = options.options) === null || _b === void 0 ? void 0 : _b.unique) !== undefined) {
-                    indexOptions.unique = options.options.unique;
-                }
-                const result = await collection.ensureIndex(indexOptions);
-                return {
-                    created: result.isNewlyCreated,
-                    name: result.name,
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to create index: ${error.message}`);
-            }
-        });
-    }
-    async createNodeConstraint(options) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const collection = this.db.collection(options.label);
-                const fields = options.properties || (options.property ? [options.property] : []);
-                const result = await collection.ensureIndex({
-                    type: 'persistent',
-                    fields,
-                    name: options.name,
-                    unique: true,
-                });
-                return {
-                    created: result.isNewlyCreated,
-                    name: result.name,
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to create constraint: ${error.message}`);
-            }
-        });
-    }
-    async createRelationshipIndex(options) {
-        return this.createNodeIndex({
-            label: options.type,
-            properties: options.properties,
-            name: options.name,
-            type: options.type,
-        });
-    }
-    async listIndexes() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const indexes = [];
-                for (const collName of [...this.vertexCollections, ...this.edgeCollections]) {
-                    const collection = this.db.collection(collName);
-                    const collIndexes = await collection.indexes();
-                    for (const idx of collIndexes) {
-                        indexes.push({
-                            name: idx.name,
-                            labelOrType: collName,
-                            properties: idx.fields || [],
-                            type: idx.type,
-                            unique: idx.unique || false,
-                        });
-                    }
-                }
-                return { indexes };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to list indexes: ${error.message}`);
-            }
-        });
-    }
-    async listConstraints() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const constraints = [];
-                for (const collName of this.vertexCollections) {
-                    const collection = this.db.collection(collName);
-                    const indexes = await collection.indexes();
-                    for (const idx of indexes) {
-                        if (idx.unique) {
-                            constraints.push({
-                                name: idx.name,
-                                label: collName,
-                                property: (idx.fields || [])[0] || '',
-                                type: 'UNIQUE',
-                            });
-                        }
-                    }
-                }
-                return { constraints };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to list constraints: ${error.message}`);
-            }
-        });
-    }
-    async dropIndex(name) {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                for (const collName of [...this.vertexCollections, ...this.edgeCollections]) {
-                    const collection = this.db.collection(collName);
-                    try {
-                        await collection.dropIndex(name);
-                        return { dropped: true };
-                    }
-                    catch (_a) {
-                        continue;
-                    }
-                }
-                return { dropped: false };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.queryError(`Failed to drop index: ${error.message}`);
-            }
-        });
-    }
-    async dropConstraint(name) {
-        const result = await this.dropIndex(name);
-        return { dropped: result.dropped };
-    }
-    // ==================== SCHEMA INTROSPECTION ====================
-    async listLabels() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const labels = [];
-            // In ArangoDB, vertex collections act as "labels"
-            for (const collectionName of this.vertexCollections) {
-                try {
-                    const collection = this.db.collection(collectionName);
-                    // Get count
-                    const countResult = await collection.count();
-                    const count = countResult.count || 0;
-                    // Get properties from a sample of documents
-                    const cursor = await this.db.query(`
-            FOR doc IN \`${collectionName}\`
-            LIMIT 100
-            RETURN ATTRIBUTES(doc, true)
-          `);
-                    const attributeArrays = await cursor.all();
-                    // Flatten and dedupe property names
-                    const propertyNames = new Set();
-                    for (const attrs of attributeArrays) {
-                        for (const attr of attrs) {
-                            if (attr !== '_key' && attr !== '_id' && attr !== '_rev') {
-                                propertyNames.add(attr);
-                            }
-                        }
-                    }
-                    const properties = Array.from(propertyNames).map(name => ({
-                        name,
-                        type: 'unknown',
-                    }));
-                    labels.push({
-                        name: collectionName,
-                        count,
-                        properties,
-                    });
-                }
-                catch (error) {
-                    // Skip collections that don't exist or have errors
-                    continue;
-                }
-            }
-            return { labels };
-        });
-    }
-    async listRelationshipTypes() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            const types = [];
-            // In ArangoDB, edge collections act as "relationship types"
-            for (const collectionName of this.edgeCollections) {
-                try {
-                    const collection = this.db.collection(collectionName);
-                    // Get count
-                    const countResult = await collection.count();
-                    const count = countResult.count || 0;
-                    // Get source and target collection information
-                    const endpointsCursor = await this.db.query(`
-            FOR edge IN \`${collectionName}\`
-            LIMIT 100
-            RETURN {
-              fromCollection: PARSE_IDENTIFIER(edge._from).collection,
-              toCollection: PARSE_IDENTIFIER(edge._to).collection
-            }
-          `);
-                    const endpoints = await endpointsCursor.all();
-                    const fromLabelsSet = new Set();
-                    const toLabelsSet = new Set();
-                    for (const ep of endpoints) {
-                        if (ep.fromCollection)
-                            fromLabelsSet.add(ep.fromCollection);
-                        if (ep.toCollection)
-                            toLabelsSet.add(ep.toCollection);
-                    }
-                    // Get properties from a sample of edges
-                    const propsCursor = await this.db.query(`
-            FOR edge IN \`${collectionName}\`
-            LIMIT 100
-            RETURN ATTRIBUTES(edge, true)
-          `);
-                    const attributeArrays = await propsCursor.all();
-                    const propertyNames = new Set();
-                    for (const attrs of attributeArrays) {
-                        for (const attr of attrs) {
-                            if (!['_key', '_id', '_rev', '_from', '_to'].includes(attr)) {
-                                propertyNames.add(attr);
-                            }
-                        }
-                    }
-                    const properties = Array.from(propertyNames).map(name => ({
-                        name,
-                        type: 'unknown',
-                    }));
-                    types.push({
-                        type: collectionName,
-                        count,
-                        fromLabels: Array.from(fromLabelsSet),
-                        toLabels: Array.from(toLabelsSet),
-                        properties: properties.length > 0 ? properties : undefined,
-                    });
-                }
-                catch (error) {
-                    // Skip collections that don't exist or have errors
-                    continue;
-                }
-            }
-            return { types };
-        });
-    }
-    // ==================== TRANSACTIONS ====================
-    async beginTransaction() {
-        this.ensureConnected();
-        return this.executeWithRetry(async () => {
-            try {
-                const trx = await this.db.beginTransaction({
-                    write: [...this.vertexCollections, ...this.edgeCollections],
-                    read: [...this.vertexCollections, ...this.edgeCollections],
-                });
-                return {
-                    id: trx.id,
-                    status: enums_1.GraphTransactionStatus.ACTIVE,
-                    startTime: new Date(),
-                    nativeTransaction: trx,
-                };
-            }
-            catch (error) {
-                throw graph_error_1.GraphError.transactionError(`Failed to begin transaction: ${error.message}`);
-            }
-        });
-    }
-    async commitTransaction(transaction) {
-        try {
-            await transaction.nativeTransaction.commit();
-            transaction.status = enums_1.GraphTransactionStatus.COMMITTED;
-        }
-        catch (error) {
-            throw graph_error_1.GraphError.transactionError(`Failed to commit transaction: ${error.message}`);
-        }
-    }
-    async rollbackTransaction(transaction) {
-        try {
-            await transaction.nativeTransaction.abort();
-            transaction.status = enums_1.GraphTransactionStatus.ROLLED_BACK;
-        }
-        catch (error) {
-            throw graph_error_1.GraphError.transactionError(`Failed to rollback transaction: ${error.message}`);
-        }
-    }
-    // ==================== HELPERS ====================
-    mapDirection(direction) {
-        switch (direction) {
-            case enums_1.TraversalDirection.OUTGOING:
-            case 'OUTGOING':
-                return 'OUTBOUND';
-            case enums_1.TraversalDirection.INCOMING:
-            case 'INCOMING':
-                return 'INBOUND';
-            case enums_1.TraversalDirection.BOTH:
-            case 'BOTH':
-            default:
-                return 'ANY';
-        }
-    }
-    mapIndexType(type) {
-        switch (type) {
-            case 'fulltext':
-                return 'fulltext';
-            case 'geo':
-            case 'point':
-                return 'geo';
-            case 'ttl':
-                return 'ttl';
-            default:
-                return 'persistent';
-        }
-    }
-    buildWhereClause(where) {
-        return this.buildArangoWhereClause(where, 'doc');
-    }
-    parseError(error) {
-        if (error instanceof graph_error_1.GraphError) {
-            return error;
-        }
-        return graph_error_1.GraphError.queryError(String(error));
-    }
-    buildArangoWhereClause(where, varName) {
-        const conditions = [];
-        const filterVars = {};
-        let varCounter = 0;
-        for (const [key, value] of Object.entries(where)) {
-            // Normalize key to lowercase for comparison
-            const normalizedKey = key.toLowerCase();
-            if (normalizedKey === '$and') {
-                if (Array.isArray(value)) {
-                    const subConditions = [];
-                    for (const item of value) {
-                        const { filterStr, filterVars: andVars } = this.buildArangoWhereClause(item, varName);
-                        if (filterStr) {
-                            subConditions.push(filterStr);
-                            Object.assign(filterVars, andVars);
-                        }
-                    }
-                    if (subConditions.length > 0) {
-                        conditions.push(`(${subConditions.join(' AND ')})`);
-                    }
-                }
-                else {
-                    const { filterStr, filterVars: andVars } = this.buildArangoWhereClause(value, varName);
-                    if (filterStr) {
-                        conditions.push(`(${filterStr})`);
-                        Object.assign(filterVars, andVars);
-                    }
-                }
-            }
-            else if (normalizedKey === '$or') {
-                if (Array.isArray(value)) {
-                    const subConditions = [];
-                    for (const item of value) {
-                        const { filterStr, filterVars: orVars } = this.buildArangoWhereClause(item, varName);
-                        if (filterStr) {
-                            subConditions.push(filterStr);
-                            Object.assign(filterVars, orVars);
-                        }
-                    }
-                    if (subConditions.length > 0) {
-                        conditions.push(`(${subConditions.join(' OR ')})`);
-                    }
-                }
-                else {
-                    const { filterStr, filterVars: orVars } = this.buildArangoWhereClause(value, varName);
-                    if (filterStr) {
-                        conditions.push(`(${filterStr.replace(/ AND /g, ' OR ')})`);
-                        Object.assign(filterVars, orVars);
-                    }
-                }
-            }
-            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                for (const [op, opValue] of Object.entries(value)) {
-                    const normalizedOp = op.toLowerCase();
-                    const varKey = `v${varCounter++}`;
-                    filterVars[varKey] = opValue;
-                    switch (normalizedOp) {
-                        case '$gt':
-                            conditions.push(`${varName}.${key} > @${varKey}`);
-                            break;
-                        case '$gte':
-                            conditions.push(`${varName}.${key} >= @${varKey}`);
-                            break;
-                        case '$lt':
-                            conditions.push(`${varName}.${key} < @${varKey}`);
-                            break;
-                        case '$lte':
-                            conditions.push(`${varName}.${key} <= @${varKey}`);
-                            break;
-                        case '$ne':
-                            conditions.push(`${varName}.${key} != @${varKey}`);
-                            break;
-                        case '$in':
-                            conditions.push(`${varName}.${key} IN @${varKey}`);
-                            break;
-                        case '$nin':
-                        case '$not_in':
-                            conditions.push(`${varName}.${key} NOT IN @${varKey}`);
-                            break;
-                        case '$contains':
-                            conditions.push(`CONTAINS(${varName}.${key}, @${varKey})`);
-                            break;
-                        case '$startswith':
-                        case '$starts_with':
-                            conditions.push(`STARTS_WITH(${varName}.${key}, @${varKey})`);
-                            break;
-                        case '$endswith':
-                        case '$ends_with':
-                            conditions.push(`LIKE(${varName}.${key}, CONCAT('%', @${varKey}))`);
-                            break;
-                        case '$exists':
-                            if (opValue) {
-                                conditions.push(`${varName}.${key} != null`);
-                            }
-                            else {
-                                conditions.push(`${varName}.${key} == null`);
-                            }
-                            break;
-                        case '$regex':
-                            conditions.push(`REGEX_TEST(${varName}.${key}, @${varKey})`);
-                            break;
-                    }
-                }
-            }
-            else {
-                const varKey = `v${varCounter++}`;
-                filterVars[varKey] = value;
-                conditions.push(`${varName}.${key} == @${varKey}`);
-            }
-        }
-        return {
-            filterStr: conditions.join(' AND '),
-            filterVars,
-        };
-    }
-    cleanArangoProps(doc) {
-        const result = {};
-        for (const [key, value] of Object.entries(doc)) {
-            if (!key.startsWith('_')) {
-                result[key] = value;
-            }
-        }
-        return result;
-    }
-    async resolveNodeId(id) {
-        for (const collName of this.vertexCollections) {
-            try {
-                const collection = this.db.collection(collName);
-                await collection.document(id);
-                return `${collName}/${id}`;
-            }
-            catch (_a) {
-                continue;
-            }
-        }
-        throw graph_error_1.GraphError.notFoundError(`Node with ID ${id} not found`);
-    }
-}
-exports.ArangoDBAdapter = ArangoDBAdapter;
-//# sourceMappingURL=arangodb.adapter.js.map