@ductape/sdk 0.1.6 → 0.1.8

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

@@ -1,1369 +0,0 @@
-"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