@ductape/sdk 0.0.4-v51 → 0.0.4-v53

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

@@ -1,7 +1,10 @@
 "use strict";
 /**
  * ArangoDB Graph Database Adapter
- * Implements the BaseGraphAdapter for ArangoDB using AQL (ArangoDB Query Language)
+ *
+ * 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;
@@ -36,1358 +39,1445 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArangoDBAdapter = void 0;
 const base_adapter_1 = require("./base.adapter");
-const graph_types_1 = require("../types/graph.types");
-const node_types_1 = require("../types/node.types");
-const relationship_types_1 = require("../types/relationship.types");
+const enums_1 = require("../types/enums");
+const graph_error_1 = require("../utils/graph-error");
 /**
- * ArangoDB connection implementation
+ * ArangoDB adapter using arangojs
  */
-class ArangoDBConnection {
-    constructor(config, id) {
-        this.config = config;
-        this.type = graph_types_1.GraphDatabaseType.ARANGODB;
-        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
-        this.queryLanguage = graph_types_1.GraphQueryLanguage.AQL;
+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.graphName = null;
-        this.id = id || `arangodb-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        this.createdAt = new Date();
-    }
-    async connect() {
-        if (this.status === graph_types_1.GraphConnectionStatus.CONNECTED) {
-            return;
-        }
-        this.status = graph_types_1.GraphConnectionStatus.CONNECTING;
+        this.graph = null;
+        this.graphName = '';
+        this.vertexCollections = [];
+        this.edgeCollections = [];
+    }
+    /**
+     * Connect to ArangoDB
+     */
+    async connect(options) {
+        var _a;
         try {
-            // Dynamic import for arangojs
+            // Dynamically import arangojs
             const arangojs = await Promise.resolve().then(() => __importStar(require('arangojs')));
             const { Database } = arangojs;
-            const dbConfig = {
-                url: this.config.url,
-                databaseName: this.config.database,
-            };
-            if (this.config.token) {
-                dbConfig.auth = { bearer: this.config.token };
-            }
-            else if (this.config.username) {
-                dbConfig.auth = {
-                    username: this.config.username,
-                    password: this.config.password || '',
-                };
-            }
-            if (this.config.agentOptions) {
-                dbConfig.agentOptions = this.config.agentOptions;
-            }
-            if (this.config.headers) {
-                dbConfig.headers = this.config.headers;
-            }
-            const db = new Database(dbConfig);
-            // Verify connectivity
-            const exists = await db.exists();
-            if (!exists) {
-                throw new Error(`Database '${this.config.database}' does not exist`);
+            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.db = db;
-            this.status = graph_types_1.GraphConnectionStatus.CONNECTED;
-            this.lastUsedAt = new Date();
+            this.client = this.db;
+            this.connected = true;
+            return {
+                connected: true,
+                type: this.graphType,
+                version: await this.getVersion(),
+            };
         }
         catch (error) {
-            this.status = graph_types_1.GraphConnectionStatus.ERROR;
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, `Failed to connect to ArangoDB: ${error.message}`, error);
+            this.connected = false;
+            throw graph_error_1.GraphError.connectionError(`Failed to connect to ArangoDB: ${error.message}`);
         }
     }
-    async disconnect() {
-        this.db = null;
-        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
-    }
-    isConnected() {
-        return this.status === graph_types_1.GraphConnectionStatus.CONNECTED && this.db !== null;
-    }
-    getClient() {
-        if (!this.db) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'ArangoDB client not initialized. Call connect() first.');
+    async getVersion() {
+        try {
+            const info = await this.db.version();
+            return info.version;
+        }
+        catch (_a) {
+            return 'unknown';
         }
-        return this.db;
-    }
-    getSession() {
-        return this.getClient();
-    }
-    getConfig() {
-        return this.config;
-    }
-    setGraphName(name) {
-        this.graphName = name;
     }
-    getGraphName() {
-        return this.graphName;
+    /**
+     * Disconnect from ArangoDB
+     */
+    async disconnect() {
+        if (this.db) {
+            this.db = null;
+            this.graph = null;
+            this.client = null;
+            this.connected = false;
+        }
     }
-}
-/**
- * ArangoDB transaction implementation
- */
-class ArangoDBTransaction {
-    constructor(connection, transaction) {
-        this.connection = connection;
-        this.status = graph_types_1.GraphTransactionStatus.PENDING;
-        this.id = `tx-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        this.createdAt = new Date();
-        this.native = transaction;
-        this.status = graph_types_1.GraphTransactionStatus.ACTIVE;
+    /**
+     * 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,
+            };
+        }
     }
-    async commit() {
-        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Cannot commit transaction in ${this.status} state`);
+    // ==================== 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 {
-            if (this.native && this.native.commit) {
-                await this.native.commit();
+            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(', ')}`;
             }
-            this.status = graph_types_1.GraphTransactionStatus.COMMITTED;
+            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) {
-            this.status = graph_types_1.GraphTransactionStatus.FAILED;
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Failed to commit transaction: ${error.message}`, error);
+            throw graph_error_1.GraphError.queryError(`Failed to find nodes: ${error.message}`);
         }
     }
-    async rollback() {
-        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
-            return;
-        }
+    async findNodeById(id, transaction) {
+        this.ensureConnected();
         try {
-            if (this.native && this.native.abort) {
-                await this.native.abort();
+            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;
             }
-            this.status = graph_types_1.GraphTransactionStatus.ROLLED_BACK;
+            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) {
-            this.status = graph_types_1.GraphTransactionStatus.FAILED;
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Failed to rollback transaction: ${error.message}`, error);
+            if (error.code === 404) {
+                return null;
+            }
+            throw graph_error_1.GraphError.queryError(`Failed to find node by ID: ${error.message}`);
         }
     }
-    isActive() {
-        return this.status === graph_types_1.GraphTransactionStatus.ACTIVE;
-    }
-}
-/**
- * ArangoDB Graph Database Adapter
- */
-class ArangoDBAdapter extends base_adapter_1.BaseGraphAdapter {
-    constructor() {
-        super(...arguments);
-        this.type = graph_types_1.GraphDatabaseType.ARANGODB;
-        this.supportedLanguages = [graph_types_1.GraphQueryLanguage.AQL];
-        this.defaultLanguage = graph_types_1.GraphQueryLanguage.AQL;
-        // Default collection names
-        this.defaultVertexCollection = 'vertices';
-        this.defaultEdgeCollection = 'edges';
+    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}`);
+        }
     }
-    // ==================== CONNECTION METHODS ====================
-    async connect(config) {
-        if (config.type !== graph_types_1.GraphDatabaseType.ARANGODB) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `Invalid config type ${config.type}. Expected ${graph_types_1.GraphDatabaseType.ARANGODB}`);
-        }
-        const connection = new ArangoDBConnection(config);
-        await connection.connect();
-        return connection;
+    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 disconnect(connection) {
-        await connection.disconnect();
+    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}`);
+        }
     }
