feat: date-range filter for knowledge table file list

custom_components/openrag/opensearch_multimodal.py

@@ -1777,6 +1777,21 @@ def _is_placeholder_term(self, term_obj: dict) -> bool:
         # term_obj like {"filename": "__IMPOSSIBLE_VALUE__"}
         return any(v == "__IMPOSSIBLE_VALUE__" for v in term_obj.values())
 
+    @staticmethod
+    def _is_valid_range_clause(clause: Any) -> bool:
+        """Return True for a single-field range clause with at least one bound."""
+        if not isinstance(clause, dict) or not isinstance(clause.get("range"), dict):
+            return False
+        range_obj = clause["range"]
+        if len(range_obj) != 1:
+            return False
+        bounds = next(iter(range_obj.values()))
+        if not isinstance(bounds, dict):
+            return False
+        return any(
+            key in bounds and bounds[key] not in (None, "") for key in ("gte", "gt", "lte", "lt")
+        )
+
     def _coerce_filter_clauses(self, filter_obj: dict | None) -> list[dict]:
         """Convert filter expressions into OpenSearch-compatible filter clauses.
 
@@ -1794,7 +1809,7 @@ def _coerce_filter_clauses(self, filter_obj: dict | None) -> list[dict]:
             filter_obj: Filter configuration dictionary or None
 
         Returns:
-            List of OpenSearch filter clauses (term/terms objects)
+            List of OpenSearch filter clauses (term/terms/range objects)
             Placeholder values with "__IMPOSSIBLE_VALUE__" are ignored
         """
         if not filter_obj:
@@ -1825,6 +1840,8 @@ def _coerce_filter_clauses(self, filter_obj: dict | None) -> list[dict]:
                     field, vals = next(iter(f["terms"].items()))
                     if isinstance(vals, list) and len(vals) > 0:
                         explicit_clauses.append(f)
+                elif self._is_valid_range_clause(f):
+                    explicit_clauses.append(f)
             return explicit_clauses
 
         # Case B: convert context-style maps into clauses
@@ -2368,6 +2385,11 @@ def search(self, query: str | None = None) -> list[dict[str, Any]]:
                     }
                 }
             }
+            # Filter inside each kNN clause so the nearest neighbours are chosen
+            # from matching documents; the outer bool filter alone would only
+            # post-filter the global top-k and miss narrow ranges.
+            if filter_clauses:
+                base_query["knn"][selected_field]["filter"] = {"bool": {"filter": filter_clauses}}
 
             if use_num_candidates:
                 query_with_candidates = copy.deepcopy(base_query)

frontend/app/api/queries/useGetSearchQuery.test.tsx

@@ -61,10 +61,17 @@ function serveSearch(body: Record<string, unknown>, status = 200) {
   return seen;
 }
 
-async function runSearch(query: string, data?: ParsedQueryData | null) {
-  const rendered = renderHook(() => useGetSearchQuery(query, data), {
-    wrapper: createQueryWrapper(),
-  });
+async function runSearch(
+  query: string,
+  data?: ParsedQueryData | null,
+  dateRange?: { createdAfter?: string; createdBefore?: string },
+) {
+  const rendered = renderHook(
+    () => useGetSearchQuery(query, data, undefined, dateRange),
+    {
+      wrapper: createQueryWrapper(),
+    },
+  );
   await waitFor(() =>
     expect(
       rendered.result.current.isSuccess || rendered.result.current.isError,
@@ -389,4 +396,41 @@ describe("useGetSearchQuery", () => {
       expect(calls).toBe(1);
     });
   });
+
+  describe("date bounds", () => {
+    const AFTER = "2026-10-07T07:00:00.000Z";
+    const BEFORE = "2026-10-11T06:59:59.999999Z";
+    const saved = () =>
+      queryData({
+        filters: {
+          data_sources: [],
+          document_types: ["application/pdf"],
+          owners: [],
+          connector_types: [],
+          created_after: AFTER,
+          created_before: BEFORE,
+        },
+      });
+
+    it("sends the effective bounds beside the PDF filter", async () => {
+      const seen = serveSearch({ results: [] });
+      await runSearch("term", saved(), {
+        createdAfter: AFTER,
+        createdBefore: BEFORE,
+      });
+      expect(seen.payload?.filters).toEqual({
+        document_types: ["application/pdf"],
+      });
+      expect(seen.payload?.created_after).toBe(AFTER);
+      expect(seen.payload?.created_before).toBe(BEFORE);
+    });
+
+    it("does not fall back to saved dates when the range was cleared", async () => {
+      const seen = serveSearch({ results: [] });
+      await runSearch("term", saved(), {});
+      expect(seen.payload?.created_after).toBeUndefined();
+      expect(seen.payload?.created_before).toBeUndefined();
+      expect(JSON.stringify(seen.payload)).not.toContain("created_");
+    });
+  });
 });

