@ductape/sdk 0.0.4-v6 → 0.0.4-v61

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

@@ -0,0 +1,1522 @@
+"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 {
+            // 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();
+        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) {
+        var _a, _b, _c, _d, _e;
+        this.ensureConnected();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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) {
+        var _a, _b, _c, _d;
+        this.ensureConnected();
+        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();
+        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();
+        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();
+        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();
+        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) {
+        var _a;
+        this.ensureConnected();
+        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) {
+        var _a;
+        this.ensureConnected();
+        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) {
+        var _a;
+        this.ensureConnected();
+        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) {
+        var _a;
+        this.ensureConnected();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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) {
+        var _a, _b;
+        this.ensureConnected();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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();
+        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