grafio-mongo 2.0.0 → 3.1.0

package/README.md

@@ -1,18 +1,15 @@
 # grafio-mongo
 
-MongoDB storage backend for [grafio](https://github.com/witspry/grafio) — a graph database with pluggable storage architecture.
+MongoDB storage backend for **grafio** — a graph database with pluggable storage architecture.
 
-## Overview
-
-This package provides the MongoDB storage provider for grafio, extracted from the core project. It enables **persistent storage** for grafio graphs using MongoDB (>= 5.0.0), with optimized indexes for nodes and edges and native transaction support.
+**Full documentation**: [https://satya-jugran.github.io/grafio](https://satya-jugran.github.io/grafio)
 
 ## Features
 
-- **MongoDB Backend** — Optional MongoDB backend (>= 5.0.0) with optimized indexes for nodes and edges
-- **Multiple Graph Support** — via `graphId` partitioning (isolated graphs in one MongoDB instance)
-- **Pluggable Storage** — implements the `IStorageProvider` interface from grafio
-- **Native Transactions** — MongoDB sessions for atomic multi-operation updates
-- **Graph Factories** — `MongoGraphFactory` for controlled instance creation
+- **MongoDB Backend** — Persistent storage with MongoDB (>= 5.0.0)
+- **Multiple Graphs** — via `graphId` partitioning
+- **Native Transactions** — Atomic multi-operation updates
+- **Optimized Indexes** — For nodes and edges
 
 ## Installation
 
@@ -26,262 +23,20 @@ npm install grafio-mongo
 import { MongoClient } from 'mongodb';
 import { MongoGraphFactory } from 'grafio-mongo';
 
-// Connect to MongoDB
 const client = new MongoClient('mongodb://localhost:27017');
 await client.connect();
 
 const factory = new MongoGraphFactory(client.db('mydb'));
-
-// Create indexes once at startup (idempotent — safe to call every time)
 await factory.ensureIndexes();
 
-// Get a graph scoped to a named partition
 const graph = factory.forGraph('my-graph');
+graph.addNode('Person', { name: 'Alice', age: 30 });
+graph.addNode('City', { name: 'New York' });
+graph.addEdge('LIVES_IN', 'alice', 'nyc', { since: 2020 });
 
-// Add nodes and edges
-const alice = await graph.addNode('Person', { name: 'Alice' });
-const bob   = await graph.addNode('Person', { name: 'Bob' });
-await graph.addEdge(alice.id, bob.id, 'KNOWS');
-
-// Navigate the graph
-const path = await graph.traverse(alice.id, bob.id, { edgeTypes: ['KNOWS'] });
-
-// Caller manages the MongoClient lifecycle
 await client.close();
 ```
 
-## MongoGraphFactory
-
-Factory class for creating MongoDB-backed Graph instances:
-
-```typescript
-import { MongoGraphFactory } from 'grafio-mongo';
-
-const factory = new MongoGraphFactory(db);
-await factory.ensureIndexes();
-
-const graph = factory.forGraph('my-graph');
-// or with custom options
-const graph2 = factory.forGraph('custom-graph', {
-  nodesCollection: 'my_nodes',  // default: 'sgdb_nodes'
-  edgesCollection: 'my_edges',  // default: 'sgdb_edges'
-});
-```
-
-### Factory Options
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `nodesCollection` | `string` | `'sgdb_nodes'` | Collection name for nodes |
-| `edgesCollection` | `string` | `'sgdb_edges'` | Collection name for edges |
-
-## Direct MongoStorageProvider Usage
-
-For fine-grained control over collection names and graph partitioning:
-
-```typescript
-import { MongoClient } from 'mongodb';
-import { Graph, MongoStorageProvider } from 'grafio-mongo';
-
-const client = new MongoClient('mongodb://localhost:27017');
-await client.connect();
-
-const provider = new MongoStorageProvider(client.db('mydb'), {
-  graphId: 'my-graph',          // default: 'default' — partitions data by graph id
-  nodesCollection: 'my_nodes',  // default: 'sgdb_nodes'
-  edgesCollection: 'my_edges',  // default: 'sgdb_edges'
-});
-
-await provider.ensureIndexes();
-
-const graph = new Graph(provider);
-```
-
-## Indexes
-
-The `ensureIndexes()` method creates the following indexes for optimized queries:
-
-### Nodes Collection
-
-| Index | Purpose |
-|-------|---------|
-| `{ graphId: 1, id: 1 }` unique | Fast node id lookups within a graph partition |
-| `{ graphId: 1, type: 1 }` | `getNodesByType()` within a graph partition |
-| `{ graphId: 1, properties: 1 }` | Property value lookups within a graph partition |
-
-### Edges Collection
-
-| Index | Purpose |
-|-------|---------|
-| `{ graphId: 1, id: 1 }` unique | Fast edge id lookups within a graph partition |
-| `{ graphId: 1, type: 1 }` | `getEdgesByType()` within a graph partition |
-| `{ graphId: 1, sourceId: 1, type: 1 }` | Outgoing adjacency queries |
-| `{ graphId: 1, targetId: 1, type: 1 }` | Incoming adjacency queries |
-
-## Transactions
-
-MongoDB storage provider supports native transactions via MongoDB sessions:
-
-```typescript
-import { Graph, GraphTransaction } from 'grafio';
-
-const graph = factory.forGraph('my-graph');
-const txn = graph.createTransaction();
-await txn.begin();
-
-try {
-  const alice = await graph.addNode('Person', { name: 'Alice' }, txn);
-  const bob = await graph.addNode('Person', { name: 'Bob' }, txn);
-  await graph.addEdge(alice.id, bob.id, 'KNOWS', {}, txn);
-  await txn.commit();
-} catch (error) {
-  if (txn.isActive()) {
-    await txn.rollback();
-  }
-  throw error;
-}
-```
-
-**Note:** MongoDB storage provider requires a replica set for transaction support.
-
-### Transaction Lifecycle
-
-- `begin()` — starts a new transaction
-- `commit()` — applies all changes atomically (throws if transaction failed)
-- `rollback()` — discards all changes
-- `isFailed()` — returns true if a storage operation failed within the transaction
-- `isActive()` — returns true if transaction is active and not failed
-
-## Cypher Query Language
-
-MongoDB-backed graphs support read-only openCypher-compatible queries via the `CypherEngine`:
-
-```typescript
-import { Graph } from 'grafio';
-import { CypherEngine } from 'grafio/cypher';
-
-const graph = factory.forGraph('my-graph');
-
-// Build your graph
-const alice = await graph.addNode('Person', { name: 'Alice', age: 30 });
-const bob   = await graph.addNode('Person', { name: 'Bob', age: 25 });
-await graph.addEdge(alice.id, bob.id, 'KNOWS', { since: 2020 });
-
-const engine = new CypherEngine(graph);
-
-// Scan nodes by type
-const result = await engine.query('MATCH (p:Person) RETURN p.name, p.age');
-
-// Filter with WHERE
-const adults = await engine.query(
-  'MATCH (p:Person) WHERE p.age > 25 RETURN p.name'
-);
-
-// Follow relationships
-const friends = await engine.query(
-  'MATCH (a:Person)-[:KNOWS]->(b:Person) RETURN a.name, b.name'
-);
-
-// Multi-hop traversal
-const network = await engine.query(
-  'MATCH (a:Person)-[:KNOWS*1..2]->(b:Person) RETURN DISTINCT a.name, b.name'
-);
-
-// Parameterized queries
-const byName = await engine.query(
-  'MATCH (p:Person {name: $name}) RETURN p',
-  { name: 'Alice' }
-);
-
-// Pagination
-const page = await engine.query(
-  'MATCH (p:Person) RETURN p ORDER BY p.age DESC SKIP 0 LIMIT 10'
-);
-```
-
-### Supported Clauses
-
-| Clause | Support | Notes |
-|--------|---------|-------|
-| `MATCH` | ✅ Read-only patterns | Typed/untyped nodes, directed edges, multi-label `(n:A\|B)`, inline property maps |
-| `WHERE` | ✅ Full expressions | `AND`/`OR`/`NOT`, comparisons, `IN`, `NOT IN`, `IS NULL`, `IS NOT NULL` |
-| `RETURN` | ✅ With `DISTINCT` | Property access, aliases with `AS` |
-| `ORDER BY` | ✅ ASC/DESC | Default ASC when omitted |
-| `SKIP` | ✅ Literal + `$param` | Evaluated at runtime |
-| `LIMIT` | ✅ Literal + `$param` | Evaluated at runtime |
-| `CREATE` / `DELETE` / `SET` / `REMOVE` / `MERGE` | ❌ Rejected | Validation gate prevents execution |
-
-### Variable-length Edge Syntax
-
-| Syntax | Meaning |
-|--------|---------|
-| `[*]` | Unbounded (up to 100 hops) |
-| `[*1..3]` | 1 to 3 hops (BFS by default) |
-| `[*2]` | Exactly 2 hops |
-| `[*..5]` | Up to 5 hops |
-
-> **Strategy selection**: BFS is used by default for multi-hop expansion. When `LIMIT` is present, DFS is selected automatically for better early-result performance.
-
-## Graph Operations
-
-All graph operations from grafio are available when using MongoDB storage. See the [grafio documentation](https://github.com/satyajugran/grafio) for the complete API reference.
-
-### Example Operations
-
-```typescript
-const graph = factory.forGraph('my-graph');
-
-// Node operations
-const alice = await graph.addNode('Person', { name: 'Alice', age: 30 });
-const bob = await graph.addNode('Person', { name: 'Bob' });
-await graph.addEdge(alice.id, bob.id, 'KNOWS');
-
-// Navigation
-const parents = await graph.getParents(bob.id);
-const children = await graph.getChildren(alice.id);
-
-// Traversal
-const path = await graph.traverse(alice.id, bob.id, { method: 'bfs' });
-
-// Type filtering
-const allPersons = await graph.getNodesByType('Person');
-
-// Property queries
-const adults = await graph.getNodesByProperty('age', 30);
-
-// DAG check and topological sort
-const isDag = await graph.isDAG();
-const order = await graph.topologicalSort();
-
-// Export/Import
-const data = await graph.exportJSON();
-await Graph.importJSON(data, new MongoStorageProvider(db, { graphId: 'restored' }));
-```
-
-## Development
-
-```bash
-# Install dependencies
-npm install
-
-# Build TypeScript
-npm run build
-
-# Run tests
-npm test
-
-# Run tests with coverage
-npm run test:coverage
-```
-
-## Testing
-
-The test suite runs against the MongoDB backend using `mongodb-memory-server` for integration testing.
-
-### Test Structure
+## License
 
-- `tests/graph/*.mongo.test.ts` — Graph operations via MongoDB provider
-- `tests/EducationGraph.mongo.test.ts` — Education domain graph via MongoDB
-- `tests/SocialGraph.mongo.test.ts` — Social network graph via MongoDB
-- `tests/storage/MongoGraphFactory.test.ts` — Factory lifecycle tests
-- `tests/storage/MongoStorageProvider.test.ts` — Provider unit tests
+GPL 3.0

package/dist/MongoStorageProvider.d.ts

@@ -1,5 +1,12 @@
 import type { Db } from 'mongodb';
-import { IStorageProvider, IOrderBy, NodeData, ITransactionHandle, EdgeData, GraphData } from 'grafio';
+import { IStorageProvider, NodeData, ITransactionHandle, EdgeData, GraphData, StorageQueryOptions } from 'grafio';
+export interface QueryOptionsFilterProperty {
+    key?: string;
+    value?: unknown;
+    op?: '=' | '<>' | '>' | '<' | '>=' | '<=' | 'CONTAINS' | 'STARTS_WITH' | 'ENDS_WITH' | 'IN' | 'NOT_IN' | 'IS_NULL' | 'IS_NOT_NULL';
+    AND?: QueryOptionsFilterProperty[];
+    OR?: QueryOptionsFilterProperty[];
+}
 export interface MongoStorageProviderOptions {
     graphId?: string;
     nodesCollection?: string;
@@ -19,23 +26,35 @@ export declare class MongoStorageProvider implements IStorageProvider {
     deleteNode(id: string, transaction?: ITransactionHandle): Promise<void>;
     hasNode(id: string, transaction?: ITransactionHandle): Promise<boolean>;
     getNode(id: string, transaction?: ITransactionHandle): Promise<NodeData | undefined>;
-    getAllNodes(limit?: number, orderBy?: IOrderBy, transaction?: ITransactionHandle): Promise<NodeData[]>;
-    getNodesByType(type: string, transaction?: ITransactionHandle): Promise<NodeData[]>;
-    getNodesByProperty(key: string, value: unknown, nodeType?: string, transaction?: ITransactionHandle): Promise<NodeData[]>;
-    getTotalNodeCount(transaction?: ITransactionHandle): Promise<number>;
-    getEdgesByProperty(key: string, value: unknown, edgeType?: string, transaction?: ITransactionHandle): Promise<EdgeData[]>;
-    getTotalEdgeCount(transaction?: ITransactionHandle): Promise<number>;
-    insertEdge(edge: EdgeData, transaction?: ITransactionHandle): Promise<void>;
-    deleteEdge(id: string, transaction?: ITransactionHandle): Promise<void>;
+    getNodesByIds(ids: string[], transaction?: ITransactionHandle): Promise<Map<string, NodeData>>;
+    getNodeCount(options?: StorageQueryOptions): Promise<number>;
+    aggregateNodeProperty(key: string, options?: StorageQueryOptions): Promise<{
+        count: number;
+        sum?: number;
+        avg?: number;
+        min?: number;
+        max?: number;
+    }>;
+    getNodes(options?: StorageQueryOptions): Promise<NodeData[]>;
     hasEdge(id: string, transaction?: ITransactionHandle): Promise<boolean>;
     getEdge(id: string, transaction?: ITransactionHandle): Promise<EdgeData | undefined>;
-    getAllEdges(limit?: number, orderBy?: IOrderBy, transaction?: ITransactionHandle): Promise<EdgeData[]>;
-    getEdgesByType(type: string, transaction?: ITransactionHandle): Promise<EdgeData[]>;
-    getEdgesBySource(nodeId: string, type?: string, transaction?: ITransactionHandle): Promise<EdgeData[]>;
-    getEdgesByTarget(nodeId: string, type?: string, transaction?: ITransactionHandle): Promise<EdgeData[]>;
+    getEdgeCount(options?: StorageQueryOptions): Promise<number>;
+    aggregateEdgeProperty(key: string, options?: StorageQueryOptions): Promise<{
+        count: number;
+        sum?: number;
+        avg?: number;
+        min?: number;
+        max?: number;
+    }>;
+    getEdges(options?: StorageQueryOptions): Promise<EdgeData[]>;
+    getEdgesBySource(nodeId: string, options?: StorageQueryOptions): Promise<EdgeData[]>;
+    getEdgesByTarget(nodeId: string, options?: StorageQueryOptions): Promise<EdgeData[]>;
+    insertEdge(edge: EdgeData, transaction?: ITransactionHandle): Promise<void>;
+    deleteEdge(id: string, transaction?: ITransactionHandle): Promise<void>;
     exportJSON(): Promise<GraphData>;
     importJSON(data: GraphData): Promise<void>;
-    createIndex(target: 'node' | 'edge', propertyKey: string, type?: string): Promise<void>;
+    createIndex(target: 'node' | 'edge', propertyKey: string): Promise<void>;
+    hasIndex(target: 'node' | 'edge', propertyKey: string): Promise<boolean>;
     addProperty(target: 'node' | 'edge', id: string, key: string, value: unknown, transaction?: ITransactionHandle): Promise<void>;
     updateProperty(target: 'node' | 'edge', id: string, key: string, value: unknown, transaction?: ITransactionHandle): Promise<void>;
     deleteProperty(target: 'node' | 'edge', id: string, key: string, transaction?: ITransactionHandle): Promise<void>;
@@ -44,6 +63,11 @@ export declare class MongoStorageProvider implements IStorageProvider {
     beginTransaction(): Promise<ITransactionHandle>;
     commitTransaction(handle: ITransactionHandle): Promise<void>;
     rollbackTransaction(handle: ITransactionHandle): Promise<void>;
+    private _buildNodeFilter;
+    private _buildEdgeFilter;
+    private _buildPropertyFilter;
+    private _buildSimplePropertyFilter;
+    private _escapeRegex;
     private _docToNode;
     private _docToEdge;
     private _isDuplicateKeyError;

package/dist/MongoStorageProvider.js

@@ -11,8 +11,8 @@ class MongoStorageProvider {
     _batchSize;
     _client = null;
     constructor(db, opts = {}) {
-        const nodesColl = opts.nodesCollection ?? 'sgdb_nodes';
-        const edgesColl = opts.edgesCollection ?? 'sgdb_edges';
+        const nodesColl = opts.nodesCollection ?? 'grafiodb_nodes';
+        const edgesColl = opts.edgesCollection ?? 'grafiodb_edges';
         this._nodes = db.collection(nodesColl);
         this._edges = db.collection(edgesColl);
         this._graphId = opts.graphId ?? 'default';
@@ -79,55 +79,178 @@ class MongoStorageProvider {
         const doc = await this._nodes.findOne({ graphId: this._graphId, id }, { session });
         return doc ? this._docToNode(doc) : undefined;
     }
-    async getAllNodes(limit, orderBy, transaction) {
+    async getNodesByIds(ids, transaction) {
         const session = transaction?.context;
-        const nodes = [];
-        const cursor = this._nodes.find({ graphId: this._graphId }, { session }).batchSize(this._batchSize);
-        if (orderBy)
-            cursor.sort(orderBy.field, orderBy.direction);
-        if (limit)
-            cursor.limit(limit);
+        const cursor = this._nodes.find({ graphId: this._graphId, id: { $in: ids } }, { session });
+        const nodes = new Map();
         for await (const doc of cursor) {
-            nodes.push(this._docToNode(doc));
+            nodes.set(doc.id, this._docToNode(doc));
         }
         return nodes;
     }
-    async getNodesByType(type, transaction) {
-        const session = transaction?.context;
-        const docs = await this._nodes.find({ graphId: this._graphId, type }, { session }).toArray();
-        return docs.map(d => this._docToNode(d));
+    async getNodeCount(options) {
+        const session = options?.transaction?.context;
+        const filter = this._buildNodeFilter(options);
+        return this._nodes.countDocuments(filter, { session });
     }
-    async getNodesByProperty(key, value, nodeType, transaction) {
-        const session = transaction?.context;
-        const filter = {
-            graphId: this._graphId,
-            [`properties.${key}`]: value,
+    async aggregateNodeProperty(key, options) {
+        const session = options?.transaction?.context;
+        const matchFilter = this._buildNodeFilter(options);
+        const propFilter = { $exists: true, $type: 'number' };
+        if (matchFilter.$and) {
+            matchFilter.$and.push({ [`properties.${key}`]: propFilter });
+        }
+        else {
+            matchFilter[`properties.${key}`] = propFilter;
+        }
+        const pipeline = [
+            { $match: matchFilter },
+            {
+                $group: {
+                    _id: null,
+                    count: { $sum: 1 },
+                    sum: { $sum: `$properties.${key}` },
+                    avg: { $avg: `$properties.${key}` },
+                    min: { $min: `$properties.${key}` },
+                    max: { $max: `$properties.${key}` },
+                },
+            },
+        ];
+        const result = await this._nodes.aggregate(pipeline, { session }).next();
+        if (!result) {
+            return { count: 0 };
+        }
+        return {
+            count: result.count,
+            sum: result.sum,
+            avg: result.avg,
+            min: result.min,
+            max: result.max,
         };
-        if (nodeType !== undefined) {
-            filter.type = nodeType;
+    }
+    async getNodes(options) {
+        const session = options?.transaction?.context;
+        const filter = this._buildNodeFilter(options);
+        const nodes = [];
+        const cursor = this._nodes.find(filter, { session }).batchSize(this._batchSize);
+        if (options?.orderBy) {
+            const { field, direction } = options.orderBy;
+            const sortField = field === 'createdOn' || field === 'updatedOn' ? field : `properties.${field}`;
+            cursor.sort(sortField, direction);
+        }
+        if (options?.limit) {
+            cursor.limit(options.limit);
         }
-        const docs = await this._nodes.find(filter, { session }).toArray();
-        return docs.map(d => this._docToNode(d));
+        for await (const doc of cursor) {
+            nodes.push(this._docToNode(doc));
+        }
+        return nodes;
     }
-    async getTotalNodeCount(transaction) {
+    async hasEdge(id, transaction) {
         const session = transaction?.context;
-        return this._nodes.countDocuments({ graphId: this._graphId }, { session });
+        const doc = await this._edges.findOne({ graphId: this._graphId, id }, { projection: { _id: 1 }, session });
+        return doc !== null;
     }
-    async getEdgesByProperty(key, value, edgeType, transaction) {
+    async getEdge(id, transaction) {
         const session = transaction?.context;
-        const filter = {
-            graphId: this._graphId,
-            [`properties.${key}`]: value,
+        const doc = await this._edges.findOne({ graphId: this._graphId, id }, { session });
+        return doc ? this._docToEdge(doc) : undefined;
+    }
+    async getEdgeCount(options) {
+        const session = options?.transaction?.context;
+        const filter = this._buildEdgeFilter(options);
+        return this._edges.countDocuments(filter, { session });
+    }
+    async aggregateEdgeProperty(key, options) {
+        const session = options?.transaction?.context;
+        const matchFilter = this._buildEdgeFilter(options);
+        const propFilter = { $exists: true, $type: 'number' };
+        if (matchFilter.$and) {
+            matchFilter.$and.push({ [`properties.${key}`]: propFilter });
+        }
+        else {
+            matchFilter[`properties.${key}`] = propFilter;
+        }
+        const pipeline = [
+            { $match: matchFilter },
+            {
+                $group: {
+                    _id: null,
+                    count: { $sum: 1 },
+                    sum: { $sum: `$properties.${key}` },
+                    avg: { $avg: `$properties.${key}` },
+                    min: { $min: `$properties.${key}` },
+                    max: { $max: `$properties.${key}` },
+                },
+            },
+        ];
+        const result = await this._edges.aggregate(pipeline, { session }).next();
+        if (!result) {
+            return { count: 0 };
+        }
+        return {
+            count: result.count,
+            sum: result.sum,
+            avg: result.avg,
+            min: result.min,
+            max: result.max,
         };
-        if (edgeType !== undefined) {
-            filter.type = edgeType;
+    }
+    async getEdges(options) {
+        const session = options?.transaction?.context;
+        const filter = this._buildEdgeFilter(options);
+        const edges = [];
+        const cursor = this._edges.find(filter, { session }).batchSize(this._batchSize);
+        if (options?.orderBy) {
+            const { field, direction } = options.orderBy;
+            const sortField = field === 'createdOn' || field === 'updatedOn' ? field : `properties.${field}`;
+            cursor.sort(sortField, direction);
         }
-        const docs = await this._edges.find(filter, { session }).toArray();
-        return docs.map(d => this._docToEdge(d));
+        if (options?.limit) {
+            cursor.limit(options.limit);
+        }
+        for await (const doc of cursor) {
+            edges.push(this._docToEdge(doc));
+        }
+        return edges;
     }
-    async getTotalEdgeCount(transaction) {
-        const session = transaction?.context;
-        return this._edges.countDocuments({ graphId: this._graphId }, { session });
+    async getEdgesBySource(nodeId, options) {
+        const session = options?.transaction?.context;
+        const baseFilter = { graphId: this._graphId, sourceId: nodeId };
+        const filter = this._buildEdgeFilter(options, baseFilter);
+        const edges = [];
+        const cursor = this._edges.find(filter, { session }).batchSize(this._batchSize);
+        if (options?.orderBy) {
+            const { field, direction } = options.orderBy;
+            const sortField = field === 'createdOn' || field === 'updatedOn' ? field : `properties.${field}`;
+            cursor.sort(sortField, direction);
+        }
+        if (options?.limit) {
+            cursor.limit(options.limit);
+        }
+        for await (const doc of cursor) {
+            edges.push(this._docToEdge(doc));
+        }
+        return edges;
+    }
+    async getEdgesByTarget(nodeId, options) {
+        const session = options?.transaction?.context;
+        const baseFilter = { graphId: this._graphId, targetId: nodeId };
+        const filter = this._buildEdgeFilter(options, baseFilter);
+        const edges = [];
+        const cursor = this._edges.find(filter, { session }).batchSize(this._batchSize);
+        if (options?.orderBy) {
+            const { field, direction } = options.orderBy;
+            const sortField = field === 'createdOn' || field === 'updatedOn' ? field : `properties.${field}`;
+            cursor.sort(sortField, direction);
+        }
+        if (options?.limit) {
+            cursor.limit(options.limit);
+        }
+        for await (const doc of cursor) {
+            edges.push(this._docToEdge(doc));
+        }
+        return edges;
     }
     async insertEdge(edge, transaction) {
         const now = Date.now();
@@ -160,50 +283,6 @@ class MongoStorageProvider {
         const session = transaction?.context;
         await this._edges.deleteOne({ graphId: this._graphId, id }, { session });
     }
-    async hasEdge(id, transaction) {
-        const session = transaction?.context;
-        const doc = await this._edges.findOne({ graphId: this._graphId, id }, { projection: { _id: 1 }, session });
-        return doc !== null;
-    }
-    async getEdge(id, transaction) {
-        const session = transaction?.context;
-        const doc = await this._edges.findOne({ graphId: this._graphId, id }, { session });
-        return doc ? this._docToEdge(doc) : undefined;
-    }
-    async getAllEdges(limit, orderBy, transaction) {
-        const session = transaction?.context;
-        const edges = [];
-        const cursor = this._edges.find({ graphId: this._graphId }, { session }).batchSize(this._batchSize);
-        if (orderBy)
-            cursor.sort(orderBy.field, orderBy.direction);
-        if (limit)
-            cursor.limit(limit);
-        for await (const doc of cursor) {
-            edges.push(this._docToEdge(doc));
-        }
-        return edges;
-    }
-    async getEdgesByType(type, transaction) {
-        const session = transaction?.context;
-        const docs = await this._edges.find({ graphId: this._graphId, type }, { session }).toArray();
-        return docs.map(d => this._docToEdge(d));
-    }
-    async getEdgesBySource(nodeId, type, transaction) {
-        const session = transaction?.context;
-        const filter = { graphId: this._graphId, sourceId: nodeId };
-        if (type)
-            filter.type = type;
-        const docs = await this._edges.find(filter, { session }).toArray();
-        return docs.map(d => this._docToEdge(d));
-    }
-    async getEdgesByTarget(nodeId, type, transaction) {
-        const session = transaction?.context;
-        const filter = { graphId: this._graphId, targetId: nodeId };
-        if (type)
-            filter.type = type;
-        const docs = await this._edges.find(filter, { session }).toArray();
-        return docs.map(d => this._docToEdge(d));
-    }
     async exportJSON() {
         const nodes = [];
         const edges = [];
@@ -294,39 +373,41 @@ class MongoStorageProvider {
             }
         }
     }
-    async createIndex(target, propertyKey, type) {
+    async createIndex(target, propertyKey) {
         if (target === 'node') {
             const indexFields = { graphId: 1, [`properties.${propertyKey}`]: 1 };
-            if (type && type !== '*') {
-                indexFields['type'] = 1;
-                await this._nodes.createIndex(indexFields, {
-                    name: `node_graphId_type_${propertyKey}`,
-                    background: true
-                });
-            }
-            else {
-                await this._nodes.createIndex(indexFields, {
-                    name: `node_graphId_${propertyKey}`,
-                    background: true
-                });
-            }
+            await this._nodes.createIndex(indexFields, {
+                name: `node_graphId_${propertyKey}`,
+                background: true
+            });
+            await this._nodes.createIndex({ ...indexFields, type: 1 }, {
+                name: `node_graphId_type_${propertyKey}`,
+                background: true
+            });
         }
         else {
             const indexFields = { graphId: 1, [`properties.${propertyKey}`]: 1 };
-            if (type && type !== '*') {
-                indexFields['type'] = 1;
-                await this._edges.createIndex(indexFields, {
-                    name: `edge_graphId_type_${propertyKey}`,
-                    background: true
-                });
-            }
-            else {
-                await this._edges.createIndex(indexFields, {
-                    name: `edge_graphId_${propertyKey}`,
-                    background: true
-                });
+            await this._edges.createIndex(indexFields, {
+                name: `edge_graphId_${propertyKey}`,
+                background: true
+            });
+            await this._edges.createIndex({ ...indexFields, type: 1 }, {
+                name: `edge_graphId_type_${propertyKey}`,
+                background: true
+            });
+        }
+    }
+    async hasIndex(target, propertyKey) {
+        const collection = target === 'node' ? this._nodes : this._edges;
+        const indexNameWithoutType = `${target === 'node' ? 'node' : 'edge'}_graphId_${propertyKey}`;
+        const indexNameWithType = `${target === 'node' ? 'node' : 'edge'}_graphId_type_${propertyKey}`;
+        for await (const index of collection.listIndexes()) {
+            const name = index.name;
+            if (name === indexNameWithoutType || name === indexNameWithType) {
+                return true;
             }
         }
+        return false;
     }
     async addProperty(target, id, key, value, transaction) {
         if (!(0, grafio_1.isPrimitive)(value)) {
@@ -432,6 +513,150 @@ class MongoStorageProvider {
             session.endSession();
         }
     }
+    _buildNodeFilter(options, baseFilter = {}) {
+        const filter = { graphId: this._graphId, ...baseFilter };
+        const andConditions = [];
+        if (options?.filter) {
+            if (options.filter.types && options.filter.types.length > 0) {
+                filter.type = { $in: options.filter.types };
+            }
+            if (options.filter.properties && options.filter.properties.length > 0) {
+                for (const prop of options.filter.properties) {
+                    const propFilter = this._buildPropertyFilter(prop);
+                    if (propFilter) {
+                        andConditions.push(propFilter);
+                    }
+                }
+            }
+        }
+        if (andConditions.length > 0) {
+            filter.$and = andConditions;
+        }
+        return filter;
+    }
+    _buildEdgeFilter(options, baseFilter = {}) {
+        const filter = { graphId: this._graphId, ...baseFilter };
+        const andConditions = [];
+        if (options?.filter) {
+            if (options.filter.types && options.filter.types.length > 0) {
+                filter.type = { $in: options.filter.types };
+            }
+            if (options.filter.properties && options.filter.properties.length > 0) {
+                for (const prop of options.filter.properties) {
+                    const propFilter = this._buildPropertyFilter(prop);
+                    if (propFilter) {
+                        andConditions.push(propFilter);
+                    }
+                }
+            }
+        }
+        if (andConditions.length > 0) {
+            filter.$and = andConditions;
+        }
+        return filter;
+    }
+    _buildPropertyFilter(prop) {
+        if (prop.AND && prop.AND.length > 0) {
+            const andFilters = [];
+            for (const subProp of prop.AND) {
+                const subFilter = this._buildPropertyFilter(subProp);
+                if (subFilter) {
+                    andFilters.push(subFilter);
+                }
+            }
+            if (andFilters.length > 0) {
+                return { $and: andFilters };
+            }
+            return undefined;
+        }
+        if (prop.OR && prop.OR.length > 0) {
+            const orFilters = [];
+            for (const subProp of prop.OR) {
+                const subFilter = this._buildPropertyFilter(subProp);
+                if (subFilter) {
+                    orFilters.push(subFilter);
+                }
+            }
+            if (orFilters.length > 0) {
+                return { $or: orFilters };
+            }
+            return undefined;
+        }
+        if (prop.key === undefined) {
+            return undefined;
+        }
+        const op = prop.op ?? '=';
+        const propPath = `properties.${prop.key}`;
+        switch (op) {
+            case '=':
+                return { [propPath]: prop.value };
+            case '<>':
+                return { [propPath]: { $ne: prop.value } };
+            case '>':
+                return { [propPath]: { $gt: prop.value } };
+            case '<':
+                return { [propPath]: { $lt: prop.value } };
+            case '>=':
+                return { [propPath]: { $gte: prop.value } };
+            case '<=':
+                return { [propPath]: { $lte: prop.value } };
+            case 'CONTAINS':
+                return { [propPath]: { $regex: String(prop.value), $options: 'i' } };
+            case 'STARTS_WITH':
+                return { [propPath]: { $regex: `^${this._escapeRegex(String(prop.value))}`, $options: 'i' } };
+            case 'ENDS_WITH':
+                return { [propPath]: { $regex: `${this._escapeRegex(String(prop.value))}$`, $options: 'i' } };
+            case 'IN':
+                return { [propPath]: { $in: Array.isArray(prop.value) ? prop.value : [prop.value] } };
+            case 'NOT_IN':
+                return { [propPath]: { $nin: Array.isArray(prop.value) ? prop.value : [prop.value] } };
+            case 'IS_NULL':
+                return { $or: [{ [propPath]: null }, { [propPath]: { $exists: false } }] };
+            case 'IS_NOT_NULL':
+                return { $and: [{ [propPath]: { $exists: true } }, { [propPath]: { $ne: null } }] };
+            default:
+                return { [propPath]: prop.value };
+        }
+    }
+    _buildSimplePropertyFilter(prop) {
+        if (prop.key === undefined) {
+            return undefined;
+        }
+        const op = prop.op ?? '=';
+        switch (op) {
+            case '=':
+                return prop.value;
+            case '<>':
+                return { $ne: prop.value };
+            case '>':
+                return { $gt: prop.value };
+            case '<':
+                return { $lt: prop.value };
+            case '>=':
+                return { $gte: prop.value };
+            case '<=':
+                return { $lte: prop.value };
+            case 'CONTAINS':
+                return { $regex: String(prop.value), $options: 'i' };
+            case 'STARTS_WITH':
+                return { $regex: `^${this._escapeRegex(String(prop.value))}`, $options: 'i' };
+            case 'ENDS_WITH':
+                return { $regex: `${this._escapeRegex(String(prop.value))}$`, $options: 'i' };
+            case 'IN':
+                return { $in: Array.isArray(prop.value) ? prop.value : [prop.value] };
+            case 'NOT_IN':
+                return { $nin: Array.isArray(prop.value) ? prop.value : [prop.value] };
+            case 'IS_NULL':
+                return { $or: [{ [prop.key]: null }, { [prop.key]: { $exists: false } }] };
+            case 'IS_NOT_NULL':
+                return { $and: [{ [prop.key]: { $exists: true } }, { [prop.key]: { $ne: null } }] };
+            default:
+                return prop.value;
+        }
+    }
+    _escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
     _docToNode(doc) {
         return {
             id: doc.id,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafio-mongo",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "description": "MongoDB storage backend for grafio",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   },
   "peerDependencies": {},
   "dependencies": {
-    "grafio": ">=6.0.0",
+    "grafio": ">=7.1.0",
     "mongodb": ">=5.0.0"
   },
   "devDependencies": {