frontend/app/api/queries/useGetSearchQuery.ts

@@ -18,6 +18,8 @@ export interface SearchPayload {
     owners?: string[];
     connector_types?: string[];
   };
+  created_after?: string;
+  created_before?: string;
 }
 
 export interface ChunkResult {
@@ -46,6 +48,7 @@ export interface ChunkResult {
   index?: number;
   allowed_users?: string[];
   allowed_groups?: string[];
+  indexed_time?: string;
 }
 
 export interface File {
@@ -82,6 +85,7 @@ export interface File {
   chunks?: ChunkResult[];
   allowed_users?: string[];
   allowed_groups?: string[];
+  indexed_time?: string;
 }
 
 // Non-fatal signal from the backend — e.g. an embedding provider was removed
@@ -124,6 +128,9 @@ export const useGetSearchQuery = (
     UseQueryOptions<SearchResult, Error, SearchResult, unknown[]>,
     "queryKey" | "queryFn"
   >,
+  // Effective UTC bounds from the caller. Saved dates inside `queryData` are
+  // deliberately not sent so a cleared temporary range cannot fall back to them.
+  dateRange?: { createdAfter?: string; createdBefore?: string },
 ) => {
   const queryClient = useQueryClient();
 
@@ -159,7 +166,15 @@ export const useGetSearchQuery = (
       };
       if (queryData?.filters) {
         searchPayload.filters =
-          buildSearchPayloadFilters(queryData.filters) ?? undefined;
+          buildSearchPayloadFilters(queryData.filters, {
+            includeDates: false,
+          }) ?? undefined;
+      }
+      if (dateRange?.createdAfter) {
+        searchPayload.created_after = dateRange.createdAfter;
+      }
+      if (dateRange?.createdBefore) {
+        searchPayload.created_before = dateRange.createdBefore;
       }
 
       const response = await apiClient.post(`/search`, searchPayload);
@@ -193,6 +208,7 @@ export const useGetSearchQuery = (
           embedding_dimensions?: number;
           allowed_users?: string[];
           allowed_groups?: string[];
+          indexed_time?: string;
         }
       >();
 
@@ -233,6 +249,7 @@ export const useGetSearchQuery = (
             embedding_dimensions: chunk.embedding_dimensions,
             allowed_users: chunk.allowed_users || [],
             allowed_groups: chunk.allowed_groups || [],
+            indexed_time: chunk.indexed_time,
           });
         }
       });
@@ -253,6 +270,7 @@ export const useGetSearchQuery = (
         chunks: file.chunks,
         allowed_users: file.allowed_users || [],
         allowed_groups: file.allowed_groups || [],
+        indexed_time: file.indexed_time,
       }));
 
       const warnings: SearchWarning[] = Array.isArray(data.warnings)
