grafio-mongo 1.0.1 → 1.1.0

package/README.md

@@ -157,7 +157,7 @@ try {
 
 ## Graph Operations
 
-All graph operations from grafio are available when using MongoDB storage. See the [grafio documentation](https://github.com/witspry/grafio) for the complete API reference.
+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
 

package/dist/MongoGraphFactory.d.ts

@@ -9,5 +9,6 @@ export declare class MongoGraphFactory implements IGraphFactory {
     ensureIndexes(): Promise<void>;
     forGraph(graphId?: string): Graph;
     fromGraphData(data: GraphData, graphId?: string): Promise<Graph>;
+    private _wrapWithCacheIfEnabled;
 }
 export {};

package/dist/MongoGraphFactory.js

@@ -15,19 +15,36 @@ class MongoGraphFactory {
         await probe.ensureIndexes();
     }
     forGraph(graphId = 'default') {
-        const provider = new MongoStorageProvider_1.MongoStorageProvider(this._db, { ...this._opts, graphId });
+        const mongoProvider = new MongoStorageProvider_1.MongoStorageProvider(this._db, { ...this._opts, graphId });
+        const provider = this._wrapWithCacheIfEnabled(mongoProvider, graphId);
         return new grafio_1.Graph(provider);
     }
     async fromGraphData(data, graphId = 'default') {
-        const provider = new MongoStorageProvider_1.MongoStorageProvider(this._db, { ...this._opts, graphId });
-        const graph = new grafio_1.Graph(provider);
+        const mongoProvider = new MongoStorageProvider_1.MongoStorageProvider(this._db, { ...this._opts, graphId });
+        const provider = this._wrapWithCacheIfEnabled(mongoProvider, graphId);
         const filteredData = {
             graphId,
             nodes: data.graphId === undefined || data.graphId === graphId ? data.nodes : [],
             edges: data.graphId === undefined || data.graphId === graphId ? data.edges : [],
         };
+        const graph = new grafio_1.Graph(provider);
         await grafio_1.Graph.importJSON(filteredData, provider);
         return graph;
     }
+    _wrapWithCacheIfEnabled(mongoProvider, graphId) {
+        if (!grafio_1.GraphManager.isInitialized()) {
+            return mongoProvider;
+        }
+        const manager = grafio_1.GraphManager.getInstance();
+        const cacheManager = manager.getCacheManager();
+        if (!cacheManager) {
+            return mongoProvider;
+        }
+        const cacheConfig = manager.getConfig()?.cache;
+        if (!cacheConfig) {
+            return mongoProvider;
+        }
+        return new grafio_1.CachedStorageProvider(mongoProvider, graphId, cacheManager, cacheConfig);
+    }
 }
 exports.MongoGraphFactory = MongoGraphFactory;

package/dist/MongoStorageProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Db } from 'mongodb';
-import { IStorageProvider, NodeData, ITransactionHandle, EdgeData, GraphData } from 'grafio';
+import { IStorageProvider, IOrderBy, NodeData, ITransactionHandle, EdgeData, GraphData } from 'grafio';
 export interface MongoStorageProviderOptions {
     graphId?: string;
     nodesCollection?: string;
@@ -19,7 +19,7 @@ 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, transaction?: ITransactionHandle): Promise<NodeData[]>;
+    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[]>;
     getEdgesByProperty(key: string, value: unknown, edgeType?: string, transaction?: ITransactionHandle): Promise<EdgeData[]>;