-    async testConnection(connection) {
-        const startTime = Date.now();
+    // ==================== LABEL MANAGEMENT ====================
+    async addLabels(options, _transaction) {
+        this.ensureConnected();
         try {
-            const db = connection.getClient();
-            const versionInfo = await db.version();
+            // 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 {
-                connected: true,
-                message: 'Connection successful',
-                databaseType: graph_types_1.GraphDatabaseType.ARANGODB,
-                queryLanguage: graph_types_1.GraphQueryLanguage.AQL,
-                version: versionInfo.version,
-                responseTime: Date.now() - startTime,
+                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 {
-                connected: false,
-                message: 'Connection failed',
-                databaseType: graph_types_1.GraphDatabaseType.ARANGODB,
-                queryLanguage: graph_types_1.GraphQueryLanguage.AQL,
-                responseTime: Date.now() - startTime,
-                error: error.message,
+                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 getDatabaseInfo(connection) {
-        const db = connection.getClient();
-        const versionInfo = await db.version();
-        return {
-            version: versionInfo.version,
-            edition: versionInfo.server,
-            features: ['graphs', 'full-text-search', 'geo-spatial'],
-        };
-    }
-    // ==================== TRANSACTION METHODS ====================
-    async beginTransaction(connection, options) {
-        const db = connection.getClient();
-        const collections = {
-            read: [this.defaultVertexCollection, this.defaultEdgeCollection],
-            write: [this.defaultVertexCollection, this.defaultEdgeCollection],
-        };
-        const trx = await db.beginTransaction(collections);
-        return new ArangoDBTransaction(connection, trx);
-    }
-    async commitTransaction(connection, transaction) {
-        await transaction.commit();
-    }
-    async rollbackTransaction(connection, transaction) {
-        await transaction.rollback();
-    }
-    // ==================== RAW QUERY METHODS ====================
-    async executeRaw(connection, options, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
+    async setLabels(options, _transaction) {
+        this.ensureConnected();
         try {
-            const cursor = await db.query(options.query, options.params || {});
-            const data = await cursor.all();
+            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 {
-                success: true,
-                executionTime: Date.now() - startTime,
-                data: data,
-                count: data.length,
+                node: {
+                    id: result._key,
+                    labels: options.labels,
+                    properties: this.cleanArangoProps(result.new),
+                    elementId: result._id,
+                },
+                previousLabels,
+                newLabels: options.labels,
             };
         }
         catch (error) {
-            throw this.wrapError(error, graph_types_1.GraphErrorType.QUERY_ERROR, `Query execution failed: ${error.message}`, options.query, options.params);
+            if (error instanceof graph_error_1.GraphError)
+                throw error;
+            throw graph_error_1.GraphError.queryError(`Failed to set labels: ${error.message}`);
         }
     }
-    // ==================== NODE OPERATIONS ====================
-    async createNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const labels = this.normalizeLabels(options.labels);
-        const collection = this.getVertexCollection(labels[0]);
-        // Add labels to properties for ArangoDB
-        const doc = Object.assign(Object.assign({}, options.properties), { _labels: labels });
-        const query = `
-      INSERT @doc INTO @@collection
-      RETURN NEW
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: {
-                doc,
-                '@collection': collection,
-            },
-        }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(result.data[0]) : undefined,
-            created: true,
-        };
+    // ==================== 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 findNodes(connection, options, transaction) {
-        const startTime = Date.now();
-        const labels = options.labels ? this.normalizeLabels(options.labels) : [];
-        const collection = labels.length > 0 ? this.getVertexCollection(labels[0]) : this.defaultVertexCollection;
-        let query = `FOR doc IN @@collection`;
-        const params = { '@collection': collection };
-        // Build filter conditions
-        const filters = [];
-        if (labels.length > 0) {
-            filters.push(`@labels ALL IN doc._labels`);
-            params.labels = labels;
-        }
-        if (options.properties) {
-            Object.entries(options.properties).forEach(([key, value], index) => {
-                const paramName = `prop_${index}`;
-                filters.push(`doc.${key} == @${paramName}`);
-                params[paramName] = value;
-            });
+    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 };
         }
-        if (options.where) {
-            const filterClause = this.buildAQLFilter(options.where, 'doc', params);
-            filters.push(filterClause);
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to find relationships: ${error.message}`);
         }
-        if (filters.length > 0) {
-            query += ` FILTER ${filters.join(' AND ')}`;
+    }
+    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,
+            };
         }
-        // ORDER BY
-        if (options.orderBy && options.orderBy.length > 0) {
-            const sortParts = options.orderBy.map(o => `doc.${o.property} ${o.direction}`);
-            query += ` SORT ${sortParts.join(', ')}`;
+        catch (error) {
+            if (error.code === 404) {
+                return null;
+            }
+            throw graph_error_1.GraphError.queryError(`Failed to find relationship by ID: ${error.message}`);
         }
-        // LIMIT with offset
-        if (options.skip !== undefined || options.limit !== undefined) {
-            const skip = options.skip || 0;
-            const limit = options.limit || 100;
-            query += ` LIMIT ${skip}, ${limit}`;
+    }
+    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}`);
         }
-        query += ` RETURN doc`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = result.data.map(doc => this.parseNode(doc));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes,
-            count: nodes.length,
-            hasMore: options.limit !== undefined && nodes.length === options.limit,
-        };
     }
-    async findNodeById(connection, id, transaction) {
-        const query = `
-      FOR doc IN @@collection
-        FILTER doc._key == @id OR doc._id == @id
-        RETURN doc
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: { id: String(id), '@collection': this.defaultVertexCollection },
-        }, transaction);
-        if (result.data.length === 0) {
-            return null;
-        }
-        return this.parseNode(result.data[0]);
+    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 updateNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        let query;
-        if (options.id !== undefined) {
-            // Update by ID
-            const updates = {};
-            if (options.set) {
-                Object.assign(updates, options.set);
-            }
-            if (options.addLabels) {
-                // Will handle label merging in AQL
+    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);
+                }
             }