@@ -272,7 +290,7 @@ export const useGetSearchQuery = (
 
   return useQuery(
     {
-      queryKey: ["search", queryData, query],
+      queryKey: ["search", queryData, query, dateRange],
       placeholderData: (prev) => prev,
       staleTime: 0,
       queryFn: getFiles,

frontend/app/api/queries/useListFiles.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Tests for useListFiles.
+ *
+ * Verifies URL parameter serialization (including the new createdAfter /
+ * createdBefore date-range params), response parsing, and error handling.
+ */
+import { renderHook, waitFor } from "@testing-library/react";
+import { HttpResponse, http } from "msw";
+import { describe, expect, it } from "vitest";
+import { server } from "@/test-utils/msw/server";
+import { createQueryWrapper } from "@/test-utils/render";
+import { useListFiles } from "./useListFiles";
+
+function makeFileResponse(overrides: Record<string, unknown> = {}) {
+  return {
+    files: [],
+    total: 0,
+    is_approximate: false,
+    page: 1,
+    page_size: 25,
+    after_key: null,
+    ...overrides,
+  };
+}
+
+describe("useListFiles", () => {
+  it("sends created_after param when createdAfter is provided", async () => {
+    let capturedUrl: string | undefined;
+    server.use(
+      http.get("/api/files", ({ request }) => {
+        capturedUrl = request.url;
+        return HttpResponse.json(makeFileResponse());
+      }),
+    );
+
+    const { result } = renderHook(
+      () =>
+        useListFiles({
+          createdAfter: "2024-01-01T00:00:00.000Z",
+        }),
+      { wrapper: createQueryWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    const url = new URL(capturedUrl!);
+    expect(url.searchParams.get("created_after")).toBe(
+      "2024-01-01T00:00:00.000Z",
+    );
+  });
+
+  it("sends created_before param when createdBefore is provided", async () => {
+    let capturedUrl: string | undefined;
+    server.use(
+      http.get("/api/files", ({ request }) => {
+        capturedUrl = request.url;
+        return HttpResponse.json(makeFileResponse());
+      }),
+    );
+
+    const { result } = renderHook(
+      () =>
+        useListFiles({
+          createdBefore: "2024-01-31T23:59:59.999Z",
+        }),
+      { wrapper: createQueryWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    const url = new URL(capturedUrl!);
+    expect(url.searchParams.get("created_before")).toBe(
+      "2024-01-31T23:59:59.999Z",
+    );
+  });
+
+  it("sends both date params together", async () => {
+    let capturedUrl: string | undefined;
+    server.use(
+      http.get("/api/files", ({ request }) => {
+        capturedUrl = request.url;
+        return HttpResponse.json(makeFileResponse());
+      }),
+    );
+
+    const { result } = renderHook(
+      () =>
+        useListFiles({
+          createdAfter: "2024-03-01T00:00:00.000Z",
+          createdBefore: "2024-03-31T23:59:59.999Z",
+        }),
+      { wrapper: createQueryWrapper() },
+    );
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    const url = new URL(capturedUrl!);
+    expect(url.searchParams.get("created_after")).toBe(
+      "2024-03-01T00:00:00.000Z",
+    );
+    expect(url.searchParams.get("created_before")).toBe(
+      "2024-03-31T23:59:59.999Z",
+    );
+  });
+
+  it("omits date params when not provided", async () => {
+    let capturedUrl: string | undefined;
+    server.use(
+      http.get("/api/files", ({ request }) => {
+        capturedUrl = request.url;
+        return HttpResponse.json(makeFileResponse());
+      }),
+    );
+
+    const { result } = renderHook(() => useListFiles({}), {
+      wrapper: createQueryWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    const url = new URL(capturedUrl!);
+    expect(url.searchParams.has("created_after")).toBe(false);
+    expect(url.searchParams.has("created_before")).toBe(false);
+  });
+
+  it("maps indexed_time from the response", async () => {
+    server.use(
+      http.get("/api/files", () =>
+        HttpResponse.json(
+          makeFileResponse({
+            files: [
+              {
+                filename: "doc.pdf",
+                mimetype: "application/pdf",
+                chunk_count: 5,
+                source_url: "",
+                owner: "user1",
+                owner_name: "User One",
+                owner_email: "user@example.com",
+                file_size: 1024,
+                connector_type: "local",
+                allowed_users: [],
+                allowed_groups: [],
+                indexed_time: "2024-06-15T10:30:00.000Z",
+              },
+            ],
+          }),
+        ),
+      ),
+    );
+
+    const { result } = renderHook(() => useListFiles({}), {
+      wrapper: createQueryWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+    expect(result.current.data?.files[0]?.indexed_time).toBe(
+      "2024-06-15T10:30:00.000Z",
+    );
+  });
+});

frontend/app/api/queries/useListFiles.ts

@@ -17,6 +17,8 @@ export interface ListFilesParams {
   dataSources?: string[];
   search?: string;
   afterKey?: Record<string, unknown> | null; //composite pagination cursor, could be undefined in the beginning
+  createdAfter?: string;
+  createdBefore?: string;
 }
 
 export interface ListFilesResponse {
@@ -50,6 +52,10 @@ export const useListFiles = (
     if (params.search) searchParams.set("search", params.search);
     if (params.afterKey)
       searchParams.set("after_key", JSON.stringify(params.afterKey));
+    if (params.createdAfter)
+      searchParams.set("created_after", params.createdAfter);
+    if (params.createdBefore)
+      searchParams.set("created_before", params.createdBefore);
 
     const url = `/files?${searchParams.toString()}`; //internal (cookie auth)
 
@@ -79,6 +85,7 @@ export const useListFiles = (
         embedding_dimensions: f.embedding_dimensions as number | undefined,
         allowed_users: (f.allowed_users as string[]) || [],
         allowed_groups: (f.allowed_groups as string[]) || [],
+        indexed_time: (f.indexed_time as string) || undefined,
         status: "active" as const,
       }),
     );