@@ -27,7 +27,7 @@ export declare class MongoStorageProvider implements IStorageProvider {
     deleteEdge(id: string, transaction?: ITransactionHandle): Promise<void>;
     hasEdge(id: string, transaction?: ITransactionHandle): Promise<boolean>;
     getEdge(id: string, transaction?: ITransactionHandle): Promise<EdgeData | undefined>;
-    getAllEdges(transaction?: ITransactionHandle): Promise<EdgeData[]>;
+    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[]>;

package/dist/MongoStorageProvider.js

@@ -39,12 +39,21 @@ class MongoStorageProvider {
         ]);
     }
     async insertNode(node, transaction) {
+        const now = Date.now();
+        if (node.createdOn === undefined) {
+            node.createdOn = now;
+        }
+        if (node.updatedOn === undefined) {
+            node.updatedOn = now;
+        }
         const session = transaction?.context;
         try {
             await this._nodes.insertOne({
                 id: node.id,
                 graphId: this._graphId,
                 type: node.type,
+                createdOn: node.createdOn,
+                updatedOn: node.updatedOn,
                 properties: node.properties,
             }, { session });
         }
@@ -68,10 +77,12 @@ class MongoStorageProvider {
         const doc = await this._nodes.findOne({ graphId: this._graphId, id }, { session });
         return doc ? this._docToNode(doc) : undefined;
     }
-    async getAllNodes(limit, transaction) {
+    async getAllNodes(limit, orderBy, 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);
         for await (const doc of cursor) {
@@ -109,6 +120,13 @@ class MongoStorageProvider {
         return docs.map(d => this._docToEdge(d));
     }
     async insertEdge(edge, transaction) {
+        const now = Date.now();
+        if (edge.createdOn === undefined) {
+            edge.createdOn = now;
+        }
+        if (edge.updatedOn === undefined) {
+            edge.updatedOn = now;
+        }
         const session = transaction?.context;
         try {
             await this._edges.insertOne({
@@ -117,6 +135,8 @@ class MongoStorageProvider {
                 sourceId: edge.sourceId,
                 targetId: edge.targetId,
                 type: edge.type,
+                createdOn: edge.createdOn,
+                updatedOn: edge.updatedOn,
                 properties: edge.properties,
             }, { session });
         }
@@ -140,10 +160,14 @@ class MongoStorageProvider {
         const doc = await this._edges.findOne({ graphId: this._graphId, id }, { session });
         return doc ? this._docToEdge(doc) : undefined;
     }
-    async getAllEdges(transaction) {
+    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));
         }
@@ -236,6 +260,8 @@ class MongoStorageProvider {
                 id: n.id,
                 graphId: this._graphId,
                 type: n.type,
+                createdOn: n.createdOn ?? Date.now(),
+                updatedOn: n.updatedOn ?? Date.now(),
                 properties: n.properties,
             }));
             for (let i = 0; i < nodeDocs.length; i += this._batchSize) {
@@ -249,6 +275,8 @@ class MongoStorageProvider {
                 sourceId: e.sourceId,
                 targetId: e.targetId,
                 type: e.type,
+                createdOn: e.createdOn ?? Date.now(),
+                updatedOn: e.updatedOn ?? Date.now(),
                 properties: e.properties,
             }));
             for (let i = 0; i < edgeDocs.length; i += this._batchSize) {
@@ -296,7 +324,7 @@ class MongoStorageProvider {
         }
         const session = transaction?.context;
         const collection = target === 'node' ? this._nodes : this._edges;
-        const result = await collection.updateOne({ graphId: this._graphId, id, [`properties.${key}`]: { $exists: false } }, { $set: { [`properties.${key}`]: value } }, { session });
+        const result = await collection.updateOne({ graphId: this._graphId, id, [`properties.${key}`]: { $exists: false } }, { $set: { [`properties.${key}`]: value, updatedOn: Date.now() } }, { session });
         if (result.matchedCount === 0) {
             const record = target === 'node' ? await this.getNode(id, transaction) : await this.getEdge(id, transaction);
             if (!record) {
@@ -311,7 +339,7 @@ class MongoStorageProvider {
         }
         const session = transaction?.context;
         const collection = target === 'node' ? this._nodes : this._edges;
-        const result = await collection.updateOne({ graphId: this._graphId, id, [`properties.${key}`]: { $exists: true } }, { $set: { [`properties.${key}`]: value } }, { session });
+        const result = await collection.updateOne({ graphId: this._graphId, id, [`properties.${key}`]: { $exists: true } }, { $set: { [`properties.${key}`]: value, updatedOn: Date.now() } }, { session });
         if (result.matchedCount === 0) {
             const record = target === 'node' ? await this.getNode(id, transaction) : await this.getEdge(id, transaction);
             if (!record) {
@@ -332,7 +360,7 @@ class MongoStorageProvider {
                 throw new errors_1.EdgeNotFoundError(id);
             }
         }
-        await collection.updateOne({ graphId: this._graphId, id }, { $unset: { [`properties.${key}`]: '' } }, { session });
+        await collection.updateOne({ graphId: this._graphId, id }, { $unset: { [`properties.${key}`]: '' }, $set: { updatedOn: Date.now() } }, { session });
     }
     async clearProperties(target, id, transaction) {
         const session = transaction?.context;
@@ -398,6 +426,8 @@ class MongoStorageProvider {
         return {
             id: doc.id,
             type: doc.type,
+            createdOn: doc.createdOn,
+            updatedOn: doc.updatedOn,
             properties: doc.properties,
         };
     }
@@ -407,6 +437,8 @@ class MongoStorageProvider {
             sourceId: doc.sourceId,
             targetId: doc.targetId,
             type: doc.type,
+            createdOn: doc.createdOn,
+            updatedOn: doc.updatedOn,
             properties: doc.properties,
         };
     }

package/dist/index.d.ts

@@ -1,3 +1,9 @@
 export { MongoStorageProvider } from './MongoStorageProvider';
 export type { MongoStorageProviderOptions } from './MongoStorageProvider';
 export { MongoGraphFactory } from './MongoGraphFactory';
+export { GraphManager } from 'grafio';
+export type { GraphManagerConfig, CacheConfig, CacheStats } from 'grafio';
+export { CachedStorageProvider, CacheManager } from 'grafio';
+export type { EvictionStrategy, PreloadStrategy, CacheStoreType } from 'grafio';
+export { InMemoryCache } from 'grafio';
+export type { ICacheProvider } from 'grafio';

package/dist/index.js

@@ -1,7 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoGraphFactory = exports.MongoStorageProvider = void 0;
+exports.InMemoryCache = exports.CacheManager = exports.CachedStorageProvider = exports.GraphManager = exports.MongoGraphFactory = exports.MongoStorageProvider = void 0;
 var MongoStorageProvider_1 = require("./MongoStorageProvider");
 Object.defineProperty(exports, "MongoStorageProvider", { enumerable: true, get: function () { return MongoStorageProvider_1.MongoStorageProvider; } });
 var MongoGraphFactory_1 = require("./MongoGraphFactory");
 Object.defineProperty(exports, "MongoGraphFactory", { enumerable: true, get: function () { return MongoGraphFactory_1.MongoGraphFactory; } });
+var grafio_1 = require("grafio");
+Object.defineProperty(exports, "GraphManager", { enumerable: true, get: function () { return grafio_1.GraphManager; } });
+var grafio_2 = require("grafio");
+Object.defineProperty(exports, "CachedStorageProvider", { enumerable: true, get: function () { return grafio_2.CachedStorageProvider; } });
+Object.defineProperty(exports, "CacheManager", { enumerable: true, get: function () { return grafio_2.CacheManager; } });
+var grafio_3 = require("grafio");
+Object.defineProperty(exports, "InMemoryCache", { enumerable: true, get: function () { return grafio_3.InMemoryCache; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grafio-mongo",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "MongoDB storage backend for grafio",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,13 +15,13 @@
   
   },
   "peerDependencies": {
-    "grafio": ">=6.0.6",
+    "grafio": ">=6.1.0",
     "mongodb": ">=5.0.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",
     "@types/node": "^25.6.0",
-    "grafio": "^6.0.6",
+    "grafio": "^6.1.0",
     "cross-env": "^10.1.0",
     "jest": "^29.5.0",
     "rimraf": "^5.0.0",