@ductape/sdk 0.0.4-v51 → 0.0.4-v52

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

@@ -1,1430 +1,1297 @@
 "use strict";
 /**
- * AWS Neptune Graph Database Adapter
- * Implements the BaseGraphAdapter for Amazon Neptune using Gremlin or openCypher
+ * Amazon Neptune Graph Database Adapter
+ *
+ * Implements the BaseGraphAdapter for Amazon Neptune using Gremlin.
+ * Neptune is a fully managed graph database service that supports
+ * both property graph (Gremlin) and RDF (SPARQL) query languages.
+ *
+ * Key features:
+ * - Apache TinkerPop Gremlin support
+ * - WebSocket connection support
+ * - IAM authentication support
+ * - High availability and replication
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NeptuneAdapter = void 0;
 const base_adapter_1 = require("./base.adapter");
-const graph_types_1 = require("../types/graph.types");
-const relationship_types_1 = require("../types/relationship.types");
-/**
- * Neptune connection implementation
- */
-class NeptuneConnection {
-    constructor(config, id) {
-        this.config = config;
-        this.type = graph_types_1.GraphDatabaseType.NEPTUNE;
-        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
-        this.httpClient = null;
-        this.awsCredentials = null;
-        this.id = id || `neptune-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        this.createdAt = new Date();
-        this.queryLanguage = config.queryLanguage;
-    }
-    async connect() {
-        var _a;
-        if (this.status === graph_types_1.GraphConnectionStatus.CONNECTED) {
-            return;
-        }
-        this.status = graph_types_1.GraphConnectionStatus.CONNECTING;
-        try {
-            // Build endpoint URL
-            const port = this.config.port || 8182;
-            const protocol = this.config.ssl !== false ? 'https' : 'http';
-            const baseUrl = `${protocol}://${this.config.endpoint}:${port}`;
-            // If using IAM auth, set up AWS signing
-            if (this.config.useIAM) {
-                this.awsCredentials = {
-                    accessKeyId: this.config.accessKeyId,
-                    secretAccessKey: this.config.secretAccessKey,
-                    sessionToken: this.config.sessionToken,
-                    region: this.config.region,
-                };
-            }
-            this.httpClient = {
-                baseUrl,
-                headers: Object.assign({ 'Content-Type': 'application/json' }, (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers),
-            };
-            // Verify connectivity with a simple query
-            await this.executeQuery(this.queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
-                ? 'g.V().limit(1).count()'
-                : 'MATCH (n) RETURN count(n) LIMIT 1');
-            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 Neptune: ${error.message}`, error);
-        }
-    }
-    async disconnect() {
-        this.httpClient = null;
-        this.awsCredentials = null;
-        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
-    }
-    isConnected() {
-        return this.status === graph_types_1.GraphConnectionStatus.CONNECTED && this.httpClient !== null;
-    }
-    getClient() {
-        if (!this.httpClient) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Neptune client not initialized. Call connect() first.');
-        }
-        return this.httpClient;
-    }
-    getSession() {
-        return this.getClient();
-    }
-    getConfig() {
-        return this.config;
-    }
-    async executeQuery(query, params) {
-        if (!this.httpClient) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Neptune client not initialized');
-        }
-        this.lastUsedAt = new Date();
-        const endpoint = this.queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
-            ? '/gremlin'
-            : '/openCypher';
-        const body = this.queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
-            ? { gremlin: query, bindings: params || {} }
-            : { query, parameters: params || {} };
-        try {
-            // Make HTTP request to Neptune
-            const response = await this.makeRequest(endpoint, body);
-            return response;
-        }
-        catch (error) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.QUERY_ERROR, `Neptune query failed: ${error.message}`, error, query, params);
-        }
-    }
-    async makeRequest(endpoint, body) {
-        const url = `${this.httpClient.baseUrl}${endpoint}`;
-        const headers = Object.assign({}, this.httpClient.headers);
-        // Sign request if using IAM auth
-        if (this.awsCredentials) {
-            const signedHeaders = await this.signRequest('POST', url, JSON.stringify(body));
-            Object.assign(headers, signedHeaders);
-        }
-        // Using fetch for HTTP requests
-        const response = await fetch(url, {
-            method: 'POST',
-            headers,
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const errorBody = await response.text();
-            throw new Error(`HTTP ${response.status}: ${errorBody}`);
-        }
-        return response.json();
-    }
-    async signRequest(method, url, body) {
-        // AWS Signature V4 signing
-        // In production, use aws-sdk or @aws-sdk/signature-v4
-        // This is a placeholder for the signing logic
-        const timestamp = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '');
-        const date = timestamp.slice(0, 8);
-        return {
-            'X-Amz-Date': timestamp,
-            'X-Amz-Security-Token': this.awsCredentials.sessionToken || '',
-            // In production, add proper Authorization header with signature
-        };
-    }
-}
+const enums_1 = require("../types/enums");
+const graph_error_1 = require("../utils/graph-error");
 /**
- * Neptune transaction implementation
- * Note: Neptune has limited transaction support, primarily for Gremlin
- */
-class NeptuneTransaction {
-    constructor(connection, transactionId) {
-        this.connection = connection;
-        this.status = graph_types_1.GraphTransactionStatus.PENDING;
-        this.id = transactionId || `tx-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-        this.createdAt = new Date();
-        this.status = graph_types_1.GraphTransactionStatus.ACTIVE;
-        this.native = { transactionId: this.id };
-    }
-    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`);
-        }
-        // Neptune auto-commits each query, so this is a no-op
-        this.status = graph_types_1.GraphTransactionStatus.COMMITTED;
-    }
-    async rollback() {
-        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
-            return;
-        }
-        // Neptune doesn't support rollback in the traditional sense
-        this.status = graph_types_1.GraphTransactionStatus.ROLLED_BACK;
-    }
-    isActive() {
-        return this.status === graph_types_1.GraphTransactionStatus.ACTIVE;
-    }
-}
-/**
- * AWS Neptune Graph Database Adapter
+ * Neptune adapter using Gremlin
+ * Uses the gremlin package for TinkerPop connectivity
  */
 class NeptuneAdapter extends base_adapter_1.BaseGraphAdapter {
     constructor() {
         super(...arguments);
-        this.type = graph_types_1.GraphDatabaseType.NEPTUNE;
-        this.supportedLanguages = [graph_types_1.GraphQueryLanguage.GREMLIN, graph_types_1.GraphQueryLanguage.OPENCYPHER];
-        this.defaultLanguage = graph_types_1.GraphQueryLanguage.GREMLIN;
-    }
-    // ==================== CONNECTION METHODS ====================
-    async connect(config) {
-        if (config.type !== graph_types_1.GraphDatabaseType.NEPTUNE) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `Invalid config type ${config.type}. Expected ${graph_types_1.GraphDatabaseType.NEPTUNE}`);
-        }
-        const connection = new NeptuneConnection(config);
-        await connection.connect();
-        return connection;
-    }
-    async disconnect(connection) {
-        await connection.disconnect();
-    }
-    async testConnection(connection) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const queryLanguage = neptuneConn.getConfig().queryLanguage;
+        this.graphType = enums_1.GraphType.NEPTUNE;
+        this.supportedFeatures = new Set([
+            enums_1.GraphFeature.SCHEMA_INDEXES,
+            enums_1.GraphFeature.GRAPH_ALGORITHMS,
+        ]);
+        this.connection = null;
+        this.g = null; // Gremlin graph traversal source
+        this.gremlin = null;
+    }
+    // ==================== CONNECTION MANAGEMENT ====================
+    async connect(options) {
         try {
-            const testQuery = queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
-                ? 'g.V().limit(1).count()'
-                : 'MATCH (n) RETURN count(n) AS count LIMIT 1';
-            await neptuneConn.executeQuery(testQuery);
+            // Dynamic import of gremlin package
+            this.gremlin = await Promise.resolve().then(() => __importStar(require('gremlin')));
+            const { DriverRemoteConnection } = this.gremlin.driver;
+            // Neptune WebSocket connection URL
+            const wsUrl = options.connectionUrl.replace(/^https?:\/\//, 'wss://').replace(/\/?$/, '/gremlin');
+            // Connection options for Neptune
+            const connectionOptions = {
+                mimeType: 'application/vnd.gremlin-v2.0+json',
+                pingEnabled: true,
+                pingInterval: 30000,
+            };
+            // Add authentication if provided
+            if (options.auth) {
+                // For IAM auth, you'd typically use AWS4 signing
+                // This is a simplified version - production would need proper IAM signing
+                connectionOptions.headers = {
+                    Authorization: `Basic ${Buffer.from(`${options.auth.username}:${options.auth.password}`).toString('base64')}`,
+                };
+            }
+            this.connection = new DriverRemoteConnection(wsUrl, connectionOptions);
+            // Create graph traversal source
+            const { Graph } = this.gremlin.structure;
+            const graph = new Graph();
+            this.g = graph.traversal().withRemote(this.connection);
+            // Test the connection
+            await this.g.V().limit(1).toList();
+            this.connected = true;
+            this.connectionUrl = options.connectionUrl;
             return {
                 connected: true,
-                message: 'Connection successful',
-                databaseType: graph_types_1.GraphDatabaseType.NEPTUNE,
-                queryLanguage,
-                responseTime: Date.now() - startTime,
+                type: enums_1.GraphType.NEPTUNE,
+                latency: 0,
             };
         }
         catch (error) {
-            return {
-                connected: false,
-                message: 'Connection failed',
-                databaseType: graph_types_1.GraphDatabaseType.NEPTUNE,
-                queryLanguage,
-                responseTime: Date.now() - startTime,
-                error: error.message,
-            };
+            this.connected = false;
+            throw graph_error_1.GraphError.connectionError(`Failed to connect to Neptune: ${error.message}`, error);
         }
     }
-    async getDatabaseInfo(connection) {
-        const neptuneConn = connection;
+    async testConnection(options) {
         try {
-            // Neptune doesn't have a direct version query, use status endpoint
-            const response = await neptuneConn.executeQuery('g.V().limit(0)');
+            const gremlin = await Promise.resolve().then(() => __importStar(require('gremlin')));
+            const { DriverRemoteConnection } = gremlin.driver;
+            const startTime = Date.now();
+            const wsUrl = options.connectionUrl.replace(/^https?:\/\//, 'wss://').replace(/\/?$/, '/gremlin');
+            const testConnection = new DriverRemoteConnection(wsUrl, {
+                mimeType: 'application/vnd.gremlin-v2.0+json',
+            });
+            const { Graph } = gremlin.structure;
+            const graph = new Graph();
+            const testG = graph.traversal().withRemote(testConnection);
+            // Test query
+            await testG.V().limit(1).toList();
+            await testConnection.close();
             return {
+                connected: true,
+                type: enums_1.GraphType.NEPTUNE,
                 version: 'Neptune',
-                edition: 'AWS Neptune',
-                features: ['gremlin', 'openCypher', 'sparql'],
+                latency: Date.now() - startTime,
             };
         }
-        catch (_a) {
-            return {
-                version: 'Unknown',
-                edition: 'AWS Neptune',
-                features: [],
-            };
-        }
-    }
-    // ==================== TRANSACTION METHODS ====================
-    async beginTransaction(connection, options) {
-        // Neptune has limited transaction support
-        return new NeptuneTransaction(connection);
-    }
-    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 neptuneConn = connection;
-        try {
-            const response = await neptuneConn.executeQuery(options.query, options.params);
-            const data = this.parseQueryResponse(response, neptuneConn.getConfig().queryLanguage);
+        catch (error) {
             return {
-                success: true,
-                executionTime: Date.now() - startTime,
-                data: data,
-                count: data.length,
+                connected: false,
+                type: enums_1.GraphType.NEPTUNE,
+                error: error.message,
             };
         }
-        catch (error) {
-            throw this.wrapError(error, graph_types_1.GraphErrorType.QUERY_ERROR, `Query execution failed: ${error.message}`, options.query, options.params);
-        }
     }
-    parseQueryResponse(response, language) {
-        if (language === graph_types_1.GraphQueryLanguage.GREMLIN) {
-            return this.parseGremlinResponse(response);
+    async disconnect() {
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+            this.g = null;
         }
-        return this.parseOpenCypherResponse(response);
-    }
-    parseGremlinResponse(response) {
-        if (!response || !response.result)
-            return [];
-        const data = response.result.data;
-        if (!data || !data['@value'])
-            return [];
-        return data['@value'].map((item) => this.parseGremlinValue(item));
+        this.connected = false;
     }
-    parseGremlinValue(value) {
-        if (!value)
-            return value;
-        if (value['@type']) {
-            const type = value['@type'];
-            const val = value['@value'];
-            switch (type) {
-                case 'g:Vertex':
-                    return this.parseGremlinVertex(val);
-                case 'g:Edge':
-                    return this.parseGremlinEdge(val);
-                case 'g:Path':
-                    return this.parseGremlinPath(val);
-                case 'g:Int64':
-                case 'g:Int32':
-                case 'g:Double':
-                case 'g:Float':
-                    return Number(val);
-                case 'g:List':
-                    return val.map((v) => this.parseGremlinValue(v));
-                case 'g:Map':
-                    return this.parseGremlinMap(val);
-                case 'g:Set':
-                    return val.map((v) => this.parseGremlinValue(v));
-                case 'g:UUID':
-                    return val;
-                case 'g:Date':
-                    return new Date(val);
-                default:
-                    return val;
-            }
+    ensureTraversal() {
+        this.ensureConnected();
+        if (!this.g) {
+            throw new Error('Graph traversal source not initialized');
         }
-        if (Array.isArray(value)) {
-            return value.map(v => this.parseGremlinValue(v));
-        }
-        if (typeof value === 'object') {
-            const result = {};
-            Object.entries(value).forEach(([k, v]) => {
-                result[k] = this.parseGremlinValue(v);
-            });
-            return result;
-        }
-        return value;
+        return this.g;
     }
-    parseGremlinVertex(val) {
-        const properties = {};
-        if (val.properties) {
-            Object.entries(val.properties).forEach(([key, propArray]) => {
-                var _a, _b, _c;
-                if (Array.isArray(propArray) && propArray.length > 0) {
-                    properties[key] = ((_b = (_a = propArray[0]) === null || _a === void 0 ? void 0 : _a['@value']) === null || _b === void 0 ? void 0 : _b.value) || ((_c = propArray[0]) === null || _c === void 0 ? void 0 : _c.value);
+    // ==================== NODE OPERATIONS ====================
+    async createNode(options, _transaction) {
+        const g = this.ensureTraversal();
+        const { t } = this.gremlin.process;
+        // Start with addV for the first label
+        let traversal = g.addV(options.labels[0]);
+        // Add additional labels
+        for (let i = 1; i < options.labels.length; i++) {
+            traversal = traversal.property(t.label, options.labels[i]);
+        }
+        // Add properties
+        if (options.properties) {
+            for (const [key, value] of Object.entries(options.properties)) {
+                if (value !== undefined && value !== null) {
+                    traversal = traversal.property(key, value);
                 }
-            });
-        }
-        return {
-            id: val.id,
-            labels: [val.label],
-            properties,
-        };
-    }
-    parseGremlinEdge(val) {
-        const properties = {};
-        if (val.properties) {
-            Object.entries(val.properties).forEach(([key, propVal]) => {
-                properties[key] = this.parseGremlinValue(propVal);
-            });
-        }
-        return {
-            id: val.id,
-            type: val.label,
-            startNodeId: val.outV,
-            endNodeId: val.inV,
-            properties,
-        };
-    }
-    parseGremlinPath(val) {
-        var _a;
-        const objects = ((_a = val.objects) === null || _a === void 0 ? void 0 : _a.map((obj) => this.parseGremlinValue(obj))) || [];
-        const nodes = [];
-        const relationships = [];
-        objects.forEach((obj) => {
-            if (obj.labels) {
-                nodes.push(obj);
-            }
-            else if (obj.type) {
-                relationships.push(obj);
             }
-        });
-        return {
-            nodes,
-            relationships,
-            length: relationships.length,
-            start: nodes[0],
-            end: nodes[nodes.length - 1],
-        };
-    }
-    parseGremlinMap(val) {
-        const result = {};
-        for (let i = 0; i < val.length; i += 2) {
-            const key = this.parseGremlinValue(val[i]);
-            const value = this.parseGremlinValue(val[i + 1]);
-            result[key] = value;
         }
-        return result;
-    }
-    parseOpenCypherResponse(response) {
-        if (!response || !response.results)
-            return [];
-        return response.results;
-    }
-    // ==================== NODE OPERATIONS ====================
-    async createNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        const labels = this.normalizeLabels(options.labels);
-        let query;
-        let params = {};
-        if (isGremlin) {
-            // Gremlin addV query
-            const propsSteps = Object.entries(options.properties)
-                .map(([key, value]) => `.property('${key}', ${this.gremlinValue(value)})`)
-                .join('');
-            query = `g.addV('${labels[0]}')${propsSteps}`;
-        }
-        else {
-            // openCypher CREATE query
-            const labelStr = labels.map(l => this.escapeIdentifier(l)).join(':');
-            const propEntries = Object.entries(options.properties);
-            const propStr = propEntries.map(([k], i) => `${k}: $prop${i}`).join(', ');
-            propEntries.forEach(([, v], i) => { params[`prop${i}`] = v; });
-            query = `CREATE (n:${labelStr} {${propStr}}) RETURN n`;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const result = await traversal.next();
+        const vertex = result.value;
+        // Fetch the complete vertex with properties
+        const fullVertex = await g.V(vertex.id).valueMap(true).next();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(result.data[0]) : undefined,
+            node: this.mapGremlinVertex(vertex.id, fullVertex.value),
             created: true,
         };
     }
-    async findNodes(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            query = this.buildGremlinFindNodesQuery(options);
+    async findNodes(options, _transaction) {
+        var _a, _b;
+        const g = this.ensureTraversal();
+        let traversal = g.V();
+        // Filter by labels
+        if ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.length) {
+            traversal = traversal.hasLabel(...options.labels);
+        }
+        // Apply where conditions
+        if (options.where) {
+            traversal = this.applyWhereConditions(traversal, options.where);
+        }
+        // Apply ordering
+        if ((_b = options.orderBy) === null || _b === void 0 ? void 0 : _b.length) {
+            const { order } = this.gremlin.process;
+            for (const orderSpec of options.orderBy) {
+                const orderDir = orderSpec.direction.toUpperCase() === 'DESC' ? order.desc : order.asc;
+                traversal = traversal.order().by(orderSpec.property, orderDir);
+            }
         }
-        else {
-            query = this.buildCypherFindNodesQuery(options, params);
+        // Apply pagination
+        if (options.skip) {
+            traversal = traversal.skip(options.skip);
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = result.data.map(row => this.parseNode(isGremlin ? row : row.n || row));
+        if (options.limit) {
+            traversal = traversal.limit(options.limit);
+        }
+        // Get vertices with properties
+        const results = await traversal.valueMap(true).toList();
+        const nodes = results.map((v) => this.mapGremlinVertexFromValueMap(v));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
             nodes,
             count: nodes.length,
-            hasMore: options.limit !== undefined && nodes.length === options.limit,
         };
     }
-    buildGremlinFindNodesQuery(options) {
-        let query = 'g.V()';
-        if (options.labels) {
-            const labels = this.normalizeLabels(options.labels);
-            query += `.hasLabel('${labels.join("', '")}')`;
-        }
-        if (options.properties) {
-            Object.entries(options.properties).forEach(([key, value]) => {
-                query += `.has('${key}', ${this.gremlinValue(value)})`;
-            });
-        }
-        if (options.orderBy && options.orderBy.length > 0) {
-            const orderSteps = options.orderBy.map(o => `by('${o.property}', ${o.direction === 'DESC' ? 'desc' : 'asc'})`).join('.');
-            query += `.order().${orderSteps}`;
-        }
-        if (options.skip) {
-            query += `.skip(${options.skip})`;
-        }
-        if (options.limit) {
-            query += `.limit(${options.limit})`;
-        }
-        return query;
-    }
-    buildCypherFindNodesQuery(options, params) {
-        const labels = options.labels ? this.normalizeLabels(options.labels) : [];
-        const labelStr = labels.length > 0 ? ':' + labels.map(l => this.escapeIdentifier(l)).join(':') : '';
-        let query = `MATCH (n${labelStr})`;
-        if (options.properties && Object.keys(options.properties).length > 0) {
-            const whereParts = [];
-            Object.entries(options.properties).forEach(([key, value], index) => {
-                const paramName = `prop_${index}`;
-                whereParts.push(`n.${key} = $${paramName}`);
-                params[paramName] = value;
-            });
-            query += ` WHERE ${whereParts.join(' AND ')}`;
-        }
-        query += ' RETURN n';
-        if (options.orderBy && options.orderBy.length > 0) {
-            const orderParts = options.orderBy.map(o => `n.${o.property} ${o.direction}`);
-            query += ` ORDER BY ${orderParts.join(', ')}`;
-        }
-        if (options.skip !== undefined) {
-            query += ` SKIP ${options.skip}`;
-        }
-        if (options.limit !== undefined) {
-            query += ` LIMIT ${options.limit}`;
-        }
-        return query;
-    }
-    async findNodeById(connection, id, transaction) {
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        const query = isGremlin
-            ? `g.V('${id}')`
-            : `MATCH (n) WHERE id(n) = $id RETURN n`;
-        const result = await this.executeRaw(connection, { query, params: { id } }, transaction);
-        if (result.data.length === 0) {
+    async findNodeById(id, _transaction) {
+        const g = this.ensureTraversal();
+        const results = await g.V(id).valueMap(true).toList();
+        if (results.length === 0) {
             return null;
         }
-        return this.parseNode(isGremlin ? result.data[0] : result.data[0].n);
+        return this.mapGremlinVertexFromValueMap(results[0]);
     }
-    async updateNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            query = `g.V('${options.id}')`;
-            if (options.set) {
-                Object.entries(options.set).forEach(([key, value]) => {
-                    query += `.property('${key}', ${this.gremlinValue(value)})`;
-                });
-            }
-            if (options.remove && options.remove.length > 0) {
-                options.remove.forEach(prop => {
-                    query += `.properties('${prop}').drop()`;
-                });
-            }
+    async updateNode(options, _transaction) {
+        var _a;
+        const g = this.ensureTraversal();
+        let traversal;
+        if (options.id) {
+            traversal = g.V(options.id);
         }
         else {
-            query = `MATCH (n) WHERE id(n) = $nodeId`;
-            params.nodeId = options.id;
-            const setParts = [];
-            if (options.set) {
-                Object.entries(options.set).forEach(([key, value], index) => {
-                    const paramName = `set_${index}`;
-                    setParts.push(`n.${key} = $${paramName}`);
-                    params[paramName] = value;
-                });
+            traversal = g.V();
+            if ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.length) {
+                traversal = traversal.hasLabel(...options.labels);
             }
-            if (setParts.length > 0) {
-                query += ` SET ${setParts.join(', ')}`;
+            if (options.where) {
+                traversal = this.applyWhereConditions(traversal, options.where);
             }
-            if (options.remove && options.remove.length > 0) {
-                query += ` REMOVE ${options.remove.map(p => `n.${p}`).join(', ')}`;
+        }
+        // Update properties
+        if (options.properties) {
+            for (const [key, value] of Object.entries(options.properties)) {
+                if (value !== undefined && value !== null) {
+                    traversal = traversal.property(this.gremlin.process.cardinality.single, key, value);
+                }
             }
-            query += ' RETURN n';
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const results = await traversal.valueMap(true).toList();
+        const nodes = results.map((v) => this.mapGremlinVertexFromValueMap(v));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(isGremlin ? result.data[0] : result.data[0].n) : undefined,
-            updated: result.data.length > 0,
-            matchedCount: result.data.length,
-            modifiedCount: Object.keys(options.set || {}).length,
+            node: nodes.length === 1 ? nodes[0] : undefined,
+            nodes: nodes.length > 1 ? nodes : undefined,
+            updatedCount: nodes.length,
+            updated: nodes.length > 0,
         };
     }
-    async deleteNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            if (options.id) {
-                query = `g.V('${options.id}').drop()`;
-            }
-            else if (options.labels) {
-                const labels = this.normalizeLabels(options.labels);
-                query = `g.V().hasLabel('${labels.join("', '")}').drop()`;
+    async deleteNode(options, _transaction) {
+        var _a, _b;
+        const g = this.ensureTraversal();
+        let traversal;
+        if (options.id) {
+            traversal = g.V(options.id);
+        }
+        else {
+            traversal = g.V();
+            if ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.length) {
+                traversal = traversal.hasLabel(...options.labels);
             }
-            else {
-                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or labels for delete');
+            if (options.where) {
+                traversal = this.applyWhereConditions(traversal, options.where);
             }
         }
+        // Count before delete
+        const countResult = await traversal.count().next();
+        const count = countResult.value;
+        // In Gremlin, drop() removes the vertex and all connected edges
+        if (options.id) {
+            await g.V(options.id).drop().iterate();
+        }
         else {
-            if (options.id) {
-                query = `MATCH (n) WHERE id(n) = $nodeId ${options.detach ? 'DETACH DELETE' : 'DELETE'} n`;
-                params.nodeId = options.id;
+            let dropTraversal = g.V();
+            if ((_b = options.labels) === null || _b === void 0 ? void 0 : _b.length) {
+                dropTraversal = dropTraversal.hasLabel(...options.labels);
             }
-            else if (options.labels) {
-                const labels = this.normalizeLabels(options.labels);
-                query = `MATCH (n:${labels.join(':')}) ${options.detach ? 'DETACH DELETE' : 'DELETE'} n`;
-            }
-            else {
-                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or labels for delete');
+            if (options.where) {
+                dropTraversal = this.applyWhereConditions(dropTraversal, options.where);
             }
+            await dropTraversal.drop().iterate();
         }
-        await this.executeRaw(connection, { query, params }, transaction);
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            deletedCount: 1, // Neptune doesn't return count
+            deleted: count > 0,
+            deletedCount: count,
         };
     }
-    async mergeNode(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        const labels = this.normalizeLabels(options.labels);
-        let query;
-        const params = {};
-        if (isGremlin) {
-            // Gremlin coalesce pattern for merge
-            const matchProps = Object.entries(options.matchProperties)
-                .map(([k, v]) => `.has('${k}', ${this.gremlinValue(v)})`)
-                .join('');
-            const createProps = Object.entries(Object.assign(Object.assign({}, options.matchProperties), options.onCreate))
-                .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
-                .join('');
-            const updateProps = Object.entries(options.onMatch || {})
-                .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
-                .join('');
-            query = `g.V().hasLabel('${labels[0]}')${matchProps}.fold().coalesce(unfold()${updateProps}, addV('${labels[0]}')${createProps})`;
+    async mergeNode(options, _transaction) {
+        const g = this.ensureTraversal();
+        // Check if node exists
+        let matchTraversal = g.V().hasLabel(options.labels[0]);
+        for (const [key, value] of Object.entries(options.matchProperties)) {
+            matchTraversal = matchTraversal.has(key, value);
+        }
+        const existing = await matchTraversal.toList();
+        if (existing.length > 0) {
+            // Update existing node
+            let updateTraversal = g.V(existing[0].id);
+            if (options.onMatch) {
+                for (const [key, value] of Object.entries(options.onMatch)) {
+                    if (value !== undefined && value !== null) {
+                        updateTraversal = updateTraversal.property(this.gremlin.process.cardinality.single, key, value);
+                    }
+                }
+            }
+            const updated = await updateTraversal.valueMap(true).next();
+            return {
+                node: this.mapGremlinVertexFromValueMap(updated.value),
+                created: false,
+                merged: true,
+            };
         }
         else {
-            // openCypher MERGE
-            const matchPropsStr = Object.entries(options.matchProperties)
-                .map(([k], i) => `${k}: $match${i}`)
-                .join(', ');
-            Object.entries(options.matchProperties).forEach(([, v], i) => { params[`match${i}`] = v; });
-            query = `MERGE (n:${labels.join(':')} {${matchPropsStr}})`;
-            if (options.onCreate && Object.keys(options.onCreate).length > 0) {
-                const createProps = Object.entries(options.onCreate)
-                    .map(([k], i) => `n.${k} = $create${i}`)
-                    .join(', ');
-                Object.entries(options.onCreate).forEach(([, v], i) => { params[`create${i}`] = v; });
-                query += ` ON CREATE SET ${createProps}`;
+            // Create new node
+            let createTraversal = g.addV(options.labels[0]);
+            // Add match properties
+            for (const [key, value] of Object.entries(options.matchProperties)) {
+                if (value !== undefined && value !== null) {
+                    createTraversal = createTraversal.property(key, value);
+                }
             }
-            if (options.onMatch && Object.keys(options.onMatch).length > 0) {
-                const matchSetProps = Object.entries(options.onMatch)
-                    .map(([k], i) => `n.${k} = $update${i}`)
-                    .join(', ');
-                Object.entries(options.onMatch).forEach(([, v], i) => { params[`update${i}`] = v; });
-                query += ` ON MATCH SET ${matchSetProps}`;
+            // Add onCreate properties
+            if (options.onCreate) {
+                for (const [key, value] of Object.entries(options.onCreate)) {
+                    if (value !== undefined && value !== null) {
+                        createTraversal = createTraversal.property(key, value);
+                    }
+                }
             }
-            query += ' RETURN n';
+            const created = await createTraversal.next();
+            const fullVertex = await g.V(created.value.id).valueMap(true).next();
+            return {
+                node: this.mapGremlinVertexFromValueMap(fullVertex.value),
+                created: true,
+                merged: true,
+            };
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+    }
+    // ==================== LABEL MANAGEMENT ====================
+    async addLabels(options, _transaction) {
+        const g = this.ensureTraversal();
+        // In Gremlin/Neptune, vertices have a single label
+        // We can add additional labels by adding them as properties or using multi-labels if supported
+        // Neptune supports multi-labels via the ::label property pattern
+        // For now, we'll treat it as a limitation - Neptune vertices typically have a single label
+        // Get the vertex first
+        const vertex = await g.V(options.id).next();
+        if (!vertex.value) {
+            throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
+        }
+        // Neptune doesn't natively support adding labels to existing vertices
+        // This is a limitation of the Gremlin model
+        // We store additional labels as a property
+        const existingLabelsResult = await g.V(options.id).values('_additionalLabels').toList();
+        const existingLabels = existingLabelsResult.length > 0
+            ? JSON.parse(existingLabelsResult[0])
+            : [];
+        const newLabels = [...new Set([...existingLabels, ...options.labels])];
+        await g.V(options.id)
+            .property('_additionalLabels', JSON.stringify(newLabels))
+            .next();
+        const fullVertex = await g.V(options.id).valueMap(true).next();
+        const node = this.mapGremlinVertexFromValueMap(fullVertex.value);
+        // Add the additional labels to the node's labels array
+        node.labels = [...new Set([...node.labels, ...options.labels])];
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            node: result.data.length > 0 ? this.parseNode(isGremlin ? result.data[0] : result.data[0].n) : undefined,
-            created: true, // Neptune doesn't distinguish
-            matched: false,
+            node,
+            addedLabels: options.labels,
+        };
+    }
+    async removeLabels(options, _transaction) {
+        const g = this.ensureTraversal();
+        // Get the vertex first
+        const vertex = await g.V(options.id).next();
+        if (!vertex.value) {
+            throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
+        }
+        // Get existing additional labels
+        const existingLabelsResult = await g.V(options.id).values('_additionalLabels').toList();
+        const existingLabels = existingLabelsResult.length > 0
+            ? JSON.parse(existingLabelsResult[0])
+            : [];
+        // Remove the specified labels
+        const newLabels = existingLabels.filter(l => !options.labels.includes(l));
+        await g.V(options.id)
+            .property('_additionalLabels', JSON.stringify(newLabels))
+            .next();
+        const fullVertex = await g.V(options.id).valueMap(true).next();
+        const node = this.mapGremlinVertexFromValueMap(fullVertex.value);
+        return {
+            node,
+            removedLabels: options.labels,
+        };
+    }
+    async setLabels(options, _transaction) {
+        const g = this.ensureTraversal();
+        // Get the vertex first
+        const vertex = await g.V(options.id).next();
+        if (!vertex.value) {
+            throw graph_error_1.GraphError.notFoundError(`Node with ID ${options.id} not found`);
+        }
+        // Get current labels (primary label + additional)
+        const primaryLabel = await g.V(options.id).label().next();
+        const existingLabelsResult = await g.V(options.id).values('_additionalLabels').toList();
+        const additionalLabels = existingLabelsResult.length > 0
+            ? JSON.parse(existingLabelsResult[0])
+            : [];
+        const previousLabels = [primaryLabel.value, ...additionalLabels];
+        // In Neptune, we can't change the primary label, so we store all labels as additional
+        // Filter out the primary label from the new labels
+        const newAdditionalLabels = options.labels.filter(l => l !== primaryLabel.value);
+        await g.V(options.id)
+            .property('_additionalLabels', JSON.stringify(newAdditionalLabels))
+            .next();
+        const fullVertex = await g.V(options.id).valueMap(true).next();
+        const node = this.mapGremlinVertexFromValueMap(fullVertex.value);
+        node.labels = [primaryLabel.value, ...newAdditionalLabels];
+        return {
+            node,
+            previousLabels,
+            newLabels: options.labels,
         };
     }
     // ==================== RELATIONSHIP OPERATIONS ====================
-    async createRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            const fromId = options.fromNode.id;
-            const toId = options.toNode.id;
-            const propsSteps = options.properties
-                ? Object.entries(options.properties)
-                    .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
-                    .join('')
-                : '';
-            query = `g.V('${fromId}').addE('${options.type}').to(g.V('${toId}'))${propsSteps}`;
-        }
-        else {
-            const fromMatch = this.buildCypherNodeMatch(options.fromNode, 'from', params, 'from_');
-            const toMatch = this.buildCypherNodeMatch(options.toNode, 'to', params, 'to_');
-            let propsStr = '';
-            if (options.properties && Object.keys(options.properties).length > 0) {
-                propsStr = ' {' + Object.entries(options.properties)
-                    .map(([k], i) => { params[`rel${i}`] = options.properties[k]; return `${k}: $rel${i}`; })
-                    .join(', ') + '}';
+    async createRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        let traversal = g.V(options.startNodeId)
+            .addE(options.type)
+            .to(__.V(options.endNodeId));
+        // Add properties
+        if (options.properties) {
+            for (const [key, value] of Object.entries(options.properties)) {
+                if (value !== undefined && value !== null) {
+                    traversal = traversal.property(key, value);
+                }
             }
-            query = `
-        MATCH ${fromMatch}, ${toMatch}
-        CREATE (from)-[r:${options.type}${propsStr}]->(to)
-        RETURN r
-      `;
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const result = await traversal.next();
+        const edge = result.value;
+        // Fetch full edge with properties
+        const fullEdge = await g.E(edge.id).valueMap(true).next();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r) : undefined,
+            relationship: this.mapGremlinEdge(edge, fullEdge.value, options.startNodeId, options.endNodeId),
             created: true,
         };
     }
-    async findRelationships(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            query = 'g.E()';
-            if (options.type) {
-                const types = Array.isArray(options.type) ? options.type : [options.type];
-                query += `.hasLabel('${types.join("', '")}')`;
-            }
-            if (options.properties) {
-                Object.entries(options.properties).forEach(([k, v]) => {
-                    query += `.has('${k}', ${this.gremlinValue(v)})`;
-                });
-            }
-            if (options.limit) {
-                query += `.limit(${options.limit})`;
-            }
+    async findRelationships(options, _transaction) {
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        let traversal;
+        if (options.startNodeId) {
+            traversal = g.V(options.startNodeId).outE();
+        }
+        else if (options.endNodeId) {
+            traversal = g.V(options.endNodeId).inE();
         }
         else {
-            let typeStr = '';
-            if (options.type) {
-                const types = Array.isArray(options.type) ? options.type : [options.type];
-                typeStr = ':' + types.join('|');
-            }
-            const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-            const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-            query = `MATCH ()-[r${typeStr}]->() RETURN r`;
-            if (options.limit) {
-                query += ` LIMIT ${options.limit}`;
-            }
+            traversal = g.E();
+        }
+        // Filter by type
+        const types = options.type
+            ? (Array.isArray(options.type) ? options.type : [options.type])
+            : (options.types || []);
+        if (types.length > 0) {
+            traversal = traversal.hasLabel(...types);
+        }
+        // Apply where conditions
+        if (options.where) {
+            traversal = this.applyWhereConditions(traversal, options.where);
+        }
+        // Apply endpoint filtering if both are specified
+        if (options.startNodeId && options.endNodeId) {
+            traversal = traversal.where(__.inV().hasId(options.endNodeId));
+        }
+        // Apply pagination
+        if (options.skip) {
+            traversal = traversal.skip(options.skip);
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const relationships = result.data.map(row => this.parseRelationship(isGremlin ? row : row.r || row));
+        if (options.limit) {
+            traversal = traversal.limit(options.limit);
+        }
+        // Get edges with in/out vertices
+        const results = await traversal.project('edge', 'outV', 'inV')
+            .by(__.valueMap(true))
+            .by(__.outV().id())
+            .by(__.inV().id())
+            .toList();
+        const relationships = results.map((r) => this.mapGremlinEdgeFromProject(r));
         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 neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        const query = isGremlin
-            ? `g.E('${id}')`
-            : `MATCH ()-[r]->() WHERE id(r) = $id RETURN r`;
-        const result = await this.executeRaw(connection, { query, params: { id } }, transaction);
-        if (result.data.length === 0) {
+    async findRelationshipById(id, _transaction) {
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        const results = await g.E(id)
+            .project('edge', 'outV', 'inV')
+            .by(__.valueMap(true))
+            .by(__.outV().id())
+            .by(__.inV().id())
+            .toList();
+        if (results.length === 0) {
             return null;
         }
-        return this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r);
+        return this.mapGremlinEdgeFromProject(results[0]);
     }
-    async updateRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            query = `g.E('${options.id}')`;
-            if (options.set) {
-                Object.entries(options.set).forEach(([k, v]) => {
-                    query += `.property('${k}', ${this.gremlinValue(v)})`;
-                });
-            }
+    async updateRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        let traversal;
+        if (options.id) {
+            traversal = g.E(options.id);
         }
         else {
-            query = `MATCH ()-[r]->() WHERE id(r) = $relId`;
-            params.relId = options.id;
-            if (options.set && Object.keys(options.set).length > 0) {
-                const setParts = Object.entries(options.set).map(([k], i) => {
-                    params[`set${i}`] = options.set[k];
-                    return `r.${k} = $set${i}`;
-                });
-                query += ` SET ${setParts.join(', ')}`;
+            traversal = g.E();
+            if (options.type) {
+                traversal = traversal.hasLabel(options.type);
+            }
+            if (options.where) {
+                traversal = this.applyWhereConditions(traversal, options.where);
             }
-            query += ' RETURN r';
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+        // Update properties
+        if (options.properties) {
+            for (const [key, value] of Object.entries(options.properties)) {
+                if (value !== undefined && value !== null) {
+                    traversal = traversal.property(key, value);
+                }
+            }
+        }
+        // Get updated edges
+        const results = await traversal.project('edge', 'outV', 'inV')
+            .by(__.valueMap(true))
+            .by(__.outV().id())
+            .by(__.inV().id())
+            .toList();
+        const relationships = results.map((r) => this.mapGremlinEdgeFromProject(r));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r) : undefined,
-            updated: result.data.length > 0,
-            matchedCount: result.data.length,
-            modifiedCount: Object.keys(options.set || {}).length,
+            relationship: relationships.length === 1 ? relationships[0] : undefined,
+            relationships: relationships.length > 1 ? relationships : undefined,
+            updatedCount: relationships.length,
+            updated: relationships.length > 0,
         };
     }
-    async deleteRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            if (options.id) {
-                query = `g.E('${options.id}').drop()`;
-            }
-            else if (options.type) {
-                const types = Array.isArray(options.type) ? options.type : [options.type];
-                query = `g.E().hasLabel('${types.join("', '")}').drop()`;
+    async deleteRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        let traversal;
+        if (options.id) {
+            traversal = g.E(options.id);
+        }
+        else {
+            if (options.startNodeId && options.endNodeId && options.type) {
+                traversal = g.V(options.startNodeId).outE(options.type).where(this.gremlin.process.__.inV().hasId(options.endNodeId));
             }
             else {
-                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or type for delete');
+                traversal = g.E();
+                if (options.type) {
+                    traversal = traversal.hasLabel(options.type);
+                }
+                if (options.where) {
+                    traversal = this.applyWhereConditions(traversal, options.where);
+                }
             }
         }
+        // Count before delete
+        let countTraversal;
+        if (options.id) {
+            countTraversal = g.E(options.id);
+        }
+        else if (options.startNodeId && options.endNodeId && options.type) {
+            countTraversal = g.V(options.startNodeId).outE(options.type).where(this.gremlin.process.__.inV().hasId(options.endNodeId));
+        }
         else {
-            if (options.id) {
-                query = `MATCH ()-[r]->() WHERE id(r) = $relId DELETE r`;
-                params.relId = options.id;
-            }
-            else if (options.type) {
-                const types = Array.isArray(options.type) ? options.type : [options.type];
-                query = `MATCH ()-[r:${types.join('|')}]->() DELETE r`;
-            }
-            else {
-                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or type for delete');
+            countTraversal = g.E();
+            if (options.type) {
+                countTraversal = countTraversal.hasLabel(options.type);
             }
         }
-        await this.executeRaw(connection, { query, params }, transaction);
+        const countResult = await countTraversal.count().next();
+        const count = countResult.value;
+        // Delete
+        await traversal.drop().iterate();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            deletedCount: 1,
+            deleted: count > 0,
+            deletedCount: count,
         };
     }
-    async mergeRelationship(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            // Gremlin coalesce pattern for edge merge
-            const fromId = options.fromNode.id;
-            const toId = options.toNode.id;
-            const matchProps = options.matchProperties
-                ? Object.entries(options.matchProperties)
-                    .map(([k, v]) => `.has('${k}', ${this.gremlinValue(v)})`)
-                    .join('')
-                : '';
-            const createProps = Object.entries(Object.assign(Object.assign({}, options.matchProperties), options.onCreate))
-                .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
-                .join('');
-            query = `g.V('${fromId}').outE('${options.type}')${matchProps}.where(inV().hasId('${toId}')).fold().coalesce(unfold(), g.V('${fromId}').addE('${options.type}').to(g.V('${toId}'))${createProps})`;
+    async mergeRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        // Check if relationship exists
+        let matchTraversal = g.V(options.startNodeId).outE(options.type).where(__.inV().hasId(options.endNodeId));
+        if (options.matchProperties) {
+            for (const [key, value] of Object.entries(options.matchProperties)) {
+                matchTraversal = matchTraversal.has(key, value);
+            }
+        }
+        const existing = await matchTraversal.toList();
+        if (existing.length > 0) {
+            // Update existing relationship
+            let updateTraversal = g.E(existing[0].id);
+            if (options.onMatch) {
+                for (const [key, value] of Object.entries(options.onMatch)) {
+                    if (value !== undefined && value !== null) {
+                        updateTraversal = updateTraversal.property(key, value);
+                    }
+                }
+            }
+            const updated = await updateTraversal.project('edge', 'outV', 'inV')
+                .by(__.valueMap(true))
+                .by(__.outV().id())
+                .by(__.inV().id())
+                .next();
+            return {
+                relationship: this.mapGremlinEdgeFromProject(updated.value),
+                created: false,
+                merged: true,
+            };
         }
         else {
-            const fromMatch = this.buildCypherNodeMatch(options.fromNode, 'from', params, 'from_');
-            const toMatch = this.buildCypherNodeMatch(options.toNode, 'to', params, 'to_');
-            query = `
-        MATCH ${fromMatch}, ${toMatch}
-        MERGE (from)-[r:${options.type}]->(to)
-      `;
-            if (options.onCreate && Object.keys(options.onCreate).length > 0) {
-                const createProps = Object.entries(options.onCreate)
-                    .map(([k], i) => { params[`create${i}`] = options.onCreate[k]; return `r.${k} = $create${i}`; })
-                    .join(', ');
-                query += ` ON CREATE SET ${createProps}`;
+            // Create new relationship
+            let createTraversal = g.V(options.startNodeId)
+                .addE(options.type)
+                .to(__.V(options.endNodeId));
+            // Add match properties
+            if (options.matchProperties) {
+                for (const [key, value] of Object.entries(options.matchProperties)) {
+                    if (value !== undefined && value !== null) {
+                        createTraversal = createTraversal.property(key, value);
+                    }
+                }
             }
-            if (options.onMatch && Object.keys(options.onMatch).length > 0) {
-                const matchSetProps = Object.entries(options.onMatch)
-                    .map(([k], i) => { params[`update${i}`] = options.onMatch[k]; return `r.${k} = $update${i}`; })
-                    .join(', ');
-                query += ` ON MATCH SET ${matchSetProps}`;
+            // Add onCreate properties
+            if (options.onCreate) {
+                for (const [key, value] of Object.entries(options.onCreate)) {
+                    if (value !== undefined && value !== null) {
+                        createTraversal = createTraversal.property(key, value);
+                    }
+                }
             }
-            query += ' RETURN r';
+            const created = await createTraversal.next();
+            const fullEdge = await g.E(created.value.id).project('edge', 'outV', 'inV')
+                .by(__.valueMap(true))
+                .by(__.outV().id())
+                .by(__.inV().id())
+                .next();
+            return {
+                relationship: this.mapGremlinEdgeFromProject(fullEdge.value),
+                created: true,
+                merged: true,
+            };
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            relationship: result.data.length > 0 ? this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r) : undefined,
-            created: true,
-            matched: false,
-        };
     }
-    // ==================== PATH & TRAVERSAL OPERATIONS ====================
-    async traverse(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        const minDepth = options.minDepth || 1;
-        const maxDepth = options.maxDepth || 10;
-        if (isGremlin) {
-            const startId = options.startNode.id;
-            const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'in' :
-                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'out' : 'both';
-            query = `g.V('${startId}').repeat(${direction}()).times(${maxDepth}).emit().path()`;
-            if (options.limit) {
-                query += `.limit(${options.limit})`;
-            }
+    // ==================== TRAVERSAL OPERATIONS ====================
+    async traverse(options, _transaction) {
+        var _a;
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        const maxDepth = options.maxDepth || 3;
+        // Build direction
+        let edgeDirection;
+        switch (options.direction) {
+            case enums_1.TraversalDirection.INCOMING:
+            case 'INCOMING':
+                edgeDirection = 'in';
+                break;
+            case enums_1.TraversalDirection.OUTGOING:
+            case 'OUTGOING':
+                edgeDirection = 'out';
+                break;
+            default:
+                edgeDirection = 'both';
+        }
+        // Build traversal
+        let traversal = g.V(options.startNodeId);
+        // Use repeat for variable-length traversal
+        const repeatStep = edgeDirection === 'out' ? __.out() :
+            edgeDirection === 'in' ? __.in_() :
+                __.both();
+        if ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length) {
+            traversal = traversal.repeat(edgeDirection === 'out' ? __.out(...options.relationshipTypes) :
+                edgeDirection === 'in' ? __.in_(...options.relationshipTypes) :
+                    __.both(...options.relationshipTypes)).times(maxDepth).emit();
         }
         else {
-            const startMatch = this.buildCypherNodeMatch(options.startNode, 'start', params);
-            const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-            const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-            query = `
-        MATCH ${startMatch}
-        MATCH path = (start)${dirStart}[*${minDepth}..${maxDepth}]${dirEnd}(end)
-        RETURN path
-      `;
-            if (options.limit) {
-                query += ` LIMIT ${options.limit}`;
-            }
+            traversal = traversal.repeat(repeatStep).times(maxDepth).emit();
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const paths = result.data.map(row => this.parsePath(isGremlin ? row : row.path || row));
+        if (options.limit) {
+            traversal = traversal.limit(options.limit);
+        }
+        // Get paths
+        const results = await traversal.path().by(__.valueMap(true)).toList();
+        const paths = [];
         const nodesMap = new Map();
         const relsMap = new Map();
-        paths.forEach(p => {
-            p.nodes.forEach(n => nodesMap.set(String(n.id), n));
-            p.relationships.forEach(r => relsMap.set(String(r.id), r));
-        });
+        for (const pathResult of results) {
+            const pathNodes = [];
+            const pathRels = [];
+            if (pathResult.objects) {
+                for (const obj of pathResult.objects) {
+                    if (obj.id) {
+                        const node = this.mapGremlinVertexFromValueMap(obj);
+                        pathNodes.push(node);
+                        nodesMap.set(String(node.id), node);
+                    }
+                }
+            }
+            if (pathNodes.length > 0) {
+                paths.push({
+                    nodes: pathNodes,
+                    relationships: pathRels,
+                    length: pathNodes.length - 1,
+                });
+            }
+        }
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            paths: options.returnPaths ? paths : undefined,
-            nodes: options.returnNodes ? Array.from(nodesMap.values()) : undefined,
+            paths,
+            nodes: Array.from(nodesMap.values()),
             relationships: Array.from(relsMap.values()),
             count: paths.length,
         };
     }
-    async shortestPath(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            const startId = options.startNode.id;
-            const endId = options.endNode.id;
-            const maxDepth = options.maxDepth || 10;
-            query = `g.V('${startId}').repeat(out().simplePath()).until(hasId('${endId}').or().loops().is(${maxDepth})).hasId('${endId}').path().limit(1)`;
+    async shortestPath(options, _transaction) {
+        var _a;
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        // Build shortest path query
+        let traversal = g.V(options.startNodeId);
+        if ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length) {
+            traversal = traversal.repeat(__.both(...options.relationshipTypes).simplePath())
+                .until(__.hasId(options.endNodeId))
+                .limit(1)
+                .path();
         }
         else {
-            const startMatch = this.buildCypherNodeMatch(options.startNode, 'start', params);
-            const endMatch = this.buildCypherNodeMatch(options.endNode, 'end', params, 'end_');
-            const maxDepth = options.maxDepth ? `*..${options.maxDepth}` : '*';
-            query = `
-        MATCH ${startMatch}, ${endMatch}
-        MATCH path = shortestPath((start)-[${maxDepth}]-(end))
-        RETURN path
-      `;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        if (result.data.length === 0) {
-            return {
-                success: true,
-                executionTime: Date.now() - startTime,
-                found: false,
-            };
+            traversal = traversal.repeat(__.both().simplePath())
+                .until(__.hasId(options.endNodeId))
+                .limit(1)
+                .path();
+        }
+        const results = await traversal.by(__.valueMap(true)).toList();
+        if (results.length === 0) {
+            return { path: null, found: false };
+        }
+        const pathResult = results[0];
+        const pathNodes = [];
+        if (pathResult.objects) {
+            for (const obj of pathResult.objects) {
+                if (obj.id) {
+                    pathNodes.push(this.mapGremlinVertexFromValueMap(obj));
+                }
+            }
         }
-        const path = this.parsePath(isGremlin ? result.data[0] : result.data[0].path);
+        const path = {
+            nodes: pathNodes,
+            relationships: [],
+            length: pathNodes.length - 1,
+        };
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
             path,
-            found: true,
             length: path.length,
+            found: true,
         };
     }
-    async allPaths(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+    async allPaths(options, _transaction) {
+        var _a;
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
         const minDepth = options.minDepth || 1;
-        const maxDepth = options.maxDepth || 10;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            const startId = options.startNode.id;
-            const endId = options.endNode.id;
-            query = `g.V('${startId}').repeat(out().simplePath()).until(hasId('${endId}').or().loops().is(${maxDepth})).hasId('${endId}').path()`;
-            if (options.limit) {
-                query += `.limit(${options.limit})`;
-            }
+        const maxDepth = options.maxDepth || 5;
+        const limit = options.limit || options.maxPaths || 100;
+        // Build all paths query
+        let traversal = g.V(options.startNodeId);
+        if ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length) {
+            traversal = traversal.repeat(__.both(...options.relationshipTypes).simplePath())
+                .until(__.hasId(options.endNodeId).or().loops().is(maxDepth))
+                .hasId(options.endNodeId)
+                .limit(limit)
+                .path();
         }
         else {
-            const startMatch = this.buildCypherNodeMatch(options.startNode, 'start', params);
-            const endMatch = this.buildCypherNodeMatch(options.endNode, 'end', params, 'end_');
-            query = `
-        MATCH ${startMatch}, ${endMatch}
-        MATCH path = (start)-[*${minDepth}..${maxDepth}]-(end)
-        RETURN path
-      `;
-            if (options.limit) {
-                query += ` LIMIT ${options.limit}`;
+            traversal = traversal.repeat(__.both().simplePath())
+                .until(__.hasId(options.endNodeId).or().loops().is(maxDepth))
+                .hasId(options.endNodeId)
+                .limit(limit)
+                .path();
+        }
+        const results = await traversal.by(__.valueMap(true)).toList();
+        const paths = [];
+        for (const pathResult of results) {
+            const pathNodes = [];
+            if (pathResult.objects) {
+                for (const obj of pathResult.objects) {
+                    if (obj.id) {
+                        pathNodes.push(this.mapGremlinVertexFromValueMap(obj));
+                    }
+                }
+            }
+            if (pathNodes.length >= minDepth + 1) {
+                paths.push({
+                    nodes: pathNodes,
+                    relationships: [],
+                    length: pathNodes.length - 1,
+                });
             }
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const paths = result.data.map(row => this.parsePath(isGremlin ? row : row.path || row));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
             paths,
             count: paths.length,
+            total: paths.length,
         };
     }
-    async matchPattern(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        if (neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Pattern matching is better supported with openCypher. Consider using traverse() for Gremlin.');
-        }
-        // Build openCypher pattern query
-        const params = {};
-        const { pattern } = options;
-        const matchClauses = [];
-        pattern.nodes.forEach(node => {
-            const labels = node.labels
-                ? ':' + (Array.isArray(node.labels) ? node.labels : [node.labels]).join(':')
-                : '';
-            matchClauses.push(`(${node.variable}${labels})`);
-        });
-        let query = `MATCH ${matchClauses.join(', ')}`;
-        if (pattern.relationships.length > 0) {
-            pattern.relationships.forEach(rel => {
-                const typeStr = rel.type
-                    ? ':' + (Array.isArray(rel.type) ? rel.type : [rel.type]).join('|')
-                    : '';
-                query += `, (${rel.startNode})-[${rel.variable || ''}${typeStr}]->(${rel.endNode})`;
-            });
-        }
-        const returnVars = options.return || pattern.nodes.map(n => n.variable);
-        query += ` RETURN ${returnVars.join(', ')}`;
+    async getNeighborhood(options, _transaction) {
+        var _a, _b, _c;
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        const depth = options.depth || 1;
+        // Build direction
+        let traversalStep;
+        switch (options.direction) {
+            case enums_1.TraversalDirection.INCOMING:
+            case 'INCOMING':
+                traversalStep = ((_a = options.relationshipTypes) === null || _a === void 0 ? void 0 : _a.length)
+                    ? __.in_(...options.relationshipTypes)
+                    : __.in_();
+                break;
+            case enums_1.TraversalDirection.OUTGOING:
+            case 'OUTGOING':
+                traversalStep = ((_b = options.relationshipTypes) === null || _b === void 0 ? void 0 : _b.length)
+                    ? __.out(...options.relationshipTypes)
+                    : __.out();
+                break;
+            default:
+                traversalStep = ((_c = options.relationshipTypes) === null || _c === void 0 ? void 0 : _c.length)
+                    ? __.both(...options.relationshipTypes)
+                    : __.both();
+        }
+        // Get neighbors
+        let traversal = g.V(options.nodeId)
+            .repeat(traversalStep)
+            .times(depth)
+            .emit()
+            .dedup();
         if (options.limit) {
-            query += ` LIMIT ${options.limit}`;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
+            traversal = traversal.limit(options.limit);
+        }
+        const nodeResults = await traversal.valueMap(true).toList();
+        const nodes = nodeResults.map((v) => this.mapGremlinVertexFromValueMap(v));
+        // Get relationships (simplified - just outgoing edges from source)
+        const edgeResults = await g.V(options.nodeId)
+            .bothE(...(options.relationshipTypes || []))
+            .project('edge', 'outV', 'inV')
+            .by(__.valueMap(true))
+            .by(__.outV().id())
+            .by(__.inV().id())
+            .toList();
+        const relationships = edgeResults.map((r) => this.mapGremlinEdgeFromProject(r));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            matches: result.data,
-            count: result.data.length,
-            hasMore: options.limit !== undefined && result.data.length === options.limit,
+            nodes,
+            relationships,
+            depth,
         };
     }
-    async extractSubgraph(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        const startNodes = Array.isArray(options.startNodes) ? options.startNodes : [options.startNodes];
-        const maxDepth = options.maxDepth || 3;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            const startIds = startNodes.map(n => `'${n.id}'`).join(', ');
-            query = `g.V(${startIds}).repeat(both().simplePath()).times(${maxDepth}).emit().dedup().fold().as('nodes').V(${startIds}).repeat(bothE().dedup().by(id).otherV().simplePath()).times(${maxDepth}).emit().dedup().fold().as('edges').select('nodes', 'edges')`;
-        }
-        else {
-            const startMatches = startNodes.map((node, idx) => this.buildCypherNodeMatch(node, `start${idx}`, params, `start${idx}_`));
-            query = `
-        MATCH ${startMatches.join(', ')}
-        WITH [${startNodes.map((_, i) => `start${i}`).join(', ')}] AS starts
-        UNWIND starts AS start
-        MATCH path = (start)-[*0..${maxDepth}]-(n)
-        WITH COLLECT(DISTINCT n) AS nodes, COLLECT(DISTINCT relationships(path)) AS rels
-        UNWIND rels AS relList
-        UNWIND relList AS r
-        RETURN nodes, COLLECT(DISTINCT r) AS relationships
-      `;
-        }
-        const result = await this.executeRaw(connection, { query, params }, 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.relationships || row.edges) {
-                (row.relationships || row.edges).forEach((r) => relationships.push(this.parseRelationship(r)));
-            }
+    async findConnectedComponents(options, _transaction) {
+        var _a;
+        const g = this.ensureTraversal();
+        const { __ } = this.gremlin.process;
+        // Neptune doesn't have built-in connected components algorithm
+        // We'll implement a basic version using Gremlin
+        let startTraversal = g.V();
+        if ((_a = options.labels) === null || _a === void 0 ? void 0 : _a.length) {
+            startTraversal = startTraversal.hasLabel(...options.labels);
+        }
+        // Get all vertices
+        const allVertices = await startTraversal.id().toList();
+        const visited = new Set();
+        const components = [];
+        for (const vertexId of allVertices) {
+            if (visited.has(String(vertexId)))
+                continue;
+            // BFS to find all connected vertices
+            const componentVertices = await g.V(vertexId)
+                .repeat(__.both(...(options.relationshipTypes || [])))
+                .until(__.not(__.both(...(options.relationshipTypes || []))))
+                .emit()
+                .dedup()
+                .valueMap(true)
+                .toList();
+            // Include the starting vertex
+            const startVertex = await g.V(vertexId).valueMap(true).next();
+            const allInComponent = [startVertex.value, ...componentVertices];
+            const nodes = allInComponent.map((v) => {
+                const node = this.mapGremlinVertexFromValueMap(v);
+                visited.add(String(node.id));
+                return node;
+            });
+            components.push({
+                nodes,
+                size: nodes.length,
+            });
         }
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            subgraph: {
-                nodes,
-                relationships,
-                nodeCount: nodes.length,
-                relationshipCount: relationships.length,
-            },
+            components,
+            count: components.length,
         };
     }
-    async getNeighborhood(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        const depth = options.depth || 1;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            const nodeId = options.node.id;
-            const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'in' :
-                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'out' : 'both';
-            query = `g.V('${nodeId}').repeat(${direction}().simplePath()).times(${depth}).emit()${options.includeCenter ? '' : '.where(neq(V(\'' + nodeId + '\')))'}`;
+    // ==================== AGGREGATION OPERATIONS ====================
+    async countNodes(labels, where, _transaction) {
+        const g = this.ensureTraversal();
+        let traversal = g.V();
+        if (labels === null || labels === void 0 ? void 0 : labels.length) {
+            traversal = traversal.hasLabel(...labels);
         }
-        else {
-            const centerMatch = this.buildCypherNodeMatch(options.node, 'center', params);
-            const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
-            const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
-                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
-            query = `
-        MATCH ${centerMatch}
-        MATCH path = (center)${dirStart}[*0..${depth}]${dirEnd}(n)
-        WITH COLLECT(DISTINCT n) AS nodes, COLLECT(DISTINCT relationships(path)) AS rels
-        UNWIND rels AS relList
-        UNWIND relList AS r
-        RETURN nodes, COLLECT(DISTINCT r) AS relationships
-      `;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const nodes = [];
-        const relationships = [];
-        if (isGremlin) {
-            result.data.forEach((n) => nodes.push(this.parseNode(n)));
-        }
-        else if (result.data.length > 0) {
-            const row = result.data[0];
-            if (row.nodes) {
-                row.nodes.forEach((n) => nodes.push(this.parseNode(n)));
-            }
-            if (row.relationships) {
-                row.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
-            }
+        if (where) {
+            traversal = this.applyWhereConditions(traversal, where);
         }
+        const result = await traversal.count().next();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodes,
-            relationships,
-            levels: new Map(), // Would need additional queries to populate
+            count: result.value,
         };
     }
-    async findConnectedComponents(connection, options, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        // Neptune doesn't have built-in connected components
-        // This is a simplified implementation
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Connected components analysis requires Neptune Analytics or manual implementation');
-    }
-    // ==================== AGGREGATION OPERATIONS ====================
-    async countNodes(connection, labels, where, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            query = 'g.V()';
-            if (labels) {
-                const labelArr = Array.isArray(labels) ? labels : [labels];
-                query += `.hasLabel('${labelArr.join("', '")}')`;
-            }
-            if (where) {
-                Object.entries(where).forEach(([k, v]) => {
-                    query += `.has('${k}', ${this.gremlinValue(v)})`;
-                });
-            }
-            query += '.count()';
+    async countRelationships(types, where, _transaction) {
+        const g = this.ensureTraversal();
+        let traversal = g.E();
+        if (types === null || types === void 0 ? void 0 : types.length) {
+            traversal = traversal.hasLabel(...types);
         }
-        else {
-            const labelStr = labels
-                ? ':' + (Array.isArray(labels) ? labels : [labels]).join(':')
-                : '';
-            query = `MATCH (n${labelStr})`;
-            if (where && Object.keys(where).length > 0) {
-                const whereParts = Object.entries(where).map(([k], i) => {
-                    params[`w${i}`] = where[k];
-                    return `n.${k} = $w${i}`;
-                });
-                query += ` WHERE ${whereParts.join(' AND ')}`;
-            }
-            query += ' RETURN count(n) AS count';
+        if (where) {
+            traversal = this.applyWhereConditions(traversal, where);
         }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const count = isGremlin
-            ? result.data[0] || 0
-            : ((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
+        const result = await traversal.count().next();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            count: Number(count),
+            count: result.value,
         };
     }
-    async countRelationships(connection, type, where, transaction) {
-        var _a;
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let query;
-        const params = {};
-        if (isGremlin) {
-            query = 'g.E()';
-            if (type) {
-                const typeArr = Array.isArray(type) ? type : [type];
-                query += `.hasLabel('${typeArr.join("', '")}')`;
-            }
-            if (where) {
-                Object.entries(where).forEach(([k, v]) => {
-                    query += `.has('${k}', ${this.gremlinValue(v)})`;
-                });
-            }
-            query += '.count()';
-        }
-        else {
-            const typeStr = type
-                ? ':' + (Array.isArray(type) ? type : [type]).join('|')
-                : '';
-            query = `MATCH ()-[r${typeStr}]->() RETURN count(r) AS count`;
-        }
-        const result = await this.executeRaw(connection, { query, params }, transaction);
-        const count = isGremlin
-            ? result.data[0] || 0
-            : ((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
+    async getStatistics(_transaction) {
+        const g = this.ensureTraversal();
+        const nodeCount = await g.V().count().next();
+        const relCount = await g.E().count().next();
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            count: Number(count),
+            nodeCount: nodeCount.value,
+            relationshipCount: relCount.value,
         };
     }
-    async getStatistics(connection, transaction) {
-        const startTime = Date.now();
-        const neptuneConn = connection;
-        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
-        let nodeCount = 0;
-        let relationshipCount = 0;
-        if (isGremlin) {
-            const nodeResult = await this.executeRaw(connection, { query: 'g.V().count()' }, transaction);
-            nodeCount = nodeResult.data[0] || 0;
-            const relResult = await this.executeRaw(connection, { query: 'g.E().count()' }, transaction);
-            relationshipCount = relResult.data[0] || 0;
-        }
-        else {
-            const result = await this.executeRaw(connection, {
-                query: `
-            MATCH (n)
-            WITH count(n) AS nodeCount
-            MATCH ()-[r]->()
-            RETURN nodeCount, count(r) AS relCount
-          `,
-            }, transaction);
-            if (result.data.length > 0) {
-                nodeCount = result.data[0].nodeCount || 0;
-                relationshipCount = result.data[0].relCount || 0;
-            }
+    // ==================== SEARCH OPERATIONS ====================
+    async fullTextSearch(options, _transaction) {
+        const g = this.ensureTraversal();
+        // Neptune supports text predicates via Neptune-specific features
+        // Basic implementation using contains predicate
+        const textPredicate = this.gremlin.process.P.containing(options.query);
+        let traversal = g.V().or(this.gremlin.process.__.has('name', textPredicate), this.gremlin.process.__.has('title', textPredicate), this.gremlin.process.__.has('description', textPredicate));
+        if (options.limit) {
+            traversal = traversal.limit(options.limit);
         }
+        const results = await traversal.valueMap(true).toList();
+        const nodes = results.map((v) => this.mapGremlinVertexFromValueMap(v));
         return {
-            success: true,
-            executionTime: Date.now() - startTime,
-            nodeCount: Number(nodeCount),
-            relationshipCount: Number(relationshipCount),
-            labelCounts: {},
-            relationshipTypeCounts: {},
+            nodes,
+            scores: nodes.map(() => 1.0),
         };
     }
-    // ==================== SEARCH OPERATIONS ====================
-    async fullTextSearch(connection, options, transaction) {
-        // Neptune doesn't have built-in full-text search
-        // Would need to use OpenSearch integration
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Full-text search requires Neptune integration with OpenSearch');
-    }
-    async vectorSearch(connection, options, transaction) {
-        // Neptune Analytics supports vector search
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Vector search requires Neptune Analytics');
-    }
-    // ==================== SCHEMA OPERATIONS ====================
-    // Note: Neptune has limited schema support compared to Neo4j
-    async createNodeConstraint(connection, constraint, transaction) {
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support explicit constraints');
-    }
-    async createRelationshipConstraint(connection, constraint, transaction) {
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support explicit constraints');
-    }
-    async dropConstraint(connection, name, transaction) {
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support explicit constraints');
+    async vectorSearch(_options, _transaction) {
+        throw graph_error_1.GraphError.unsupportedOperationError('Vector search is not natively supported in Neptune. Consider using Amazon OpenSearch with Neptune.', this.graphType);
     }
-    async listConstraints(connection, transaction) {
+    // ==================== RAW QUERY ====================
+    async query(options, _transaction) {
+        // For Gremlin, the query is a Gremlin script string
+        // Neptune supports script execution via the submit method
+        if (!this.connection) {
+            throw new Error('Not connected to Neptune');
+        }
+        const result = await this.connection.submit(options.query, options.params || {});
+        const records = await result.toArray();
         return {
-            success: true,
-            executionTime: 0,
-            constraints: [],
+            records: records,
+            summary: {},
         };
     }
-    async createNodeIndex(connection, index, transaction) {
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune automatically indexes all properties');
-    }
-    async createRelationshipIndex(connection, index, transaction) {
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune automatically indexes all properties');
+    // ==================== SCHEMA OPERATIONS ====================
+    async createNodeIndex(options) {
+        // Neptune doesn't support user-created indexes in the same way as Neo4j
+        // Indexes are managed automatically by Neptune
+        // Return success as Neptune will handle optimization automatically
+        return { created: true, name: options.name };
+    }
+    async createNodeConstraint(_options) {
+        // Neptune doesn't support constraints like Neo4j
+        throw graph_error_1.GraphError.unsupportedOperationError('Neptune does not support user-defined constraints. Data validation should be handled at the application level.', this.graphType);
+    }
+    async createRelationshipIndex(options) {
+        // Neptune handles indexes automatically
+        return { created: true, name: options.name };
+    }
+    async listIndexes() {
+        // Neptune indexes are managed internally
+        return { indexes: [] };
+    }
+    async listConstraints() {
+        // Neptune doesn't have user-defined constraints
+        return { constraints: [] };
+    }
+    async dropIndex(_name) {
+        // Neptune indexes are managed internally
+        return { dropped: false };
+    }
+    async dropConstraint(_name) {
+        // Neptune doesn't have user-defined constraints
+        return { dropped: false };
+    }
+    // ==================== SCHEMA INTROSPECTION ====================
+    async listLabels() {
+        this.ensureConnected();
+        try {
+            // Get all distinct vertex labels
+            const labelsTraversal = this.g.V().label().dedup();
+            const labelNames = await labelsTraversal.toList();
+            const labels = [];
+            for (const labelName of labelNames) {
+                // Get count for each label
+                const countTraversal = this.g.V().hasLabel(labelName).count();
+                const countResult = await countTraversal.next();
+                const count = countResult.value || 0;
+                // Get properties from a sample of vertices with this label
+                const propsTraversal = this.g.V().hasLabel(labelName).limit(100).properties().key().dedup();
+                const propertyNames = await propsTraversal.toList();
+                const properties = propertyNames.map((name) => ({
+                    name,
+                    type: 'unknown',
+                }));
+                labels.push({
+                    name: String(labelName),
+                    count: Number(count),
+                    properties,
+                });
+            }
+            return { labels };
+        }
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to list labels: ${error.message}`);
+        }
     }
