@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,1430 @@
+"use strict";
+/**
+ * AWS Neptune Graph Database Adapter
+ * Implements the BaseGraphAdapter for Amazon Neptune using Gremlin or openCypher
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeptuneAdapter = void 0;
+const base_adapter_1 = require("./base.adapter");
+const graph_types_1 = require("../types/graph.types");
+const relationship_types_1 = require("../types/relationship.types");
+/**
+ * Neptune connection implementation
+ */
+class NeptuneConnection {
+    constructor(config, id) {
+        this.config = config;
+        this.type = graph_types_1.GraphDatabaseType.NEPTUNE;
+        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
+        this.httpClient = null;
+        this.awsCredentials = null;
+        this.id = id || `neptune-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        this.createdAt = new Date();
+        this.queryLanguage = config.queryLanguage;
+    }
+    async connect() {
+        var _a;
+        if (this.status === graph_types_1.GraphConnectionStatus.CONNECTED) {
+            return;
+        }
+        this.status = graph_types_1.GraphConnectionStatus.CONNECTING;
+        try {
+            // Build endpoint URL
+            const port = this.config.port || 8182;
+            const protocol = this.config.ssl !== false ? 'https' : 'http';
+            const baseUrl = `${protocol}://${this.config.endpoint}:${port}`;
+            // If using IAM auth, set up AWS signing
+            if (this.config.useIAM) {
+                this.awsCredentials = {
+                    accessKeyId: this.config.accessKeyId,
+                    secretAccessKey: this.config.secretAccessKey,
+                    sessionToken: this.config.sessionToken,
+                    region: this.config.region,
+                };
+            }
+            this.httpClient = {
+                baseUrl,
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (_a = this.config.options) === null || _a === void 0 ? void 0 : _a.headers),
+            };
+            // Verify connectivity with a simple query
+            await this.executeQuery(this.queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
+                ? 'g.V().limit(1).count()'
+                : 'MATCH (n) RETURN count(n) LIMIT 1');
+            this.status = graph_types_1.GraphConnectionStatus.CONNECTED;
+            this.lastUsedAt = new Date();
+        }
+        catch (error) {
+            this.status = graph_types_1.GraphConnectionStatus.ERROR;
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, `Failed to connect to Neptune: ${error.message}`, error);
+        }
+    }
+    async disconnect() {
+        this.httpClient = null;
+        this.awsCredentials = null;
+        this.status = graph_types_1.GraphConnectionStatus.DISCONNECTED;
+    }
+    isConnected() {
+        return this.status === graph_types_1.GraphConnectionStatus.CONNECTED && this.httpClient !== null;
+    }
+    getClient() {
+        if (!this.httpClient) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Neptune client not initialized. Call connect() first.');
+        }
+        return this.httpClient;
+    }
+    getSession() {
+        return this.getClient();
+    }
+    getConfig() {
+        return this.config;
+    }
+    async executeQuery(query, params) {
+        if (!this.httpClient) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.CONNECTION_ERROR, 'Neptune client not initialized');
+        }
+        this.lastUsedAt = new Date();
+        const endpoint = this.queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
+            ? '/gremlin'
+            : '/openCypher';
+        const body = this.queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
+            ? { gremlin: query, bindings: params || {} }
+            : { query, parameters: params || {} };
+        try {
+            // Make HTTP request to Neptune
+            const response = await this.makeRequest(endpoint, body);
+            return response;
+        }
+        catch (error) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.QUERY_ERROR, `Neptune query failed: ${error.message}`, error, query, params);
+        }
+    }
+    async makeRequest(endpoint, body) {
+        const url = `${this.httpClient.baseUrl}${endpoint}`;
+        const headers = Object.assign({}, this.httpClient.headers);
+        // Sign request if using IAM auth
+        if (this.awsCredentials) {
+            const signedHeaders = await this.signRequest('POST', url, JSON.stringify(body));
+            Object.assign(headers, signedHeaders);
+        }
+        // Using fetch for HTTP requests
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+        }
+        return response.json();
+    }
+    async signRequest(method, url, body) {
+        // AWS Signature V4 signing
+        // In production, use aws-sdk or @aws-sdk/signature-v4
+        // This is a placeholder for the signing logic
+        const timestamp = new Date().toISOString().replace(/[:-]|\.\d{3}/g, '');
+        const date = timestamp.slice(0, 8);
+        return {
+            'X-Amz-Date': timestamp,
+            'X-Amz-Security-Token': this.awsCredentials.sessionToken || '',
+            // In production, add proper Authorization header with signature
+        };
+    }
+}
+/**
+ * Neptune transaction implementation
+ * Note: Neptune has limited transaction support, primarily for Gremlin
+ */
+class NeptuneTransaction {
+    constructor(connection, transactionId) {
+        this.connection = connection;
+        this.status = graph_types_1.GraphTransactionStatus.PENDING;
+        this.id = transactionId || `tx-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+        this.createdAt = new Date();
+        this.status = graph_types_1.GraphTransactionStatus.ACTIVE;
+        this.native = { transactionId: this.id };
+    }
+    async commit() {
+        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.TRANSACTION_ERROR, `Cannot commit transaction in ${this.status} state`);
+        }
+        // Neptune auto-commits each query, so this is a no-op
+        this.status = graph_types_1.GraphTransactionStatus.COMMITTED;
+    }
+    async rollback() {
+        if (this.status !== graph_types_1.GraphTransactionStatus.ACTIVE) {
+            return;
+        }
+        // Neptune doesn't support rollback in the traditional sense
+        this.status = graph_types_1.GraphTransactionStatus.ROLLED_BACK;
+    }
+    isActive() {
+        return this.status === graph_types_1.GraphTransactionStatus.ACTIVE;
+    }
+}
+/**
+ * AWS Neptune Graph Database Adapter
+ */
+class NeptuneAdapter extends base_adapter_1.BaseGraphAdapter {
+    constructor() {
+        super(...arguments);
+        this.type = graph_types_1.GraphDatabaseType.NEPTUNE;
+        this.supportedLanguages = [graph_types_1.GraphQueryLanguage.GREMLIN, graph_types_1.GraphQueryLanguage.OPENCYPHER];
+        this.defaultLanguage = graph_types_1.GraphQueryLanguage.GREMLIN;
+    }
+    // ==================== CONNECTION METHODS ====================
+    async connect(config) {
+        if (config.type !== graph_types_1.GraphDatabaseType.NEPTUNE) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, `Invalid config type ${config.type}. Expected ${graph_types_1.GraphDatabaseType.NEPTUNE}`);
+        }
+        const connection = new NeptuneConnection(config);
+        await connection.connect();
+        return connection;
+    }
+    async disconnect(connection) {
+        await connection.disconnect();
+    }
+    async testConnection(connection) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const queryLanguage = neptuneConn.getConfig().queryLanguage;
+        try {
+            const testQuery = queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN
+                ? 'g.V().limit(1).count()'
+                : 'MATCH (n) RETURN count(n) AS count LIMIT 1';
+            await neptuneConn.executeQuery(testQuery);
+            return {
+                connected: true,
+                message: 'Connection successful',
+                databaseType: graph_types_1.GraphDatabaseType.NEPTUNE,
+                queryLanguage,
+                responseTime: Date.now() - startTime,
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                message: 'Connection failed',
+                databaseType: graph_types_1.GraphDatabaseType.NEPTUNE,
+                queryLanguage,
+                responseTime: Date.now() - startTime,
+                error: error.message,
+            };
+        }
+    }
+    async getDatabaseInfo(connection) {
+        const neptuneConn = connection;
+        try {
+            // Neptune doesn't have a direct version query, use status endpoint
+            const response = await neptuneConn.executeQuery('g.V().limit(0)');
+            return {
+                version: 'Neptune',
+                edition: 'AWS Neptune',
+                features: ['gremlin', 'openCypher', 'sparql'],
+            };
+        }
+        catch (_a) {
+            return {
+                version: 'Unknown',
+                edition: 'AWS Neptune',
+                features: [],
+            };
+        }
+    }
+    // ==================== TRANSACTION METHODS ====================
+    async beginTransaction(connection, options) {
+        // Neptune has limited transaction support
+        return new NeptuneTransaction(connection);
+    }
+    async commitTransaction(connection, transaction) {
+        await transaction.commit();
+    }
+    async rollbackTransaction(connection, transaction) {
+        await transaction.rollback();
+    }
+    // ==================== RAW QUERY METHODS ====================
+    async executeRaw(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        try {
+            const response = await neptuneConn.executeQuery(options.query, options.params);
+            const data = this.parseQueryResponse(response, neptuneConn.getConfig().queryLanguage);
+            return {
+                success: true,
+                executionTime: Date.now() - startTime,
+                data: data,
+                count: data.length,
+            };
+        }
+        catch (error) {
+            throw this.wrapError(error, graph_types_1.GraphErrorType.QUERY_ERROR, `Query execution failed: ${error.message}`, options.query, options.params);
+        }
+    }
+    parseQueryResponse(response, language) {
+        if (language === graph_types_1.GraphQueryLanguage.GREMLIN) {
+            return this.parseGremlinResponse(response);
+        }
+        return this.parseOpenCypherResponse(response);
+    }
+    parseGremlinResponse(response) {
+        if (!response || !response.result)
+            return [];
+        const data = response.result.data;
+        if (!data || !data['@value'])
+            return [];
+        return data['@value'].map((item) => this.parseGremlinValue(item));
+    }
+    parseGremlinValue(value) {
+        if (!value)
+            return value;
+        if (value['@type']) {
+            const type = value['@type'];
+            const val = value['@value'];
+            switch (type) {
+                case 'g:Vertex':
+                    return this.parseGremlinVertex(val);
+                case 'g:Edge':
+                    return this.parseGremlinEdge(val);
+                case 'g:Path':
+                    return this.parseGremlinPath(val);
+                case 'g:Int64':
+                case 'g:Int32':
+                case 'g:Double':
+                case 'g:Float':
+                    return Number(val);
+                case 'g:List':
+                    return val.map((v) => this.parseGremlinValue(v));
+                case 'g:Map':
+                    return this.parseGremlinMap(val);
+                case 'g:Set':
+                    return val.map((v) => this.parseGremlinValue(v));
+                case 'g:UUID':
+                    return val;
+                case 'g:Date':
+                    return new Date(val);
+                default:
+                    return val;
+            }
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.parseGremlinValue(v));
+        }
+        if (typeof value === 'object') {
+            const result = {};
+            Object.entries(value).forEach(([k, v]) => {
+                result[k] = this.parseGremlinValue(v);
+            });
+            return result;
+        }
+        return value;
+    }
+    parseGremlinVertex(val) {
+        const properties = {};
+        if (val.properties) {
+            Object.entries(val.properties).forEach(([key, propArray]) => {
+                var _a, _b, _c;
+                if (Array.isArray(propArray) && propArray.length > 0) {
+                    properties[key] = ((_b = (_a = propArray[0]) === null || _a === void 0 ? void 0 : _a['@value']) === null || _b === void 0 ? void 0 : _b.value) || ((_c = propArray[0]) === null || _c === void 0 ? void 0 : _c.value);
+                }
+            });
+        }
+        return {
+            id: val.id,
+            labels: [val.label],
+            properties,
+        };
+    }
+    parseGremlinEdge(val) {
+        const properties = {};
+        if (val.properties) {
+            Object.entries(val.properties).forEach(([key, propVal]) => {
+                properties[key] = this.parseGremlinValue(propVal);
+            });
+        }
+        return {
+            id: val.id,
+            type: val.label,
+            startNodeId: val.outV,
+            endNodeId: val.inV,
+            properties,
+        };
+    }
+    parseGremlinPath(val) {
+        var _a;
+        const objects = ((_a = val.objects) === null || _a === void 0 ? void 0 : _a.map((obj) => this.parseGremlinValue(obj))) || [];
+        const nodes = [];
+        const relationships = [];
+        objects.forEach((obj) => {
+            if (obj.labels) {
+                nodes.push(obj);
+            }
+            else if (obj.type) {
+                relationships.push(obj);
+            }
+        });
+        return {
+            nodes,
+            relationships,
+            length: relationships.length,
+            start: nodes[0],
+            end: nodes[nodes.length - 1],
+        };
+    }
+    parseGremlinMap(val) {
+        const result = {};
+        for (let i = 0; i < val.length; i += 2) {
+            const key = this.parseGremlinValue(val[i]);
+            const value = this.parseGremlinValue(val[i + 1]);
+            result[key] = value;
+        }
+        return result;
+    }
+    parseOpenCypherResponse(response) {
+        if (!response || !response.results)
+            return [];
+        return response.results;
+    }
+    // ==================== NODE OPERATIONS ====================
+    async createNode(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const labels = this.normalizeLabels(options.labels);
+        let query;
+        let params = {};
+        if (isGremlin) {
+            // Gremlin addV query
+            const propsSteps = Object.entries(options.properties)
+                .map(([key, value]) => `.property('${key}', ${this.gremlinValue(value)})`)
+                .join('');
+            query = `g.addV('${labels[0]}')${propsSteps}`;
+        }
+        else {
+            // openCypher CREATE query
+            const labelStr = labels.map(l => this.escapeIdentifier(l)).join(':');
+            const propEntries = Object.entries(options.properties);
+            const propStr = propEntries.map(([k], i) => `${k}: $prop${i}`).join(', ');
+            propEntries.forEach(([, v], i) => { params[`prop${i}`] = v; });
+            query = `CREATE (n:${labelStr} {${propStr}}) RETURN n`;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            node: result.data.length > 0 ? this.parseNode(result.data[0]) : undefined,
+            created: true,
+        };
+    }
+    async findNodes(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            query = this.buildGremlinFindNodesQuery(options);
+        }
+        else {
+            query = this.buildCypherFindNodesQuery(options, params);
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const nodes = result.data.map(row => this.parseNode(isGremlin ? row : row.n || row));
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            nodes,
+            count: nodes.length,
+            hasMore: options.limit !== undefined && nodes.length === options.limit,
+        };
+    }
+    buildGremlinFindNodesQuery(options) {
+        let query = 'g.V()';
+        if (options.labels) {
+            const labels = this.normalizeLabels(options.labels);
+            query += `.hasLabel('${labels.join("', '")}')`;
+        }
+        if (options.properties) {
+            Object.entries(options.properties).forEach(([key, value]) => {
+                query += `.has('${key}', ${this.gremlinValue(value)})`;
+            });
+        }
+        if (options.orderBy && options.orderBy.length > 0) {
+            const orderSteps = options.orderBy.map(o => `by('${o.property}', ${o.direction === 'DESC' ? 'desc' : 'asc'})`).join('.');
+            query += `.order().${orderSteps}`;
+        }
+        if (options.skip) {
+            query += `.skip(${options.skip})`;
+        }
+        if (options.limit) {
+            query += `.limit(${options.limit})`;
+        }
+        return query;
+    }
+    buildCypherFindNodesQuery(options, params) {
+        const labels = options.labels ? this.normalizeLabels(options.labels) : [];
+        const labelStr = labels.length > 0 ? ':' + labels.map(l => this.escapeIdentifier(l)).join(':') : '';
+        let query = `MATCH (n${labelStr})`;
+        if (options.properties && Object.keys(options.properties).length > 0) {
+            const whereParts = [];
+            Object.entries(options.properties).forEach(([key, value], index) => {
+                const paramName = `prop_${index}`;
+                whereParts.push(`n.${key} = $${paramName}`);
+                params[paramName] = value;
+            });
+            query += ` WHERE ${whereParts.join(' AND ')}`;
+        }
+        query += ' RETURN n';
+        if (options.orderBy && options.orderBy.length > 0) {
+            const orderParts = options.orderBy.map(o => `n.${o.property} ${o.direction}`);
+            query += ` ORDER BY ${orderParts.join(', ')}`;
+        }
+        if (options.skip !== undefined) {
+            query += ` SKIP ${options.skip}`;
+        }
+        if (options.limit !== undefined) {
+            query += ` LIMIT ${options.limit}`;
+        }
+        return query;
+    }
+    async findNodeById(connection, id, transaction) {
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const query = isGremlin
+            ? `g.V('${id}')`
+            : `MATCH (n) WHERE id(n) = $id RETURN n`;
+        const result = await this.executeRaw(connection, { query, params: { id } }, transaction);
+        if (result.data.length === 0) {
+            return null;
+        }
+        return this.parseNode(isGremlin ? result.data[0] : result.data[0].n);
+    }
+    async updateNode(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            query = `g.V('${options.id}')`;
+            if (options.set) {
+                Object.entries(options.set).forEach(([key, value]) => {
+                    query += `.property('${key}', ${this.gremlinValue(value)})`;
+                });
+            }
+            if (options.remove && options.remove.length > 0) {
+                options.remove.forEach(prop => {
+                    query += `.properties('${prop}').drop()`;
+                });
+            }
+        }
+        else {
+            query = `MATCH (n) WHERE id(n) = $nodeId`;
+            params.nodeId = options.id;
+            const setParts = [];
+            if (options.set) {
+                Object.entries(options.set).forEach(([key, value], index) => {
+                    const paramName = `set_${index}`;
+                    setParts.push(`n.${key} = $${paramName}`);
+                    params[paramName] = value;
+                });
+            }
+            if (setParts.length > 0) {
+                query += ` SET ${setParts.join(', ')}`;
+            }
+            if (options.remove && options.remove.length > 0) {
+                query += ` REMOVE ${options.remove.map(p => `n.${p}`).join(', ')}`;
+            }
+            query += ' RETURN n';
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            node: result.data.length > 0 ? this.parseNode(isGremlin ? result.data[0] : result.data[0].n) : undefined,
+            updated: result.data.length > 0,
+            matchedCount: result.data.length,
+            modifiedCount: Object.keys(options.set || {}).length,
+        };
+    }
+    async deleteNode(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            if (options.id) {
+                query = `g.V('${options.id}').drop()`;
+            }
+            else if (options.labels) {
+                const labels = this.normalizeLabels(options.labels);
+                query = `g.V().hasLabel('${labels.join("', '")}').drop()`;
+            }
+            else {
+                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or labels for delete');
+            }
+        }
+        else {
+            if (options.id) {
+                query = `MATCH (n) WHERE id(n) = $nodeId ${options.detach ? 'DETACH DELETE' : 'DELETE'} n`;
+                params.nodeId = options.id;
+            }
+            else if (options.labels) {
+                const labels = this.normalizeLabels(options.labels);
+                query = `MATCH (n:${labels.join(':')}) ${options.detach ? 'DETACH DELETE' : 'DELETE'} n`;
+            }
+            else {
+                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or labels for delete');
+            }
+        }
+        await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            deletedCount: 1, // Neptune doesn't return count
+        };
+    }
+    async mergeNode(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const labels = this.normalizeLabels(options.labels);
+        let query;
+        const params = {};
+        if (isGremlin) {
+            // Gremlin coalesce pattern for merge
+            const matchProps = Object.entries(options.matchProperties)
+                .map(([k, v]) => `.has('${k}', ${this.gremlinValue(v)})`)
+                .join('');
+            const createProps = Object.entries(Object.assign(Object.assign({}, options.matchProperties), options.onCreate))
+                .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
+                .join('');
+            const updateProps = Object.entries(options.onMatch || {})
+                .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
+                .join('');
+            query = `g.V().hasLabel('${labels[0]}')${matchProps}.fold().coalesce(unfold()${updateProps}, addV('${labels[0]}')${createProps})`;
+        }
+        else {
+            // openCypher MERGE
+            const matchPropsStr = Object.entries(options.matchProperties)
+                .map(([k], i) => `${k}: $match${i}`)
+                .join(', ');
+            Object.entries(options.matchProperties).forEach(([, v], i) => { params[`match${i}`] = v; });
+            query = `MERGE (n:${labels.join(':')} {${matchPropsStr}})`;
+            if (options.onCreate && Object.keys(options.onCreate).length > 0) {
+                const createProps = Object.entries(options.onCreate)
+                    .map(([k], i) => `n.${k} = $create${i}`)
+                    .join(', ');
+                Object.entries(options.onCreate).forEach(([, v], i) => { params[`create${i}`] = v; });
+                query += ` ON CREATE SET ${createProps}`;
+            }
+            if (options.onMatch && Object.keys(options.onMatch).length > 0) {
+                const matchSetProps = Object.entries(options.onMatch)
+                    .map(([k], i) => `n.${k} = $update${i}`)
+                    .join(', ');
+                Object.entries(options.onMatch).forEach(([, v], i) => { params[`update${i}`] = v; });
+                query += ` ON MATCH SET ${matchSetProps}`;
+            }
+            query += ' RETURN n';
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            node: result.data.length > 0 ? this.parseNode(isGremlin ? result.data[0] : result.data[0].n) : undefined,
+            created: true, // Neptune doesn't distinguish
+            matched: false,
+        };
+    }
+    // ==================== RELATIONSHIP OPERATIONS ====================
+    async createRelationship(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            const fromId = options.fromNode.id;
+            const toId = options.toNode.id;
+            const propsSteps = options.properties
+                ? Object.entries(options.properties)
+                    .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
+                    .join('')
+                : '';
+            query = `g.V('${fromId}').addE('${options.type}').to(g.V('${toId}'))${propsSteps}`;
+        }
+        else {
+            const fromMatch = this.buildCypherNodeMatch(options.fromNode, 'from', params, 'from_');
+            const toMatch = this.buildCypherNodeMatch(options.toNode, 'to', params, 'to_');
+            let propsStr = '';
+            if (options.properties && Object.keys(options.properties).length > 0) {
+                propsStr = ' {' + Object.entries(options.properties)
+                    .map(([k], i) => { params[`rel${i}`] = options.properties[k]; return `${k}: $rel${i}`; })
+                    .join(', ') + '}';
+            }
+            query = `
+        MATCH ${fromMatch}, ${toMatch}
+        CREATE (from)-[r:${options.type}${propsStr}]->(to)
+        RETURN r
+      `;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            relationship: result.data.length > 0 ? this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r) : undefined,
+            created: true,
+        };
+    }
+    async findRelationships(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            query = 'g.E()';
+            if (options.type) {
+                const types = Array.isArray(options.type) ? options.type : [options.type];
+                query += `.hasLabel('${types.join("', '")}')`;
+            }
+            if (options.properties) {
+                Object.entries(options.properties).forEach(([k, v]) => {
+                    query += `.has('${k}', ${this.gremlinValue(v)})`;
+                });
+            }
+            if (options.limit) {
+                query += `.limit(${options.limit})`;
+            }
+        }
+        else {
+            let typeStr = '';
+            if (options.type) {
+                const types = Array.isArray(options.type) ? options.type : [options.type];
+                typeStr = ':' + types.join('|');
+            }
+            const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
+            const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
+                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
+            query = `MATCH ()-[r${typeStr}]->() RETURN r`;
+            if (options.limit) {
+                query += ` LIMIT ${options.limit}`;
+            }
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const relationships = result.data.map(row => this.parseRelationship(isGremlin ? row : row.r || row));
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            relationships,
+            count: relationships.length,
+            hasMore: options.limit !== undefined && relationships.length === options.limit,
+        };
+    }
+    async findRelationshipById(connection, id, transaction) {
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const query = isGremlin
+            ? `g.E('${id}')`
+            : `MATCH ()-[r]->() WHERE id(r) = $id RETURN r`;
+        const result = await this.executeRaw(connection, { query, params: { id } }, transaction);
+        if (result.data.length === 0) {
+            return null;
+        }
+        return this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r);
+    }
+    async updateRelationship(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            query = `g.E('${options.id}')`;
+            if (options.set) {
+                Object.entries(options.set).forEach(([k, v]) => {
+                    query += `.property('${k}', ${this.gremlinValue(v)})`;
+                });
+            }
+        }
+        else {
+            query = `MATCH ()-[r]->() WHERE id(r) = $relId`;
+            params.relId = options.id;
+            if (options.set && Object.keys(options.set).length > 0) {
+                const setParts = Object.entries(options.set).map(([k], i) => {
+                    params[`set${i}`] = options.set[k];
+                    return `r.${k} = $set${i}`;
+                });
+                query += ` SET ${setParts.join(', ')}`;
+            }
+            query += ' RETURN r';
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            relationship: result.data.length > 0 ? this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r) : undefined,
+            updated: result.data.length > 0,
+            matchedCount: result.data.length,
+            modifiedCount: Object.keys(options.set || {}).length,
+        };
+    }
+    async deleteRelationship(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            if (options.id) {
+                query = `g.E('${options.id}').drop()`;
+            }
+            else if (options.type) {
+                const types = Array.isArray(options.type) ? options.type : [options.type];
+                query = `g.E().hasLabel('${types.join("', '")}').drop()`;
+            }
+            else {
+                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or type for delete');
+            }
+        }
+        else {
+            if (options.id) {
+                query = `MATCH ()-[r]->() WHERE id(r) = $relId DELETE r`;
+                params.relId = options.id;
+            }
+            else if (options.type) {
+                const types = Array.isArray(options.type) ? options.type : [options.type];
+                query = `MATCH ()-[r:${types.join('|')}]->() DELETE r`;
+            }
+            else {
+                throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Must specify id or type for delete');
+            }
+        }
+        await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            deletedCount: 1,
+        };
+    }
+    async mergeRelationship(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            // Gremlin coalesce pattern for edge merge
+            const fromId = options.fromNode.id;
+            const toId = options.toNode.id;
+            const matchProps = options.matchProperties
+                ? Object.entries(options.matchProperties)
+                    .map(([k, v]) => `.has('${k}', ${this.gremlinValue(v)})`)
+                    .join('')
+                : '';
+            const createProps = Object.entries(Object.assign(Object.assign({}, options.matchProperties), options.onCreate))
+                .map(([k, v]) => `.property('${k}', ${this.gremlinValue(v)})`)
+                .join('');
+            query = `g.V('${fromId}').outE('${options.type}')${matchProps}.where(inV().hasId('${toId}')).fold().coalesce(unfold(), g.V('${fromId}').addE('${options.type}').to(g.V('${toId}'))${createProps})`;
+        }
+        else {
+            const fromMatch = this.buildCypherNodeMatch(options.fromNode, 'from', params, 'from_');
+            const toMatch = this.buildCypherNodeMatch(options.toNode, 'to', params, 'to_');
+            query = `
+        MATCH ${fromMatch}, ${toMatch}
+        MERGE (from)-[r:${options.type}]->(to)
+      `;
+            if (options.onCreate && Object.keys(options.onCreate).length > 0) {
+                const createProps = Object.entries(options.onCreate)
+                    .map(([k], i) => { params[`create${i}`] = options.onCreate[k]; return `r.${k} = $create${i}`; })
+                    .join(', ');
+                query += ` ON CREATE SET ${createProps}`;
+            }
+            if (options.onMatch && Object.keys(options.onMatch).length > 0) {
+                const matchSetProps = Object.entries(options.onMatch)
+                    .map(([k], i) => { params[`update${i}`] = options.onMatch[k]; return `r.${k} = $update${i}`; })
+                    .join(', ');
+                query += ` ON MATCH SET ${matchSetProps}`;
+            }
+            query += ' RETURN r';
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            relationship: result.data.length > 0 ? this.parseRelationship(isGremlin ? result.data[0] : result.data[0].r) : undefined,
+            created: true,
+            matched: false,
+        };
+    }
+    // ==================== PATH & TRAVERSAL OPERATIONS ====================
+    async traverse(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        const minDepth = options.minDepth || 1;
+        const maxDepth = options.maxDepth || 10;
+        if (isGremlin) {
+            const startId = options.startNode.id;
+            const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'in' :
+                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'out' : 'both';
+            query = `g.V('${startId}').repeat(${direction}()).times(${maxDepth}).emit().path()`;
+            if (options.limit) {
+                query += `.limit(${options.limit})`;
+            }
+        }
+        else {
+            const startMatch = this.buildCypherNodeMatch(options.startNode, 'start', params);
+            const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
+            const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
+                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
+            query = `
+        MATCH ${startMatch}
+        MATCH path = (start)${dirStart}[*${minDepth}..${maxDepth}]${dirEnd}(end)
+        RETURN path
+      `;
+            if (options.limit) {
+                query += ` LIMIT ${options.limit}`;
+            }
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const paths = result.data.map(row => this.parsePath(isGremlin ? row : row.path || row));
+        const nodesMap = new Map();
+        const relsMap = new Map();
+        paths.forEach(p => {
+            p.nodes.forEach(n => nodesMap.set(String(n.id), n));
+            p.relationships.forEach(r => relsMap.set(String(r.id), r));
+        });
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            paths: options.returnPaths ? paths : undefined,
+            nodes: options.returnNodes ? Array.from(nodesMap.values()) : undefined,
+            relationships: Array.from(relsMap.values()),
+            count: paths.length,
+        };
+    }
+    async shortestPath(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            const startId = options.startNode.id;
+            const endId = options.endNode.id;
+            const maxDepth = options.maxDepth || 10;
+            query = `g.V('${startId}').repeat(out().simplePath()).until(hasId('${endId}').or().loops().is(${maxDepth})).hasId('${endId}').path().limit(1)`;
+        }
+        else {
+            const startMatch = this.buildCypherNodeMatch(options.startNode, 'start', params);
+            const endMatch = this.buildCypherNodeMatch(options.endNode, 'end', params, 'end_');
+            const maxDepth = options.maxDepth ? `*..${options.maxDepth}` : '*';
+            query = `
+        MATCH ${startMatch}, ${endMatch}
+        MATCH path = shortestPath((start)-[${maxDepth}]-(end))
+        RETURN path
+      `;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        if (result.data.length === 0) {
+            return {
+                success: true,
+                executionTime: Date.now() - startTime,
+                found: false,
+            };
+        }
+        const path = this.parsePath(isGremlin ? result.data[0] : result.data[0].path);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            path,
+            found: true,
+            length: path.length,
+        };
+    }
+    async allPaths(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const minDepth = options.minDepth || 1;
+        const maxDepth = options.maxDepth || 10;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            const startId = options.startNode.id;
+            const endId = options.endNode.id;
+            query = `g.V('${startId}').repeat(out().simplePath()).until(hasId('${endId}').or().loops().is(${maxDepth})).hasId('${endId}').path()`;
+            if (options.limit) {
+                query += `.limit(${options.limit})`;
+            }
+        }
+        else {
+            const startMatch = this.buildCypherNodeMatch(options.startNode, 'start', params);
+            const endMatch = this.buildCypherNodeMatch(options.endNode, 'end', params, 'end_');
+            query = `
+        MATCH ${startMatch}, ${endMatch}
+        MATCH path = (start)-[*${minDepth}..${maxDepth}]-(end)
+        RETURN path
+      `;
+            if (options.limit) {
+                query += ` LIMIT ${options.limit}`;
+            }
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const paths = result.data.map(row => this.parsePath(isGremlin ? row : row.path || row));
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            paths,
+            count: paths.length,
+        };
+    }
+    async matchPattern(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        if (neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Pattern matching is better supported with openCypher. Consider using traverse() for Gremlin.');
+        }
+        // Build openCypher pattern query
+        const params = {};
+        const { pattern } = options;
+        const matchClauses = [];
+        pattern.nodes.forEach(node => {
+            const labels = node.labels
+                ? ':' + (Array.isArray(node.labels) ? node.labels : [node.labels]).join(':')
+                : '';
+            matchClauses.push(`(${node.variable}${labels})`);
+        });
+        let query = `MATCH ${matchClauses.join(', ')}`;
+        if (pattern.relationships.length > 0) {
+            pattern.relationships.forEach(rel => {
+                const typeStr = rel.type
+                    ? ':' + (Array.isArray(rel.type) ? rel.type : [rel.type]).join('|')
+                    : '';
+                query += `, (${rel.startNode})-[${rel.variable || ''}${typeStr}]->(${rel.endNode})`;
+            });
+        }
+        const returnVars = options.return || pattern.nodes.map(n => n.variable);
+        query += ` RETURN ${returnVars.join(', ')}`;
+        if (options.limit) {
+            query += ` LIMIT ${options.limit}`;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            matches: result.data,
+            count: result.data.length,
+            hasMore: options.limit !== undefined && result.data.length === options.limit,
+        };
+    }
+    async extractSubgraph(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const startNodes = Array.isArray(options.startNodes) ? options.startNodes : [options.startNodes];
+        const maxDepth = options.maxDepth || 3;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            const startIds = startNodes.map(n => `'${n.id}'`).join(', ');
+            query = `g.V(${startIds}).repeat(both().simplePath()).times(${maxDepth}).emit().dedup().fold().as('nodes').V(${startIds}).repeat(bothE().dedup().by(id).otherV().simplePath()).times(${maxDepth}).emit().dedup().fold().as('edges').select('nodes', 'edges')`;
+        }
+        else {
+            const startMatches = startNodes.map((node, idx) => this.buildCypherNodeMatch(node, `start${idx}`, params, `start${idx}_`));
+            query = `
+        MATCH ${startMatches.join(', ')}
+        WITH [${startNodes.map((_, i) => `start${i}`).join(', ')}] AS starts
+        UNWIND starts AS start
+        MATCH path = (start)-[*0..${maxDepth}]-(n)
+        WITH COLLECT(DISTINCT n) AS nodes, COLLECT(DISTINCT relationships(path)) AS rels
+        UNWIND rels AS relList
+        UNWIND relList AS r
+        RETURN nodes, COLLECT(DISTINCT r) AS relationships
+      `;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const nodes = [];
+        const relationships = [];
+        if (result.data.length > 0) {
+            const row = result.data[0];
+            if (row.nodes) {
+                row.nodes.forEach((n) => nodes.push(this.parseNode(n)));
+            }
+            if (row.relationships || row.edges) {
+                (row.relationships || row.edges).forEach((r) => relationships.push(this.parseRelationship(r)));
+            }
+        }
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            subgraph: {
+                nodes,
+                relationships,
+                nodeCount: nodes.length,
+                relationshipCount: relationships.length,
+            },
+        };
+    }
+    async getNeighborhood(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        const depth = options.depth || 1;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            const nodeId = options.node.id;
+            const direction = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? 'in' :
+                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? 'out' : 'both';
+            query = `g.V('${nodeId}').repeat(${direction}().simplePath()).times(${depth}).emit()${options.includeCenter ? '' : '.where(neq(V(\'' + nodeId + '\')))'}`;
+        }
+        else {
+            const centerMatch = this.buildCypherNodeMatch(options.node, 'center', params);
+            const dirStart = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '<-' : '-';
+            const dirEnd = options.direction === relationship_types_1.RelationshipDirection.INCOMING ? '-' :
+                options.direction === relationship_types_1.RelationshipDirection.OUTGOING ? '->' : '-';
+            query = `
+        MATCH ${centerMatch}
+        MATCH path = (center)${dirStart}[*0..${depth}]${dirEnd}(n)
+        WITH COLLECT(DISTINCT n) AS nodes, COLLECT(DISTINCT relationships(path)) AS rels
+        UNWIND rels AS relList
+        UNWIND relList AS r
+        RETURN nodes, COLLECT(DISTINCT r) AS relationships
+      `;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const nodes = [];
+        const relationships = [];
+        if (isGremlin) {
+            result.data.forEach((n) => nodes.push(this.parseNode(n)));
+        }
+        else if (result.data.length > 0) {
+            const row = result.data[0];
+            if (row.nodes) {
+                row.nodes.forEach((n) => nodes.push(this.parseNode(n)));
+            }
+            if (row.relationships) {
+                row.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
+            }
+        }
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            nodes,
+            relationships,
+            levels: new Map(), // Would need additional queries to populate
+        };
+    }
+    async findConnectedComponents(connection, options, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        // Neptune doesn't have built-in connected components
+        // This is a simplified implementation
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Connected components analysis requires Neptune Analytics or manual implementation');
+    }
+    // ==================== AGGREGATION OPERATIONS ====================
+    async countNodes(connection, labels, where, transaction) {
+        var _a;
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            query = 'g.V()';
+            if (labels) {
+                const labelArr = Array.isArray(labels) ? labels : [labels];
+                query += `.hasLabel('${labelArr.join("', '")}')`;
+            }
+            if (where) {
+                Object.entries(where).forEach(([k, v]) => {
+                    query += `.has('${k}', ${this.gremlinValue(v)})`;
+                });
+            }
+            query += '.count()';
+        }
+        else {
+            const labelStr = labels
+                ? ':' + (Array.isArray(labels) ? labels : [labels]).join(':')
+                : '';
+            query = `MATCH (n${labelStr})`;
+            if (where && Object.keys(where).length > 0) {
+                const whereParts = Object.entries(where).map(([k], i) => {
+                    params[`w${i}`] = where[k];
+                    return `n.${k} = $w${i}`;
+                });
+                query += ` WHERE ${whereParts.join(' AND ')}`;
+            }
+            query += ' RETURN count(n) AS count';
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const count = isGremlin
+            ? result.data[0] || 0
+            : ((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            count: Number(count),
+        };
+    }
+    async countRelationships(connection, type, where, transaction) {
+        var _a;
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let query;
+        const params = {};
+        if (isGremlin) {
+            query = 'g.E()';
+            if (type) {
+                const typeArr = Array.isArray(type) ? type : [type];
+                query += `.hasLabel('${typeArr.join("', '")}')`;
+            }
+            if (where) {
+                Object.entries(where).forEach(([k, v]) => {
+                    query += `.has('${k}', ${this.gremlinValue(v)})`;
+                });
+            }
+            query += '.count()';
+        }
+        else {
+            const typeStr = type
+                ? ':' + (Array.isArray(type) ? type : [type]).join('|')
+                : '';
+            query = `MATCH ()-[r${typeStr}]->() RETURN count(r) AS count`;
+        }
+        const result = await this.executeRaw(connection, { query, params }, transaction);
+        const count = isGremlin
+            ? result.data[0] || 0
+            : ((_a = result.data[0]) === null || _a === void 0 ? void 0 : _a.count) || 0;
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            count: Number(count),
+        };
+    }
+    async getStatistics(connection, transaction) {
+        const startTime = Date.now();
+        const neptuneConn = connection;
+        const isGremlin = neptuneConn.getConfig().queryLanguage === graph_types_1.GraphQueryLanguage.GREMLIN;
+        let nodeCount = 0;
+        let relationshipCount = 0;
+        if (isGremlin) {
+            const nodeResult = await this.executeRaw(connection, { query: 'g.V().count()' }, transaction);
+            nodeCount = nodeResult.data[0] || 0;
+            const relResult = await this.executeRaw(connection, { query: 'g.E().count()' }, transaction);
+            relationshipCount = relResult.data[0] || 0;
+        }
+        else {
+            const result = await this.executeRaw(connection, {
+                query: `
+            MATCH (n)
+            WITH count(n) AS nodeCount
+            MATCH ()-[r]->()
+            RETURN nodeCount, count(r) AS relCount
+          `,
+            }, transaction);
+            if (result.data.length > 0) {
+                nodeCount = result.data[0].nodeCount || 0;
+                relationshipCount = result.data[0].relCount || 0;
+            }
+        }
+        return {
+            success: true,
+            executionTime: Date.now() - startTime,
+            nodeCount: Number(nodeCount),
+            relationshipCount: Number(relationshipCount),
+            labelCounts: {},
+            relationshipTypeCounts: {},
+        };
+    }
+    // ==================== SEARCH OPERATIONS ====================
+    async fullTextSearch(connection, options, transaction) {
+        // Neptune doesn't have built-in full-text search
+        // Would need to use OpenSearch integration
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Full-text search requires Neptune integration with OpenSearch');
+    }
+    async vectorSearch(connection, options, transaction) {
+        // Neptune Analytics supports vector search
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Vector search requires Neptune Analytics');
+    }
+    // ==================== SCHEMA OPERATIONS ====================
+    // Note: Neptune has limited schema support compared to Neo4j
+    async createNodeConstraint(connection, constraint, transaction) {
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support explicit constraints');
+    }
+    async createRelationshipConstraint(connection, constraint, transaction) {
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support explicit constraints');
+    }
+    async dropConstraint(connection, name, transaction) {
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support explicit constraints');
+    }
+    async listConstraints(connection, transaction) {
+        return {
+            success: true,
+            executionTime: 0,
+            constraints: [],
+        };
+    }
+    async createNodeIndex(connection, index, transaction) {
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune automatically indexes all properties');
+    }
+    async createRelationshipIndex(connection, index, transaction) {
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune automatically indexes all properties');
+    }
+    async dropIndex(connection, name, transaction) {
+        throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.VALIDATION_ERROR, 'Neptune does not support dropping indexes');
+    }
+    async listIndexes(connection, transaction) {
+        return {
+            success: true,
+            executionTime: 0,
+            indexes: [],
+        };
+    }
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        return identifier.replace(/[^a-zA-Z0-9_]/g, '_');
+    }
+    escapeValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "\\'")}'`;
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value ? 'true' : 'false';
+        if (value instanceof Date)
+            return `datetime('${value.toISOString()}')`;
+        if (Array.isArray(value))
+            return `[${value.map(v => this.escapeValue(v)).join(', ')}]`;
+        return String(value);
+    }
+    buildWhereClause(where, variableName = 'n') {
+        const params = {};
+        const parts = [];
+        Object.entries(where).forEach(([key, value], index) => {
+            const paramName = `where_${index}`;
+            parts.push(`${variableName}.${key} = $${paramName}`);
+            params[paramName] = value;
+        });
+        return {
+            clause: parts.join(' AND '),
+            params,
+        };
+    }
+    // ==================== PROTECTED PARSER METHODS ====================
+    parseNode(nativeNode) {
+        if (!nativeNode) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.NODE_ERROR, 'Cannot parse null node');
+        }
+        // Already parsed
+        if (nativeNode.labels && nativeNode.properties !== undefined) {
+            return nativeNode;
+        }
+        return {
+            id: nativeNode.id || '',
+            labels: nativeNode.labels || [nativeNode.label] || [],
+            properties: (nativeNode.properties || nativeNode),
+        };
+    }
+    parseRelationship(nativeRelationship) {
+        if (!nativeRelationship) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.RELATIONSHIP_ERROR, 'Cannot parse null relationship');
+        }
+        // Already parsed
+        if (nativeRelationship.type && nativeRelationship.startNodeId !== undefined) {
+            return nativeRelationship;
+        }
+        return {
+            id: nativeRelationship.id || '',
+            type: nativeRelationship.type || nativeRelationship.label || '',
+            startNodeId: nativeRelationship.startNodeId || nativeRelationship.outV || '',
+            endNodeId: nativeRelationship.endNodeId || nativeRelationship.inV || '',
+            properties: (nativeRelationship.properties || nativeRelationship),
+        };
+    }
+    parsePath(nativePath) {
+        if (!nativePath) {
+            throw new graph_types_1.GraphError(graph_types_1.GraphErrorType.PATH_ERROR, 'Cannot parse null path');
+        }
+        // Already parsed
+        if (nativePath.nodes && nativePath.relationships !== undefined) {
+            return nativePath;
+        }
+        const nodes = [];
+        const relationships = [];
+        if (nativePath.objects) {
+            // Gremlin path
+            nativePath.objects.forEach((obj) => {
+                if (obj.labels || obj.label) {
+                    nodes.push(this.parseNode(obj));
+                }
+                else if (obj.type || obj.outV) {
+                    relationships.push(this.parseRelationship(obj));
+                }
+            });
+        }
+        else if (nativePath.nodes && nativePath.relationships) {
+            // Already structured
+            nativePath.nodes.forEach((n) => nodes.push(this.parseNode(n)));
+            nativePath.relationships.forEach((r) => relationships.push(this.parseRelationship(r)));
+        }
+        return {
+            nodes,
+            relationships,
+            length: relationships.length,
+            start: nodes[0],
+            end: nodes[nodes.length - 1],
+        };
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    normalizeLabels(labels) {
+        return Array.isArray(labels) ? labels : [labels];
+    }
+    gremlinValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "\\'")}'`;
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'boolean')
+            return value.toString();
+        if (value instanceof Date)
+            return `datetime('${value.toISOString()}')`;
+        if (Array.isArray(value))
+            return `[${value.map(v => this.gremlinValue(v)).join(', ')}]`;
+        return String(value);
+    }
+    buildCypherNodeMatch(ref, alias, params, prefix = '') {
+        let pattern = `(${alias}`;
+        if (ref.labels) {
+            const labels = this.normalizeLabels(ref.labels);
+            pattern += ':' + labels.join(':');
+        }
+        if (ref.id !== undefined) {
+            const paramName = `${prefix}id`;
+            params[paramName] = ref.id;
+            pattern += ` {id: $${paramName}}`;
+        }
+        else if (ref.properties && Object.keys(ref.properties).length > 0) {
+            const propParts = Object.entries(ref.properties).map(([k], i) => {
+                const paramName = `${prefix}prop${i}`;
+                params[paramName] = ref.properties[k];
+                return `${k}: $${paramName}`;
+            });
+            pattern += ` {${propParts.join(', ')}}`;
+        }
+        pattern += ')';
+        return pattern;
+    }
+}
+exports.NeptuneAdapter = NeptuneAdapter;
+exports.default = NeptuneAdapter;
+//# sourceMappingURL=neptune.adapter.js.map