@convex-dev/rag 0.5.4 → 0.6.0

package/src/component/_generated/{server.d.ts → server.ts}

@@ -8,9 +8,8 @@
  * @module
  */
 
-import {
+import type {
   ActionBuilder,
-  AnyComponents,
   HttpActionBuilder,
   MutationBuilder,
   QueryBuilder,
@@ -19,15 +18,18 @@ import {
   GenericQueryCtx,
   GenericDatabaseReader,
   GenericDatabaseWriter,
-  FunctionReference,
+} from "convex/server";
+import {
+  actionGeneric,
+  httpActionGeneric,
+  queryGeneric,
+  mutationGeneric,
+  internalActionGeneric,
+  internalMutationGeneric,
+  internalQueryGeneric,
 } from "convex/server";
 import type { DataModel } from "./dataModel.js";
 
-type GenericCtx =
-  | GenericActionCtx<DataModel>
-  | GenericMutationCtx<DataModel>
-  | GenericQueryCtx<DataModel>;
-
 /**
  * Define a query in this Convex app's public API.
  *
@@ -36,7 +38,7 @@ type GenericCtx =
  * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
-export declare const query: QueryBuilder<DataModel, "public">;
+export const query: QueryBuilder<DataModel, "public"> = queryGeneric;
 
 /**
  * Define a query that is only accessible from other Convex functions (but not from the client).
@@ -46,7 +48,8 @@ export declare const query: QueryBuilder<DataModel, "public">;
  * @param func - The query function. It receives a {@link QueryCtx} as its first argument.
  * @returns The wrapped query. Include this as an `export` to name it and make it accessible.
  */
-export declare const internalQuery: QueryBuilder<DataModel, "internal">;
+export const internalQuery: QueryBuilder<DataModel, "internal"> =
+  internalQueryGeneric;
 
 /**
  * Define a mutation in this Convex app's public API.
@@ -56,7 +59,7 @@ export declare const internalQuery: QueryBuilder<DataModel, "internal">;
  * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
-export declare const mutation: MutationBuilder<DataModel, "public">;
+export const mutation: MutationBuilder<DataModel, "public"> = mutationGeneric;
 
 /**
  * Define a mutation that is only accessible from other Convex functions (but not from the client).
@@ -66,7 +69,8 @@ export declare const mutation: MutationBuilder<DataModel, "public">;
  * @param func - The mutation function. It receives a {@link MutationCtx} as its first argument.
  * @returns The wrapped mutation. Include this as an `export` to name it and make it accessible.
  */
-export declare const internalMutation: MutationBuilder<DataModel, "internal">;
+export const internalMutation: MutationBuilder<DataModel, "internal"> =
+  internalMutationGeneric;
 
 /**
  * Define an action in this Convex app's public API.
@@ -79,7 +83,7 @@ export declare const internalMutation: MutationBuilder<DataModel, "internal">;
  * @param func - The action. It receives an {@link ActionCtx} as its first argument.
  * @returns The wrapped action. Include this as an `export` to name it and make it accessible.
  */
-export declare const action: ActionBuilder<DataModel, "public">;
+export const action: ActionBuilder<DataModel, "public"> = actionGeneric;
 
 /**
  * Define an action that is only accessible from other Convex functions (but not from the client).
@@ -87,19 +91,26 @@ export declare const action: ActionBuilder<DataModel, "public">;
  * @param func - The function. It receives an {@link ActionCtx} as its first argument.
  * @returns The wrapped function. Include this as an `export` to name it and make it accessible.
  */
-export declare const internalAction: ActionBuilder<DataModel, "internal">;
+export const internalAction: ActionBuilder<DataModel, "internal"> =
+  internalActionGeneric;
 
 /**
  * Define an HTTP action.
  *
- * This function will be used to respond to HTTP requests received by a Convex
- * deployment if the requests matches the path and method where this action
- * is routed. Be sure to route your action in `convex/http.js`.
+ * The wrapped function will be used to respond to HTTP requests received
+ * by a Convex deployment if the requests matches the path and method where
+ * this action is routed. Be sure to route your httpAction in `convex/http.js`.
  *
- * @param func - The function. It receives an {@link ActionCtx} as its first argument.
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument
+ * and a Fetch API `Request` object as its second.
  * @returns The wrapped function. Import this function from `convex/http.js` and route it to hook it up.
  */
-export declare const httpAction: HttpActionBuilder;
+export const httpAction: HttpActionBuilder = httpActionGeneric;
+
+type GenericCtx =
+  | GenericActionCtx<DataModel>
+  | GenericMutationCtx<DataModel>
+  | GenericQueryCtx<DataModel>;
 
 /**
  * A set of services for use within Convex query functions.
@@ -107,8 +118,7 @@ export declare const httpAction: HttpActionBuilder;
  * The query context is passed as the first argument to any Convex query
  * function run on the server.
  *
- * This differs from the {@link MutationCtx} because all of the services are
- * read-only.
+ * If you're using code generation, use the `QueryCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type QueryCtx = GenericQueryCtx<DataModel>;
 
@@ -117,6 +127,8 @@ export type QueryCtx = GenericQueryCtx<DataModel>;
  *
  * The mutation context is passed as the first argument to any Convex mutation
  * function run on the server.
+ *
+ * If you're using code generation, use the `MutationCtx` type in `convex/_generated/server.d.ts` instead.
  */
 export type MutationCtx = GenericMutationCtx<DataModel>;
 

package/src/component/chunks.test.ts

@@ -30,7 +30,7 @@ describe("chunks", () => {
     namespaceId: Id<"namespaces">,
     key = "test-entry",
     version = 0,
-    status: "ready" | "pending" = "ready"
+    status: "ready" | "pending" = "ready",
   ) {
     return await t.run(async (ctx) => {
       return ctx.db.insert("entries", {
@@ -70,7 +70,7 @@ describe("chunks", () => {
           startOrder: 0,
           chunks,
         });
-      })
+      }),
     ).rejects.toThrow(`Entry ${nonExistentDocId} not found`);
   });
 
@@ -141,10 +141,10 @@ describe("chunks", () => {
     expect(overwrittenChunk2).toBeDefined();
 
     const content1 = await t.run(async (ctx) =>
-      ctx.db.get(overwrittenChunk1!.contentId)
+      ctx.db.get(overwrittenChunk1!.contentId),
     );
     const content2 = await t.run(async (ctx) =>
-      ctx.db.get(overwrittenChunk2!.contentId)
+      ctx.db.get(overwrittenChunk2!.contentId),
     );
 
     expect(content1!.text).toBe("Overwritten chunk 1 content");
@@ -176,7 +176,7 @@ describe("chunks", () => {
       namespaceId,
       "versioned-entry",
       2,
-      "pending"
+      "pending",
     );
 
     // Insert chunks in version 2 (this should mark v1 chunks as replaced)
@@ -279,10 +279,10 @@ describe("chunks", () => {
 
     // Verify chunk content
     const doc1Content0 = await t.run(async (ctx) =>
-      ctx.db.get(doc1ChunksList[0].contentId)
+      ctx.db.get(doc1ChunksList[0].contentId),
     );
     const doc2Content0 = await t.run(async (ctx) =>
-      ctx.db.get(doc2ChunksList[0].contentId)
+      ctx.db.get(doc2ChunksList[0].contentId),
     );
 
     expect(doc1Content0!.text).toBe("Test chunk content 1");
@@ -309,7 +309,7 @@ describe("chunks", () => {
       return ctx.db
         .query("chunks")
         .withIndex("entryId_order", (q) =>
-          q.eq("entryId", entryId).eq("order", 2)
+          q.eq("entryId", entryId).eq("order", 2),
         )
         .first();
     });
@@ -319,7 +319,7 @@ describe("chunks", () => {
 
     // Verify content
     const content = await t.run(async (ctx) =>
-      ctx.db.get(singleChunk!.contentId)
+      ctx.db.get(singleChunk!.contentId),
     );
     expect(content!.text).toBe("Test chunk content 3");
   });
@@ -467,7 +467,7 @@ describe("chunks", () => {
         {
           embeddingIds: [chunkDocs[2].state.embeddingId],
           chunkContext: { before: 1, after: 2 },
-        }
+        },
       );
       expect(entries).toHaveLength(1);
       expect(entries[0].entryId).toBe(entryId);
@@ -532,7 +532,7 @@ describe("chunks", () => {
             doc2ChunkDocs[2].state.embeddingId, // doc2, chunk at order 2
           ],
           chunkContext: { before: 1, after: 1 },
-        }
+        },
       );
 
       expect(entries).toHaveLength(2);
@@ -562,7 +562,7 @@ describe("chunks", () => {
         namespaceId,
         "versioned-entry",
         1,
-        "ready"
+        "ready",
       );
 
       // Insert chunks in version 1
@@ -580,7 +580,7 @@ describe("chunks", () => {
         namespaceId,
         "versioned-entry",
         2,
-        "pending"
+        "pending",
       );
 
       // Insert chunks in version 2
@@ -631,7 +631,7 @@ describe("chunks", () => {
             v2ChunkDocs[1].state.embeddingId, // v2, chunk at order 1
           ],
           chunkContext: { before: 1, after: 1 },
-        }
+        },
       );
 
       expect(entries).toHaveLength(2);

package/src/component/chunks.ts

@@ -50,7 +50,7 @@ export const insert = mutation({
 
 export async function insertChunks(
   ctx: MutationCtx,
-  { entryId, startOrder, chunks }: InsertChunksArgs
+  { entryId, startOrder, chunks }: InsertChunksArgs,
 ) {
   const entry = await ctx.db.get(entryId);
   if (!entry) {
@@ -71,12 +71,12 @@ export async function insertChunks(
       q
         .eq("entryId", entryId)
         .gte("order", startOrder)
-        .lt("order", startOrder + chunks.length)
+        .lt("order", startOrder + chunks.length),
     )
     .collect();
   if (existingChunks.length > 0) {
     console.debug(
-      `Deleting ${existingChunks.length} existing chunks for entry ${entryId} at version ${entry.version}`
+      `Deleting ${existingChunks.length} existing chunks for entry ${entryId} at version ${entry.version}`,
     );
   }
   // TODO: avoid writing if they're the same
@@ -87,11 +87,11 @@ export async function insertChunks(
       }
       await ctx.db.delete(c.contentId);
       await ctx.db.delete(c._id);
-    })
+    }),
   );
   const numberedFilter = numberedFilterFromNamedFilters(
     entry.filterValues,
-    namespace!.filterNames
+    namespace!.filterNames,
   );
   for (const chunk of chunks) {
     const contentId = await ctx.db.insert("content", {
@@ -110,7 +110,7 @@ export async function insertChunks(
         chunk.embedding,
         entry.namespaceId,
         entry.importance,
-        numberedFilter
+        numberedFilter,
       );
       state = {
         kind: "ready",
@@ -126,13 +126,11 @@ export async function insertChunks(
         contentId,
         namespaceId: entry.namespaceId,
         ...filterFieldsFromNumbers(entry.namespaceId, numberedFilter),
-      })
+      }),
     );
     order++;
   }
-  return {
-    status: previousEntry ? ("pending" as const) : ("ready" as const),
-  };
+  return { status: previousEntry ? ("pending" as const) : ("ready" as const) };
 }
 
 async function ensureLatestEntryVersion(ctx: QueryCtx, entry: Doc<"entries">) {
@@ -148,14 +146,14 @@ async function ensureLatestEntryVersion(ctx: QueryCtx, entry: Doc<"entries">) {
             .eq("namespaceId", entry.namespaceId)
             .eq("status.kind", status)
             .eq("key", entry.key)
-            .gt("version", entry.version)
-        )
+            .gt("version", entry.version),
+        ),
     ),
