@ductape/sdk 0.0.4-v51 → 0.0.4-v53

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

@@ -1,37 +1,63 @@
 "use strict";
 /**
- * Base Graph Database Adapter
- * Abstract class defining the interface for all graph database adapters
+ * Base Graph Adapter
+ *
+ * Abstract base class defining the interface for all graph database adapters.
+ * Each adapter implementation must extend this class and implement all abstract methods.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseGraphAdapter = void 0;
-const graph_types_1 = require("../types/graph.types");
 /**
  * Abstract base class for graph database adapters
- * All specific database adapters (Neo4j, Neptune, ArangoDB, Memgraph) extend this class
  */
 class BaseGraphAdapter {
+    constructor() {
+        /** Underlying client instance */
+        this.client = null;
+        /** Whether currently connected */
+        this.connected = false;
+        /** Current connection URL */
+        this.connectionUrl = '';
+    }
     /**
-     * Execute a callback within a transaction (auto-commit on success, rollback on error)
+     * Check if connected
      */
-    async executeTransaction(connection, callback, options) {
-        const transaction = await this.beginTransaction(connection, options);
-        try {
-            const result = await callback(transaction);
-            await this.commitTransaction(connection, transaction);
-            return result;
-        }
-        catch (error) {
-            await this.rollbackTransaction(connection, transaction);
-            throw error;
-        }
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get the graph type
+     */
+    getGraphType() {
+        return this.graphType;
+    }
+    /**
+     * Check if a feature is supported
+     */
+    supportsFeature(feature) {
+        return this.supportedFeatures.has(feature);
+    }
+    /**
+     * Get all supported features
+     */
+    getSupportedFeatures() {
+        return Array.from(this.supportedFeatures);
     }
-    // ==================== ERROR HANDLING ====================
+    // ==================== UTILITY METHODS ====================
     /**
-     * Wrap database-specific errors in GraphError
+     * Get the underlying client
      */
-    wrapError(error, type, message, query, params) {
-        return new graph_types_1.GraphError(type, message, error, query, params);
+    getClient() {
+        return this.client;
+    }
+    /**
+     * Ensure the adapter is connected before performing operations
+     * @throws GraphError if not connected
+     */
+    ensureConnected() {
+        if (!this.connected) {
+            throw new Error('Not connected to the graph database. Call connect() first.');
+        }
     }
 }
 exports.BaseGraphAdapter = BaseGraphAdapter;

package/dist/graph/adapters/base.adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.adapter.js","sourceRoot":"","sources":["../../../src/graph/adapters/base.adapter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,sDAQ8B;AAmF9B;;;GAGG;AACH,MAAsB,gBAAgB;IAoEpC;;OAEG;IACH,KAAK,CAAC,kBAAkB,CACtB,UAA4B,EAC5B,QAAwD,EACxD,OAAkC;QAElC,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QAErE,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC3C,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YACtD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YACxD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAmXD,2DAA2D;IAE3D;;OAEG;IACO,SAAS,CACjB,KAAU,EACV,IAAoB,EACpB,OAAe,EACf,KAAc,EACd,MAA4B;QAE5B,OAAO,IAAI,wBAAU,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;CACF;AAvdD,4CAudC"}
+{"version":3,"file":"base.adapter.js","sourceRoot":"","sources":["../../../src/graph/adapters/base.adapter.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAqGH;;GAEG;AACH,MAAsB,gBAAgB;IAAtC;QAIE,iCAAiC;QACvB,WAAM,GAAQ,IAAI,CAAC;QAE7B,kCAAkC;QACxB,cAAS,GAAY,KAAK,CAAC;QAErC,6BAA6B;QACnB,kBAAa,GAAW,EAAE,CAAC;IA6WvC,CAAC;IAvVC;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,OAAqB;QACnC,OAAO,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;IAED;;OAEG;IACH,oBAAoB;QAClB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC5C,CAAC;IAiSD,4DAA4D;IAE5D;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;;OAGG;IACO,eAAe;QACvB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACpB,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;QAChF,CAAC;IACH,CAAC;CAWF;AAxXD,4CAwXC"}

package/dist/graph/adapters/index.d.ts

@@ -1,10 +1,11 @@
 /**
- * Graph Adapters Index
- * Re-exports all graph database adapters
+ * Graph Adapters Module
+ *
+ * Exports all graph database adapters and factory
  */
-export { BaseGraphAdapter } from './base.adapter';
+export { BaseGraphAdapter, IAdapterConnectionOptions } from './base.adapter';
 export { Neo4jAdapter } from './neo4j.adapter';
 export { NeptuneAdapter } from './neptune.adapter';
 export { ArangoDBAdapter } from './arangodb.adapter';
 export { MemgraphAdapter } from './memgraph.adapter';
-export { Neo4jAdapter as default } from './neo4j.adapter';
+export { GraphAdapterFactory } from './adapter.factory';

package/dist/graph/adapters/index.js

@@ -1,14 +1,13 @@
 "use strict";
 /**
- * Graph Adapters Index
- * Re-exports all graph database adapters
+ * Graph Adapters Module
+ *
+ * Exports all graph database adapters and factory
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = exports.MemgraphAdapter = exports.ArangoDBAdapter = exports.NeptuneAdapter = exports.Neo4jAdapter = exports.BaseGraphAdapter = void 0;
-// Base adapter
+exports.GraphAdapterFactory = exports.MemgraphAdapter = exports.ArangoDBAdapter = exports.NeptuneAdapter = exports.Neo4jAdapter = exports.BaseGraphAdapter = void 0;
 var base_adapter_1 = require("./base.adapter");
 Object.defineProperty(exports, "BaseGraphAdapter", { enumerable: true, get: function () { return base_adapter_1.BaseGraphAdapter; } });
-// Database-specific adapters
 var neo4j_adapter_1 = require("./neo4j.adapter");
 Object.defineProperty(exports, "Neo4jAdapter", { enumerable: true, get: function () { return neo4j_adapter_1.Neo4jAdapter; } });
 var neptune_adapter_1 = require("./neptune.adapter");
@@ -17,7 +16,6 @@ var arangodb_adapter_1 = require("./arangodb.adapter");
 Object.defineProperty(exports, "ArangoDBAdapter", { enumerable: true, get: function () { return arangodb_adapter_1.ArangoDBAdapter; } });
 var memgraph_adapter_1 = require("./memgraph.adapter");
 Object.defineProperty(exports, "MemgraphAdapter", { enumerable: true, get: function () { return memgraph_adapter_1.MemgraphAdapter; } });
-// Default exports for convenience
-var neo4j_adapter_2 = require("./neo4j.adapter");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return neo4j_adapter_2.Neo4jAdapter; } });
+var adapter_factory_1 = require("./adapter.factory");
+Object.defineProperty(exports, "GraphAdapterFactory", { enumerable: true, get: function () { return adapter_factory_1.GraphAdapterFactory; } });
 //# sourceMappingURL=index.js.map

package/dist/graph/adapters/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/graph/adapters/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,eAAe;AACf,+CAAkD;AAAzC,gHAAA,gBAAgB,OAAA;AAEzB,6BAA6B;AAC7B,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AACrB,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AACvB,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AACxB,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AAExB,kCAAkC;AAClC,iDAA0D;AAAjD,wGAAA,YAAY,OAAW"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/graph/adapters/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEH,+CAA6E;AAApE,gHAAA,gBAAgB,OAAA;AACzB,iDAA+C;AAAtC,6GAAA,YAAY,OAAA;AACrB,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AACvB,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AACxB,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AACxB,qDAAwD;AAA/C,sHAAA,mBAAmB,OAAA"}

package/dist/graph/adapters/memgraph.adapter.d.ts

@@ -1,85 +1,110 @@
 /**
  * Memgraph Graph Database Adapter
- * Implements the BaseGraphAdapter for Memgraph using Cypher query language
- * Memgraph is Cypher-compatible and uses the Bolt protocol similar to Neo4j
+ *
+ * Implements the BaseGraphAdapter for Memgraph.
+ * Memgraph is a high-performance, in-memory graph database
+ * that is fully compatible with Neo4j's Bolt protocol and Cypher query language.
+ *
+ * Key features:
+ * - Cypher query language compatibility
+ * - Bolt protocol support
+ * - In-memory performance
+ * - Triggers and streams support
+ * - MAGE graph algorithms library
  */
-import { BaseGraphAdapter } from './base.adapter';
-import { GraphDatabaseType, GraphQueryLanguage, IGraphConnection, IGraphTransaction, IGraphTransactionOptions } from '../types/graph.types';
-import { GraphConnectionConfig, IGraphConnectionTestResult } from '../types/connection.types';
-import { INode, NodeProperties, ICreateNodeOptions, IFindNodesOptions, IUpdateNodeOptions, IDeleteNodeOptions, IMergeNodeOptions, INodeConstraint, INodeIndex } from '../types/node.types';
-import { IRelationship, RelationshipProperties, ICreateRelationshipOptions, IFindRelationshipsOptions, IUpdateRelationshipOptions, IDeleteRelationshipOptions, IMergeRelationshipOptions, IRelationshipConstraint, IRelationshipIndex } from '../types/relationship.types';
-import { IPath, ITraverseOptions, IShortestPathOptions, IAllPathsOptions, IMatchPatternOptions, ISubgraphOptions, INeighborhoodOptions, IConnectedComponentsOptions } from '../types/path.types';
-import { IRawQueryOptions, IFullTextSearchOptions, IVectorSearchOptions } from '../types/query.types';
-import { IGraphQueryResult, ICreateNodeResult, IFindNodesResult, IUpdateNodeResult, IDeleteNodeResult, IMergeNodeResult, ICreateRelationshipResult, IFindRelationshipsResult, IUpdateRelationshipResult, IDeleteRelationshipResult, IMergeRelationshipResult, ITraverseResult, IShortestPathResult, IAllPathsResult, IPatternMatchResult, ISubgraphResult, INeighborhoodResult, IConnectedComponentsResult, ICountResult, ICreateConstraintResult, IDropConstraintResult, IListConstraintsResult, ICreateIndexResult, IDropIndexResult, IListIndexesResult, IFullTextSearchResult, IVectorSearchResult, IGraphStatisticsResult } from '../types/result.types';
+import { BaseGraphAdapter, IAdapterConnectionOptions } from './base.adapter';
+import { GraphType, GraphFeature } from '../types/enums';
+import { IGraphConnectionResult, IGraphTestConnectionResult } from '../types/connection.interface';
+import { ICreateNodeOptions, ICreateNodeResult, IFindNodesOptions, IFindNodesResult, IUpdateNodeOptions, IUpdateNodeResult, IDeleteNodeOptions, IDeleteNodeResult, IMergeNodeOptions, IMergeNodeResult, INode, IAddLabelsOptions, IAddLabelsResult, IRemoveLabelsOptions, IRemoveLabelsResult, ISetLabelsOptions, ISetLabelsResult } from '../types/node.interface';
+import { ICreateRelationshipOptions, ICreateRelationshipResult, IFindRelationshipsOptions, IFindRelationshipsResult, IUpdateRelationshipOptions, IUpdateRelationshipResult, IDeleteRelationshipOptions, IDeleteRelationshipResult, IMergeRelationshipOptions, IMergeRelationshipResult, IRelationship, ICreateRelationshipIndexOptions } from '../types/relationship.interface';
+import { ITraverseOptions, ITraverseResult, IShortestPathOptions, IShortestPathResult, IAllPathsOptions, IAllPathsResult, INeighborhoodOptions, INeighborhoodResult, IConnectedComponentsOptions, IConnectedComponentsResult } from '../types/traversal.interface';
+import { IGraphTransaction, IGraphTransactionOptions } from '../types/transaction.interface';
+import { IRawQueryOptions, IRawQueryResult, ICountNodesResult, ICountRelationshipsResult, IGraphStatistics, IFullTextSearchOptions, IFullTextSearchResult, IVectorSearchOptions, IVectorSearchResult, IGraphWhereClause } from '../types/query.interface';
+import { ICreateNodeIndexOptions, ICreateNodeConstraintOptions, IListIndexesResult, IListConstraintsResult, ICreateIndexResult, ICreateConstraintResult, IDropIndexResult, IDropConstraintResult, IListLabelsResult, IListRelationshipTypesResult } from '../types/schema.interface';
 /**
- * Memgraph Graph Database Adapter
+ * Memgraph adapter - Cypher-compatible graph database
+ * Uses the neo4j-driver package as Memgraph supports the Bolt protocol
  */
 export declare class MemgraphAdapter extends BaseGraphAdapter {
-    readonly type = GraphDatabaseType.MEMGRAPH;
-    readonly supportedLanguages: GraphQueryLanguage[];
-    readonly defaultLanguage = GraphQueryLanguage.CYPHER;
-    connect(config: GraphConnectionConfig): Promise<IGraphConnection>;
-    disconnect(connection: IGraphConnection): Promise<void>;
-    testConnection(connection: IGraphConnection): Promise<IGraphConnectionTestResult>;
-    getDatabaseInfo(connection: IGraphConnection): Promise<{
-        version: string;
-        edition?: string;
-        features?: string[];
-    }>;
-    beginTransaction(connection: IGraphConnection, options?: IGraphTransactionOptions): Promise<IGraphTransaction>;
-    commitTransaction(connection: IGraphConnection, transaction: IGraphTransaction): Promise<void>;
-    rollbackTransaction(connection: IGraphConnection, transaction: IGraphTransaction): Promise<void>;
-    executeRaw<T = any>(connection: IGraphConnection, options: IRawQueryOptions, transaction?: IGraphTransaction): Promise<IGraphQueryResult<T>>;
-    createNode<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: ICreateNodeOptions<T>, transaction?: IGraphTransaction): Promise<ICreateNodeResult<T>>;
-    findNodes<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: IFindNodesOptions, transaction?: IGraphTransaction): Promise<IFindNodesResult<T>>;
-    findNodeById<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, id: string | number, transaction?: IGraphTransaction): Promise<INode<T> | null>;
-    updateNode<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: IUpdateNodeOptions, transaction?: IGraphTransaction): Promise<IUpdateNodeResult<T>>;
-    deleteNode(connection: IGraphConnection, options: IDeleteNodeOptions, transaction?: IGraphTransaction): Promise<IDeleteNodeResult>;
-    mergeNode<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: IMergeNodeOptions<T>, transaction?: IGraphTransaction): Promise<IMergeNodeResult<T>>;
-    createRelationship<T extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: ICreateRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<ICreateRelationshipResult<T>>;
-    findRelationships<T extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: IFindRelationshipsOptions, transaction?: IGraphTransaction): Promise<IFindRelationshipsResult<T>>;
-    findRelationshipById<T extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, id: string | number, transaction?: IGraphTransaction): Promise<IRelationship<T> | null>;
-    updateRelationship<T extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: IUpdateRelationshipOptions, transaction?: IGraphTransaction): Promise<IUpdateRelationshipResult<T>>;
-    deleteRelationship(connection: IGraphConnection, options: IDeleteRelationshipOptions, transaction?: IGraphTransaction): Promise<IDeleteRelationshipResult>;
-    mergeRelationship<T extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: IMergeRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<IMergeRelationshipResult<T>>;
-    traverse<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: ITraverseOptions, transaction?: IGraphTransaction): Promise<ITraverseResult<N, R>>;
-    shortestPath<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: IShortestPathOptions, transaction?: IGraphTransaction): Promise<IShortestPathResult<N, R>>;
-    allPaths<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: IAllPathsOptions, transaction?: IGraphTransaction): Promise<IAllPathsResult<N, R>>;
-    matchPattern(connection: IGraphConnection, options: IMatchPatternOptions, transaction?: IGraphTransaction): Promise<IPatternMatchResult>;
-    extractSubgraph<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: ISubgraphOptions, transaction?: IGraphTransaction): Promise<ISubgraphResult<N, R>>;
-    getNeighborhood<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties>(connection: IGraphConnection, options: INeighborhoodOptions, transaction?: IGraphTransaction): Promise<INeighborhoodResult<N, R>>;
-    findConnectedComponents<N extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: IConnectedComponentsOptions, transaction?: IGraphTransaction): Promise<IConnectedComponentsResult<N>>;
-    countNodes(connection: IGraphConnection, labels?: string | string[], where?: Record<string, any>, transaction?: IGraphTransaction): Promise<ICountResult>;
-    countRelationships(connection: IGraphConnection, type?: string | string[], where?: Record<string, any>, transaction?: IGraphTransaction): Promise<ICountResult>;
-    getStatistics(connection: IGraphConnection, transaction?: IGraphTransaction): Promise<IGraphStatisticsResult>;
-    fullTextSearch<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: IFullTextSearchOptions, transaction?: IGraphTransaction): Promise<IFullTextSearchResult<T>>;
-    vectorSearch<T extends NodeProperties = NodeProperties>(connection: IGraphConnection, options: IVectorSearchOptions, transaction?: IGraphTransaction): Promise<IVectorSearchResult<T>>;
-    createNodeConstraint(connection: IGraphConnection, constraint: INodeConstraint, transaction?: IGraphTransaction): Promise<ICreateConstraintResult>;
-    createRelationshipConstraint(connection: IGraphConnection, constraint: IRelationshipConstraint, transaction?: IGraphTransaction): Promise<ICreateConstraintResult>;
-    dropConstraint(connection: IGraphConnection, name: string, transaction?: IGraphTransaction): Promise<IDropConstraintResult>;
-    listConstraints(connection: IGraphConnection, transaction?: IGraphTransaction): Promise<IListConstraintsResult>;
-    createNodeIndex(connection: IGraphConnection, index: INodeIndex, transaction?: IGraphTransaction): Promise<ICreateIndexResult>;
-    createRelationshipIndex(connection: IGraphConnection, index: IRelationshipIndex, transaction?: IGraphTransaction): Promise<ICreateIndexResult>;
-    dropIndex(connection: IGraphConnection, name: string, transaction?: IGraphTransaction): Promise<IDropIndexResult>;
-    listIndexes(connection: IGraphConnection, transaction?: IGraphTransaction): Promise<IListIndexesResult>;
-    escapeIdentifier(identifier: string): string;
-    escapeValue(value: any): string;
-    buildWhereClause(where: Record<string, any>, variableName?: string): {
+    protected readonly graphType = GraphType.MEMGRAPH;
+    protected readonly supportedFeatures: Set<GraphFeature>;
+    private driver;
+    private session;
+    connect(options: IAdapterConnectionOptions): Promise<IGraphConnectionResult>;
+    testConnection(options: IAdapterConnectionOptions): Promise<IGraphTestConnectionResult>;
+    disconnect(): Promise<void>;
+    private getSession;
+    createNode<T = any>(options: ICreateNodeOptions<T>, transaction?: IGraphTransaction): Promise<ICreateNodeResult<T>>;
+    findNodes<T = any>(options: IFindNodesOptions, transaction?: IGraphTransaction): Promise<IFindNodesResult<T>>;
+    findNodeById<T = any>(id: string | number, transaction?: IGraphTransaction): Promise<INode<T> | null>;
+    updateNode<T = any>(options: IUpdateNodeOptions<T>, transaction?: IGraphTransaction): Promise<IUpdateNodeResult<T>>;
+    deleteNode(options: IDeleteNodeOptions, transaction?: IGraphTransaction): Promise<IDeleteNodeResult>;
+    mergeNode<T = any>(options: IMergeNodeOptions<T>, transaction?: IGraphTransaction): Promise<IMergeNodeResult<T>>;
+    addLabels<T = any>(options: IAddLabelsOptions, transaction?: IGraphTransaction): Promise<IAddLabelsResult<T>>;
+    removeLabels<T = any>(options: IRemoveLabelsOptions, transaction?: IGraphTransaction): Promise<IRemoveLabelsResult<T>>;
+    setLabels<T = any>(options: ISetLabelsOptions, transaction?: IGraphTransaction): Promise<ISetLabelsResult<T>>;
+    createRelationship<T = any>(options: ICreateRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<ICreateRelationshipResult<T>>;
+    findRelationships<T = any>(options: IFindRelationshipsOptions, transaction?: IGraphTransaction): Promise<IFindRelationshipsResult<T>>;
+    findRelationshipById<T = any>(id: string | number, transaction?: IGraphTransaction): Promise<IRelationship<T> | null>;
+    updateRelationship<T = any>(options: IUpdateRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<IUpdateRelationshipResult<T>>;
+    deleteRelationship(options: IDeleteRelationshipOptions, transaction?: IGraphTransaction): Promise<IDeleteRelationshipResult>;
+    mergeRelationship<T = any>(options: IMergeRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<IMergeRelationshipResult<T>>;
+    traverse<TNode = any, TRel = any>(options: ITraverseOptions, transaction?: IGraphTransaction): Promise<ITraverseResult<TNode, TRel>>;
+    shortestPath<TNode = any, TRel = any>(options: IShortestPathOptions, transaction?: IGraphTransaction): Promise<IShortestPathResult<TNode, TRel>>;
+    allPaths<TNode = any, TRel = any>(options: IAllPathsOptions, transaction?: IGraphTransaction): Promise<IAllPathsResult<TNode, TRel>>;
+    getNeighborhood<TNode = any, TRel = any>(options: INeighborhoodOptions, transaction?: IGraphTransaction): Promise<INeighborhoodResult<TNode, TRel>>;
+    findConnectedComponents<TNode = any>(options: IConnectedComponentsOptions, transaction?: IGraphTransaction): Promise<IConnectedComponentsResult<TNode>>;
+    countNodes(labels?: string[], where?: IGraphWhereClause, transaction?: IGraphTransaction): Promise<ICountNodesResult>;
+    countRelationships(types?: string[], where?: IGraphWhereClause, transaction?: IGraphTransaction): Promise<ICountRelationshipsResult>;
+    getStatistics(transaction?: IGraphTransaction): Promise<IGraphStatistics>;
+    fullTextSearch<T = any>(options: IFullTextSearchOptions, transaction?: IGraphTransaction): Promise<IFullTextSearchResult<T>>;
+    vectorSearch<T = any>(_options: IVectorSearchOptions, _transaction?: IGraphTransaction): Promise<IVectorSearchResult<T>>;
+    query<T = any>(options: IRawQueryOptions, transaction?: IGraphTransaction): Promise<IRawQueryResult<T>>;
+    createNodeIndex(options: ICreateNodeIndexOptions): Promise<ICreateIndexResult>;
+    createNodeConstraint(options: ICreateNodeConstraintOptions): Promise<ICreateConstraintResult>;
+    createRelationshipIndex(options: ICreateRelationshipIndexOptions): Promise<ICreateIndexResult>;
+    listIndexes(): Promise<IListIndexesResult>;
+    listConstraints(): Promise<IListConstraintsResult>;
+    dropIndex(name: string): Promise<IDropIndexResult>;
+    dropConstraint(name: string): Promise<IDropConstraintResult>;
+    listLabels(): Promise<IListLabelsResult>;
+    listRelationshipTypes(): Promise<IListRelationshipTypesResult>;
+    beginTransaction(_options?: IGraphTransactionOptions): Promise<IGraphTransaction>;
+    commitTransaction(transaction: IGraphTransaction): Promise<void>;
+    rollbackTransaction(transaction: IGraphTransaction): Promise<void>;
+    /**
+     * Create a trigger in Memgraph
+     */
+    createTrigger(name: string, event: 'CREATE' | 'UPDATE' | 'DELETE', target: 'NODE' | 'RELATIONSHIP', procedure: string): Promise<void>;
+    /**
+     * Drop a trigger in Memgraph
+     */
+    dropTrigger(name: string): Promise<void>;
+    /**
+     * List all triggers in Memgraph
+     */
+    listTriggers(): Promise<Array<{
+        name: string;
+        statement: string;
+    }>>;
+    /**
+     * Create a stream consumer in Memgraph
+     */
+    createStream(name: string, type: 'KAFKA' | 'PULSAR', topics: string[], transformationProcedure: string, config: Record<string, any>): Promise<void>;
+    /**
+     * Run a MAGE algorithm (if installed)
+     */
+    runMageAlgorithm<T = any>(algorithm: string, params?: Record<string, any>): Promise<T[]>;
+    protected buildWhereClause(where: IGraphWhereClause, alias?: string): {
         clause: string;
         params: Record<string, any>;
     };
-    protected parseNode<T extends NodeProperties = NodeProperties>(nativeNode: any): INode<T>;
-    protected parseRelationship<T extends RelationshipProperties = RelationshipProperties>(nativeRelationship: any): IRelationship<T>;
-    protected parsePath<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties>(nativePath: any): IPath<N, R>;
-    private convertValue;
+    parseError(error: unknown): Error;
+    private mapMemgraphNode;
+    private mapMemgraphRelationship;
+    private mapMemgraphPath;
     private convertProperties;
+    private convertValue;
     private toNumber;
-    private normalizeLabels;
-    private buildPropertiesClause;
-    private buildNodeReference;
-    private buildWhereFromClause;
-    private buildWhereCondition;
-    private buildNodeSelectorMatch;
-    private parseStatistics;
+    private getDirectionArrow;
 }
-export default MemgraphAdapter;