grafio-mongo 3.1.0 → 3.3.0

package/dist/MongoStorageProvider.d.ts

@@ -7,6 +7,10 @@ export interface QueryOptionsFilterProperty {
     AND?: QueryOptionsFilterProperty[];
     OR?: QueryOptionsFilterProperty[];
 }
+import { GraphError } from 'grafio/errors';
+export declare class IndexAlreadyExistsError extends GraphError {
+    constructor(indexName: string);
+}
 export interface MongoStorageProviderOptions {
     graphId?: string;
     nodesCollection?: string;
@@ -53,8 +57,19 @@ export declare class MongoStorageProvider implements IStorageProvider {
     deleteEdge(id: string, transaction?: ITransactionHandle): Promise<void>;
     exportJSON(): Promise<GraphData>;
     importJSON(data: GraphData): Promise<void>;
-    createIndex(target: 'node' | 'edge', propertyKey: string): Promise<void>;
-    hasIndex(target: 'node' | 'edge', propertyKey: string): Promise<boolean>;
+    createIndex(name: string, target: 'node' | 'edge', propertyKeys: string[]): Promise<void>;
+    hasIndex(target: 'node' | 'edge', propertyKeys: string[]): Promise<boolean>;
+    getIndex(name: string): Promise<{
+        name: string;
+        target: 'node' | 'edge';
+        propertyKeys: string[];
+    } | undefined>;
+    deleteIndex(name: string): Promise<void>;
+    getIndexes(): Promise<{
+        name: string;
+        target: 'node' | 'edge';
+        propertyKeys: string[];
+    }[]>;
     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>;

package/dist/MongoStorageProvider.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoStorageProvider = void 0;
+exports.MongoStorageProvider = exports.IndexAlreadyExistsError = void 0;
 const mongodb_1 = require("mongodb");
 const grafio_1 = require("grafio");
 const errors_1 = require("grafio/errors");
+class IndexAlreadyExistsError extends errors_1.GraphError {
+    constructor(indexName) {
+        super(`Index '${indexName}' already exists`);
+        this.name = 'IndexAlreadyExistsError';
+    }
+}
+exports.IndexAlreadyExistsError = IndexAlreadyExistsError;
 class MongoStorageProvider {
     _nodes;
     _edges;
@@ -35,6 +42,8 @@ class MongoStorageProvider {
         await this._edges.createIndex({ graphId: 1, targetId: 1, type: 1 }, { name: 'edge_graph_target_type' });
     }
     async clear() {
+        const indexes = await this.getIndexes();
+        await Promise.all(indexes.map(index => this.deleteIndex(index.name)));
         await Promise.all([
             this._nodes.deleteMany({ graphId: this._graphId }),
             this._edges.deleteMany({ graphId: this._graphId }),
@@ -373,42 +382,107 @@ class MongoStorageProvider {
             }
         }
     }
-    async createIndex(target, propertyKey) {
-        if (target === 'node') {
-            const indexFields = { graphId: 1, [`properties.${propertyKey}`]: 1 };
-            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
-            });
+    async createIndex(name, target, propertyKeys) {
+        const sortedPropertyKeys = [...propertyKeys].sort();
+        const metadataCollection = this._nodes.db.collection('grafio_index_metadata');
+        const existing = await metadataCollection.findOne({ name, graphId: this._graphId });
+        if (existing) {
+            throw new IndexAlreadyExistsError(name);
         }
-        else {
-            const indexFields = { graphId: 1, [`properties.${propertyKey}`]: 1 };
-            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
-            });
+        await metadataCollection.insertOne({
+            name,
+            graphId: this._graphId,
+            target,
+            propertyKeys: sortedPropertyKeys,
+            createdOn: Date.now()
+        });
+        for (const propertyKey of sortedPropertyKeys) {
+            if (target === 'node') {
+                const indexFields = { graphId: 1, [`properties.${propertyKey}`]: 1 };
+                await this._nodes.createIndex(indexFields, {
+                    name: `${name}_node_graphId_${propertyKey}`,
+                    background: true
+                });
+                await this._nodes.createIndex({ ...indexFields, type: 1 }, {
+                    name: `${name}_node_graphId_type_${propertyKey}`,
+                    background: true
+                });
+            }
+            else {
+                const indexFields = { graphId: 1, [`properties.${propertyKey}`]: 1 };
+                await this._edges.createIndex(indexFields, {
+                    name: `${name}_edge_graphId_${propertyKey}`,
+                    background: true
+                });
+                await this._edges.createIndex({ ...indexFields, type: 1 }, {
+                    name: `${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) {
+    async hasIndex(target, propertyKeys) {
+        const sortedPropertyKeys = [...propertyKeys].sort();
+        const metadataCollection = this._nodes.db.collection('grafio_index_metadata');
+        const cursor = metadataCollection.find({ graphId: this._graphId, target });
+        for await (const metadata of cursor) {
+            const indexPropertyKeys = metadata.propertyKeys;
+            const sortedIndexPropertyKeys = [...indexPropertyKeys].sort();
+            const hasAllKeys = sortedPropertyKeys.every(key => sortedIndexPropertyKeys.includes(key));
+            if (hasAllKeys) {
                 return true;
             }
         }
         return false;
     }
+    async getIndex(name) {
+        const metadataCollection = this._nodes.db.collection('grafio_index_metadata');
+        const metadata = await metadataCollection.findOne({ name, graphId: this._graphId });
+        if (!metadata) {
+            return undefined;
+        }
+        return {
+            name: metadata.name,
+            target: metadata.target,
+            propertyKeys: metadata.propertyKeys
+        };
+    }
+    async deleteIndex(name) {
+        const metadataCollection = this._nodes.db.collection('grafio_index_metadata');
+        const metadata = await metadataCollection.findOne({ name, graphId: this._graphId });
+        if (!metadata) {
+            throw new Error(`Index with name '${name}' does not exist`);
+        }
+        const target = metadata.target;
+        const propertyKeys = metadata.propertyKeys;
+        const collection = target === 'node' ? this._nodes : this._edges;
+        for (const propertyKey of propertyKeys) {
+            try {
+                await collection.dropIndex(`${name}_${target === 'node' ? 'node' : 'edge'}_graphId_${propertyKey}`);
+            }
+            catch {
+            }
+            try {
+                await collection.dropIndex(`${name}_${target === 'node' ? 'node' : 'edge'}_graphId_type_${propertyKey}`);
+            }
+            catch {
+            }
+        }
+        await metadataCollection.deleteOne({ name, graphId: this._graphId });
+    }
+    async getIndexes() {
+        const metadataCollection = this._nodes.db.collection('grafio_index_metadata');
+        const cursor = metadataCollection.find({ graphId: this._graphId });
+        const indexes = [];
+        for await (const metadata of cursor) {
+            indexes.push({
+                name: metadata.name,
+                target: metadata.target,
+                propertyKeys: metadata.propertyKeys
+            });
+        }
+        return indexes;
+    }
     async addProperty(target, id, key, value, transaction) {
         if (!(0, grafio_1.isPrimitive)(value)) {
             throw new errors_1.InvalidPropertyError(key, value);

package/package.json

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