-    ["version"]
+    ["version"],
   ).first();
   if (newerEntry) {
     console.warn(
-      `Bailing from inserting chunks for entry ${entry.key} at version ${entry.version} since there's a newer version ${newerEntry.version} (status ${newerEntry.status}) creation time difference ${(newerEntry._creationTime - entry._creationTime).toFixed(0)}ms`
+      `Bailing from inserting chunks for entry ${entry.key} at version ${entry.version} since there's a newer version ${newerEntry.version} (status ${newerEntry.status}) creation time difference ${(newerEntry._creationTime - entry._creationTime).toFixed(0)}ms`,
     );
     return false;
   }
@@ -163,14 +161,8 @@ async function ensureLatestEntryVersion(ctx: QueryCtx, entry: Doc<"entries">) {
 }
 
 export const replaceChunksPage = mutation({
-  args: v.object({
-    entryId: v.id("entries"),
-    startOrder: v.number(),
-  }),
-  returns: v.object({
-    status: vStatus,
-    nextStartOrder: v.number(),
-  }),
+  args: v.object({ entryId: v.id("entries"), startOrder: v.number() }),
+  returns: v.object({ status: vStatus, nextStartOrder: v.number() }),
   handler: async (ctx, args) => {
     const { entryId, startOrder } = args;
     const entryOrNull = await ctx.db.get(entryId);
@@ -180,10 +172,7 @@ export const replaceChunksPage = mutation({
     const entry = entryOrNull;
     const isLatest = await ensureLatestEntryVersion(ctx, entry);
     if (!isLatest) {
-      return {
-        status: "replaced" as const,
-        nextStartOrder: startOrder,
-      };
+      return { status: "replaced" as const, nextStartOrder: startOrder };
     }
 
     // Get the namespace for filter conversion
@@ -200,7 +189,7 @@ export const replaceChunksPage = mutation({
                 q
                   .eq("namespaceId", entry.namespaceId)
                   .eq("status.kind", "pending")
-                  .eq("key", entry.key)
+                  .eq("key", entry.key),
               )
               .collect()
           ).filter((e) => e._id !== entry._id)
@@ -212,29 +201,27 @@ export const replaceChunksPage = mutation({
           stream(ctx.db, schema)
             .query("chunks")
             .withIndex("entryId_order", (q) =>
-              q.eq("entryId", entry._id).gte("order", startOrder)
-            )
+              q.eq("entryId", entry._id).gte("order", startOrder),
+            ),
         ),
-      ["order"]
+      ["order"],
     );
     const namespaceId = entry.namespaceId;
     const namedFilters = numberedFilterFromNamedFilters(
       entry.filterValues,
-      namespace!.filterNames
+      namespace!.filterNames,
     );
     async function addChunk(
-      chunk: Doc<"chunks"> & { state: { kind: "pending" } }
+      chunk: Doc<"chunks"> & { state: { kind: "pending" } },
     ) {
       const embeddingId = await insertEmbedding(
         ctx,
         chunk.state.embedding,
         namespaceId,
         entry.importance,
-        namedFilters
+        namedFilters,
       );
-      await ctx.db.patch(chunk._id, {
-        state: { kind: "ready", embeddingId },
-      });
+      await ctx.db.patch(chunk._id, { state: { kind: "ready", embeddingId } });
     }
     let dataUsedSoFar = 0;
     let indexToDelete = startOrder;
@@ -256,7 +243,7 @@ export const replaceChunksPage = mutation({
               pendingSearchableText: chunk.state.searchableText,
             },
           });
-        })
+        }),
       );
       chunksToDeleteEmbeddings = [];
       if (chunkToAdd) {
@@ -277,23 +264,17 @@ export const replaceChunksPage = mutation({
         // check if we're close to the limit
         // if so, bail and pick up on this chunk.order.
         if (dataUsedSoFar > BANDWIDTH_PER_TRANSACTION_SOFT_LIMIT) {
-          return {
-            status: "pending" as const,
-            nextStartOrder: indexToDelete,
-          };
+          return { status: "pending" as const, nextStartOrder: indexToDelete };
         }
       }
       if (dataUsedSoFar > BANDWIDTH_PER_TRANSACTION_HARD_LIMIT) {
-        return {
-          status: "pending" as const,
-          nextStartOrder: indexToDelete,
-        };
+        return { status: "pending" as const, nextStartOrder: indexToDelete };
       }
       if (chunk.state.kind === "pending") {
         if (chunk.entryId === entryId) {
           if (chunkToAdd) {
             console.warn(
-              `Multiple pending chunks before changing order ${chunk.order} for entry ${entryId} version ${entry.version}: ${chunkToAdd._id} and ${chunk._id}`
+              `Multiple pending chunks before changing order ${chunk.order} for entry ${entryId} version ${entry.version}: ${chunkToAdd._id} and ${chunk._id}`,
             );
             await addChunk(chunkToAdd);
           }
@@ -304,7 +285,7 @@ export const replaceChunksPage = mutation({
           chunksToDeleteEmbeddings.push(chunk);
         } else {
           console.debug(
-            `Skipping adding chunk ${chunk._id} for entry ${entryId} version ${entry.version} since it's already ready`
+            `Skipping adding chunk ${chunk._id} for entry ${entryId} version ${entry.version} since it's already ready`,
           );
         }
       }
@@ -312,10 +293,7 @@ export const replaceChunksPage = mutation({
     // handle the last batch
     await handleBatch();
 
-    return {
-      status: "ready" as const,
-      nextStartOrder: 0,
-    };
+    return { status: "ready" as const, nextStartOrder: 0 };
   },
 });
 
@@ -327,7 +305,7 @@ export const vRangeResult = v.object({
     v.object({
       text: v.string(),
       metadata: v.optional(v.record(v.string(), v.any())),
-    })
+    }),
   ),
 });
 