-            query = `
-        UPDATE { _key: @id } WITH @updates IN @@collection
-        RETURN NEW
-      `;
-            params.id = String(options.id);
-            params.updates = updates;
-            params['@collection'] = this.defaultVertexCollection;
-        }
-        else {
-            // Update by filter
-            const filters = [];
-            if (options.labels) {
-                const labels = this.normalizeLabels(options.labels);
-                filters.push(`@labels ALL IN doc._labels`);
-                params.labels = labels;
+            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,
+                };
             }
-            if (options.where) {
-                const filterClause = this.buildAQLFilter(options.where, 'doc', params);
-                filters.push(filterClause);
+            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 };
             }
-            query = `
-        FOR doc IN @@collection
-          ${filters.length > 0 ? `FILTER ${filters.join(' AND ')}` : ''}
-          UPDATE doc WITH @updates IN @@collection
-          RETURN NEW
+        }
+        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 }
       `;
-            params.updates = options.set || {};
-            params['@collection'] = this.defaultVertexCollection;
+            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}`);
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(result.data[0]) : undefined,
-            updated: result.data.length > 0,
-            matchedCount: result.data.length,
-            modifiedCount: result.data.length,
-        };
     }
-    async deleteNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = {};
-        let query;
-        if (options.id !== undefined) {
-            if (options.detach) {
-                // Delete edges first
-                query = `
-          LET doc = DOCUMENT(@@collection, @id)
-          LET edges = (
-            FOR e IN @@edges
-              FILTER e._from == doc._id OR e._to == doc._id
-              REMOVE e IN @@edges
-              RETURN 1
-          )
-          REMOVE doc IN @@collection
-          RETURN { deleted: 1, edgesDeleted: LENGTH(edges) }
+    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 {
-                query = `
-          REMOVE { _key: @id } IN @@collection
-          RETURN { deleted: 1 }
+                aql = `
+          FOR v, e IN OUTBOUND SHORTEST_PATH @start TO @end
+          ${edgeCollections}
+          RETURN { vertex: v, edge: e }
         `;
             }
-            params.id = String(options.id);
-            params['@collection'] = this.defaultVertexCollection;
-            params['@edges'] = this.defaultEdgeCollection;
-        }
-        else {
-            const filters = [];
-            if (options.labels) {
-                const labels = this.normalizeLabels(options.labels);
-                filters.push(`@labels ALL IN doc._labels`);
-                params.labels = labels;
+            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 };
             }
-            if (options.where) {
-                const filterClause = this.buildAQLFilter(options.where, 'doc', params);
-                filters.push(filterClause);
+            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,
+                    });
+                }
             }
-            query = `
-        FOR doc IN @@collection
-          ${filters.length > 0 ? `FILTER ${filters.join(' AND ')}` : ''}
-          ${options.detach ? `
-            LET edges = (
-              FOR e IN @@edges
-                FILTER e._from == doc._id OR e._to == doc._id
-                REMOVE e IN @@edges
-                RETURN 1
-            )
-          ` : ''}
-          REMOVE doc IN @@collection
-          RETURN 1
-      `;
-            params['@collection'] = this.defaultVertexCollection;
-            params['@edges'] = this.defaultEdgeCollection;
+            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}`);
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            deletedCount: result.data.length,
-            deletedRelationshipsCount: 0, // Could be calculated from detach query
-        };
-    }
-    async mergeNode(connection, options, transaction) {
-        var _a, _b;
-        const startTime = Date.now();
-        const labels = this.normalizeLabels(options.labels);
-        const collection = this.getVertexCollection(labels[0]);
-        // Build match filter
-        const matchFilters = [];
-        const params = { '@collection': collection };
-        matchFilters.push(`@labels ALL IN doc._labels`);
-        params.labels = labels;
-        Object.entries(options.matchProperties).forEach(([key, value], index) => {
-            const paramName = `match_${index}`;
-            matchFilters.push(`doc.${key} == @${paramName}`);
-            params[paramName] = value;
-        });
-        const onCreate = Object.assign(Object.assign(Object.assign({}, options.matchProperties), options.onCreate), { _labels: labels });
-        const onMatch = options.onMatch || {};
-        const query = `
-      UPSERT { ${Object.keys(options.matchProperties).map(k => `${k}: @match_${Object.keys(options.matchProperties).indexOf(k)}`).join(', ')}, _labels: @labels }
-      INSERT @onCreate
-      UPDATE @onMatch
-      IN @@collection
-      RETURN { doc: NEW, created: OLD ? false : true }
-    `;
-        params.onCreate = onCreate;
-        params.onMatch = onMatch;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(result.data[0].doc) : undefined,
-            created: ((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.created) || false,
-            matched: !((_b = result.data[0]) === null || _b === void 0 ? void 0 : _b.created),
-        };
-    }
-    // ==================== RELATIONSHIP OPERATIONS ====================
-    async createRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const fromId = this.resolveNodeId(options.fromNode);
-        const toId = this.resolveNodeId(options.toNode);
-        const edge = Object.assign({ _from: fromId, _to: toId, _type: options.type }, options.properties);
-        const query = `
-      INSERT @edge INTO @@collection
-      RETURN NEW
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: {
-                edge,
-                '@collection': this.defaultEdgeCollection,
-            },
-        }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(result.data[0]) : undefined,
-            created: true,
-        };
     }
-    async findRelationships(connection, options, transaction) {
-        const startTime = Date.now();
-        let query = `FOR edge IN @@collection`;
-        const params = { '@collection': this.defaultEdgeCollection };
-        const filters = [];
-        if (options.type) {
-            const types = Array.isArray(options.type) ? options.type : [options.type];
-            filters.push(`edge._type IN @types`);
-            params.types = types;
-        }
-        if (options.fromNode && options.fromNode.id) {
-            filters.push(`edge._from == @fromId`);
-            params.fromId = this.resolveNodeId(options.fromNode);
-        }
-        if (options.toNode && options.toNode.id) {
-            filters.push(`edge._to == @toId`);
-            params.toId = this.resolveNodeId(options.toNode);
-        }
-        if (options.properties) {
-            Object.entries(options.properties).forEach(([key, value], index) => {
-                const paramName = `prop_${index}`;
-                filters.push(`edge.${key} == @${paramName}`);
-                params[paramName] = value;
+    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 };
         }
-        if (filters.length > 0) {
-            query += ` FILTER ${filters.join(' AND ')}`;
-        }
-        // ORDER BY
-        if (options.orderBy && options.orderBy.length > 0) {
-            const sortParts = options.orderBy.map(o => `edge.${o.property} ${o.direction}`);
-            query += ` SORT ${sortParts.join(', ')}`;
-        }
-        // LIMIT
-        if (options.skip !== undefined || options.limit !== undefined) {
-            const skip = options.skip || 0;
-            const limit = options.limit || 100;
-            query += ` LIMIT ${skip}, ${limit}`;
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to find all paths: ${error.message}`);
         }
