@vertesia/ui 1.5.0-dev.20260807.073259Z → 1.5.0-dev.20260901.005903Z

package/src/features/facets/CollectionsFacetsNav.tsx

@@ -1,4 +1,4 @@
-import type { FacetBucket } from '@vertesia/common';
+import type { ComplexCollectionSearchQuery, FacetBucket } from '@vertesia/common';
 import {
     type Filter as BaseFilter,
     FilterBar,
@@ -9,14 +9,22 @@ import {
 } from '@vertesia/ui/core';
 import { useState } from 'react';
 import { useTypeRegistry } from '../store/types/TypeRegistryProvider.js';
-import { filterValueToQueryValue, type SearchInterface, setSearchQueryValue } from './utils/SearchInterface';
+import {
+    createSearchQueryKeyGuard,
+    filterValueToQueryValue,
+    type SearchInterface,
+    setSearchQueryValue,
+} from './utils/SearchInterface';
+
+const collectionFilterNames = ['name', 'types'] as const satisfies readonly (keyof ComplexCollectionSearchQuery)[];
+const isCollectionFilterName = createSearchQueryKeyGuard<ComplexCollectionSearchQuery>(collectionFilterNames);
 
 interface CollectionsFacetsNavProps {
     facets: {
         type?: FacetBucket[];
         dynamic?: FacetBucket[];
     };
-    search: SearchInterface;
+    search: SearchInterface<ComplexCollectionSearchQuery>;
     /**
      * Optional controlled filter state. When provided, the parent owns the filter list (and is
      * responsible for translating it into the search query via {@link useCollectionsFilterHandler}).
@@ -70,7 +78,7 @@ export function useCollectionsFilterGroups(facets: CollectionsFacetsNavProps['fa
 }
 
 // Hook to create filter change handler for collections
-export function useCollectionsFilterHandler(search: SearchInterface) {
+export function useCollectionsFilterHandler(search: SearchInterface<ComplexCollectionSearchQuery>) {
     return (newFilters: BaseFilter[]) => {
         if (newFilters.length === 0) {
             // Clear filters without applying defaults - user wants to remove all filters
@@ -83,6 +91,9 @@ export function useCollectionsFilterHandler(search: SearchInterface) {
 
         newFilters.forEach((filter) => {
             if (filter.value && filter.value.length > 0) {
+                if (!isCollectionFilterName(filter.name)) {
+                    return;
+                }
                 const filterName = filter.name;
                 const filterValue = filterValueToQueryValue(filter);
                 setSearchQueryValue(search, filterName, filterValue);

package/src/features/facets/DocumentsFacetsNav.tsx

@@ -1,4 +1,4 @@
-import type { ComputedFacetResponse } from '@vertesia/common';
+import type { ComplexSearchQuery, ComputedFacetResponse } from '@vertesia/common';
 import {
     type Filter as BaseFilter,
     FilterBar,
@@ -11,6 +11,7 @@ import {
 import { useState } from 'react';
 import { useTypeRegistry } from '../store/types/TypeRegistryProvider.js';
 import {
+    createSearchQueryKeyGuard,
     filterValueToQueryValue,
     type SearchInterface,
     setSearchQueryValue,
@@ -19,9 +20,24 @@ import {
 import { VStringFacet } from './utils/VStringFacet';
 import { VTypeFacet } from './utils/VTypeFacet';
 
+const documentQueryFilterNames = [
+    'id',
+    'name',
+    'types',
+    'status',
+] as const satisfies readonly (keyof ComplexSearchQuery)[];
+const documentMatchFilterNames = ['tags', 'created_at', 'updated_at'] as const;
+const isDocumentQueryFilterName = createSearchQueryKeyGuard<ComplexSearchQuery>(documentQueryFilterNames);
+const documentMatchFilterNameSet = new Set<string>(documentMatchFilterNames);
+type DocumentMatchFilterName = (typeof documentMatchFilterNames)[number];
+
+function isDocumentMatchFilterName(name: string): name is DocumentMatchFilterName {
+    return documentMatchFilterNameSet.has(name);
+}
+
 interface DocumentsFacetsNavProps {
     facets: ComputedFacetResponse;
-    search: SearchInterface;
+    search: SearchInterface<ComplexSearchQuery>;
 }
 
 function getBuckets(value: ComputedFacetResponse[string]) {
@@ -100,7 +116,7 @@ export function useDocumentFilterGroups(facets: DocumentsFacetsNavProps['facets'
 }
 
 // Hook to create filter change handler for documents
-export function useDocumentFilterHandler(search: SearchInterface) {
+export function useDocumentFilterHandler(search: SearchInterface<ComplexSearchQuery>) {
     return (newFilters: BaseFilter[]) => {
         if (newFilters.length === 0) {
             search.clearFilters();
@@ -138,12 +154,13 @@ export function useDocumentFilterHandler(search: SearchInterface) {
                     filterValue = filterValueToQueryValue(filter);
                 }
 
-                if (filterName === 'name') {
-                    setSearchQueryValue(search, 'name', filterValue);
-                } else if (filterName === 'id') {
-                    setSearchQueryValue(search, 'id', filterValue);
-                } else {
+                if (isDocumentQueryFilterName(filterName)) {
                     setSearchQueryValue(search, filterName, filterValue);
+                } else if (isDocumentMatchFilterName(filterName) && filterValue !== undefined) {
+                    search.query.match = {
+                        ...search.query.match,
+                        [filterName]: filterValue,
+                    };
                 }
             }
         });

package/src/features/facets/FacetQueryHandlers.test.ts

@@ -0,0 +1,84 @@
+import type {
+    ComplexCollectionSearchQuery,
+    ComplexSearchQuery,
+    InteractionSearchQuery,
+    PromptSearchQuery,
+} from '@vertesia/common';
+import { describe, expect, it, vi } from 'vitest';
+import type { AgentRunnerFilterQuery } from './AgentRunnerFacetsNav.js';
+import { createAgentRunnerFilterHandler } from './AgentRunnerFacetsNav.js';
+import { useCollectionsFilterHandler } from './CollectionsFacetsNav.js';
+import { useDocumentFilterHandler } from './DocumentsFacetsNav.js';
+import { useInteractionsFilterHandler } from './InteractionsFacetsNav.js';
+import { usePromptsFilterHandler } from './PromptsFacetsNav.js';
+import type { SearchInterface } from './utils/SearchInterface.js';
+
+function createSearch<Query extends object>(): SearchInterface<Query> {
+    return {
+        query: {} as Query,
+        isRunning: false,
+        getFilterValue: vi.fn(),
+        setFilterValue: vi.fn(),
+        clearFilters: vi.fn(),
+        search: vi.fn().mockResolvedValue(true),
+        setDefaultKeys: vi.fn(),
+    };
+}
+
+describe('facet query handlers', () => {
+    it('only writes supported collection query keys', () => {
+        const search = createSearch<ComplexCollectionSearchQuery>();
+        useCollectionsFilterHandler(search)([
+            { name: 'name', type: 'text', value: [{ value: 'Policies' }] },
+            { name: 'unsupported', type: 'text', value: [{ value: 'ignored' }] },
+        ]);
+        expect(search.query).toEqual({ name: 'Policies' });
+    });
+
+    it('only writes supported prompt query keys', () => {
+        const search = createSearch<PromptSearchQuery>();
+        usePromptsFilterHandler(search)([
+            { name: 'tags', type: 'stringList', multiple: true, value: ['reviewed'] },
+            { name: 'unsupported', type: 'text', value: [{ value: 'ignored' }] },
+        ]);
+        expect(search.query).toEqual({ tags: ['reviewed'] });
+    });
+
+    it('only writes supported interaction query keys', () => {
+        const search = createSearch<InteractionSearchQuery>();
+        useInteractionsFilterHandler(search)([
+            { name: 'model', type: 'text', value: [{ value: 'model-1' }] },
+            { name: 'unsupported', type: 'text', value: [{ value: 'ignored' }] },
+        ]);
+        expect(search.query).toEqual({ model: 'model-1' });
+    });
+
+    it('nests document match filters instead of adding unsupported top-level properties', () => {
+        const search = createSearch<ComplexSearchQuery>();
+        useDocumentFilterHandler(search)([
+            { name: 'tags', type: 'stringList', multiple: true, value: ['legal'] },
+            {
+                name: 'created_at',
+                type: 'date',
+                multiple: true,
+                value: [{ value: '2026-01-01' }, { value: '2026-01-31' }],
+            },
+            { name: 'unsupported', type: 'text', value: [{ value: 'ignored' }] },
+        ]);
+        expect(search.query).toEqual({
+            match: {
+                tags: ['legal'],
+                created_at: { gte: '2026-01-01', lte: '2026-01-31' },
+            },
+        });
+    });
+
+    it('only writes supported agent runner adapter keys', () => {
+        const search = createSearch<AgentRunnerFilterQuery>();
+        createAgentRunnerFilterHandler(search)([
+            { name: 'initiated_by', type: 'text', value: [{ value: 'user-1' }] },
+            { name: 'started_by', type: 'text', value: [{ value: 'ignored' }] },
+        ]);
+        expect(search.query).toEqual({ initiated_by: 'user-1' });
+    });
+});

package/src/features/facets/InteractionsFacetsNav.tsx

@@ -1,4 +1,4 @@
-import type { ComputedFacetResponse } from '@vertesia/common';
+import type { ComputedFacetResponse, InteractionSearchQuery } from '@vertesia/common';
 import {
     type Filter as BaseFilter,
     FilterBar,
@@ -8,11 +8,24 @@ import {
     FilterProvider,
 } from '@vertesia/ui/core';
 import { useState } from 'react';
-import { filterValueToQueryValue, type SearchInterface, setSearchQueryValue } from './utils/SearchInterface';
+import {
+    createSearchQueryKeyGuard,
+    filterValueToQueryValue,
+    type SearchInterface,
+    setSearchQueryValue,
+} from './utils/SearchInterface';
+
+const interactionFilterNames = [
+    'name',
+    'prompt',
+    'model',
+    'tags',
+] as const satisfies readonly (keyof InteractionSearchQuery)[];
+const isInteractionFilterName = createSearchQueryKeyGuard<InteractionSearchQuery>(interactionFilterNames);
 
 interface InteractionsFacetsNavProps {
     facets: ComputedFacetResponse;
-    search: SearchInterface;
+    search: SearchInterface<InteractionSearchQuery>;
     env?: string | null;
     /**
      * Optional controlled filter state. When provided, the parent owns the filter list (and is
@@ -69,7 +82,7 @@ export function useInteractionsFilterGroups(facets: InteractionsFacetsNavProps['
 }
 
 // Hook to create filter change handler for interactions
-export function useInteractionsFilterHandler(search: SearchInterface) {
+export function useInteractionsFilterHandler(search: SearchInterface<InteractionSearchQuery>) {
     return (newFilters: BaseFilter[]) => {
         if (newFilters.length === 0) {
             search.clearFilters(true, true);
@@ -82,6 +95,9 @@ export function useInteractionsFilterHandler(search: SearchInterface) {
 
         newFilters.forEach((filter) => {
             if (filter.value && filter.value.length > 0) {
+                if (!isInteractionFilterName(filter.name)) {
+                    return;
+                }
                 const filterName = filter.name;
                 const filterValue = filterValueToQueryValue(filter);
                 setSearchQueryValue(search, filterName, filterValue);

package/src/features/facets/PromptsFacetsNav.tsx

@@ -1,4 +1,4 @@
-import type { ComputedFacetResponse, FacetBucket } from '@vertesia/common';
+import type { ComputedFacetResponse, FacetBucket, PromptSearchQuery } from '@vertesia/common';
 import {
     type Filter as BaseFilter,
     FilterBar,
@@ -8,7 +8,15 @@ import {
     FilterProvider,
 } from '@vertesia/ui/core';
 import { useState } from 'react';
-import { filterValueToQueryValue, type SearchInterface, setSearchQueryValue } from './utils/SearchInterface';
+import {
+    createSearchQueryKeyGuard,
+    filterValueToQueryValue,
+    type SearchInterface,
+    setSearchQueryValue,
+} from './utils/SearchInterface';
+
+const promptFilterNames = ['name', 'role', 'tags'] as const satisfies readonly (keyof PromptSearchQuery)[];
+const isPromptFilterName = createSearchQueryKeyGuard<PromptSearchQuery>(promptFilterNames);
 
 interface PromptsFacetsNavProps {
     /**
@@ -18,7 +26,7 @@ interface PromptsFacetsNavProps {
      * requests and could not describe a caller that asks for a different one.
      */
     facets: ComputedFacetResponse;
-    search: SearchInterface;
+    search: SearchInterface<PromptSearchQuery>;
     /**
      * Optional controlled filter state. When provided, the parent owns the filter list (and is
      * responsible for translating it into the search query via {@link usePromptsFilterHandler}). This
@@ -81,7 +89,7 @@ export function usePromptsFilterGroups(facets: PromptsFacetsNavProps['facets']):
 }
 
 // Hook to create filter change handler for prompts
-export function usePromptsFilterHandler(search: SearchInterface) {
+export function usePromptsFilterHandler(search: SearchInterface<PromptSearchQuery>) {
     return (newFilters: BaseFilter[]) => {
         if (newFilters.length === 0) {
             // Clear filters without applying defaults - user wants to remove all filters
@@ -94,6 +102,9 @@ export function usePromptsFilterHandler(search: SearchInterface) {
 
         newFilters.forEach((filter) => {
             if (filter.value && filter.value.length > 0) {
+                if (!isPromptFilterName(filter.name)) {
+                    return;
+                }
                 const filterName = filter.name;
                 const filterValue = filterValueToQueryValue(filter);
                 setSearchQueryValue(search, filterName, filterValue);

package/src/features/facets/RunsFacetsNav.test.ts

@@ -0,0 +1,59 @@
+import type { RunSearchQuery } from '@vertesia/common';
+import { describe, expect, it, vi } from 'vitest';
+import { useRunsFilterGroups, useRunsFilterHandler } from './RunsFacetsNav.js';
+import type { SearchInterface } from './utils/SearchInterface.js';
+
+function createSearch(): SearchInterface<RunSearchQuery> {
+    return {
+        query: {},
+        isRunning: false,
+        getFilterValue: vi.fn(),
+        setFilterValue: vi.fn(),
+        clearFilters: vi.fn(),
+        search: vi.fn().mockResolvedValue(true),
+        setDefaultKeys: vi.fn(),
+    };
+}
+
+describe('useRunsFilterGroups', () => {
+    it('builds controls from supported facets and keeps query-only filters', () => {
+        const groups = useRunsFilterGroups({
+            interactions: [
+                { _id: null, count: 2 },
+                { _id: 'interaction-1', count: 3, name: 'Interaction One' },
+            ],
+            finish_reason: [{ _id: null, count: 4 }],
+            environments: [{ _id: 'production', count: 5 }],
+        });
+
+        expect(groups.map((group) => group.name)).toEqual([
+            'run_ids',
+            'interaction',
+            'environment',
+            'tags',
+            'finish_reason',
+            'start',
+            'end',
+            'workflow_run_ids',
+            'workflow_ids',
+        ]);
+        expect(groups.find((group) => group.name === 'interaction')?.options).toEqual([
+            { label: '(3)', value: 'interaction-1' },
+        ]);
+        expect(groups.find((group) => group.name === 'finish_reason')?.options).toEqual([
+            { label: 'none (4)', value: 'none' },
+        ]);
+    });
+
+    it('uses the singular API environment key and ignores unsupported names', () => {
+        const search = createSearch();
+
+        useRunsFilterHandler(search)([
+            { name: 'environment', type: 'text', value: [{ value: 'production' }] },
+            { name: 'environments', type: 'text', value: [{ value: 'ignored' }] },
+        ]);
+
+        expect(search.query).toEqual({ environment: 'production' });
+        expect(search.search).toHaveBeenCalledOnce();
+    });
+});

package/src/features/facets/RunsFacetsNav.tsx

@@ -1,4 +1,4 @@
-import type { FacetBucket } from '@vertesia/common';
+import type { ComputeRunFacetsResponse, RunSearchQuery } from '@vertesia/common';
 import {
     type Filter as BaseFilter,
     Button,
@@ -10,25 +10,34 @@ import {
 } from '@vertesia/ui/core';
 import { RefreshCw } from 'lucide-react';
 import { useState } from 'react';
-import { filterValueToQueryValue, type SearchInterface, setSearchQueryValue } from './utils/SearchInterface';
+import {
+    createSearchQueryKeyGuard,
+    filterValueToQueryValue,
+    type SearchInterface,
+    setSearchQueryValue,
+} from './utils/SearchInterface';
 import { VEnvironmentFacet } from './utils/VEnvironmentFacet';
-import type { EnrichedFacetBucket } from './utils/VInteractionFacet';
 import { VInteractionFacet } from './utils/VInteractionFacet';
 import { VStringFacet } from './utils/VStringFacet';
-import { VUserFacet } from './utils/VUserFacet';
+
+const runFilterNames = [
+    'run_ids',
+    'interaction',
+    'environment',
+    'tags',
+    'model',
+    'status',
+    'finish_reason',
+    'start',
+    'end',
+    'workflow_run_ids',
+    'workflow_ids',
+] as const satisfies readonly (keyof RunSearchQuery)[];
+const isRunFilterName = createSearchQueryKeyGuard<RunSearchQuery>(runFilterNames);
 
 interface RunsFacetsNavProps {
-    facets: {
-        type?: FacetBucket[];
-        interactions?: EnrichedFacetBucket[];
-        environments?: FacetBucket[];
-        models?: FacetBucket[];
-        statuses?: FacetBucket[];
-        tags?: FacetBucket[];
-        finish_reason?: FacetBucket[];
-        created_by?: FacetBucket[];
-    };
-    search: SearchInterface;
+    facets: Pick<ComputeRunFacetsResponse, 'interactions' | 'environments' | 'models' | 'statuses' | 'finish_reason'>;
+    search: SearchInterface<RunSearchQuery>;
     actions?: React.ReactNode[];
     selectionCount?: number;
     /**
@@ -42,6 +51,13 @@ interface RunsFacetsNavProps {
     filterGroups?: FilterGroup[];
 }
 
+type RunFacetBucket = NonNullable<ComputeRunFacetsResponse['models']>[number];
+type IdentifiedRunFacetBucket<T extends RunFacetBucket = RunFacetBucket> = T & { _id: string };
+
+function identifiedBuckets<T extends RunFacetBucket>(buckets: T[]): IdentifiedRunFacetBucket<T>[] {
+    return buckets.filter((bucket): bucket is IdentifiedRunFacetBucket<T> => bucket._id !== null);
+}
+
 // Hook to create filter groups for runs
 export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): FilterGroup[] {
     const customFilterGroups: FilterGroup[] = [];
@@ -56,7 +72,7 @@ export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): Filte
 
     if (facets.interactions) {
         const interactionFilterGroup = VInteractionFacet({
-            buckets: facets.interactions || [],
+            buckets: identifiedBuckets(facets.interactions),
             name: 'interaction',
             placeholder: 'Interactions',
         });
@@ -65,8 +81,8 @@ export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): Filte
 
     if (facets.environments) {
         const environmentFilterGroup = VEnvironmentFacet({
-            buckets: facets.environments || [],
-            name: 'environments',
+            buckets: identifiedBuckets(facets.environments),
+            name: 'environment',
         });
         customFilterGroups.push(environmentFilterGroup);
     }
@@ -82,7 +98,7 @@ export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): Filte
 
     if (facets.models) {
         const modelFilterGroup = VStringFacet({
-            buckets: facets.models || [],
+            buckets: identifiedBuckets(facets.models),
             name: 'model',
         });
         customFilterGroups.push(modelFilterGroup);
@@ -90,7 +106,7 @@ export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): Filte
 
     if (facets.statuses) {
         const statusFilterGroup = VStringFacet({
-            buckets: facets.statuses || [],
+            buckets: identifiedBuckets(facets.statuses),
             name: 'status',
         });
         customFilterGroups.push(statusFilterGroup);
@@ -110,15 +126,6 @@ export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): Filte
         customFilterGroups.push(finishReasonFilterGroup);
     }
 
-    if (facets.created_by) {
-        const createdByFilterGroup = VUserFacet({
-            buckets: facets.created_by || [],
-            name: 'created_by',
-            placeholder: 'Created By',
-        });
-        customFilterGroups.push(createdByFilterGroup);
-    }
-
     const dateAfterFilterGroup = {
         name: 'start',
         placeholder: 'Date After',
@@ -155,7 +162,7 @@ export function useRunsFilterGroups(facets: RunsFacetsNavProps['facets']): Filte
 }
 
 // Hook to create filter change handler for runs
-export function useRunsFilterHandler(search: SearchInterface) {
+export function useRunsFilterHandler(search: SearchInterface<RunSearchQuery>) {
     return (newFilters: BaseFilter[]) => {
         if (newFilters.length === 0) {
             // Clear filters without applying defaults - user wants to remove all filters
@@ -168,6 +175,9 @@ export function useRunsFilterHandler(search: SearchInterface) {
 
         newFilters.forEach((filter) => {
             if (filter.value && filter.value.length > 0) {
+                if (!isRunFilterName(filter.name)) {
+                    return;
+                }
                 const filterName = filter.name;
                 let filterValue = filterValueToQueryValue(filter);
 

package/src/features/facets/WorkflowExecutionsFacetsNav.test.ts

@@ -0,0 +1,57 @@
+import type { ListWorkflowRunsPayload } from '@vertesia/common';
+import { describe, expect, it, vi } from 'vitest';
+import type { SearchInterface } from './utils/SearchInterface.js';
+import {
+    useWorkflowExecutionsFilterGroups,
+    useWorkflowExecutionsFilterHandler,
+} from './WorkflowExecutionsFacetsNav.js';
+
+function createSearch(): SearchInterface<ListWorkflowRunsPayload> {
+    return {
+        query: {},
+        isRunning: false,
+        getFilterValue: vi.fn(),
+        setFilterValue: vi.fn(),
+        clearFilters: vi.fn(),
+        search: vi.fn().mockResolvedValue(true),
+        setDefaultKeys: vi.fn(),
+    };
+}
+
+describe('useWorkflowExecutionsFilterHandler', () => {
+    it('uses API payload keys for every filter group', () => {
+        expect(
+            useWorkflowExecutionsFilterGroups({
+                status: [{ _id: 'running', count: 1 }],
+                initiated_by: [{ _id: 'user-1', count: 1 }],
+            }).map((group) => group.name),
+        ).toEqual(['search_term', 'status', 'initiated_by', 'start', 'end', 'has_reported_errors']);
+    });
+
+    it('maps the workflow name or run ID filter directly to search_term', () => {
+        const search = createSearch();
+        const handleFilters = useWorkflowExecutionsFilterHandler(search);
+
+        handleFilters([
+            {
+                name: 'search_term',
+                type: 'text',
+                value: [{ value: 'workflow-or-run-id' }],
+            },
+        ]);
+
+        expect(search.query).toEqual({ search_term: 'workflow-or-run-id' });
+        expect(search.clearFilters).toHaveBeenCalledWith(false);
+        expect(search.search).toHaveBeenCalledOnce();
+    });
+
+    it('does not copy unknown filter names into the API payload', () => {
+        const search = createSearch();
+        const handleFilters = useWorkflowExecutionsFilterHandler(search);
+
+        handleFilters([{ name: 'unsupported', type: 'text', value: [{ value: 'value' }] }]);
+
+        expect(search.query).toEqual({});
+        expect(search.search).toHaveBeenCalledOnce();
+    });
+});