@@ -342,7 +320,7 @@ export const getRangesOfChunks = internalQuery({
   }),
   handler: async (
     ctx,
-    args
+    args,
   ): Promise<{
     ranges: (null | Infer<typeof vRangeResult>)[];
     entries: Entry[];
@@ -353,19 +331,19 @@ export const getRangesOfChunks = internalQuery({
         ctx.db
           .query("chunks")
           .withIndex("embeddingId", (q) =>
-            q.eq("state.embeddingId", embeddingId)
+            q.eq("state.embeddingId", embeddingId),
           )
           .order("desc")
-          .first()
-      )
+          .first(),
+      ),
     );
 
     // Note: This preserves order of entries as they first appeared.
     const entries = (
       await Promise.all(
         Array.from(
-          new Set(chunks.filter((c) => c !== null).map((c) => c.entryId))
-        ).map((id) => ctx.db.get(id))
+          new Set(chunks.filter((c) => c !== null).map((c) => c.entryId)),
+        ).map((id) => ctx.db.get(id)),
       )
     )
       .filter((d) => d !== null)
@@ -383,7 +361,7 @@ export const getRangesOfChunks = internalQuery({
           acc[entryId] = [...(acc[entryId] ?? []), order].sort((a, b) => a - b);
           return acc;
         },
-        {} as Record<Id<"entries">, number[]>
+        {} as Record<Id<"entries">, number[]>,
       );
 
     const result: Array<Infer<typeof vRangeResult> | null> = [];
