fix(search): keep private history independent of indexed search

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/home/components/message-content/components/source-history-context.tsx

@@ -9,6 +9,7 @@ import {
   useMemo,
 } from 'react'
 import { noop } from '@sim/utils/helpers'
+import { truncateAtCodePoint } from '@sim/utils/string'
 import type { ViewedSearchSource } from '@/lib/api/contracts/knowledge/search-history'
 import { isKnowledgeSourceUrl } from '@/lib/knowledge/search/source-url'
 import { handleExternalLinkClick } from '@/app/workspace/[workspaceId]/home/components/message-content/components/source-link'
@@ -71,9 +72,18 @@ export function useSourceNavigation(source: SourceTagData) {
   return useCallback(
     (event: MouseEvent<HTMLAnchorElement>) => {
       if (event.defaultPrevented || (event.button !== 0 && event.button !== 1)) return
-      recordSource({ url: source.url })
+      recordSource({
+        url: source.url,
+        title: source.title?.trim() ? truncateAtCodePoint(source.title.trim(), 512, '') : undefined,
+        siteName: source.siteName?.trim()
+          ? truncateAtCodePoint(source.siteName.trim(), 128, '')
+          : undefined,
+        connectorType: source.connectorType?.trim()
+          ? truncateAtCodePoint(source.connectorType.trim(), 64, '')
+          : undefined,
+      })
       handleExternalLinkClick(event, source.url)
     },
-    [source.url, recordSource]
+    [source.url, source.title, source.siteName, source.connectorType, recordSource]
   )
 }

apps/sim/lib/api/contracts/knowledge/search-history.ts

@@ -14,11 +14,10 @@ export const viewedSearchSourceSchema = z.object({
   siteName: z.string().trim().min(1).max(128).optional(),
   connectorType: z.string().trim().min(1).max(64).optional(),
 })
