@ductape/sdk 0.1.8 → 0.1.9

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

@@ -0,0 +1,1369 @@
+"use strict";
+/**
+ * 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 enums_1 = require("../types/enums");
+const graph_error_1 = require("../utils/graph-error");
+/**
+ * Neptune adapter using Gremlin
+ * Uses the gremlin package for TinkerPop connectivity
+ */
+class NeptuneAdapter extends base_adapter_1.BaseGraphAdapter {
+    constructor() {
+        super(...arguments);
+        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 {
+            // Store connection options for reconnection
+            this.connectionOptions = options;
+            // 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,
+                type: enums_1.GraphType.NEPTUNE,
+                latency: 0,
+            };
+        }
+        catch (error) {
+            this.connected = false;
+            throw graph_error_1.GraphError.connectionError(`Failed to connect to Neptune: ${error.message}`, error);
+        }
+    }
+    async testConnection(options) {
+        try {
+            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',
+                latency: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                type: enums_1.GraphType.NEPTUNE,
+                error: error.message,
+            };
+        }
+    }
+    async disconnect() {
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+            this.g = null;
+        }
+        this.connected = false;
+    }
+    ensureTraversal() {
+        this.ensureConnected();
+        if (!this.g) {
+            throw new Error('Graph traversal source not initialized');
+        }
+        return this.g;
+    }
+    // ==================== NODE OPERATIONS ====================
+    async createNode(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            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);
+                    }
+                }
+            }
+            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 {
+                node: this.mapGremlinVertex(vertex.id, fullVertex.value),
+                created: true,
+            };
+        });
+    }
+    async findNodes(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a, _b;
+            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);
+                }
+            }
+            // Apply pagination
+            if (options.skip) {
+                traversal = traversal.skip(options.skip);
+            }
+            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 {
+                nodes,
+                count: nodes.length,
+            };
+        });
+    }
+    async findNodeById(id, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            const results = await g.V(id).valueMap(true).toList();
+            if (results.length === 0) {
+                return null;
+            }
+            return this.mapGremlinVertexFromValueMap(results[0]);
+        });
+    }
+    async updateNode(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a;
+            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);
+                }
+                if (options.where) {
+                    traversal = this.applyWhereConditions(traversal, options.where);
+                }
+            }
+            // 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);
+                    }
+                }
+            }
+            const results = await traversal.valueMap(true).toList();
+            const nodes = results.map((v) => this.mapGremlinVertexFromValueMap(v));
+            return {
+                node: nodes.length === 1 ? nodes[0] : undefined,
+                nodes: nodes.length > 1 ? nodes : undefined,
+                updatedCount: nodes.length,
+                updated: nodes.length > 0,
+            };
+        });
+    }
+    async deleteNode(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a, _b;
+            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);
+                }
+                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 {
+                let dropTraversal = g.V();
+                if ((_b = options.labels) === null || _b === void 0 ? void 0 : _b.length) {
+                    dropTraversal = dropTraversal.hasLabel(...options.labels);
+                }
+                if (options.where) {
+                    dropTraversal = this.applyWhereConditions(dropTraversal, options.where);
+                }
+                await dropTraversal.drop().iterate();
+            }
+            return {
+                deleted: count > 0,
+                deletedCount: count,
+            };
+        });
+    }
+    async mergeNode(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            // 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 {
+                // 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);
+                    }
+                }
+                // 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);
+                        }
+                    }
+                }
+                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,
+                };
+            }
+        });
+    }
+    // ==================== LABEL MANAGEMENT ====================
+    async addLabels(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            // 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 {
+                node,
+                addedLabels: options.labels,
+            };
+        });
+    }
+    async removeLabels(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            // 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();
+        return this.executeWithRetry(async () => {
+            // 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(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            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);
+                    }
+                }
+            }
+            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 {
+                relationship: this.mapGremlinEdge(edge, fullEdge.value, options.startNodeId, options.endNodeId),
+                created: true,
+            };
+        });
+    }
+    async findRelationships(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            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 {
+                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);
+            }
+            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 {
+                relationships,
+                count: relationships.length,
+            };
+        });
+    }
+    async findRelationshipById(id, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            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.mapGremlinEdgeFromProject(results[0]);
+        });
+    }
+    async updateRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            const { __ } = this.gremlin.process;
+            let traversal;
+            if (options.id) {
+                traversal = g.E(options.id);
+            }
+            else {
+                traversal = g.E();
+                if (options.type) {
+                    traversal = traversal.hasLabel(options.type);
+                }
+                if (options.where) {
+                    traversal = this.applyWhereConditions(traversal, options.where);
+                }
+            }
+            // 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 {
+                relationship: relationships.length === 1 ? relationships[0] : undefined,
+                relationships: relationships.length > 1 ? relationships : undefined,
+                updatedCount: relationships.length,
+                updated: relationships.length > 0,
+            };
+        });
+    }
+    async deleteRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            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 {
+                    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 {
+                countTraversal = g.E();
+                if (options.type) {
+                    countTraversal = countTraversal.hasLabel(options.type);
+                }
+            }
+            const countResult = await countTraversal.count().next();
+            const count = countResult.value;
+            // Delete
+            await traversal.drop().iterate();
+            return {
+                deleted: count > 0,
+                deletedCount: count,
+            };
+        });
+    }
+    async mergeRelationship(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            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 {
+                // 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);
+                        }
+                    }
+                }
+                // 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);
+                        }
+                    }
+                }
+                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,
+                };
+            }
+        });
+    }
+    // ==================== TRAVERSAL OPERATIONS ====================
+    async traverse(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a;
+            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 {
+                traversal = traversal.repeat(repeatStep).times(maxDepth).emit();
+            }
+            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();
+            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 {
+                paths,
+                nodes: Array.from(nodesMap.values()),
+                relationships: Array.from(relsMap.values()),
+                count: paths.length,
+            };
+        });
+    }
+    async shortestPath(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a;
+            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 {
+                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 = {
+                nodes: pathNodes,
+                relationships: [],
+                length: pathNodes.length - 1,
+            };
+            return {
+                path,
+                length: path.length,
+                found: true,
+            };
+        });
+    }
+    async allPaths(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a;
+            const { __ } = this.gremlin.process;
+            const minDepth = options.minDepth || 1;
+            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 {
+                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,
+                    });
+                }
+            }
+            return {
+                paths,
+                count: paths.length,
+                total: paths.length,
+            };
+        });
+    }
+    async getNeighborhood(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a, _b, _c;
+            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) {
+                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 {
+                nodes,
+                relationships,
+                depth,
+            };
+        });
+    }
+    async findConnectedComponents(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            var _a;
+            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 {
+                components,
+                count: components.length,
+            };
+        });
+    }
+    // ==================== AGGREGATION OPERATIONS ====================
+    async countNodes(labels, where, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            let traversal = g.V();
+            if (labels === null || labels === void 0 ? void 0 : labels.length) {
+                traversal = traversal.hasLabel(...labels);
+            }
+            if (where) {
+                traversal = this.applyWhereConditions(traversal, where);
+            }
+            const result = await traversal.count().next();
+            return {
+                count: result.value,
+            };
+        });
+    }
+    async countRelationships(types, where, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            let traversal = g.E();
+            if (types === null || types === void 0 ? void 0 : types.length) {
+                traversal = traversal.hasLabel(...types);
+            }
+            if (where) {
+                traversal = this.applyWhereConditions(traversal, where);
+            }
+            const result = await traversal.count().next();
+            return {
+                count: result.value,
+            };
+        });
+    }
+    async getStatistics(_transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            const nodeCount = await g.V().count().next();
+            const relCount = await g.E().count().next();
+            return {
+                nodeCount: nodeCount.value,
+                relationshipCount: relCount.value,
+            };
+        });
+    }
+    // ==================== SEARCH OPERATIONS ====================
+    async fullTextSearch(options, _transaction) {
+        const g = this.ensureTraversal();
+        return this.executeWithRetry(async () => {
+            // 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 {
+                nodes,
+                scores: nodes.map(() => 1.0),
+            };
+        });
+    }
+    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);
+    }
+    // ==================== 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');
+        }
+        return this.executeWithRetry(async () => {
+            const result = await this.connection.submit(options.query, options.params || {});
+            const records = await result.toArray();
+            return {
+                records: records,
+                summary: {},
+            };
+        });
+    }
+    // ==================== 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();
+        return this.executeWithRetry(async () => {
+            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 listRelationshipTypes() {
+        this.ensureConnected();
+        return this.executeWithRetry(async () => {
+            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}`);
+            }
+        });
+    }
+    // ==================== TRANSACTION OPERATIONS ====================
+    async beginTransaction(_options) {
+        // Neptune has limited transaction support via sessions
+        // For now, we create a session-based pseudo-transaction
+        this.ensureConnected();
+        return {
+            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
+            },
+        };
+    }
+    async commitTransaction(_transaction) {
+        // Neptune auto-commits each query
+    }
+    async rollbackTransaction(_transaction) {
+        // Neptune doesn't support rollback for individual queries
+    }
+    // ==================== 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)) {
+            // Normalize key to lowercase for comparison
+            const normalizedKey = key.toLowerCase();
+            if (normalizedKey === '$and') {
+                // Apply AND conditions
+                if (Array.isArray(value)) {
+                    traversal = traversal.and(...value.flatMap((v) => Object.entries(v).map(([k, val]) => this.gremlin.process.__.has(k, val))));
+                }
+                else {
+                    traversal = traversal.and(...Object.entries(value).map(([k, v]) => this.gremlin.process.__.has(k, v)));
+                }
+            }
+            else if (normalizedKey === '$or') {
+                // Apply OR conditions
+                if (Array.isArray(value)) {
+                    traversal = traversal.or(...value.flatMap((v) => Object.entries(v).map(([k, val]) => this.gremlin.process.__.has(k, val))));
+                }
+                else {
+                    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)) {
+                    const normalizedOp = op.toLowerCase();
+                    switch (normalizedOp) {
+                        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 '$nin':
+                        case '$not_in':
+                            traversal = traversal.has(key, P.without(...opValue));
+                            break;
+                        case '$contains':
+                            traversal = traversal.has(key, P.containing(opValue));
+                            break;
+                        case '$startswith':
+                        case '$starts_with':
+                            traversal = traversal.has(key, P.startingWith(opValue));
+                            break;
+                        case '$endswith':
+                        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;
+    }
+    parseError(error) {
+        if (error instanceof graph_error_1.GraphError) {
+            return error;
+        }
+        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: String(id),
+            labels,
+            properties: props,
+        };
+    }
+    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,
+            labels,
+            properties: props,
+        };
+    }
+    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 (key === 'id' || String(key).includes('id')) {
+                    // Skip id
+                }
+                else {
+                    props[key] = Array.isArray(value) ? value[0] : value;
+                }
+            }
+        }
+        return {
+            id: String(edge.id),
+            type: type || edge.label,
+            startNodeId: String(startId),
+            endNodeId: String(endId),
+            properties: props,
+        };
+    }
+    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;
+            }
+        }
+        return {
+            id,
+            type,
+            startNodeId: String(result.outV),
+            endNodeId: String(result.inV),
+            properties: props,
+        };
+    }
+}
+exports.NeptuneAdapter = NeptuneAdapter;
+//# sourceMappingURL=neptune.adapter.js.map