-        query += ` RETURN edge`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const relationships = result.data.map(doc => this.parseRelationship(doc));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationships,
-            count: relationships.length,
-            hasMore: options.limit !== undefined && relationships.length === options.limit,
-        };
-    }
-    async findRelationshipById(connection, id, transaction) {
-        const query = `
-      FOR edge IN @@collection
-        FILTER edge._key == @id OR edge._id == @id
-        RETURN edge
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: { id: String(id), '@collection': this.defaultEdgeCollection },
-        }, transaction);
-        if (result.data.length === 0) {
-            return null;
-        }
-        return this.parseRelationship(result.data[0]);
-    }
-    async updateRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const query = `
-      UPDATE { _key: @id } WITH @updates IN @@collection
-      RETURN NEW
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: {
-                id: String(options.id),
-                updates: options.set || {},
-                '@collection': this.defaultEdgeCollection,
-            },
-        }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(result.data[0]) : undefined,
-            updated: result.data.length > 0,
-            matchedCount: result.data.length,
-            modifiedCount: result.data.length,
-        };
     }
-    async deleteRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const params = { '@collection': this.defaultEdgeCollection };
-        let query;
-        if (options.id !== undefined) {
-            query = `
-        REMOVE { _key: @id } IN @@collection
-        RETURN 1
+    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' }
       `;
-            params.id = String(options.id);
-        }
-        else {
-            const filters = [];
-            if (options.type) {
-                const types = Array.isArray(options.type) ? options.type : [options.type];
-                filters.push(`edge._type IN @types`);
-                params.types = types;
+            if (options.limit) {
+                aql += ` LIMIT @limit`;
             }
-            query = `
-        FOR edge IN @@collection
-          ${filters.length > 0 ? `FILTER ${filters.join(' AND ')}` : ''}
-          REMOVE edge IN @@collection
-          RETURN 1
-      `;
+            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}`);
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            deletedCount: result.data.length,
-        };
     }
-    async mergeRelationship(connection, options, transaction) {
-        var _a, _b;
-        const startTime = Date.now();
-        const fromId = this.resolveNodeId(options.fromNode);
-        const toId = this.resolveNodeId(options.toNode);
-        const matchDoc = Object.assign({ _from: fromId, _to: toId, _type: options.type }, options.matchProperties);
-        const insertDoc = Object.assign(Object.assign({}, matchDoc), options.onCreate);
-        const updateDoc = options.onMatch || {};
-        const query = `
-      UPSERT @matchDoc
-      INSERT @insertDoc
-      UPDATE @updateDoc
-      IN @@collection
-      RETURN { doc: NEW, created: OLD ? false : true }
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: {
-                matchDoc,
-                insertDoc,
-                updateDoc,
-                '@collection': this.defaultEdgeCollection,
-            },
-        }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(result.data[0].doc) : undefined,
-            created: ((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.created) || false,
-            matched: !((_b = result.data[0]) === null || _b === void 0 ? void 0 : _b.created),
-        };
+    async findConnectedComponents(options, transaction) {
+        throw graph_error_1.GraphError.unsupportedOperationError('Connected components', 'ArangoDB (requires Pregel or SmartGraphs)');
     }
-    // ==================== PATH & TRAVERSAL OPERATIONS ====================
-    async traverse(connection, options, transaction) {
-        const startTime = Date.now();
-        const startId = this.resolveNodeId(options.startNode);
-        const minDepth = options.minDepth || 1;
-        const maxDepth = options.maxDepth || 10;
-        const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'INBOUND' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'OUTBOUND' : 'ANY';
-        let edgeCollections = this.defaultEdgeCollection;
-        if (options.relationships) {
-            const patterns = Array.isArray(options.relationships) ? options.relationships : [options.relationships];
-            const types = patterns.filter(p => p.type).map(p => p.type);
-            if (types.length > 0) {
-                // In ArangoDB, you'd filter by edge type within the traversal
+    // ==================== 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}`);
         }
-        const query = `
-      FOR vertex, edge, path IN ${minDepth}..${maxDepth} ${direction} @startId
-        GRAPH @graphName
-        ${options.limit ? `LIMIT ${options.limit}` : ''}
-        RETURN { vertex, edge, path }
-    `;
-        const arangoConn = connection;
-        const graphName = arangoConn.getGraphName() || 'defaultGraph';
-        const result = await this.executeRaw(connection, {
-            query,
-            params: { startId, graphName },
-        }, transaction);
-        const nodesMap = new Map();
-        const relsMap = new Map();
-        const paths = [];
-        result.data.forEach(row => {
-            if (row.vertex) {
-                const node = this.parseNode(row.vertex);
-                nodesMap.set(String(node.id), node);
+    }
+    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);
+                }
             }
-            if (row.edge) {
-                const rel = this.parseRelationship(row.edge);
-                relsMap.set(String(rel.id), rel);
+            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;
             }
-            if (row.path && options.returnPaths) {
-                paths.push(this.parsePath(row.path));
+            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 {
-            success: true,
-            executionTime: Date.now() - startTime,
-            paths: options.returnPaths ? paths : undefined,
-            nodes: options.returnNodes ? Array.from(nodesMap.values()) : undefined,
-            relationships: Array.from(relsMap.values()),
-            count: result.data.length,
-        };
+            return {
+                nodeCount,
+                relationshipCount,
+                nodesByLabel,
+                relationshipsByType,
+            };
+        }
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to get statistics: ${error.message}`);
+        }
     }
-    async shortestPath(connection, options, transaction) {
-        const startTime = Date.now();
-        const startId = this.resolveNodeId(options.startNode);
-        const endId = this.resolveNodeId(options.endNode);
-        const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'INBOUND' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'OUTBOUND' : 'ANY';
-        let query;
-        if (options.weightProperty) {
-            // Weighted shortest path using SHORTEST_PATH with weight
-            query = `
-        FOR path IN ${direction} SHORTEST_PATH @startId TO @endId
-          GRAPH @graphName
-          OPTIONS { weightAttribute: @weightProp }
-          RETURN path
+    // ==================== 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,
+                })),
+            };
         }
