chore: lint and format

bevzzz · bevzzz · commit e3baef359e0a · 2025-06-02T11:07:41.000+02:00
diff --git a/src/collections/query/integration.test.ts b/src/collections/query/integration.test.ts
@@ -134,7 +134,11 @@ describe('Testing of the collection.query methods with a simple collection', ()
     expect(ret.objects[0].uuid).toEqual(id);
   });
 
-  requireAtLeast(1, 31, 0)('bm25 search operator (minimum_should_match)', () => {
+  requireAtLeast(
+    1,
+    31,
+    0
+  )('bm25 search operator (minimum_should_match)', () => {
     it('should query with bm25 + operator', async () => {
       const ret = await collection.query.bm25('carrot', {
         limit: 1,
diff --git a/src/collections/query/types.ts b/src/collections/query/types.ts
@@ -87,7 +87,7 @@ export type Bm25QueryProperty<T> = {
 export type Bm25OperatorOptions = {
   operator: 'And' | 'Or';
   minimumMatch: number;
-}
+};
 
 export type Bm25SearchOptions<T> = {
   /** Which properties of the collection to perform the keyword search on. */
@@ -507,12 +507,12 @@ interface NearVector<T> {
 /** All the available methods on the `.query` namespace. */
 export interface Query<T>
   extends Bm25<T>,
-  Hybrid<T>,
-  NearImage<T>,
-  NearMedia<T>,
-  NearObject<T>,
-  NearText<T>,
-  NearVector<T> {
+    Hybrid<T>,
+    NearImage<T>,
+    NearMedia<T>,
+    NearObject<T>,
+    NearText<T>,
+    NearVector<T> {
   /**
    * Retrieve an object from the server by its UUID.
    *
diff --git a/src/collections/query/utils.ts b/src/collections/query/utils.ts
@@ -43,5 +43,4 @@ export class Bm25Operator {
   static or(opts: Omit<Bm25OperatorOptions, 'operator'>): Bm25OperatorOptions {
     return { ...opts, operator: 'Or' };
   }
-
 }
diff --git a/src/collections/serialize/index.ts b/src/collections/serialize/index.ts
@@ -388,10 +388,10 @@ class Aggregate {
         text:
           metric.kind === 'text'
             ? AggregateRequest_Aggregation_Text.fromPartial({
-              count: metric.count,
-              topOccurencesLimit: metric.minOccurrences,
-              topOccurences: metric.topOccurrences != undefined,
-            })
+                count: metric.count,
+                topOccurencesLimit: metric.minOccurrences,
+                topOccurences: metric.topOccurrences != undefined,
+              })
             : undefined,
       })
     );
@@ -525,27 +525,27 @@ class Search {
       returnAllNonrefProperties: nonRefProperties === undefined,
       refProperties: refProperties
         ? refProperties.map((property) => {
-          return {
-            referenceProperty: property.linkOn,
-            properties: Search.queryProperties(property.returnProperties as any),
-            metadata: Search.metadata(property.includeVector, property.returnMetadata),
-            targetCollection: property.targetCollection ? property.targetCollection : '',
-          };
-        })
+            return {
+              referenceProperty: property.linkOn,
+              properties: Search.queryProperties(property.returnProperties as any),
+              metadata: Search.metadata(property.includeVector, property.returnMetadata),
+              targetCollection: property.targetCollection ? property.targetCollection : '',
+            };
+          })
         : [],
       objectProperties: objectProperties
         ? objectProperties.map((property) => {
-          const objProps = property.properties.filter(
-            (property) => typeof property !== 'string'
-          ) as unknown; // cannot get types to work currently :(
-          return {
-            propName: property.name,
-            primitiveProperties: property.properties.filter(
-              (property) => typeof property === 'string'
-            ) as string[],
-            objectProperties: (objProps as QueryNested<T>[]).map(resolveObjectProperty),
-          };
-        })
+            const objProps = property.properties.filter(
+              (property) => typeof property !== 'string'
+            ) as unknown; // cannot get types to work currently :(
+            return {
+              propName: property.name,
+              primitiveProperties: property.properties.filter(
+                (property) => typeof property === 'string'
+              ) as string[],
+              objectProperties: (objProps as QueryNested<T>[]).map(resolveObjectProperty),
+            };
+          })
         : [],
     };
   };
@@ -917,30 +917,30 @@ export class Serialize {
 
     return args.supportsSingleGrouped
       ? GenerativeSearch.fromPartial({
-        single: opts?.singlePrompt
-          ? GenerativeSearch_Single.fromPartial({
-            prompt: singlePrompt,
-            debug: singlePromptDebug,
-            queries: opts.config ? [await Serialize.generativeQuery(opts.config, singleOpts)] : undefined,
-          })
-          : undefined,
-        grouped: opts?.groupedTask
-          ? GenerativeSearch_Grouped.fromPartial({
-            task: groupedTask,
-            queries: opts.config
-              ? [await Serialize.generativeQuery(opts.config, groupedOpts)]
-              : undefined,
-            properties: groupedProperties
-              ? TextArray.fromPartial({ values: groupedProperties as string[] })
-              : undefined,
-          })
-          : undefined,
-      })
+          single: opts?.singlePrompt
+            ? GenerativeSearch_Single.fromPartial({
+                prompt: singlePrompt,
+                debug: singlePromptDebug,
+                queries: opts.config ? [await Serialize.generativeQuery(opts.config, singleOpts)] : undefined,
+              })
+            : undefined,
+          grouped: opts?.groupedTask
+            ? GenerativeSearch_Grouped.fromPartial({
+                task: groupedTask,
+                queries: opts.config
+                  ? [await Serialize.generativeQuery(opts.config, groupedOpts)]
+                  : undefined,
+                properties: groupedProperties
+                  ? TextArray.fromPartial({ values: groupedProperties as string[] })
+                  : undefined,
+              })
+            : undefined,
+        })
       : GenerativeSearch.fromPartial({
-        singleResponsePrompt: singlePrompt,
-        groupedResponseTask: groupedTask,
-        groupedProperties: groupedProperties as string[],
-      });
+          singleResponsePrompt: singlePrompt,
+          groupedResponseTask: groupedTask,
+          groupedProperties: groupedProperties as string[],
+        });
   };
 
   public static isSinglePrompt(arg?: string | SinglePrompt): arg is SinglePrompt {
@@ -963,14 +963,19 @@ export class Serialize {
     });
   };
 
-  private static bm25SearchOperator = (searchOperator?: Bm25OperatorOptions): SearchOperatorOptions | undefined => {
+  private static bm25SearchOperator = (
+    searchOperator?: Bm25OperatorOptions
+  ): SearchOperatorOptions | undefined => {
     if (searchOperator) {
       return SearchOperatorOptions.fromPartial({
         minimumOrTokensMatch: searchOperator.minimumMatch,
-        operator: searchOperator.operator === 'And' as const ? SearchOperatorOptions_Operator.OPERATOR_AND : SearchOperatorOptions_Operator.OPERATOR_OR,
+        operator:
+          searchOperator.operator === ('And' as const)
+            ? SearchOperatorOptions_Operator.OPERATOR_AND
+            : SearchOperatorOptions_Operator.OPERATOR_OR,
       });
     }
-  }
+  };
 
   public static bm25Search = <T>(args: { query: string } & Bm25SearchOptions<T>): BM25 => {
     return BM25.fromPartial({
@@ -1018,13 +1023,13 @@ export class Serialize {
       return vectorBytes !== undefined
         ? { vectorBytes, targetVectors, targets }
         : {
-          targetVectors,
-          targets,
-          nearVector: NearVector.fromPartial({
-            vectorForTargets,
-            vectorPerTarget,
-          }),
-        };
+            targetVectors,
+            targets,
+            nearVector: NearVector.fromPartial({
+              vectorForTargets,
+              vectorPerTarget,
+            }),
+          };
     } else if (Serialize.isHybridNearTextSearch(vector)) {
       const { targetVectors, targets } = Serialize.targetVector(args);
       return {
@@ -1081,7 +1086,11 @@ export class Serialize {
     };
     const { targets, targetVectors, vectorBytes, nearText, nearVector } = Serialize.hybridVector(args);
 
-    console.info(`search operator: ${JSON.stringify(SearchOperatorOptions.toJSON(this.bm25SearchOperator(args.bm25Operator)!))}`);
+    console.info(
+      `search operator: ${JSON.stringify(
+        SearchOperatorOptions.toJSON(this.bm25SearchOperator(args.bm25Operator)!)
+      )}`
+    );
     return Hybrid.fromPartial({
       query: args.query,
       alpha: args.alpha ? args.alpha : 0.5,
@@ -1181,17 +1190,17 @@ export class Serialize {
       targetVectors,
       moveAway: args.moveAway
         ? NearTextSearch_Move.fromPartial({
-          concepts: args.moveAway.concepts,
-          force: args.moveAway.force,
-          uuids: args.moveAway.objects,
-        })
+            concepts: args.moveAway.concepts,
+            force: args.moveAway.force,
+            uuids: args.moveAway.objects,
+          })
         : undefined,
       moveTo: args.moveTo
         ? NearTextSearch_Move.fromPartial({
-          concepts: args.moveTo.concepts,
-          force: args.moveTo.force,
-          uuids: args.moveTo.objects,
-        })
+            concepts: args.moveTo.concepts,
+            force: args.moveTo.force,
+            uuids: args.moveTo.objects,
+          })
         : undefined,
     });
   };
@@ -1247,18 +1256,18 @@ export class Serialize {
     } else if (TargetVectorInputGuards.isSingle(args.targetVector)) {
       return args.supportsTargets
         ? {
-          targets: Targets.fromPartial({
-            targetVectors: [args.targetVector],
-          }),
-        }
+            targets: Targets.fromPartial({
+              targetVectors: [args.targetVector],
+            }),
+          }
         : { targetVectors: [args.targetVector] };
     } else if (TargetVectorInputGuards.isMulti(args.targetVector)) {
       return args.supportsTargets
         ? {
-          targets: Targets.fromPartial({
-            targetVectors: args.targetVector,
-          }),
-        }
+            targets: Targets.fromPartial({
+              targetVectors: args.targetVector,
+            }),
+          }
         : { targetVectors: args.targetVector };
     } else {
       return { targets: Serialize.targets(args.targetVector, args.supportsWeightsForTargets) };
@@ -1303,22 +1312,22 @@ export class Serialize {
           .reduce((acc, { target, vector }) => {
             return ArrayInputGuards.is2DArray(vector)
               ? acc.concat(
-                vector.map((v) => ({ name: target, vectorBytes: Serialize.vectorToBytes(v), vectors: [] }))
-              )
+                  vector.map((v) => ({ name: target, vectorBytes: Serialize.vectorToBytes(v), vectors: [] }))
+                )
               : acc.concat([{ name: target, vectorBytes: Serialize.vectorToBytes(vector), vectors: [] }]);
           }, [] as VectorForTarget[]);
         return args.targetVector !== undefined
           ? {
-            ...Serialize.targetVector(args),
-            vectorForTargets,
-          }
+              ...Serialize.targetVector(args),
+              vectorForTargets,
+            }
           : {
-            targetVectors: undefined,
-            targets: Targets.fromPartial({
-              targetVectors: vectorForTargets.map((v) => v.name),
-            }),
-            vectorForTargets,
-          };
+              targetVectors: undefined,
+              targets: Targets.fromPartial({
+                targetVectors: vectorForTargets.map((v) => v.name),
+              }),
+              vectorForTargets,
+            };
       } else {
         const vectorPerTarget: Record<string, Uint8Array> = {};
         Object.entries(args.vector).forEach(([k, v]) => {
@@ -1337,15 +1346,15 @@ export class Serialize {
         } else {
           return args.supportsTargets
             ? {
-              targets: Targets.fromPartial({
-                targetVectors: Object.keys(vectorPerTarget),
-              }),
-              vectorPerTarget,
-            }
+                targets: Targets.fromPartial({
+                  targetVectors: Object.keys(vectorPerTarget),
+                }),
+                vectorPerTarget,
+              }
             : {
-              targetVectors: Object.keys(vectorPerTarget),
-              vectorPerTarget,
-            };
+                targetVectors: Object.keys(vectorPerTarget),
+                vectorPerTarget,
+              };
         }
       }
     } else {

Original file line number	Diff line number	Diff line change
`@@ -43,5 +43,4 @@ export class Bm25Operator {`
`43`	`43`	`static or(opts: Omit<Bm25OperatorOptions, 'operator'>): Bm25OperatorOptions {`
`44`	`44`	`return { ...opts, operator: 'Or' };`
`45`	`45`	`}`
`46`		`-`
`47`	`46`	`}`