@ductape/sdk 0.0.4-v6 → 0.0.4-v60

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

@@ -0,0 +1,1313 @@
+"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 {
+            // 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();
+        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) {
+        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);
+            }
+        }
+        // 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();
+        const results = await g.V(id).valueMap(true).toList();
+        if (results.length === 0) {
+            return null;
+        }
+        return this.mapGremlinVertexFromValueMap(results[0]);
+    }
+    async updateNode(options, _transaction) {
+        var _a;
+        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);
+            }
+            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) {
+        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);
+            }
+            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();
+        // 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();
+        // 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();
+        // 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(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);
+                }
+            }
+        }
+        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();
+        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();
+        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();
+        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();
+        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();
+        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) {
+        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 {
+            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) {
+        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 {
+            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) {
+        var _a;
+        const g = this.ensureTraversal();
+        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) {
+        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) {
+            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) {
+        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 {
+            components,
+            count: components.length,
+        };
+    }
+    // ==================== 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);
+        }
+        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();
+        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();
+        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();
+        // 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');
+        }
+        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();
+        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();
+        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