-        else {
-            query = `
-        FOR path IN ${direction} SHORTEST_PATH @startId TO @endId
-          GRAPH @graphName
-          RETURN path
-      `;
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to perform full-text search: ${error.message}`);
         }
-        const arangoConn = connection;
-        const graphName = arangoConn.getGraphName() || 'defaultGraph';
-        const result = await this.executeRaw(connection, {
-            query,
-            params: {
-                startId,
-                endId,
-                graphName,
-                weightProp: options.weightProperty || 'weight',
-            },
-        }, transaction);
-        if (result.data.length === 0 || !result.data[0]) {
+    }
+    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 {
-                success: true,
-                executionTime: Date.now() - startTime,
-                found: false,
+                records: records,
+                summary: {
+                    database: this.db.name,
+                },
             };
         }
-        const path = this.parsePath(result.data[0]);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            path,
-            found: true,
-            length: path.length,
-        };
-    }
-    async allPaths(connection, options, transaction) {
-        const startTime = Date.now();
-        const startId = this.resolveNodeId(options.startNode);
-        const endId = this.resolveNodeId(options.endNode);
-        const minDepth = options.minDepth || 1;
-        const maxDepth = options.maxDepth || 10;
-        const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'INBOUND' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'OUTBOUND' : 'ANY';
-        const query = `
-      FOR vertex, edge, path IN ${minDepth}..${maxDepth} ${direction} @startId
-        GRAPH @graphName
-        FILTER vertex._id == @endId
-        ${options.limit ? `LIMIT ${options.limit}` : ''}
-        RETURN path
-    `;
-        const arangoConn = connection;
-        const graphName = arangoConn.getGraphName() || 'defaultGraph';
-        const result = await this.executeRaw(connection, {
-            query,
-            params: { startId, endId, graphName },
-        }, transaction);
-        const paths = result.data.map(p => this.parsePath(p));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            paths,
-            count: paths.length,
-        };
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to execute query: ${error.message}`);
+        }
     }
-    async matchPattern(connection, options, transaction) {
-        const startTime = Date.now();
-        const { pattern } = options;
-        // Build AQL query from pattern
-        const forClauses = [];
-        const filters = [];
-        const params = {};
-        pattern.nodes.forEach((node, index) => {
-            forClauses.push(`FOR ${node.variable} IN @@vertices_${index}`);
-            params[`@vertices_${index}`] = this.defaultVertexCollection;
-            if (node.labels) {
-                const labels = Array.isArray(node.labels) ? node.labels : [node.labels];
-                filters.push(`@labels_${index} ALL IN ${node.variable}._labels`);
-                params[`labels_${index}`] = labels;
+    // ==================== 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 (node.properties) {
-                Object.entries(node.properties).forEach(([key, value], propIndex) => {
-                    const paramName = `node_${index}_prop_${propIndex}`;
-                    filters.push(`${node.variable}.${key} == @${paramName}`);
-                    params[paramName] = value;
-                });
+            if (((_b = options.options) === null || _b === void 0 ? void 0 : _b.unique) !== undefined) {
+                indexOptions.unique = options.options.unique;
             }
-        });
-        // Handle relationships
-        pattern.relationships.forEach((rel, index) => {
-            forClauses.push(`FOR ${rel.variable || `_edge_${index}`} IN @@edges_${index}`);
-            params[`@edges_${index}`] = this.defaultEdgeCollection;
-            const edgeVar = rel.variable || `_edge_${index}`;
-            filters.push(`${edgeVar}._from == ${rel.startNode}._id`);
-            filters.push(`${edgeVar}._to == ${rel.endNode}._id`);
-            if (rel.type) {
-                const types = Array.isArray(rel.type) ? rel.type : [rel.type];
-                filters.push(`${edgeVar}._type IN @relTypes_${index}`);
-                params[`relTypes_${index}`] = types;
-            }
-        });
-        const returnVars = options.return || pattern.nodes.map(n => n.variable);
-        let query = forClauses.join('\n');
-        if (filters.length > 0) {
-            query += `\nFILTER ${filters.join(' AND ')}`;
+            const result = await collection.ensureIndex(indexOptions);
+            return {
+                created: result.isNewlyCreated,
+                name: result.name,
+            };
         }
-        if (options.limit) {
-            query += `\nLIMIT ${options.skip || 0}, ${options.limit}`;
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to create index: ${error.message}`);
         }
-        query += `\nRETURN { ${returnVars.map(v => `${v}: ${v}`).join(', ')} }`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            matches: result.data,
-            count: result.data.length,
-            hasMore: options.limit !== undefined && result.data.length === options.limit,
-        };
     }
-    async extractSubgraph(connection, options, transaction) {
-        const startTime = Date.now();
-        const startNodes = Array.isArray(options.startNodes) ? options.startNodes : [options.startNodes];
-        const startIds = startNodes.map(n => this.resolveNodeId(n));
-        const maxDepth = options.maxDepth || 3;
-        const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'INBOUND' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'OUTBOUND' : 'ANY';
-        const query = `
-      LET startNodes = @startIds
-      LET subgraphNodes = (
-        FOR startId IN startNodes
-          FOR vertex IN 0..@maxDepth ${direction} startId
-            GRAPH @graphName
-            RETURN DISTINCT vertex
-      )
-      LET subgraphEdges = (
-        FOR startId IN startNodes
-          FOR vertex, edge IN 1..@maxDepth ${direction} startId
-            GRAPH @graphName
-            RETURN DISTINCT edge
-      )
-      RETURN { nodes: subgraphNodes, edges: subgraphEdges }
-    `;
-        const arangoConn = connection;
-        const graphName = arangoConn.getGraphName() || 'defaultGraph';
-        const result = await this.executeRaw(connection, {
-            query,
-            params: { startIds, maxDepth, graphName },
-        }, transaction);
-        const nodes = [];
-        const relationships = [];
-        if (result.data.length > 0) {
-            const row = result.data[0];
-            if (row.nodes) {
-                row.nodes.forEach((n) => nodes.push(this.parseNode(n)));
-            }
-            if (row.edges) {
-                row.edges.filter((e) => e).forEach((e) => relationships.push(this.parseRelationship(e)));
-            }
+    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}`);
         }
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            subgraph: {
-                nodes,
-                relationships,
-                nodeCount: nodes.length,
-                relationshipCount: relationships.length,
-            },
-        };
     }
