Fix subsearches type and mapping

Author: tsmith023

src/graphql/getter.test.ts

@@ -1415,7 +1415,7 @@ describe('hybrid valid searchers', () => {
   });
 
   test('query and subsearches', () => {
-    const subQuery = `searches:[{vector:[1,2,3],certainty:0.8,targetVectors:["employer"]},{concepts:["accountant"],distance:0.3,moveTo:{concepts:["foo"],objects:[{id:"uuid"}],force:0.8}}]`;
+    const subQuery = `searches:[{nearVector:{vector:[1,2,3],certainty:0.8,targetVectors:["employer"]}},{nearText:{concepts:["accountant"],distance:0.3,moveTo:{concepts:["foo"],objects:[{id:"uuid"}],force:0.8}}}]`;
     const expectedQuery = `{Get{Person(hybrid:{query:"accountant",${subQuery}}){name}}}`;
 
     new Getter(mockClient)
@@ -1424,21 +1424,22 @@ describe('hybrid valid searchers', () => {
       .withHybrid({
         query: 'accountant',
         searches: [
-          { certainty: 0.8, targetVectors: ['employer'], vector: [1, 2, 3] },
+          { nearVector: { certainty: 0.8, targetVectors: ['employer'], vector: [1, 2, 3] } },
           {
-            concepts: ['accountant'],
-            distance: 0.3,
-            moveTo: {
-              concepts: ['foo'],
-              objects: [{ id: 'uuid' }],
-              force: 0.8,
+            nearText: {
+              concepts: ['accountant'],
+              distance: 0.3,
+              moveTo: {
+                concepts: ['foo'],
+                objects: [{ id: 'uuid' }],
+                force: 0.8,
+              },
             },
           },
         ],
       })
       .do();
 
-    console.log(mockClient.query.mock.calls);
     expect(mockClient.query).toHaveBeenCalledWith(expectedQuery);
   });
 });

src/graphql/hybrid.ts

@@ -7,7 +7,7 @@ export interface HybridArgs {
   properties?: string[];
   targetVectors?: string[];
   fusionType?: FusionType;
-  searches?: (NearTextSubSearch | NearVectorSubSearch)[];
+  searches?: HybridSubSearch[];
 }
 
 export interface NearTextSubSearch {
@@ -25,91 +25,57 @@ export interface NearVectorSubSearch {
   targetVectors?: string[];
 }
 
+export interface HybridSubSearch {
+  nearText?: NearTextSubSearch;
+  nearVector?: NearVectorSubSearch;
+}
+
 export enum FusionType {
   rankedFusion = 'rankedFusion',
   relativeScoreFusion = 'relativeScoreFusion',
 }
 
 class GraphQLHybridSubSearch {
-  constructor() {
-    if (new.target === GraphQLHybridSubSearch) {
-      throw new Error('Cannot instantiate abstract class');
-    }
-  }
-
-  static fromArgs(args: NearTextSubSearch | NearVectorSubSearch): GraphQLHybridSubSearch {
-    if ('concepts' in args) {
-      return new GraphQLHybridSubSearchNearText(args);
-    } else {
-      return new GraphQLHybridSubSearchNearVector(args);
-    }
-  }
-
-  toString(): string {
-    throw new Error('Method not implemented.');
-  }
-}
-
-class GraphQLHybridSubSearchNearText extends GraphQLHybridSubSearch {
-  private concepts: string[];
-  private certainty?: number;
-  private distance?: number;
-  private moveAwayFrom?: Move;
-  private moveTo?: Move;
-
-  constructor(args: NearTextSubSearch) {
-    super();
-    this.concepts = args.concepts;
-    this.certainty = args.certainty;
-    this.distance = args.distance;
-    this.moveAwayFrom = args.moveAwayFrom;
-    this.moveTo = args.moveTo;
-  }
-
-  toString(): string {
-    let args = [`concepts:${JSON.stringify(this.concepts)}`];
-    if (this.certainty) {
-      args = [...args, `certainty:${this.certainty}`];
-    }
-    if (this.distance) {
-      args = [...args, `distance:${this.distance}`];
-    }
-    if (this.moveTo) {
-      args = [...args, parseMove('moveTo', this.moveTo)];
-    }
-    if (this.moveAwayFrom) {
-      args = [...args, parseMove('moveAwayFrom', this.moveAwayFrom)];
-    }
-    return `{${args.join(',')}}`;
-  }
-}
+  private nearText?: NearTextSubSearch;
+  private nearVector?: NearVectorSubSearch;
 
-class GraphQLHybridSubSearchNearVector extends GraphQLHybridSubSearch {
-  private vector: number[];
-  private certainty?: number;
-  private distance?: number;
-  private targetVectors?: string[];
-
-  constructor(args: NearVectorSubSearch) {
-    super();
-    this.vector = args.vector;
-    this.certainty = args.certainty;
-    this.distance = args.distance;
-    this.targetVectors = args.targetVectors;
+  constructor(args: HybridSubSearch) {
+    this.nearText = args.nearText;
+    this.nearVector = args.nearVector;
   }
 
   toString(): string {
-    let args = [`vector:${JSON.stringify(this.vector)}`];
-    if (this.certainty) {
-      args = [...args, `certainty:${this.certainty}`];
+    let outer: string[] = [];
+    if (this.nearText !== undefined) {
+      let inner = [`concepts:${JSON.stringify(this.nearText.concepts)}`];
+      if (this.nearText.certainty) {
+        inner = [...inner, `certainty:${this.nearText.certainty}`];
+      }
+      if (this.nearText.distance) {
+        inner = [...inner, `distance:${this.nearText.distance}`];
+      }
+      if (this.nearText.moveTo) {
+        inner = [...inner, parseMove('moveTo', this.nearText.moveTo)];
+      }
+      if (this.nearText.moveAwayFrom) {
+        inner = [...inner, parseMove('moveAwayFrom', this.nearText.moveAwayFrom)];
+      }
+      outer = [...outer, `nearText:{${inner.join(',')}}`];
     }
-    if (this.distance) {
-      args = [...args, `distance:${this.distance}`];
+    if (this.nearVector !== undefined) {
+      let inner = [`vector:${JSON.stringify(this.nearVector.vector)}`];
+      if (this.nearVector.certainty) {
+        inner = [...inner, `certainty:${this.nearVector.certainty}`];
+      }
+      if (this.nearVector.distance) {
+        inner = [...inner, `distance:${this.nearVector.distance}`];
+      }
+      if (this.nearVector.targetVectors && this.nearVector.targetVectors.length > 0) {
+        inner = [...inner, `targetVectors:${JSON.stringify(this.nearVector.targetVectors)}`];
+      }
+      outer = [...outer, `nearVector:{${inner.join(',')}}`];
     }
-    if (this.targetVectors && this.targetVectors.length > 0) {
-      args = [...args, `targetVectors:${JSON.stringify(this.targetVectors)}`];
-    }
-    return `{${args.join(',')}}`;
+    return `{${outer.join(',')}}`;
   }
 }
 
@@ -129,7 +95,7 @@ export default class GraphQLHybrid {
     this.properties = args.properties;
     this.targetVectors = args.targetVectors;
     this.fusionType = args.fusionType;
-    this.searches = args.searches?.map((search) => GraphQLHybridSubSearch.fromArgs(search));
+    this.searches = args.searches?.map((search) => new GraphQLHybridSubSearch(search));
   }
 
   toString() {

src/graphql/journey.test.ts

@@ -472,8 +472,10 @@ describe('the graphql journey', () => {
         query: '',
         searches: [
           {
-            concepts: ['Article'],
-            certainty: 0.7,
+            nearText: {
+              concepts: ['Article'],
+              certainty: 0.7,
+            },
           },
         ],
       })
@@ -536,8 +538,10 @@ describe('the graphql journey', () => {
         query: '',
         searches: [
           {
-            vector: searchVec,
-            distance: 0.3,
+            nearVector: {
+              vector: searchVec,
+              certainty: 0.7,
+            },
           },
         ],
       })