@convex-dev/rag 0.3.0 → 0.3.2

package/src/component/entries.ts

@@ -1,7 +1,7 @@
 import { assert, omit } from "convex-helpers";
 import { createFunctionHandle, paginationOptsValidator } from "convex/server";
 import { v, type Value } from "convex/values";
-import type { ChunkerAction, EntryFilterValues, EntryId } from "../shared.js";
+import type { ChunkerAction, EntryFilter, EntryId } from "../shared.js";
 import {
   statuses,
   vActiveStatus,
@@ -115,7 +115,7 @@ function workpoolName(
   key: string | undefined,
   entryId: Id<"entries">
 ) {
-  return `async-chunker-${namespace}-${key ? key + "-" + entryId : entryId}`;
+  return `rag-async-${namespace}-${key ? key + "-" + entryId : entryId}`;
 }
 
 export const addAsyncOnComplete = internalMutation({
@@ -197,7 +197,7 @@ export const add = mutation({
     entryId: v.id("entries"),
     status: vStatus,
     created: v.boolean(),
-    replacedVersion: v.union(vEntry, v.null()),
+    replacedEntry: v.union(vEntry, v.null()),
   }),
   handler: async (ctx, args) => {
     const { namespaceId, key } = args.entry;
@@ -213,7 +213,7 @@ export const add = mutation({
         entryId: existing._id,
         status: existing.status.kind,
         created: false,
-        replacedVersion: null,
+        replacedEntry: null,
       };
     }
     const version = existing ? existing.version + 1 : 0;
@@ -228,21 +228,21 @@ export const add = mutation({
         startOrder: 0,
         chunks: args.allChunks,
       });
-      const { replacedVersion } = await promoteToReadyHandler(ctx, {
+      const { replacedEntry } = await promoteToReadyHandler(ctx, {
         entryId,
       });
       return {
         entryId,
         status: "ready" as const,
         created: true,
-        replacedVersion,
+        replacedEntry,
       };
     }
     return {
       entryId,
       status: "pending" as const,
       created: true,
-      replacedVersion: null,
+      replacedEntry: null,
     };
   },
 });
@@ -293,19 +293,20 @@ function entryIsSame(existing: Doc<"entries">, newEntry: AddEntryArgs) {
  */
 export const list = query({
   args: {
-    namespaceId: v.id("namespaces"),
+    namespaceId: v.optional(v.id("namespaces")),
     order: v.optional(v.union(v.literal("desc"), v.literal("asc"))),
     status: vStatus,
     paginationOpts: paginationOptsValidator,
   },
   returns: vPaginationResult(vEntry),
   handler: async (ctx, args) => {
+    const { namespaceId } = args;
     const results = await stream(ctx.db, schema)
       .query("entries")
       .withIndex("status_namespaceId", (q) =>
-        q
-          .eq("status.kind", args.status ?? "ready")
-          .eq("namespaceId", args.namespaceId)
+        namespaceId
+          ? q.eq("status.kind", args.status).eq("namespaceId", namespaceId)
+          : q.eq("status.kind", args.status)
       )
       .order(args.order ?? "asc")
       .paginate(args.paginationOpts);
@@ -389,14 +390,14 @@ export const findByContentHash = query({
  * Note: this will not replace the chunks automatically, so you should first
  * call `replaceChunksPage` on all its chunks.
  * Edge case: if the entry has already been replaced, it will return the
- * same entry (replacedVersion.entryId === args.entryId).
+ * same entry (replacedEntry.entryId === args.entryId).
  */
 export const promoteToReady = mutation({
   args: v.object({
     entryId: v.id("entries"),
   }),
   returns: v.object({
-    replacedVersion: v.union(vEntry, v.null()),
+    replacedEntry: v.union(vEntry, v.null()),
   }),
   handler: promoteToReadyHandler,
 });
@@ -411,12 +412,12 @@ async function promoteToReadyHandler(
   assert(namespace, `Namespace for ${entry.namespaceId} not found`);
   if (entry.status.kind === "ready") {
     console.debug(`Entry ${args.entryId} is already ready, skipping...`);
-    return { replacedVersion: null };
+    return { replacedEntry: null };
   } else if (entry.status.kind === "replaced") {
     console.debug(
       `Entry ${args.entryId} is already replaced, returning the current version...`
     );
-    return { replacedVersion: publicEntry(entry) };
+    return { replacedEntry: publicEntry(entry) };
   }
   const previousEntry = await getPreviousEntry(ctx, entry);
   // First mark the previous entry as replaced,
@@ -471,7 +472,7 @@ async function promoteToReadyHandler(
     );
   }
   return {
-    replacedVersion: previousEntry ? publicEntry(previousEntry) : null,
+    replacedEntry: previousEntry ? publicEntry(previousEntry) : null,
   };
 }
 
@@ -496,7 +497,7 @@ export function publicEntry(entry: {
   _id: Id<"entries">;
   key?: string | undefined;
   importance: number;
-  filterValues: EntryFilterValues[];
+  filterValues: EntryFilter[];
   contentHash?: string | undefined;
   title?: string | undefined;
   metadata?: Record<string, Value> | undefined;
@@ -504,7 +505,7 @@ export function publicEntry(entry: {
 }): Entry {
   const { key, importance, filterValues, contentHash, title, metadata } = entry;
 
-  return {
+  const fields = {
     entryId: entry._id as unknown as EntryId,
     key,
     title,
@@ -512,8 +513,19 @@ export function publicEntry(entry: {
     importance,
     filterValues,
     contentHash,
-    status: entry.status.kind,
   };
+  if (entry.status.kind === "replaced") {
+    return {
+      ...fields,
+      status: "replaced" as const,
+      replacedAt: entry.status.replacedAt,
+    };
+  } else {
+    return {
+      ...fields,
+      status: entry.status.kind,
+    };
+  }
 }
 
 export const deleteAsync = mutation({

package/src/component/namespaces.ts

@@ -188,7 +188,7 @@ export const promoteToReady = mutation({
     namespaceId: v.id("namespaces"),
   },
   returns: v.object({
-    replacedVersion: v.union(v.null(), vNamespace),
+    replacedNamespace: v.union(v.null(), vNamespace),
   }),
   handler: promoteToReadyHandler,
 });
@@ -203,12 +203,12 @@ async function promoteToReadyHandler(
     console.debug(
       `Namespace ${args.namespaceId} is already ready, not promoting`
     );
-    return { replacedVersion: null };
+    return { replacedNamespace: null };
   } else if (namespace.status.kind === "replaced") {
     console.debug(
       `Namespace ${args.namespaceId} is already replaced, not promoting and returning itself`
     );
-    return { replacedVersion: publicNamespace(namespace) };
+    return { replacedNamespace: publicNamespace(namespace) };
   }
   const previousNamespace = await ctx.db
     .query("namespaces")
@@ -259,7 +259,7 @@ async function promoteToReadyHandler(
     })
   );
   return {
-    replacedVersion: previousNamespace
+    replacedNamespace: previousNamespace
       ? publicNamespace(previousNamespace)
       : null,
   };

package/src/shared.ts

@@ -60,6 +60,7 @@ export const vEntry = v.object({
   filterValues: v.array(vNamedFilter),
   contentHash: v.optional(v.string()),
   status: vStatus,
+  replacedAt: v.optional(v.number()),
 });
 
 export type VEntry<
@@ -72,8 +73,8 @@ export type VEntry<
   typeof vEntry.fieldPaths
 >;
 
-// Type assertion to keep us honest
-const _1: Entry = {} as Infer<typeof vEntry>;
+// Type assertion to keep us honest (modulo the replacedAt field)
+const _1: Entry = {} as Infer<typeof vEntry> & { status: "pending" | "ready" };
 const _2: Infer<typeof vEntry> = {} as Entry;
 
 export const vSearchEntry = v.object({
@@ -98,7 +99,7 @@ export type SearchEntry<
   text: string;
 };
 
-export type EntryFilterValues<
+export type EntryFilter<
   Filters extends Record<string, Value> = Record<string, Value>,
 > = {
   [K in keyof Filters & string]: NamedFilter<K, Filters[K]>;
@@ -125,14 +126,21 @@ export type Entry<
   /** Filters that can be used to search for this entry.
    * Up to 4 filters are supported, of any type.
    */
-  filterValues: EntryFilterValues<Filters>[];
+  filterValues: EntryFilter<Filters>[];
   /** Hash of the entry contents.
    * If supplied, it will avoid adding if the hash is the same.
    */
   contentHash?: string | undefined;
-  /** Whether this entry's contents have all been inserted and indexed. */
-  status: Status;
-};
+} & (
+  | {
+      /** Whether this entry's contents have all been inserted and indexed. */
+      status: "pending" | "ready";
+    }
+  | {
+      status: "replaced";
+      replacedAt: number;
+    }
+);
 
 export const vChunk = v.object({
   order: v.number(),