@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,1393 @@
+"use strict";
+/**
+ * ArangoDB Graph Database Adapter
+ * Implements the BaseGraphAdapter for ArangoDB using AQL (ArangoDB Query Language)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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");
+/**
+ * ArangoDB connection implementation
+ */
+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;
+        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;
+        try {
+            // Dynamic import for 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 = db;
+            this.status = graph_types_1.GraphConnectionStatus.CONNECTED;
+            this.lastUsedAt = new Date();
+        }
+        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);
+        }
+    }
+    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.');
+        }
+        return this.db;
+    }
+    getSession() {
+        return this.getClient();
+    }
+    getConfig() {
+        return this.config;
+    }
+    setGraphName(name) {
+        this.graphName = name;
+    }
+    getGraphName() {
+        return this.graphName;
+    }
+}
+/**
+ * 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;
+    }
+    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`);
+        }
+        try {
+            if (this.native && this.native.commit) {
+                await this.native.commit();
+            }
+            this.status = graph_types_1.GraphTransactionStatus.COMMITTED;
+        }
+        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);
+        }
+    }
+    async rollback() {
+        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
+            return;
+        }
+        try {
+            if (this.native && this.native.abort) {
+                await this.native.abort();
+            }
+            this.status = graph_types_1.GraphTransactionStatus.ROLLED_BACK;
+        }
+        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);
+        }
+    }
+    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';
+    }
+    // ==================== 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 disconnect(connection) {
+        await connection.disconnect();
+    }
+    async testConnection(connection) {
+        const startTime = Date.now();
+        try {
+            const db = connection.getClient();
+            const versionInfo = await db.version();
+            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,
+            };
+        }
+        catch (error) {
+            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,
+            };
+        }
+    }
+    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();
+        try {
+            const cursor = await db.query(options.query, options.params || {});
+            const data = await cursor.all();
+            return {
+                success: true,
+                executionTime: Date.now() - startTime,
+                data: data,
+                count: data.length,
+            };
+        }
+        catch (error) {
+            throw this.wrapError(error, graph_types_1.GraphErrorType.QUERY_ERROR, `Query execution failed: ${error.message}`, options.query, options.params);
+        }
+    }
+    // ==================== 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,
+        };
+    }
+    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;
+            });
+        }
+        if (options.where) {
+            const filterClause = this.buildAQLFilter(options.where, 'doc', params);
+            filters.push(filterClause);
+        }
+        if (filters.length > 0) {
+            query += ` FILTER ${filters.join(' AND ')}`;
+        }
+        // ORDER BY
+        if (options.orderBy && options.orderBy.length > 0) {
+            const sortParts = options.orderBy.map(o => `doc.${o.property} ${o.direction}`);
+            query += ` SORT ${sortParts.join(', ')}`;
+        }
+        // LIMIT with offset
+        if (options.skip !== undefined || options.limit !== undefined) {
+            const skip = options.skip || 0;
+            const limit = options.limit || 100;
+            query += ` LIMIT ${skip}, ${limit}`;
+        }
+        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 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
+            }
+            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;
+            }
+            if (options.where) {
+                const filterClause = this.buildAQLFilter(options.where, 'doc', params);
+                filters.push(filterClause);
+            }
+            query = `
+        FOR doc IN @@collection
+          ${filters.length > 0 ? `FILTER ${filters.join(' AND ')}` : ''}
+          UPDATE doc WITH @updates IN @@collection
+          RETURN NEW
+      `;
+            params.updates = options.set || {};
+            params['@collection'] = this.defaultVertexCollection;
+        }
+        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) }
+        `;
+            }
+            else {
+                query = `
+          REMOVE { _key: @id } IN @@collection
+          RETURN { deleted: 1 }
+        `;
+            }
+            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;
+            }
+            if (options.where) {
+                const filterClause = this.buildAQLFilter(options.where, 'doc', params);
+                filters.push(filterClause);
+            }
+            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;
+        }
+        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;
+            });
+        }
+        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}`;
+        }
+        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
+      `;
+            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;
+            }
+            query = `
+        FOR edge IN @@collection
+          ${filters.length > 0 ? `FILTER ${filters.join(' AND ')}` : ''}
+          REMOVE edge IN @@collection
+          RETURN 1
+      `;
+        }
+        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),
+        };
+    }
+    // ==================== 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
+            }
+        }
+        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);
+            }
+            if (row.edge) {
+                const rel = this.parseRelationship(row.edge);
+                relsMap.set(String(rel.id), rel);
+            }
+            if (row.path && options.returnPaths) {
+                paths.push(this.parsePath(row.path));
+            }
+        });
+        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,
+        };
+    }
+    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
+      `;
+        }
+        else {
+            query = `
+        FOR path IN ${direction} SHORTEST_PATH @startId TO @endId
+          GRAPH @graphName
+          RETURN path
+      `;
+        }
+        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]) {
+            return {
+                success: true,
+                executionTime: Date.now() - startTime,
+                found: false,
+            };
+        }
+        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,
+        };
+    }
+    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;
+            }
+            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;
+                });
+            }
+        });
+        // 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 ')}`;
+        }
+        if (options.limit) {
+            query += `\nLIMIT ${options.skip || 0}, ${options.limit}`;
+        }
+        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)));
+            }
+        }
+        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);
+            }
+        });
+        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;
+            });
+        }
+        if (filters.length > 0) {
+            query += ` FILTER ${filters.join(' AND ')}`;
+        }
+        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;
+            });
+        }
+        if (filters.length > 0) {
+            query += ` FILTER ${filters.join(' AND ')}`;
+        }
+        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 });
+            }
+            return node;
+        });
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            nodes,
+            count: nodes.length,
+        };
+    }
+    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');
+    }
+    // ==================== 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,
+            });
+        }
+        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 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 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;
+            default:
+                indexType = 'persistent';
+        }
+        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');
+        }
+        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,
+        };
+    }
+    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));
+            });
+        }
+        return {
+            nodes,
+            relationships,
+            length: relationships.length,
+            start: nodes[0],
+            end: nodes[nodes.length - 1],
+        };
+    }
+    // ==================== 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}`;
+            }
+            return id;
+        }
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Node reference must have an id');
+    }
+    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 ')})`;
+        }
+        return condition;
+    }
+}
+exports.ArangoDBAdapter = ArangoDBAdapter;
+exports.default = ArangoDBAdapter;
+//# sourceMappingURL=arangodb.adapter.js.map