-    async getNeighborhood(connection, options, transaction) {
-        const startTime = Date.now();
-        const nodeId = this.resolveNodeId(options.node);
-        const depth = options.depth || 1;
-        const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'INBOUND' :
-            options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'OUTBOUND' : 'ANY';
-        const query = `
-      FOR vertex, edge IN 0..@depth ${direction} @nodeId
-        GRAPH @graphName
-        RETURN { vertex, edge }
-    `;
-        const arangoConn = connection;
-        const graphName = arangoConn.getGraphName() || 'defaultGraph';
-        const result = await this.executeRaw(connection, {
-            query,
-            params: { nodeId, depth, graphName },
-        }, transaction);
-        const nodesMap = new Map();
-        const relsMap = new Map();
-        result.data.forEach(row => {
-            if (row.vertex) {
-                const node = this.parseNode(row.vertex);
-                nodesMap.set(String(node.id), node);
-            }
-            if (row.edge) {
-                const rel = this.parseRelationship(row.edge);
-                relsMap.set(String(rel.id), rel);
-            }
+    async createRelationshipIndex(options) {
+        return this.createNodeIndex({
+            label: options.type,
+            properties: options.properties,
+            name: options.name,
+            type: options.type,
         });
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes: Array.from(nodesMap.values()),
-            relationships: Array.from(relsMap.values()),
-            levels: new Map(),
-        };
     }
-    async findConnectedComponents(connection, options, transaction) {
-        const startTime = Date.now();
-        // ArangoDB doesn't have built-in connected components
-        // This would require Pregel or custom implementation
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Connected components analysis requires ArangoDB Pregel or custom implementation');
-    }
-    // ==================== AGGREGATION OPERATIONS ====================
-    async countNodes(connection, labels, where, transaction) {
-        const startTime = Date.now();
-        let query = `RETURN COUNT(FOR doc IN @@collection`;
-        const params = { '@collection': this.defaultVertexCollection };
-        const filters = [];
-        if (labels) {
-            const labelArr = Array.isArray(labels) ? labels : [labels];
-            filters.push(`@labels ALL IN doc._labels`);
-            params.labels = labelArr;
-        }
-        if (where) {
-            Object.entries(where).forEach(([key, value], index) => {
-                const paramName = `where_${index}`;
-                filters.push(`doc.${key} == @${paramName}`);
-                params[paramName] = value;
-            });
+    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 };
         }
-        if (filters.length > 0) {
-            query += ` FILTER ${filters.join(' AND ')}`;
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to list indexes: ${error.message}`);
         }
-        query += ` RETURN 1)`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            count: result.data[0] || 0,
-        };
     }
-    async countRelationships(connection, type, where, transaction) {
-        const startTime = Date.now();
-        let query = `RETURN COUNT(FOR edge IN @@collection`;
-        const params = { '@collection': this.defaultEdgeCollection };
-        const filters = [];
-        if (type) {
-            const typeArr = Array.isArray(type) ? type : [type];
-            filters.push(`edge._type IN @types`);
-            params.types = typeArr;
-        }
-        if (where) {
-            Object.entries(where).forEach(([key, value], index) => {
-                const paramName = `where_${index}`;
-                filters.push(`edge.${key} == @${paramName}`);
-                params[paramName] = value;
-            });
+    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 };
         }
-        if (filters.length > 0) {
-            query += ` FILTER ${filters.join(' AND ')}`;
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to list constraints: ${error.message}`);
         }
-        query += ` RETURN 1)`;
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            count: result.data[0] || 0,
-        };
-    }
-    async getStatistics(connection, transaction) {
-        const startTime = Date.now();
-        const nodeCountResult = await this.countNodes(connection, undefined, undefined, transaction);
-        const relCountResult = await this.countRelationships(connection, undefined, undefined, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodeCount: nodeCountResult.count,
-            relationshipCount: relCountResult.count,
-            labelCounts: {},
-            relationshipTypeCounts: {},
-        };
     }