-export const recordSearchSourceSchema = viewedSearchSourceSchema.pick({ url: true })
-export type ViewedSearchSource = z.output<typeof recordSearchSourceSchema>
+export type ViewedSearchSource = z.output<typeof viewedSearchSourceSchema>
 
 export const recordSearchHistoryBodySchema = z.discriminatedUnion('kind', [
-  z.object({ kind: z.literal('source'), source: recordSearchSourceSchema }),
+  z.object({ kind: z.literal('source'), source: viewedSearchSourceSchema }),
   z.object({
     kind: z.literal('query'),
     query: z.string().trim().min(1, 'Search query is required').max(4000),

apps/sim/lib/knowledge/application/search-history.ts

@@ -5,14 +5,11 @@ import {
 import { defineOrganizationOperation } from '@/lib/core/application/organization-operation'
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import { requireOrganizationSearchAvailable } from '@/lib/knowledge/access/availability'
-import { createUserKnowledgeAccessProvider } from '@/lib/knowledge/access/scope'
 import {
-  readAccessibleHistorySources,
   readSearchHistory,
   type SearchHistoryEvent,
   updateSearchHistory,
 } from '@/lib/knowledge/search/history/repository'
-import { findSearchIndex } from '@/lib/knowledge/search/search-index'
 import { isKnowledgeSourceUrl } from '@/lib/knowledge/search/source-url'
 
 export const searchHistoryOperations = {
@@ -43,30 +40,15 @@ interface RecordSearchHistoryInput extends SearchHistoryInput {
   event: SearchHistoryEvent
 }
 
-/** Navigation history belongs to the current person, never to the connector or organization collectively. */
+/**
+ * Private navigation snapshots, not a current source catalog. Reading history does not grant
+ * source access; the destination enforces current permissions when the person opens it.
+ */
 export const listSearchHistory = defineAuthorizedOrganizationUseCase({
   operation: searchHistoryOperations.list,
   authorizeResource: ({ context }) => requireOrganizationSearchAvailable(context.organizationId),
-  async execute({ context, request }: OrganizationUseCaseContext<SearchHistoryInput>) {
-    const history = await readSearchHistory(context)
-    if (!history.sources.length) return { ...history, sources: [] }
-    const index = await findSearchIndex({
-      kind: 'organization',
-      organizationId: context.organizationId,
-    })
-    if (!index) return { ...history, sources: [] }
-    const access = createUserKnowledgeAccessProvider(context.userId, {
-      organizationId: context.organizationId,
-      knowledgeBaseIds: [index.id],
-      signal: request?.signal,
-    })
-    const sources = await readAccessibleHistorySources(
-      index.id,
-      history.sources,
-      access,
-      request?.signal
-    )
-    return { ...history, sources }
+  execute({ context }: OrganizationUseCaseContext<SearchHistoryInput>) {
+    return readSearchHistory(context)
   },
 })
 export const recordSearchHistory = defineAuthorizedOrganizationUseCase({

apps/sim/lib/knowledge/search/history/history.integration.ts

@@ -1,14 +1,5 @@
 import { db } from '@sim/db'
-import {
-  document,
-  knowledgeBase,
-  knowledgeConnector,
-  member,
-  organization,
-  organizationSearchHistory,
-  organizationSearchIntegration,
-  user,
-} from '@sim/db/schema'
+import { member, organization, organizationSearchHistory, user } from '@sim/db/schema'
 import { generateId } from '@sim/utils/id'
 import { and, eq, inArray } from 'drizzle-orm'
 import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest'
@@ -21,16 +12,10 @@ import { SEARCH_HISTORY_LIMIT } from '@/lib/knowledge/search/history/limits'
 
 vi.mock('@/lib/knowledge/access/availability', () => ({
   requireOrganizationSearchAvailable: vi.fn(),
-  resolveKnowledgeAccessAvailability: vi.fn(async () => ({
-    sourceMirrored: true,
-    memberScoped: true,
-  })),
 }))
 
 const userIds = [generateId(), generateId()]
 const orgIds = [generateId(), generateId()]
-const indexId = generateId()
-const connectorId = generateId()
 const principal = { kind: 'session', userId: userIds[0], sessionId: 'history-test' } as const
 const input = { organizationId: orgIds[0] }
 const scope = and(
@@ -56,20 +41,6 @@ beforeAll(async () => {
   await db
     .insert(organization)
     .values(orgIds.map((id) => ({ id, name: 'History fixture', slug: id })))
-  await db.insert(knowledgeBase).values({
-    id: indexId,
-    organizationId: orgIds[0],
-    userId: userIds[0],
-    name: 'Search',
-    isSearchIndex: true,
-  })
-  await db.insert(knowledgeConnector).values({
-    id: connectorId,
-    knowledgeBaseId: indexId,
-    connectorType: 'google_drive',
-    sourceConfig: {},
-    accessMode: 'admin',
-  })
   await db.insert(member).values(
     userIds.map((userId) => ({
       id: generateId(),
@@ -80,33 +51,6 @@ beforeAll(async () => {
   )
 })
 beforeEach(async () => {
-  await db
-    .delete(organizationSearchIntegration)
-    .where(eq(organizationSearchIntegration.organizationId, orgIds[0]))
-  await db
-    .update(knowledgeConnector)
-    .set({ archivedAt: null })
-    .where(eq(knowledgeConnector.id, connectorId))
-  await db.delete(document).where(eq(document.knowledgeBaseId, indexId))
-  await db.insert(document).values(
-    [
-      source.url,
-      'https://example.com/other',
-      ...Array.from({ length: 24 }, (_, i) => `https://example.com/${i}`),
-    ].map((url) => ({
-      id: generateId(),
-      knowledgeBaseId: indexId,
-      filename: url === 'https://example.com/23' ? 'Updated title' : source.title,
-      fileUrl: url,
-      sourceUrl: url,
-      fileSize: 1,
-      mimeType: 'text/plain',
-      acl: ['pub'],
-      connectorId,
-      aclVerifiedAt: new Date(),
-      processingStatus: 'completed',
-    }))
-  )
   await db
     .delete(organizationSearchHistory)
     .where(inArray(organizationSearchHistory.organizationId, orgIds))
@@ -173,49 +117,20 @@ describe('private search navigation history', () => {
     expect((await listSearchHistory.execute({ principal, input })).sources).toHaveLength(1)
   })
 
-  it('revalidates current document access and metadata instead of replaying saved titles', async () => {
-    await recordSearchHistory.execute({
-      principal,
-      input: { ...input, event: { kind: 'source', source } },
-    })
-    await db
-      .update(document)
-      .set({ filename: 'Current title' })
-      .where(eq(document.sourceUrl, source.url))
-    expect((await listSearchHistory.execute({ principal, input })).sources[0]?.title).toBe(
-      'Current title'
+  it('retains live and internal navigation without an organization search index', async () => {
+    const visits = [
+      { ...source, siteName: 'Google Docs', connectorType: 'google_drive' },
+      { url: 'https://sim.example.com/o/fixture/knowledge/base/document', title: 'Upload' },
+    ]
+    for (const visit of visits) {
+      await recordSearchHistory.execute({
+        principal,
+        input: { ...input, event: { kind: 'source', source: visit } },
+      })
+    }
+    expect((await listSearchHistory.execute({ principal, input })).sources).toMatchObject(
+      [...visits].reverse()
     )
-    await db
-      .update(document)
-      .set({ acl: ['u:another@fixture.test'] })
-      .where(eq(document.sourceUrl, source.url))
-    expect((await listSearchHistory.execute({ principal, input })).sources).toEqual([])
-    await db
-      .update(document)
-      .set({ acl: ['pub'], userExcluded: true })
-      .where(eq(document.sourceUrl, source.url))
-    expect((await listSearchHistory.execute({ principal, input })).sources).toEqual([])
-    await db.update(document).set({ userExcluded: false }).where(eq(document.sourceUrl, source.url))
-    await db
-      .insert(organizationSearchIntegration)
-      .values({ organizationId: orgIds[0], connectorType: 'google_drive', approved: false })
-    expect((await listSearchHistory.execute({ principal, input })).sources).toEqual([])
-    await db
-      .delete(organizationSearchIntegration)
-      .where(eq(organizationSearchIntegration.organizationId, orgIds[0]))
-    await db
-      .update(knowledgeConnector)
-      .set({ archivedAt: new Date() })
-      .where(eq(knowledgeConnector.id, connectorId))
-    expect((await listSearchHistory.execute({ principal, input })).sources).toEqual([])
-    await recordSearchHistory.execute({
-      principal,
-      input: {
-        ...input,
-        event: { kind: 'source', source: { ...source, url: 'https://example.com/unverifiable' } },
-      },
-    })
-    expect((await listSearchHistory.execute({ principal, input })).sources).toEqual([])
   })
 
   it('deduplicates and bounds concurrent visits without losing unrelated queries', async () => {
@@ -245,7 +160,7 @@ describe('private search navigation history', () => {
         ...input,
         event: {
           kind: 'source',
-          source: { ...source, url: 'https://example.com/23' },
+          source: { ...source, url: 'https://example.com/23', title: 'Updated title' },
         },
       },
     })

apps/sim/lib/knowledge/search/history/repository.ts

@@ -1,15 +1,6 @@
 import { db } from '@sim/db'
-import { document, knowledgeConnector, organizationSearchHistory } from '@sim/db/schema'
-import { truncateAtCodePoint } from '@sim/utils/string'
-import { and, asc, eq, inArray, isNull, sql } from 'drizzle-orm'
-import {
-  knowledgeAccessCondition,
-  knowledgeMetadataCandidateAccessCondition,
-} from '@/lib/knowledge/access/predicate'
-import {
-  type KnowledgeAccessProvider,
-  MAX_KNOWLEDGE_ACCESS_CANDIDATES,
-} from '@/lib/knowledge/access/types'
+import { organizationSearchHistory } from '@sim/db/schema'
+import { and, eq } from 'drizzle-orm'
 import {
   SEARCH_HISTORY_LIMIT,
   SEARCH_HISTORY_MAX_AGE_MS,
@@ -38,8 +29,7 @@ function recentHistory(history: SearchHistory): SearchHistory {
   return {
     sources: history.sources
       .filter((source) => Date.parse(source.viewedAt) > cutoff)
-      .slice(0, SEARCH_HISTORY_LIMIT)
-      .map(({ url, viewedAt }) => ({ url, viewedAt })),
+      .slice(0, SEARCH_HISTORY_LIMIT),
     queries: history.queries
       .filter((entry) => Date.parse(entry.searchedAt) > cutoff)
       .slice(0, SEARCH_HISTORY_LIMIT),
@@ -74,7 +64,7 @@ export async function updateSearchHistory(
     const now = new Date().toISOString()
     if (event?.kind === 'source') {
       history.sources = [
-        { url: event.source.url, viewedAt: now },
+        { ...event.source, viewedAt: now },
         ...history.sources.filter((source) => source.url !== event.source.url),
       ].slice(0, SEARCH_HISTORY_LIMIT)
     } else if (event?.kind === 'query') {
@@ -86,79 +76,3 @@ export async function updateSearchHistory(
     await tx.update(organizationSearchHistory).set(history).where(ownerCondition(owner))
   })
 }
-
-/** Only current indexed metadata can leave the server; an unprovable saved URL is omitted. */
-export async function readAccessibleHistorySources(
-  knowledgeBaseId: string,
-  sources: SearchHistory['sources'],
-  access: KnowledgeAccessProvider,
-  signal?: AbortSignal
-) {
-  if (!sources.length) return []
-  signal?.throwIfAborted()
-  const conditions = [
-    eq(document.knowledgeBaseId, knowledgeBaseId),
-    inArray(
-      sql<string>`md5(${document.sourceUrl})`,
-      sources.map(({ url }) => sql`md5(${url})`)
-    ),
-    inArray(
-      document.sourceUrl,
-      sources.map(({ url }) => url)
-    ),
-    eq(document.enabled, true),
-    eq(document.userExcluded, false),
-    isNull(document.archivedAt),
-    isNull(document.deletedAt),
-  ]
-  let scope = await access.get()
-  let ids: string[] | undefined
-  if (await access.liveSourceConnectorCondition()) {
-    const candidates = await db
-      .select({ id: document.id, connectorId: document.connectorId })
-      .from(document)
-      .where(and(...conditions, knowledgeMetadataCandidateAccessCondition(scope)))
-      .orderBy(asc(document.id))
-      .limit(MAX_KNOWLEDGE_ACCESS_CANDIDATES)
-    if (!candidates.length) return []
-    ids = candidates.map(({ id }) => id)
-    scope = await access.getForConnectors(
-      candidates.flatMap(({ connectorId }) => (connectorId ? [connectorId] : [])),
-      signal
-    )
-  }
-  signal?.throwIfAborted()
-  const rows = await db
-    .select({
-      url: document.sourceUrl,
-      title: sql<string>`left(${document.filename}, 512)`,
-      connectorType: knowledgeConnector.connectorType,
-    })
-    .from(document)
-    .leftJoin(knowledgeConnector, eq(knowledgeConnector.id, document.connectorId))
-    .where(
-      and(
-        ...conditions,
-        ids ? inArray(document.id, ids) : undefined,
-        knowledgeAccessCondition(scope)
-      )
-    )
-    .orderBy(asc(document.id))
-    .limit(MAX_KNOWLEDGE_ACCESS_CANDIDATES)
-  const byUrl = new Map(rows.map((row) => [row.url, row]))
-  return sources.flatMap(({ url, viewedAt }) => {
-    const row = byUrl.get(url)
-    return row
-      ? [
-          {
-            url,
-            viewedAt,
-            title: truncateAtCodePoint(row.title.trim(), 512, '') || undefined,
-            connectorType: row.connectorType
-              ? truncateAtCodePoint(row.connectorType, 64, '')
-              : undefined,
-          },
-        ]
-      : []
-  })
-}