@@ -397,7 +375,7 @@ export const getRangesOfChunks = internalQuery({
       // instead we'd check that other chunks are not the same doc/order
       if (
         result.find(
-          (r) => r?.entryId === chunk.entryId && r?.order === chunk.order
+          (r) => r?.entryId === chunk.entryId && r?.order === chunk.order,
         )
       ) {
         // De-dupe chunks
@@ -415,12 +393,12 @@ export const getRangesOfChunks = internalQuery({
       const startOrder = Math.max(
         chunk.order - chunkContext.before,
         0,
-        Math.min(previousOrder + 1, chunk.order)
+        Math.min(previousOrder + 1, chunk.order),
       );
       // We stop short if the next chunk order's "before" context will cover it.
       const endOrder = Math.min(
         chunk.order + chunkContext.after + 1,
-        Math.max(nextOrder - chunkContext.before, chunk.order + 1)
+        Math.max(nextOrder - chunkContext.before, chunk.order + 1),
       );
       const contentIds: Id<"content">[] = [];
       if (startOrder === chunk.order && endOrder === chunk.order + 1) {
@@ -432,7 +410,7 @@ export const getRangesOfChunks = internalQuery({
             q
               .eq("entryId", entryId)
               .gte("order", startOrder)
-              .lt("order", endOrder)
+              .lt("order", endOrder),
           )
           .collect();
         for (const chunk of chunks) {
@@ -444,21 +422,13 @@ export const getRangesOfChunks = internalQuery({
           const content = await ctx.db.get(contentId);
           assert(content, `Content ${contentId} not found`);
           return { text: content.text, metadata: content.metadata };
-        })
+        }),
       );
 
-      result.push({
-        entryId,
-        order: chunk.order,
-        startOrder,
-        content,
-      });
+      result.push({ entryId, order: chunk.order, startOrder, content });
     }
 
-    return {
-      ranges: result,
-      entries,
-    };
+    return { ranges: result, entries };
   },
 });
 
@@ -483,7 +453,7 @@ export const list = query({
           const content = await ctx.db.get(chunk.contentId);
           assert(content, `Content ${chunk.contentId} not found`);
           return publicChunk(chunk, content);
-        })
+        }),
       ),
     };
   },
