Move biolink, caching to utils

__test__/unittest/biolink.test.ts

@@ -0,0 +1,72 @@
+import { biolink } from '../../src/biolink';
+
+describe('Test BioLinkModel class', () => {
+  test('test reverse with correct predicate', () => {
+    const res = biolink.reverse('treats');
+    expect(res).toBe('treated_by');
+  });
+
+  test('test reverse with correct predicate if it contains underscore', () => {
+    const res = biolink.reverse('treated_by');
+    expect(res).toBe('treats');
+  });
+
+  test('test reverse with predicate having symmetric equal to true', () => {
+    const res = biolink.reverse('correlated_with');
+    expect(res).toBe('correlated_with');
+  });
+
+  test('test predicate with no inverse property and symmetric not equal to true', () => {
+    const res = biolink.reverse('has_phenotype');
+    expect(res).toBe('phenotype_of');
+  });
+
+  test('test predicate not exist in biolink model', () => {
+    const res = biolink.reverse('haha');
+    expect(res).toBeUndefined();
+  });
+
+  test('if input not string, return undefined', () => {
+    //@ts-expect-error: Explicitly testing for wrong type
+    const res = biolink.reverse(['dd']);
+    expect(res).toBeUndefined();
+  });
+
+  describe('Test getDescendants function', () => {
+    test('if input is in biolink model, return all its desendants and itself', () => {
+      const res = biolink.getDescendantClasses('MolecularEntity');
+      expect(res).toContain('SmallMolecule');
+      expect(res).toContain('NucleicAcidEntity');
+      expect(res).toContain('MolecularEntity');
+    });
+
+    test("if input is in biolink model but doesn't have descendants, return itself", () => {
+      const res = biolink.getDescendantClasses('Gene');
+      expect(res).toEqual(['Gene']);
+    });
+
+    test('if input is not in biolink, return itself', () => {
+      const res = biolink.getDescendantClasses('Gene1');
+      expect(res).toEqual('Gene1');
+    });
+  });
+
+  describe('Test getDescendantPredicates function', () => {
+    test('if input is in biolink model, return all its desendants and itself', () => {
+      const res = biolink.getDescendantPredicates('related_to');
+      expect(res).toContain('subclass_of');
+      expect(res).toContain('superclass_of');
+      expect(res).toContain('related_to');
+    });
+
+    test("if input is in biolink model but doesn't have descendants, return itself", () => {
+      const res = biolink.getDescendantPredicates('subclass_of');
+      expect(res).toEqual(['subclass_of']);
+    });
+
+    test('if input is not in biolink, return itself', () => {
+      const res = biolink.getDescendantPredicates('Gene1');
+      expect(res).toEqual(['Gene1']);
+    });
+  });
+});

package.json

@@ -58,6 +58,7 @@
     "ioredis": "^5.3.2",
     "ioredis-mock": "^8.9.0",
     "lodash": "^4.17.21",
-    "redlock": "5.0.0-beta.2"
+    "redlock": "5.0.0-beta.2",
+    "biolink-model": "workspace:*"
   }
 }

src/biolink.ts

@@ -0,0 +1,74 @@
+import { BioLink } from 'biolink-model';
+import Debug from 'debug';
+const debug = Debug('bte:biothings-explorer-trapi:EdgeReverse');
+
+class BioLinkModel {
+  biolink: BioLink;
+  constructor() {
+    this.biolink = new BioLink();
+    this.biolink.loadSync();
+  }
+
+  reverse(predicate: string) {
+    if (typeof predicate === 'string') {
+      if (predicate in this.biolink.slotTree.objects) {
+        if (this.biolink.slotTree.objects[predicate].symmetric === true) {
+          return predicate;
+        }
+        return this.biolink.slotTree.objects[predicate].inverse;
+      }
+    }
+
+    return undefined;
+  }
+
+  getAncestorClasses(className: string): string | string[] {
+    if (className in this.biolink.classTree.objects) {
+      const ancestors = this.biolink.classTree.getAncestors(className).map((entity) => entity.name);
+      return [...ancestors, ...[className]];
+    }
+    return className;
+  }
+
+  getAncestorPredicates(predicate: string): string | string[] {
+    if (predicate in this.biolink.slotTree.objects) {
+      const ancestors = this.biolink.slotTree.getAncestors(predicate).map((entity) => entity.name);
+      return [...ancestors, ...[predicate]];
+    }
+    return predicate;
+  }
+
+  getDescendantClasses(className: string): string | string[] {
+    if (className in this.biolink.classTree.objects) {
+      const descendants = this.biolink.classTree.getDescendants(className).map((entity) => entity.name);
+      return [...descendants, ...[className]];
+    }
+    return className;
+  }
+
+  getDescendantPredicates(predicate: string): string[] {
+    if (predicate in this.biolink.slotTree.objects) {
+      const descendants = this.biolink.slotTree.getDescendants(predicate).map((entity) => entity.name);
+      return [...descendants, ...[predicate]];
+    }
+    return [predicate];
+  }
+
+  getDescendantQualifiers(qualifier: string): string[] {
+    try {
+      const descendants = this.biolink.enumTree.getDescendants(qualifier).map((entity) => entity.name);
+      return [...descendants, qualifier];
+    } catch (e) {
+      console.log('qual error', e);
+      return [qualifier];
+    }
+  }
+}
+
+// Freeze an instance to avoid multiple reloads
+const biolink = new BioLinkModel();
+Object.freeze(biolink);
+
+global.BIOLINK_VERSION = biolink.biolink.biolinkJSON.version;
+
+export { biolink };