@sentry/junior-memory 0.130.0 → 0.132.0

package/dist/db/schema.d.ts

@@ -121,6 +121,27 @@ export declare const juniorMemoryMemories: import("drizzle-orm/pg-core").PgTable
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        searchVector: import("drizzle-orm/pg-core").PgColumn<{
+            name: "search_vector";
+            tableName: "junior_memory_memories";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: {
+                type: "always";
+            };
+        }, {}, {
+            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+        }>;
         sourcePlatform: import("drizzle-orm/pg-core").PgColumn<{
             name: "source_platform";
             tableName: "junior_memory_memories";

package/dist/index.js

@@ -29,6 +29,7 @@ import { sql } from "drizzle-orm";
 import {
   bigint,
   check,
+  customType,
   index,
   integer,
   pgTable,
@@ -75,6 +76,11 @@ var memoryRuntimeContextSchema = z.union([
 ]);
 
 // src/db/schema.ts
+var tsvector = customType({
+  dataType() {
+    return "tsvector";
+  }
+});
 var juniorMemoryMemories = pgTable(
   "junior_memory_memories",
   {
@@ -85,6 +91,9 @@ var juniorMemoryMemories = pgTable(
     subjectType: text("subject_type", { enum: MEMORY_SUBJECT_TYPES }).notNull(),
     subjectKey: text("subject_key"),
     content: text("content").notNull(),
+    searchVector: tsvector("search_vector").generatedAlwaysAs(
+      sql`to_tsvector('english', "content")`
+    ),
     sourcePlatform: text("source_platform", {
       enum: MEMORY_SOURCE_PLATFORMS
     }).notNull(),
@@ -105,7 +114,7 @@ var juniorMemoryMemories = pgTable(
     index("junior_memory_memories_expiration_idx").on(table.expiresAtMs).where(
       sql`${table.archivedAtMs} IS NULL AND ${table.expiresAtMs} IS NOT NULL`
     ),
-    index("junior_memory_memories_search_idx").using("gin", sql`to_tsvector('english', ${table.content})`).where(
+    index("junior_memory_memories_search_idx").using("gin", table.scope, table.scopeKey, table.searchVector).where(
       sql`${table.archivedAtMs} IS NULL AND ${table.supersededAtMs} IS NULL AND ${table.supersededById} IS NULL`
     ),
     uniqueIndex("junior_memory_memories_idempotency_idx").on(table.scope, table.scopeKey, table.idempotencyKey).where(
@@ -204,16 +213,11 @@ function rankMemoryMatches(matches, options) {
     }
     byId.set(match.memory.id, {
       ...existing,
-      exactIdentifier: existing.exactIdentifier || match.exactIdentifier,
       ...match.lexical ? { lexical: match.lexical } : {},
       ...match.vector ? { vector: match.vector } : {}
     });
   }
   return [...byId.values()].sort((left, right) => {
-    const identifierDelta = Number(right.exactIdentifier) - Number(left.exactIdentifier);
-    if (identifierDelta !== 0) {
-      return identifierDelta;
-    }
     const scoreDelta = matchScore(right) - matchScore(left);
     if (scoreDelta !== 0) {
       return scoreDelta;
@@ -393,6 +397,7 @@ var memoryRowSchema = z2.object({
   id: z2.string().min(1),
   idempotencyKey: optionalStringSchema,
   observedAtMs: z2.coerce.number(),
+  searchVector: z2.string().optional(),
   scope: z2.enum(MEMORY_SCOPES),
   scopeKey: z2.string().min(1),
   sourceKey: z2.string().min(1),
@@ -649,14 +654,6 @@ async function archiveExpiredMemoryBatch(args) {
   });
   return { archivedCount: archivedIds.length };
 }
-function structuredQueryIdentifiers(query) {
-  const matches = query.toLowerCase().match(
-    /(?:[a-z0-9][a-z0-9._-]*\/)+[a-z0-9][a-z0-9._-]*|[a-z0-9]+(?:[._][a-z0-9]+)+|[a-z0-9]+(?:-[a-z0-9]+){2,}/g
-  ) ?? [];
-  return [
-    ...new Set(matches.map((identifier) => identifier.replace(/\.+$/, "")))
-  ];
-}
 function denseRanks(values, key) {
   let previous;
   let rank = 0;
@@ -906,39 +903,18 @@ async function searchVisibleLexicalMemories(args) {
     )
     FROM unnest(tsvector_to_array(${queryVector})) AS query_terms(term)
   )`;
-  const textsearch = sql2`to_tsvector('english', ${juniorMemoryMemories.content})`;
+  const textsearch = juniorMemoryMemories.searchVector;
   const textRank = sql2`ts_rank_cd(${textsearch}, ${tsquery})`;
-  const identifiers = structuredQueryIdentifiers(args.query);
-  const contentTokens = sql2`regexp_split_to_array(lower(${juniorMemoryMemories.content}), '[^a-z0-9._/-]+')`;
-  const identifierArray = identifiers.length > 0 ? sql2`ARRAY[${sql2.join(
-    identifiers.map((identifier) => sql2`${identifier}`),
-    sql2`, `
-  )}]::text[]` : void 0;
-  const exactIdentifierMatch = identifierArray !== void 0 ? sql2`EXISTS (
-          SELECT 1
-          FROM unnest(${contentTokens}) AS content_token(value)
-          CROSS JOIN unnest(${identifierArray}) AS query_identifier(value)
-          WHERE strpos(
-            '/' || regexp_replace(content_token.value, '\\.+$', '') || '/',
-            '/' || query_identifier.value || '/'
-          ) > 0
-        )` : sql2`false`;
   const rows = await args.db.select({
-    exactIdentifierMatch,
     memory: juniorMemoryMemories,
     textRank
   }).from(juniorMemoryMemories).where(and(predicate, sql2`${textsearch} @@ ${tsquery}`)).orderBy(
-    ...identifiers.length > 0 ? [desc(exactIdentifierMatch)] : [],
     desc(textRank),
     desc(juniorMemoryMemories.observedAtMs),
     asc(juniorMemoryMemories.id)
   ).limit(args.limit);
-  const ranks = denseRanks(
-    rows,
-    (row) => `${row.exactIdentifierMatch}:${Number(row.textRank)}`
-  );
+  const ranks = denseRanks(rows, (row) => Number(row.textRank));
   return rows.map((row, index2) => ({
-    exactIdentifier: row.exactIdentifierMatch,
     lexical: { rank: ranks[index2] },
     memory: parseMemoryRow(row.memory),
     sourceKey: row.memory.sourceKey
@@ -993,7 +969,6 @@ async function searchVisibleVectorMemories(args) {
     }
     return [
       {
-        exactIdentifier: false,
         memory: parseMemoryRow(row.memory),
         sourceKey: row.memory.sourceKey,
         vector: {