@ductape/sdk 0.0.4-v9 → 0.0.4-v90

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

@@ -0,0 +1,1588 @@
+"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