grafio-mongo 1.0.0

package/src/index.ts

@@ -0,0 +1,4 @@
+// Re-export MongoDB implementations from grafio-mongo
+export { MongoStorageProvider } from './MongoStorageProvider';
+export type { MongoStorageProviderOptions } from './MongoStorageProvider';
+export { MongoGraphFactory } from './MongoGraphFactory';

package/tests/EducationGraph.mongo.test.ts

@@ -0,0 +1,33 @@
+import { afterAll, beforeAll, beforeEach, describe } from '@jest/globals';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { Graph } from 'grafio';
+import { MongoStorageProvider } from 'grafio';
+import { educationGraphData, runEducationGraphScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  client = new MongoClient(mongoServer.getUri());
+  await client.connect();
+  provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+  await provider.ensureIndexes();
+});
+
+beforeEach(async () => {
+  await provider.clear();
+});
+
+afterAll(async () => {
+  await client.close();
+  await mongoServer.stop();
+});
+
+describe('Education Graph (MongoDB)', () => {
+  runEducationGraphScenarios(async () => {
+    return await Graph.importJSON(educationGraphData, provider);
+  });
+});

package/tests/SocialGraph.mongo.test.ts

@@ -0,0 +1,30 @@
+import { afterAll, beforeAll, beforeEach, describe } from '@jest/globals';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from 'grafio';
+import { runSocialGraphScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+beforeAll(async () => {
+  mongoServer = await MongoMemoryServer.create();
+  client = new MongoClient(mongoServer.getUri());
+  await client.connect();
+  provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+  await provider.ensureIndexes();
+});
+
+beforeEach(async () => {
+  await provider.clear();
+});
+
+afterAll(async () => {
+  await client.close();
+  await mongoServer.stop();
+});
+
+describe('Facebook Social Graph (MongoDB)', () => {
+  runSocialGraphScenarios(provider);
+});

package/tests/graph/Graph.clear.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphClearScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphClearScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.edge.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphEdgeScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphEdgeScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.fromJSON.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphFromJSONScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphFromJSONScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.index.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphIndexScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphIndexScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.isDAG.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphIsDAGScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphIsDAGScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.node.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphNodeScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphNodeScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.properties.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphPropertiesScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphPropertiesScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.serialization.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphSerializationScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphSerializationScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.topologicalSort.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphTopologicalSortScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphTopologicalSortScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.transaction.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryReplSet } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphTransactionScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryReplSet;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphTransactionScenarios(
+  async () => {
+    mongoServer = await MongoMemoryReplSet.create({ replSet: { count: 2 } });
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'test-transactions' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/Graph.traverse.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphTraverseScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphTraverseScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/graph/GraphToMermaid.mongo.test.ts

@@ -0,0 +1,24 @@
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+import { MongoStorageProvider } from '../../src/MongoStorageProvider';
+import { runGraphToMermaidScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let provider: MongoStorageProvider;
+
+runGraphToMermaidScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    client = new MongoClient(mongoServer.getUri());
+    await client.connect();
+    provider = new MongoStorageProvider(client.db('test'), { graphId: 'default' });
+    await provider.ensureIndexes();
+    return provider;
+  },
+  async () => {},
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  }
+);

package/tests/storage/MongoGraphFactory.test.ts

@@ -0,0 +1,102 @@
+import { beforeAll, afterAll, beforeEach, describe, expect, it, test } from '@jest/globals';
+import { MongoMemoryServer } from 'mongodb-memory-server';
+import { MongoClient } from 'mongodb';
+
+import { MongoGraphFactory } from 'grafio';
+import { runGraphFactoryScenarios } from 'grafio/testing';
+
+let mongoServer: MongoMemoryServer;
+let client: MongoClient;
+let factory: MongoGraphFactory;
+
+runGraphFactoryScenarios(
+  async () => {
+    mongoServer = await MongoMemoryServer.create();
+    const uri = mongoServer.getUri();
+    client = new MongoClient(uri);
+    await client.connect();
+    factory = new MongoGraphFactory(client.db('test'));
+    await factory.ensureIndexes();
+    return factory;
+  },
+  async () => { },
+  async () => {
+    await client.close();
+    await mongoServer.stop();
+  },
+  async () => {
+    describe('MongoGraphFactory', () => {
+
+      it('should import graph data and return a Graph instance', async () => {
+        const data = {
+          nodes: [
+            { id: 'n1', type: 'Person', properties: { name: 'Alice' } },
+            { id: 'n2', type: 'Person', properties: { name: 'Bob' } },
+          ],
+          edges: [
+            { id: 'e1', sourceId: 'n1', targetId: 'n2', type: 'KNOWS', properties: {} },
+          ],
+        };
+
+        const graph = await factory.fromGraphData(data, 'import-test');
+
+        const nodes = await graph.getNodes();
+        expect(nodes).toHaveLength(2);
+        expect(nodes[0].properties.name).toBe('Alice');
+        expect(nodes[1].properties.name).toBe('Bob');
+
+        const edges = await graph.getEdges();
+        expect(edges).toHaveLength(1);
+        expect(edges[0].type).toBe('KNOWS');
+      });
+
+      it('should use default graphId when not specified', async () => {
+        const data = {
+          nodes: [
+            { id: 'n1', type: 'Person', properties: { name: 'Carol' } },
+          ],
+          edges: [],
+        };
+
+        const graph = await factory.fromGraphData(data);
+
+        const nodes = await graph.getNodes();
+        expect(nodes).toHaveLength(1);
+        expect(nodes[0].properties.name).toBe('Carol');
+      });
+
+      it('should filter out data when graphId does not match', async () => {
+        const data = {
+          graphId: 'other-graph',
+          nodes: [
+            { id: 'n1', type: 'Person', properties: { name: 'ShouldNotImport' } },
+          ],
+          edges: [],
+        };
+
+        const graph = await factory.fromGraphData(data, 'my-graph');
+
+        const nodes = await graph.getNodes();
+        expect(nodes).toHaveLength(0);
+      });
+
+      it('should import data when graphId matches', async () => {
+        const data = {
+          graphId: 'my-graph',
+          nodes: [
+            { id: 'n1', type: 'Person', properties: { name: 'ShouldImport' } },
+          ],
+          edges: [],
+        };
+
+        const graph = await factory.fromGraphData(data, 'my-graph');
+
+        const nodes = await graph.getNodes();
+        expect(nodes).toHaveLength(1);
+        expect(nodes[0].properties.name).toBe('ShouldImport');
+      });
+    });
+  },
+);
+
+

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "nodenext",
+    "isolatedModules": true,
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests", "examples"]
+}

package/tsconfig.perf.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "lib": ["ES2022"],
+    "outDir": "./dist-perf",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "types": ["node"]
+  },
+  "include": ["perf/**/*", "src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/tsconfig.prod.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": false,
+    "sourceMap": false,
+    "stripInternal": true,
+    "removeComments": true
+  },
+  "exclude": ["tests/**/*", "plans/**/*"]
+}