-    // ==================== SEARCH OPERATIONS ====================
-    async fullTextSearch(connection, options, transaction) {
-        const startTime = Date.now();
-        // ArangoDB uses ArangoSearch for full-text search
-        const query = `
-      FOR doc IN @@view
-        SEARCH ANALYZER(doc.${options.index} IN TOKENS(@searchQuery, "text_en"), "text_en")
-        ${options.labels ? `FILTER @labels ALL IN doc._labels` : ''}
-        ${options.limit ? `LIMIT ${options.limit}` : ''}
-        ${options.score ? `RETURN MERGE(doc, { score: BM25(doc) })` : `RETURN doc`}
-    `;
-        const result = await this.executeRaw(connection, {
-            query,
-            params: {
-                '@view': `${this.defaultVertexCollection}_search`,
-                searchQuery: options.query,
-                labels: options.labels || [],
-            },
-        }, transaction);
-        const nodes = result.data.map(doc => {
-            const node = this.parseNode(doc);
-            if (options.score && doc.score !== undefined) {
-                return Object.assign(Object.assign({}, node), { score: doc.score });
+    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 node;
-        });
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes,
-            count: nodes.length,
-        };
+            return { dropped: false };
+        }
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to drop index: ${error.message}`);
+        }
     }
-    async vectorSearch(connection, options, transaction) {
-        // ArangoDB requires ArangoSearch with custom analyzers for vector similarity
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Vector search requires ArangoDB Enterprise with custom vector analyzer configuration');
+    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 };
     }
-    // ==================== SCHEMA OPERATIONS ====================
-    async createNodeConstraint(connection, constraint, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const collection = this.getVertexCollection(constraint.label);
-        const coll = db.collection(collection);
-        // ArangoDB uses unique indexes for constraints
-        if (constraint.type === node_types_1.NodeConstraintType.UNIQUE) {
-            await coll.ensureIndex({
-                type: 'persistent',
-                fields: constraint.properties,
-                unique: true,
-                name: constraint.name,
+    // ==================== 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}`);
         }
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: constraint.name,
-            created: true,
-        };
-    }
-    async createRelationshipConstraint(connection, constraint, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const coll = db.collection(this.defaultEdgeCollection);
-        await coll.ensureIndex({
-            type: 'persistent',
-            fields: constraint.properties,
-            unique: true,
-            name: constraint.name,
-        });
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: constraint.name,
-            created: true,
-        };
     }
-    async dropConstraint(connection, name, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        // ArangoDB drops constraints via dropIndex
-        const coll = db.collection(this.defaultVertexCollection);
-        await coll.dropIndex(name);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name,
-            dropped: true,
-        };
+    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 listConstraints(connection, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const coll = db.collection(this.defaultVertexCollection);
-        const indexes = await coll.indexes();
-        const constraints = indexes
-            .filter((idx) => idx.unique)
-            .map((idx) => ({
-            name: idx.name,
-            type: 'UNIQUE',
-            entityType: 'NODE',
-            labelsOrTypes: [],
-            properties: idx.fields,
-        }));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            constraints,
-        };
+    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}`);
+        }
     }
-    async createNodeIndex(connection, index, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const collection = this.getVertexCollection(index.label);
-        const coll = db.collection(collection);
-        let indexType = 'persistent';
-        const options = {
-            fields: index.properties,
-            name: index.name,
-        };
-        switch (index.type) {
-            case node_types_1.NodeIndexType.FULLTEXT:
-                indexType = 'fulltext';
-                break;
-            case node_types_1.NodeIndexType.POINT:
-                indexType = 'geo';
-                break;
+    // ==================== 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:
-                indexType = 'persistent';
+                return 'ANY';
         }
-        options.type = indexType;
-        await coll.ensureIndex(options);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: index.name,
-            created: true,
-        };
-    }
-    async createRelationshipIndex(connection, index, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const coll = db.collection(this.defaultEdgeCollection);
-        await coll.ensureIndex({
-            type: 'persistent',
-            fields: index.properties,
-            name: index.name,
-        });
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name: index.name,
-            created: true,
-        };
     }
-    async dropIndex(connection, name, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const coll = db.collection(this.defaultVertexCollection);
-        await coll.dropIndex(name);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            name,
-            dropped: true,
-        };
-    }
-    async listIndexes(connection, transaction) {
-        const startTime = Date.now();
-        const db = connection.getClient();
-        const coll = db.collection(this.defaultVertexCollection);
-        const indexes = await coll.indexes();
-        const indexList = indexes.map((idx) => ({
-            name: idx.name,
-            type: idx.type,
-            entityType: 'NODE',
-            labelsOrTypes: [],
-            properties: idx.fields,
-            state: 'ONLINE',
-            uniqueness: idx.unique ? 'UNIQUE' : 'NONUNIQUE',
-        }));
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            indexes: indexList,
-        };
-    }
-    // ==================== UTILITY METHODS ====================
-    escapeIdentifier(identifier) {
-        return identifier.replace(/[^a-zA-Z0-9_]/g, '_');
-    }
-    escapeValue(value) {
-        if (value === null)
-            return 'null';
-        if (typeof value === 'string')
-            return `"${value.replace(/"/g, '\\"')}"`;
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'boolean')
-            return value ? 'true' : 'false';
-        if (value instanceof Date)
-            return `"${value.toISOString()}"`;
-        if (Array.isArray(value))
-            return `[${value.map(v => this.escapeValue(v)).join(', ')}]`;
-        return JSON.stringify(value);
-    }
-    buildWhereClause(where, variableName = 'doc') {
-        const params = {};
-        const parts = [];
-        Object.entries(where).forEach(([key, value], index) => {
-            const paramName = `where_${index}`;
-            parts.push(`${variableName}.${key} == @${paramName}`);
-            params[paramName] = value;
-        });
-        return {
-            clause: parts.join(' AND '),
-            params,
-        };
-    }
-    // ==================== PROTECTED PARSER METHODS ====================
-    parseNode(nativeNode) {
-        if (!nativeNode) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.NODE_ERROR, 'Cannot parse null node');
+    mapIndexType(type) {
+        switch (type) {
+            case 'fulltext':
+                return 'fulltext';
+            case 'geo':
+            case 'point':
+                return 'geo';
+            case 'ttl':
+                return 'ttl';
+            default:
+                return 'persistent';
         }
-        const { _key, _id, _rev, _labels } = nativeNode, properties = __rest(nativeNode, ["_key", "_id", "_rev", "_labels"]);
-        return {
-            id: _key || _id,
-            labels: _labels || [],
-            properties: properties,
-            elementId: _id,
-        };
     }