@@ -516,22 +486,19 @@ async function publicChunk(chunk: Doc<"chunks">, content: Doc<"content">) {
 }
 
 export const deleteChunksPage = internalMutation({
-  args: v.object({
-    entryId: v.id("entries"),
-    startOrder: v.number(),
-  }),
+  args: v.object({ entryId: v.id("entries"), startOrder: v.number() }),
   returns: v.object({ isDone: v.boolean(), nextStartOrder: v.number() }),
   handler: deleteChunksPageHandler,
 });
 
 export async function deleteChunksPageHandler(
   ctx: MutationCtx,
-  { entryId, startOrder }: { entryId: Id<"entries">; startOrder: number }
+  { entryId, startOrder }: { entryId: Id<"entries">; startOrder: number },
 ) {
   const chunkStream = ctx.db
     .query("chunks")
     .withIndex("entryId_order", (q) =>
-      q.eq("entryId", entryId).gte("order", startOrder)
+      q.eq("entryId", entryId).gte("order", startOrder),
     );
   let dataUsedSoFar = 0;
   for await (const chunk of chunkStream) {
@@ -590,7 +557,7 @@ async function estimateContentSize(ctx: QueryCtx, contentId: Id<"content">) {
   if (content) {
     dataUsedSoFar += content.text.length;
     dataUsedSoFar += JSON.stringify(
-      convexToJson(content.metadata ?? {})
+      convexToJson(content.metadata ?? {}),
     ).length;
   }
   return dataUsedSoFar;

package/src/component/embeddings/importance.test.ts

@@ -45,7 +45,7 @@ describe("importance.ts", () => {
       expect(result[0]).toBeCloseTo(embedding[0] * importance);
       expect(result[1]).toBeCloseTo(embedding[1] * importance);
       expect(
-        Math.sqrt(result[0] ** 2 + result[1] ** 2 + result[2] ** 2)
+        Math.sqrt(result[0] ** 2 + result[1] ** 2 + result[2] ** 2),
       ).toBeCloseTo(1);
     });
 
@@ -175,7 +175,7 @@ describe("importance.ts", () => {
 
         expect(retrievedImportance).toBeCloseTo(importance, 3);
         expect(Math.abs(retrievedImportance - importance)).toBeLessThan(
-          tolerance
+          tolerance,
         );
       });
     });
@@ -198,13 +198,13 @@ describe("importance.ts", () => {
       // Create vector with initial importance
       const vectorWithInitialImp = vectorWithImportance(
         embedding,
-        initialImportance
+        initialImportance,
       );
 
       // Modify importance
       const vectorWithModifiedImp = modifyImportance(
         vectorWithInitialImp,
-        newImportance
+        newImportance,
       );
 
       // Retrieve and verify

package/src/component/embeddings/importance.ts

@@ -35,7 +35,7 @@ export function vectorWithImportance(embedding: number[], importance: number) {
   // We drop the final dimension if it'd make it larger than 4096.
   // Unfortunate current limitation of Convex vector search.
   const vectorToModify = normalizeVector(
-    embedding.length === 4096 ? embedding.slice(0, 4095) : embedding
+    embedding.length === 4096 ? embedding.slice(0, 4095) : embedding,
   );
   const scaled = scaleVector(vectorToModify, importance);
 

package/src/component/embeddings/index.test.ts

@@ -25,7 +25,6 @@ const testApi: ApiFromModules<{
   fns: {
     search: typeof search;
   };
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
 }>["fns"] = anyApi["embeddings"]["index.test"] as any;
 
 describe("embeddings", () => {
@@ -62,7 +61,7 @@ describe("embeddings", () => {
     expect(insertedVector).toBeDefined();
     expect(insertedVector!.namespaceId).toBe(namespaceId);
     expect(insertedVector!.vector).toHaveLength(
-      vectorWithImportanceDimension(128)
+      vectorWithImportanceDimension(128),
     );
     expect(insertedVector!.filter0).toBeUndefined();
     expect(insertedVector!.filter1).toBeUndefined();
@@ -94,7 +93,7 @@ describe("embeddings", () => {
         embedding,
         namespaceId,
         importance,
-        undefined
+        undefined,
       );
     });
 
@@ -116,7 +115,7 @@ describe("embeddings", () => {
 
     // Vectors should be different due to importance scaling
     expect(insertedVector!.vector).not.toEqual(
-      vectorWithoutImportanceData!.vector
+      vectorWithoutImportanceData!.vector,
     );
 
     // The last element should be the weight: sqrt(1 - importance^2)