fix(audit-logs): make the placeholder scope-aware, and separate a failed lookup

Two more from review, both on the same surface.

The placeholder I added held previous pages across a workspace change, so
following a scoped link from the organization-wide feed painted the organization's
rows under a workspace-scoped URL until the scoped page arrived — with Export
armed against them. Gating presentation on `isPlaceholderData` would have fixed it
by throwing away the reason the placeholder exists, blanking the feed on every
keystroke again. The scope now leads the query key instead, ahead of the filters,
so "hold across a filter change, never across a scope change" is a prefix
comparison — the same shape the breakdown query already uses, and it retires the
hand-maintained key index.

A failed workspace lookup was reported as a workspace that is not part of the
organization. That is a wrong answer rather than a cautious one, and it offered
nothing to do about it. The two states are now distinct, the error one says so,
and Refresh retries the lookup alongside the feed so the control on screen can
actually clear the state it is showing.

Author: waleedlatif1

apps/sim/ee/audit-logs/components/audit-logs.tsx

@@ -322,7 +322,17 @@ export function AuditLogs({ organizationId }: AuditLogsProps) {
   const isWorkspaceScopePending = Boolean(workspaceScope) && orgWorkspaces.isPending
 
   /**
-   * The link named a workspace this organization cannot resolve — deleted since, or
+   * The lookup itself failed, so whether the workspace exists is simply unknown.
+   *
+   * Kept apart from {@link isWorkspaceScopeUnresolved}: telling an admin their
+   * workspace is not part of the organization because a request timed out is a wrong
+   * answer, not a cautious one, and it offers nothing to do about it. Refresh retries
+   * this lookup alongside the feed.
+   */
+  const isWorkspaceScopeUnavailable = Boolean(workspaceScope) && orgWorkspaces.isError
+
+  /**
+   * The link named a workspace this organization does not have — deleted since, or
    * never one of ours.
    *
    * The feed stays closed rather than falling back to the organization. Every other
@@ -332,10 +342,14 @@ export function AuditLogs({ organizationId }: AuditLogsProps) {
    * that still claims to be scoped, and the CSV export would follow.
    */
   const isWorkspaceScopeUnresolved =
-    Boolean(workspaceScope) && !isWorkspaceScopePending && !scopedWorkspace
+    Boolean(workspaceScope) &&
+    !isWorkspaceScopePending &&
+    !isWorkspaceScopeUnavailable &&
+    !scopedWorkspace
 
   /** The feed can answer the scope the URL asks for — the gate on reading or exporting. */
-  const isScopeAnswerable = !isWorkspaceScopePending && !isWorkspaceScopeUnresolved
+  const isScopeAnswerable =
+    !isWorkspaceScopePending && !isWorkspaceScopeUnresolved && !isWorkspaceScopeUnavailable
   const {
     data,
     isLoading,
@@ -392,7 +406,12 @@ export function AuditLogs({ organizationId }: AuditLogsProps) {
       refreshTimers.delete(timerId)
     }, REFRESH_SPINNER_DURATION_MS)
     refreshTimers.add(timerId)
-    refetch().catch((error: unknown) => {
+    /*
+      Both, because a failed workspace lookup closes the feed — refreshing only the
+      feed would leave the one control on screen unable to clear the state it is
+      showing.
+    */
+    Promise.all([refetch(), orgWorkspaces.refetch()]).catch((error: unknown) => {
       logger.error('Failed to refresh audit logs', { error })
     })
   }
@@ -495,7 +514,7 @@ export function AuditLogs({ organizationId }: AuditLogsProps) {
             {/* Rendered for an unresolved scope too, or a bad link would leave the
                 feed closed with no control to reopen it. */}
             <OverflowText
-              label={`Workspace: ${scopedWorkspace?.name ?? 'not found'}`}
+              label={`Workspace: ${scopedWorkspace?.name ?? (isWorkspaceScopeUnavailable ? 'unavailable' : 'not found')}`}
               className='block min-w-0'
             />
           </Chip>
@@ -559,7 +578,11 @@ export function AuditLogs({ organizationId }: AuditLogsProps) {
       <ActivityLog
         entries={allEntries.map(toActivityEntry)}
         emptyState={
-          isLoading || isWorkspaceScopePending ? undefined : isWorkspaceScopeUnresolved ? (
+          isLoading || isWorkspaceScopePending ? undefined : isWorkspaceScopeUnavailable ? (
+            <SettingsEmptyState tone='error'>
+              Couldn't check that workspace. Refresh to try again.
+            </SettingsEmptyState>
+          ) : isWorkspaceScopeUnresolved ? (
             <SettingsEmptyState>
               That workspace is not part of this organization.
             </SettingsEmptyState>

apps/sim/ee/audit-logs/hooks/audit-logs.test.tsx

@@ -53,13 +53,15 @@ let queryClient: QueryClient
 function AuditProbe({
   organizationId,
   workspaceId,
+  search,
   enabled = true,
 }: {
   organizationId: string
   workspaceId?: string
+  search?: string
   enabled?: boolean
 }) {
-  const auditLogs = useAuditLogs(organizationId, { workspaceId }, enabled)
+  const auditLogs = useAuditLogs(organizationId, { workspaceId, search }, enabled)
   const entries = auditLogs.data?.pages.flatMap((page) => page.data) ?? []
 
   return (
@@ -70,11 +72,22 @@ function AuditProbe({
   )
 }
 
-function renderAuditLogs(organizationId: string, workspaceId?: string, enabled = true) {
+interface RenderOptions {
+  workspaceId?: string
+  search?: string
+  enabled?: boolean
+}
+
+function renderAuditLogs(organizationId: string, options: RenderOptions = {}) {
   act(() => {
     root.render(
       <QueryClientProvider client={queryClient}>
-        <AuditProbe organizationId={organizationId} workspaceId={workspaceId} enabled={enabled} />
+        <AuditProbe
+          organizationId={organizationId}
+          workspaceId={options.workspaceId}
+          search={options.search}
+          enabled={options.enabled ?? true}
+        />
       </QueryClientProvider>
     )
   })
@@ -140,25 +153,51 @@ describe('useAuditLogs identity transitions', () => {
   })
 
   /** Blanking the feed on each keystroke is what the placeholder exists to stop. */
-  it('holds the current entries while a filter change loads, within one organization', async () => {
+  it('holds the current entries while a filter change loads, within one scope', async () => {
     const filteredPage = createDeferred<AuditLogPage>()
     mockRequestJson.mockImplementation(
-      (contract: unknown, input: { query?: { workspaceId?: string } }) => {
+      (contract: unknown, input: { query?: { search?: string } }) => {
         if (contract !== listAuditLogsContract) throw new Error('Unexpected contract')
-        return input.query?.workspaceId ? filteredPage.promise : Promise.resolve(AUDIT_PAGE_A)
+        return input.query?.search ? filteredPage.promise : Promise.resolve(AUDIT_PAGE_A)
       }
     )
 
     renderAuditLogs('org-a')
     await flushQueries()
     expect(container).toHaveTextContent('Updated Organization A')
 
-    renderAuditLogs('org-a', 'workspace-a')
+    renderAuditLogs('org-a', { search: 'canary' })
     await flushQueries()
 
     expect(container).toHaveTextContent('Updated Organization A')
   })
 
+  /**
+   * The other side of that rule. A workspace is a scope, not a filter: holding the
+   * organization-wide rows while the scoped page loads would show, under a
+   * workspace-scoped URL, entries that scope does not cover — with Export armed
+   * against them, since it gates on this list being non-empty.
+   */
+  it('clears the entries when the workspace scope changes, within one organization', async () => {
+    const scopedPage = createDeferred<AuditLogPage>()
+    mockRequestJson.mockImplementation(
+      (contract: unknown, input: { query?: { workspaceId?: string } }) => {
+        if (contract !== listAuditLogsContract) throw new Error('Unexpected contract')
+        return input.query?.workspaceId ? scopedPage.promise : Promise.resolve(AUDIT_PAGE_A)
+      }
+    )
+
+    renderAuditLogs('org-a')
+    await flushQueries()
+    expect(container).toHaveTextContent('Updated Organization A')
+
+    renderAuditLogs('org-a', { workspaceId: 'workspace-a' })
+    await flushQueries()
+
+    expect(container).not.toHaveTextContent('Updated Organization A')
+    expect(container.querySelector('button')).toBeNull()
+  })
+
   /**
    * The scope a link asks for is a ceiling, not a hint. A workspace id that no longer
    * resolves must leave the feed closed rather than answering with the whole
@@ -167,7 +206,7 @@ describe('useAuditLogs identity transitions', () => {
   it('never queries unscoped while a workspace scope is unresolved', async () => {
     mockRequestJson.mockResolvedValue(AUDIT_PAGE_A)
 
-    renderAuditLogs('org-a', undefined, false)
+    renderAuditLogs('org-a', { enabled: false })
     await flushQueries()
 
     expect(mockRequestJson).not.toHaveBeenCalled()

apps/sim/ee/audit-logs/hooks/audit-logs.ts

@@ -1,4 +1,4 @@
-import { useInfiniteQuery } from '@tanstack/react-query'
+import { hashKey, useInfiniteQuery } from '@tanstack/react-query'
 import { requestJson } from '@/lib/api/client/request'
 import { type AuditLogPage, listAuditLogsContract } from '@/lib/api/contracts/audit-logs'
 
@@ -7,16 +7,23 @@ export const AUDIT_LOG_LIST_STALE_TIME = 30 * 1000
 export const auditLogKeys = {
   all: ['audit-logs'] as const,
   lists: () => [...auditLogKeys.all, 'list'] as const,
+  /**
+   * What a key is allowed to see: the organization, and the workspace within it.
+   *
+   * It leads the key, ahead of the filters, because previous data may be held across
+   * a filter change but never across a scope change — and a leading scope makes that
+   * a prefix comparison rather than a reach inside the filter object.
+   */
+  scope: (organizationId: string, workspaceId?: string) =>
+    [...auditLogKeys.lists(), organizationId, workspaceId ?? ''] as const,
   list: (organizationId: string, filters: AuditLogFilters) =>
-    [...auditLogKeys.lists(), organizationId, filters] as const,
+    [...auditLogKeys.scope(organizationId, filters.workspaceId), filters] as const,
 }
 
-/**
- * Position of the organization id in a key built by {@link auditLogKeys.list} —
- * derived from the factory rather than restated, so a new prefix segment cannot
- * silently point this at the wrong element.
- */
-const AUDIT_LOG_KEY_ORGANIZATION_INDEX = auditLogKeys.lists().length
+/** The scope a key reads from, which is everything but its trailing filter object. */
+function auditListScopeIdentity(key: readonly unknown[]): string {
+  return hashKey(key.slice(0, -1))
+}
 
 export interface AuditLogFilters {
   search?: string
@@ -53,24 +60,28 @@ async function fetchAuditLogs(
 }
 
 export function useAuditLogs(organizationId: string, filters: AuditLogFilters, enabled = true) {
+  const queryKey = auditLogKeys.list(organizationId, filters)
   return useInfiniteQuery({
-    queryKey: auditLogKeys.list(organizationId, filters),
+    queryKey,
     queryFn: ({ pageParam, signal }) => fetchAuditLogs(organizationId, filters, pageParam, signal),
     initialPageParam: undefined as string | undefined,
     getNextPageParam: (lastPage) => lastPage.nextCursor,
     enabled: Boolean(organizationId) && enabled,
     staleTime: AUDIT_LOG_LIST_STALE_TIME,
     /**
-     * Held across a filter change, never across an organization change.
+     * Held across a filter change, never across a scope change.
      *
-     * Every filter — search, types, window, workspace — is part of the key, so
-     * without a placeholder the feed blanks to its empty state on each keystroke, and
-     * the Export action's `isPlaceholderData` guard was dead. But the organization is
-     * in the key too, and `keepPreviousData` alone would paint one tenant's audit
-     * entries under another tenant's heading while the new page loaded.
+     * Search, types and the window are all part of the key, so without a placeholder
+     * the feed blanks to its empty state on each keystroke and the Export action's
+     * `isPlaceholderData` guard is dead. But the organization and the workspace are in
+     * the key too, and holding across either shows rows the current scope does not
+     * cover — one tenant's entries under another's heading, or the organization's
+     * under a workspace-scoped URL — with Export armed against them.
      */
     placeholderData: (previous, previousQuery) =>
-      previous && previousQuery?.queryKey[AUDIT_LOG_KEY_ORGANIZATION_INDEX] === organizationId
+      previous &&
+      previousQuery &&
+      auditListScopeIdentity(previousQuery.queryKey) === auditListScopeIdentity(queryKey)
         ? previous
         : undefined,
   })