-    parseRelationship(nativeRelationship) {
-        if (!nativeRelationship) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.RELATIONSHIP_ERROR, 'Cannot parse null relationship');
-        }
-        const { _key, _id, _rev, _from, _to, _type } = nativeRelationship, properties = __rest(nativeRelationship, ["_key", "_id", "_rev", "_from", "_to", "_type"]);
-        return {
-            id: _key || _id,
-            type: _type || '',
-            startNodeId: _from,
-            endNodeId: _to,
-            properties: properties,
-            elementId: _id,
-        };
+    buildWhereClause(where) {
+        return this.buildArangoWhereClause(where, 'doc');
     }
-    parsePath(nativePath) {
-        if (!nativePath) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.PATH_ERROR, 'Cannot parse null path');
-        }
-        const nodes = [];
-        const relationships = [];
-        if (nativePath.vertices) {
-            nativePath.vertices.forEach((v) => nodes.push(this.parseNode(v)));
-        }
-        if (nativePath.edges) {
-            nativePath.edges.forEach((e) => {
-                if (e)
-                    relationships.push(this.parseRelationship(e));
-            });
+    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)) {
+            if (key === '$AND') {
+                const { filterStr, filterVars: andVars } = this.buildArangoWhereClause(value, varName);
+                if (filterStr) {
+                    conditions.push(`(${filterStr})`);
+                    Object.assign(filterVars, andVars);
+                }
+            }
+            else if (key === '$OR') {
+                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 varKey = `v${varCounter++}`;
+                    filterVars[varKey] = opValue;
+                    switch (op) {
+                        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 '$NOT_IN':
+                            conditions.push(`${varName}.${key} NOT IN @${varKey}`);
+                            break;
+                        case '$CONTAINS':
+                            conditions.push(`CONTAINS(${varName}.${key}, @${varKey})`);
+                            break;
+                        case '$STARTS_WITH':
+                            conditions.push(`STARTS_WITH(${varName}.${key}, @${varKey})`);
+                            break;
+                        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;
+                    }
+                }
+            }
+            else {
+                const varKey = `v${varCounter++}`;
+                filterVars[varKey] = value;
+                conditions.push(`${varName}.${key} == @${varKey}`);
+            }
         }
         return {
-            nodes,
-            relationships,
-            length: relationships.length,
-            start: nodes[0],
-            end: nodes[nodes.length - 1],
+            filterStr: conditions.join(' AND '),
+            filterVars,
         };
     }
-    // ==================== PRIVATE HELPER METHODS ====================
-    normalizeLabels(labels) {
-        return Array.isArray(labels) ? labels : [labels];
-    }
-    getVertexCollection(label) {
-        // In ArangoDB, you might use different collections per label
-        // For simplicity, using default collection
-        return this.defaultVertexCollection;
-    }
-    resolveNodeId(ref) {
-        if (typeof ref === 'string')
-            return ref;
-        if (ref.id) {
-            const id = String(ref.id);
-            // If it's not already a full document ID, prefix it
-            if (!id.includes('/')) {
-                return `${this.defaultVertexCollection}/${id}`;
+    cleanArangoProps(doc) {
+        const result = {};
+        for (const [key, value] of Object.entries(doc)) {
+            if (!key.startsWith('_')) {
+                result[key] = value;
             }
-            return id;
         }
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Node reference must have an id');
+        return result;
     }
-    buildAQLFilter(where, alias, params, prefix = '') {
-        const paramName = `${prefix}filter_${Object.keys(params).length}`;
-        let operator;
-        switch (where.operator) {
-            case node_types_1.NodeComparisonOperator.EQUALS:
-                operator = '==';
-                break;
-            case node_types_1.NodeComparisonOperator.NOT_EQUALS:
-                operator = '!=';
-                break;
-            case node_types_1.NodeComparisonOperator.GREATER_THAN:
-                operator = '>';
-                break;
-            case node_types_1.NodeComparisonOperator.GREATER_THAN_OR_EQUAL:
-                operator = '>=';
-                break;
-            case node_types_1.NodeComparisonOperator.LESS_THAN:
-                operator = '<';
-                break;
-            case node_types_1.NodeComparisonOperator.LESS_THAN_OR_EQUAL:
-                operator = '<=';
-                break;
-            case node_types_1.NodeComparisonOperator.IN:
-                operator = 'IN';
-                break;
-            case node_types_1.NodeComparisonOperator.NOT_IN:
-                operator = 'NOT IN';
-                break;
-            case node_types_1.NodeComparisonOperator.CONTAINS:
-                params[paramName] = where.value;
-                return `CONTAINS(${alias}.${where.property}, @${paramName})`;
-            case node_types_1.NodeComparisonOperator.STARTS_WITH:
-                params[paramName] = where.value;
-                return `STARTS_WITH(${alias}.${where.property}, @${paramName})`;
-            case node_types_1.NodeComparisonOperator.IS_NULL:
-                return `${alias}.${where.property} == null`;
-            case node_types_1.NodeComparisonOperator.IS_NOT_NULL:
-                return `${alias}.${where.property} != null`;
-            case node_types_1.NodeComparisonOperator.REGEX:
-                params[paramName] = where.value;
-                return `REGEX_TEST(${alias}.${where.property}, @${paramName})`;
-            default:
-                operator = '==';
-        }
-        params[paramName] = where.value;
-        let condition = `${alias}.${where.property} ${operator} @${paramName}`;
-        if (where.and && where.and.length > 0) {
-            const andClauses = where.and.map((w, i) => this.buildAQLFilter(w, alias, params, `${prefix}and${i}_`));
-            condition = `(${condition} AND ${andClauses.join(' AND ')})`;
-        }
-        if (where.or && where.or.length > 0) {
-            const orClauses = where.or.map((w, i) => this.buildAQLFilter(w, alias, params, `${prefix}or${i}_`));
-            condition = `(${condition} OR ${orClauses.join(' OR ')})`;
+    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;
+            }
         }
-        return condition;
+        throw graph_error_1.GraphError.notFoundError(`Node with ID ${id} not found`);
     }
 }
 exports.ArangoDBAdapter = ArangoDBAdapter;
-exports.default = ArangoDBAdapter;
 //# sourceMappingURL=arangodb.adapter.js.map