-    async dropIndex(connection, name, transaction) {
-        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support dropping indexes');
+    async listRelationshipTypes() {
+        this.ensureConnected();
+        try {
+            // Get all distinct edge labels
+            const typesTraversal = this.g.E().label().dedup();
+            const typeNames = await typesTraversal.toList();
+            const types = [];
+            for (const typeName of typeNames) {
+                // Get count for each edge label
+                const countTraversal = this.g.E().hasLabel(typeName).count();
+                const countResult = await countTraversal.next();
+                const count = countResult.value || 0;
+                // Get source and target vertex labels
+                const endpointsTraversal = this.g.E().hasLabel(typeName).limit(100)
+                    .project('fromLabel', 'toLabel')
+                    .by(this.gremlin.process.statics.outV().label())
+                    .by(this.gremlin.process.statics.inV().label());
+                const endpoints = await endpointsTraversal.toList();
+                const fromLabelsSet = new Set();
+                const toLabelsSet = new Set();
+                for (const ep of endpoints) {
+                    if (ep.fromLabel)
+                        fromLabelsSet.add(String(ep.fromLabel));
+                    if (ep.toLabel)
+                        toLabelsSet.add(String(ep.toLabel));
+                }
+                // Get properties from a sample of edges
+                const propsTraversal = this.g.E().hasLabel(typeName).limit(100).properties().key().dedup();
+                const propertyNames = await propsTraversal.toList();
+                const properties = propertyNames.map((name) => ({
+                    name,
+                    type: 'unknown',
+                }));
+                types.push({
+                    type: String(typeName),
+                    count: Number(count),
+                    fromLabels: Array.from(fromLabelsSet),
+                    toLabels: Array.from(toLabelsSet),
+                    properties: properties.length > 0 ? properties : undefined,
+                });
+            }
+            return { types };
+        }
+        catch (error) {
+            throw graph_error_1.GraphError.queryError(`Failed to list relationship types: ${error.message}`);
+        }
     }
-    async listIndexes(connection, transaction) {
+    // ==================== TRANSACTION OPERATIONS ====================
+    async beginTransaction(_options) {
+        // Neptune has limited transaction support via sessions
+        // For now, we create a session-based pseudo-transaction
+        this.ensureConnected();
         return {
-            success: true,
-            executionTime: 0,
-            indexes: [],
+            id: `tx_${Date.now()}`,
+            status: enums_1.GraphTransactionStatus.ACTIVE,
+            client: this.g,
+            nativeTransaction: null,
+            startTime: new Date(),
+            commit: async () => {
+                // Neptune auto-commits each query
+            },
+            rollback: async () => {
+                // Neptune doesn't support rollback for individual queries
+            },
         };
     }
-    // ==================== UTILITY METHODS ====================
-    escapeIdentifier(identifier) {
-        return identifier.replace(/[^a-zA-Z0-9_]/g, '_');
+    async commitTransaction(_transaction) {
+        // Neptune auto-commits each query
     }
-    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 `datetime('${value.toISOString()}')`;
-        if (Array.isArray(value))
-            return `[${value.map(v => this.escapeValue(v)).join(', ')}]`;
-        return String(value);
+    async rollbackTransaction(_transaction) {
+        // Neptune doesn't support rollback for individual queries
     }
-    buildWhereClause(where, variableName = 'n') {
-        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,
-        };
+    // ==================== UTILITY METHODS ====================
+    buildWhereClause(where) {
+        // For Gremlin, we return the where clause object as-is
+        // The actual predicate building is done in applyWhereConditions
+        return where;
+    }
+    applyWhereConditions(traversal, where) {
+        const { P } = this.gremlin.process;
+        for (const [key, value] of Object.entries(where)) {
+            if (key === '$AND') {
+                // Apply AND conditions
+                traversal = traversal.and(...Object.entries(value).map(([k, v]) => this.gremlin.process.__.has(k, v)));
+            }
+            else if (key === '$OR') {
+                // Apply OR conditions
+                traversal = traversal.or(...Object.entries(value).map(([k, v]) => this.gremlin.process.__.has(k, v)));
+            }
+            else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+                // Apply operator conditions
+                for (const [op, opValue] of Object.entries(value)) {
+                    switch (op) {
+                        case '$GT':
+                            traversal = traversal.has(key, P.gt(opValue));
+                            break;
+                        case '$GTE':
+                            traversal = traversal.has(key, P.gte(opValue));
+                            break;
+                        case '$LT':
+                            traversal = traversal.has(key, P.lt(opValue));
+                            break;
+                        case '$LTE':
+                            traversal = traversal.has(key, P.lte(opValue));
+                            break;
+                        case '$NE':
+                            traversal = traversal.has(key, P.neq(opValue));
+                            break;
+                        case '$IN':
+                            traversal = traversal.has(key, P.within(...opValue));
+                            break;
+                        case '$NOT_IN':
+                            traversal = traversal.has(key, P.without(...opValue));
+                            break;
+                        case '$CONTAINS':
+                            traversal = traversal.has(key, P.containing(opValue));
+                            break;
+                        case '$STARTS_WITH':
+                            traversal = traversal.has(key, P.startingWith(opValue));
+                            break;
+                        case '$ENDS_WITH':
+                            traversal = traversal.has(key, P.endingWith(opValue));
+                            break;
+                        case '$EXISTS':
+                            if (opValue) {
+                                traversal = traversal.has(key);
+                            }
+                            else {
+                                traversal = traversal.hasNot(key);
+                            }
+                            break;
+                    }
+                }
+            }
+            else {
+                // Simple equality
+                traversal = traversal.has(key, value);
+            }
+        }
+        return traversal;
     }
-    // ==================== PROTECTED PARSER METHODS ====================
-    parseNode(nativeNode) {
-        if (!nativeNode) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.NODE_ERROR, 'Cannot parse null node');
+    parseError(error) {
+        if (error instanceof graph_error_1.GraphError) {
+            return error;
         }
-        // Already parsed
-        if (nativeNode.labels && nativeNode.properties !== undefined) {
-            return nativeNode;
+        return graph_error_1.GraphError.queryError(String(error));
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    mapGremlinVertex(id, properties) {
+        const props = {};
+        const labels = [];
+        if (properties) {
+            for (const [key, value] of properties) {
+                if (key === 'label' || key === this.gremlin.process.t.label) {
+                    labels.push(Array.isArray(value) ? value[0] : value);
+                }
+                else if (key === 'id' || key === this.gremlin.process.t.id) {
+                    // Skip id as we have it separately
+                }
+                else {
+                    props[key] = Array.isArray(value) ? value[0] : value;
+                }
+            }
         }
         return {
-            id: nativeNode.id || '',
-            labels: nativeNode.labels || [nativeNode.label] || [],
-            properties: (nativeNode.properties || nativeNode),
+            id: String(id),
+            labels,
+            properties: props,
         };
     }
-    parseRelationship(nativeRelationship) {
-        if (!nativeRelationship) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.RELATIONSHIP_ERROR, 'Cannot parse null relationship');
-        }
-        // Already parsed
-        if (nativeRelationship.type && nativeRelationship.startNodeId !== undefined) {
-            return nativeRelationship;
+    mapGremlinVertexFromValueMap(valueMap) {
+        const props = {};
+        const labels = [];
+        let id = '';
+        if (valueMap) {
+            for (const [key, value] of Object.entries(valueMap)) {
+                if (key === 'label' || String(key).includes('label')) {
+                    const labelValue = Array.isArray(value) ? value[0] : value;
+                    labels.push(String(labelValue));
+                }
+                else if (key === 'id' || String(key).includes('id')) {
+                    id = String(Array.isArray(value) ? value[0] : value);
+                }
+                else {
+                    props[key] = Array.isArray(value) ? value[0] : value;
+                }
+            }
         }
         return {
-            id: nativeRelationship.id || '',
-            type: nativeRelationship.type || nativeRelationship.label || '',
-            startNodeId: nativeRelationship.startNodeId || nativeRelationship.outV || '',
-            endNodeId: nativeRelationship.endNodeId || nativeRelationship.inV || '',
-            properties: (nativeRelationship.properties || nativeRelationship),
+            id,
+            labels,
+            properties: props,
         };
     }
-    parsePath(nativePath) {
-        if (!nativePath) {
-            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.PATH_ERROR, 'Cannot parse null path');
-        }
-        // Already parsed
-        if (nativePath.nodes && nativePath.relationships !== undefined) {
-            return nativePath;
-        }
-        const nodes = [];
-        const relationships = [];
-        if (nativePath.objects) {
-            // Gremlin path
-            nativePath.objects.forEach((obj) => {
-                if (obj.labels || obj.label) {
-                    nodes.push(this.parseNode(obj));
+    mapGremlinEdge(edge, properties, startId, endId) {
+        const props = {};
+        let type = '';
+        if (properties) {
+            for (const [key, value] of Object.entries(properties)) {
+                if (key === 'label' || String(key).includes('label')) {
+                    type = String(Array.isArray(value) ? value[0] : value);
                 }
-                else if (obj.type || obj.outV) {
-                    relationships.push(this.parseRelationship(obj));
+                else if (key === 'id' || String(key).includes('id')) {
+                    // Skip id
                 }
-            });
-        }
-        else if (nativePath.nodes && nativePath.relationships) {
-            // Already structured
-            nativePath.nodes.forEach((n) => nodes.push(this.parseNode(n)));
-            nativePath.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
+                else {
+                    props[key] = Array.isArray(value) ? value[0] : value;
+                }
+            }
         }
         return {
-            nodes,
-            relationships,
-            length: relationships.length,
-            start: nodes[0],
-            end: nodes[nodes.length - 1],
+            id: String(edge.id),
+            type: type || edge.label,
+            startNodeId: String(startId),
+            endNodeId: String(endId),
+            properties: props,
         };
     }
-    // ==================== PRIVATE HELPER METHODS ====================
-    normalizeLabels(labels) {
-        return Array.isArray(labels) ? labels : [labels];
-    }
-    gremlinValue(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.toString();
-        if (value instanceof Date)
-            return `datetime('${value.toISOString()}')`;
-        if (Array.isArray(value))
-            return `[${value.map(v => this.gremlinValue(v)).join(', ')}]`;
-        return String(value);
-    }
-    buildCypherNodeMatch(ref, alias, params, prefix = '') {
-        let pattern = `(${alias}`;
-        if (ref.labels) {
-            const labels = this.normalizeLabels(ref.labels);
-            pattern += ':' + labels.join(':');
-        }
-        if (ref.id !== undefined) {
-            const paramName = `${prefix}id`;
-            params[paramName] = ref.id;
-            pattern += ` {id: $${paramName}}`;
-        }
-        else if (ref.properties && Object.keys(ref.properties).length > 0) {
-            const propParts = Object.entries(ref.properties).map(([k], i) => {
-                const paramName = `${prefix}prop${i}`;
-                params[paramName] = ref.properties[k];
-                return `${k}: $${paramName}`;
-            });
-            pattern += ` {${propParts.join(', ')}}`;
+    mapGremlinEdgeFromProject(result) {
+        const edge = result.edge || {};
+        const props = {};
+        let type = '';
+        let id = '';
+        for (const [key, value] of Object.entries(edge)) {
+            if (key === 'label' || String(key).includes('label')) {
+                type = String(Array.isArray(value) ? value[0] : value);
+            }
+            else if (key === 'id' || String(key).includes('id')) {
+                id = String(Array.isArray(value) ? value[0] : value);
+            }
+            else {
+                props[key] = Array.isArray(value) ? value[0] : value;
+            }
         }
-        pattern += ')';
-        return pattern;
+        return {
+            id,
+            type,
+            startNodeId: String(result.outV),
+            endNodeId: String(result.inV),
+            properties: props,
+        };
     }
 }
 exports.NeptuneAdapter = NeptuneAdapter;
-exports.default = NeptuneAdapter;
 //# sourceMappingURL=neptune.adapter.js.map