dashboard: update paginatedTableDocuments to support disabling filters (#35061)

Adds backwards-compatible support for an `enabled` field on filters for the data page. Fields that set this field to false will not be including in filtering.

Also adds a test configuration for `system-udfs` because we moved tests there at some point, but did not make sure they were still running.

GitOrigin-RevId: 85a53d643e2c31d57a2686bd721a7730e4f204ea

Author: atrakh

npm-packages/common/config/rush/pnpm-lock.yaml

@@ -0,0 +1,7 @@
+// Mock for convex/server
+module.exports = {
+  GenericDocument: {},
+  Index: {},
+  SearchIndex: {},
+  VectorIndex: {},
+};

npm-packages/system-udfs/__mocks__/convex/server.js

@@ -0,0 +1,28 @@
+// Mock for convex/values
+module.exports = {
+  JSONValue: {},
+  ValidatorJSON: {},
+  Value: {},
+  jsonToConvex: (value) => {
+    // Simple validation: reject objects with keys starting with $
+    if (typeof value === "object" && value !== null) {
+      for (const key in value) {
+        if (key.startsWith("$")) {
+          throw new Error(`Invalid value: ${JSON.stringify(value)}.`);
+        }
+      }
+    }
+    return value;
+  },
+  validateValue: (value) => {
+    // Simple validation: reject objects with keys starting with $
+    if (typeof value === "object" && value !== null) {
+      for (const key in value) {
+        if (key.startsWith("$")) {
+          throw new Error(`Invalid value: ${JSON.stringify(value)}.`);
+        }
+      }
+    }
+    return value;
+  },
+};

npm-packages/system-udfs/__mocks__/convex/values.js

@@ -0,0 +1,4 @@
+// Mock for id-encoding
+module.exports = {
+  isId: (value) => typeof value === "string" && value.length === 32,
+};

npm-packages/system-udfs/__mocks__/id-encoding.js

@@ -51,6 +51,26 @@ describe("filters", () => {
       ]);
     });
 
+    it("should partition filters with enabled field", () => {
+      expect(
+        partitionFiltersByOperator([
+          { field: "foo", op: "type", value: "string", enabled: true },
+          { field: "foo", op: "eq", value: "bar", enabled: false },
+          { field: "foo", op: "notype", value: "string", enabled: true },
+          { field: "foo", op: "neq", value: "bar", enabled: false },
+        ]),
+      ).toStrictEqual([
+        [
+          { field: "foo", op: "eq", value: "bar", enabled: false },
+          { field: "foo", op: "neq", value: "bar", enabled: false },
+        ],
+        [
+          { field: "foo", op: "type", value: "string", enabled: true },
+          { field: "foo", op: "notype", value: "string", enabled: true },
+        ],
+      ]);
+    });
+
     it("should return empty lists", () => {
       expect(partitionFiltersByOperator([])).toStrictEqual([[], []]);
     });
@@ -74,7 +94,10 @@ describe("filters", () => {
     test.each<{
       name: string;
       page: GenericDocument[];
-      filters: Omit<ValidFilterByType, "id">[];
+      filters: (
+        | Omit<ValidFilterByType, "id">
+        | (Omit<ValidFilterByType, "id" | "enabled"> & { enabled?: boolean })
+      )[];
       expected: GenericDocument[];
     }>([
       {
@@ -152,8 +175,49 @@ describe("filters", () => {
         ],
         expected: [samplePage[1]],
       },
+      {
+        name: "respects enabled=false",
+        page: samplePage,
+        filters: [
+          {
+            field: "variableType",
+            op: "type",
+            value: "string",
+            enabled: false,
+          },
+        ],
+        expected: samplePage,
+      },
+      {
+        name: "respects enabled=true",
+        page: samplePage,
+        filters: [
+          { field: "variableType", op: "type", value: "string", enabled: true },
+        ],
+        expected: [samplePage[0], samplePage[1], samplePage[6]],
+      },
+      {
+        name: "mixed enabled filters",
+        page: samplePage,
+        filters: [
+          { field: "variableType", op: "type", value: "string", enabled: true },
+          { field: "name", op: "type", value: "string", enabled: false },
+        ],
+        expected: [samplePage[0], samplePage[1], samplePage[6]],
+      },
+      {
+        name: "respects missing enabled field (backward compatibility)",
+        page: samplePage,
+        filters: [
+          { field: "variableType", op: "type", value: "string" }, // enabled field is missing
+        ],
+        expected: [samplePage[0], samplePage[1], samplePage[6]],
+      },
     ])(`filterPage $name`, ({ page, filters, expected }) => {
-      const filteredPage = applyTypeFilters(page, filters);
+      const filteredPage = applyTypeFilters(
+        page,
+        filters as ValidFilterByType[],
+      );
       expect(filteredPage).toEqual(expected);
     });
   });

npm-packages/system-udfs/convex/_system/frontend/lib/filters.test.ts

@@ -18,6 +18,7 @@ export interface FilterExpression {
 export type FilterCommon = {
   id?: string;
   field?: string;
+  enabled?: boolean;
 };
 
 export type FilterByBuiltin = {
@@ -26,17 +27,21 @@ export type FilterByBuiltin = {
 };
 
 export type ValidFilterByBuiltin = {
-  [P in keyof FilterCommon]-?: FilterCommon[P];
-} & { [P in keyof FilterByBuiltin]-?: FilterByBuiltin[P] };
+  [P in keyof Omit<FilterCommon, "enabled">]-?: FilterCommon[P];
+} & { [P in keyof FilterByBuiltin]-?: FilterByBuiltin[P] } & {
+  enabled?: boolean;
+};
 
 export type FilterByOr = {
   op: "anyOf" | "noneOf";
   value?: JSONValue[];
 };
 
 export type ValidFilterByOr = {
-  [P in keyof FilterCommon]-?: FilterCommon[P];
-} & { [P in keyof FilterByOr]-?: FilterByOr[P] };
+  [P in keyof Omit<FilterCommon, "enabled">]-?: FilterCommon[P];
+} & { [P in keyof FilterByOr]-?: FilterByOr[P] } & {
+  enabled?: boolean;
+};
 
 export type ValidFilterByBuiltInOrOr = ValidFilterByBuiltin | ValidFilterByOr;
 
@@ -61,8 +66,10 @@ export type FilterByType = {
 };
 
 export type ValidFilterByType = {
-  [P in keyof FilterCommon]-?: FilterCommon[P];
-} & { [P in keyof FilterByBuiltin]-?: FilterByType[P] };
+  [P in keyof Omit<FilterCommon, "enabled">]-?: FilterCommon[P];
+} & { [P in keyof FilterByBuiltin]-?: FilterByType[P] } & {
+  enabled?: boolean;
+};
 
 const TypeFilterOpKeys = ["type", "notype"] as const;
 
@@ -95,18 +102,23 @@ const FilterSchema = z.array(
       field: z.string().optional(),
       value: z.any().optional(),
       id: z.string().optional(),
+      enabled: z.boolean().optional(),
     }),
     z.object({
       op: z.union([z.literal("type"), z.literal("notype")]),
       field: z.string().optional(),
       // @ts-expect-error I don't know how to fix this type error,
       // but i'll test to make sure this works.
       value: z.union(TypeFilterSchema).optional(),
+      id: z.string().optional(),
+      enabled: z.boolean().optional(),
     }),
     z.object({
       op: z.union([z.literal("anyOf"), z.literal("noneOf")]),
       field: z.string().optional(),
       value: z.array(z.any()).optional(),
+      id: z.string().optional(),
+      enabled: z.boolean().optional(),
     }),
   ]),
 );
@@ -172,9 +184,10 @@ export function applyTypeFilters(
   page: GenericDocument[],
   filters: FilterByType[],
 ) {
-  const validatedFilters = filters.filter<ValidFilterByType>(
-    (f): f is ValidFilterByType => isValidFilter(f),
-  );
+  const validatedFilters = filters
+    .filter<ValidFilterByType>((f): f is ValidFilterByType => isValidFilter(f))
+    // Only apply filters that are enabled (or where enabled is undefined for backward compatibility)
+    .filter((f) => f.enabled !== false);
   return page.filter((doc) => {
     for (const filter of validatedFilters) {
       const value = doc[filter.field];

npm-packages/system-udfs/convex/_system/frontend/lib/filters.ts

@@ -72,11 +72,13 @@ export default queryGeneric({
         });
       }
     }
-
-    const [builtinFilters, typeFilters] = partitionFiltersByOperator(
-      parsedFilters?.clauses,
+    const enabledFilters = parsedFilters?.clauses?.filter(
+      (f) => f.enabled !== false,
     );
 
+    const [builtinFilters, typeFilters] =
+      partitionFiltersByOperator(enabledFilters);
+
     const queryInitializer = db.query(table);
     let query: OrderedQuery<any> | undefined = undefined;
 

npm-packages/system-udfs/convex/_system/frontend/paginatedTableDocuments.ts

@@ -0,0 +1,19 @@
+/** @type {import('jest').Config} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  testMatch: ["**/*.test.ts"],
+  transform: {
+    "^.+\\.tsx?$": [
+      "ts-jest",
+      {
+        tsconfig: "tsconfig.json",
+      },
+    ],
+  },
+  moduleNameMapper: {
+    "convex/(.*)": "<rootDir>/__mocks__/convex/$1",
+    "^id-encoding$": "<rootDir>/__mocks__/id-encoding",
+  },
+  moduleDirectories: ["node_modules", "../common/temp/node_modules/.pnpm"],
+};

npm-packages/system-udfs/jest.config.js

@@ -7,7 +7,8 @@
     "build": "rm -rf dist && tsc",
     "clean": "rm -rf dist",
     "lint": "tsc && cd convex && eslint .",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "test": "jest"
   },
   "dependencies": {
     "object-inspect": "^1.12.0",
@@ -31,6 +32,7 @@
     "eslint-plugin-react-hooks": "^5.1.0-beta-26f2496093-20240514",
     "eslint-plugin-react": "^7.37.2",
     "jest": "^29.6.0",
+    "ts-jest": "^29.1.1",
     "@typescript-eslint/eslint-plugin": "^6.7.4",
     "@typescript-eslint/parser": "^6.7.4",
     "eslint-config-prettier": "^9.1.0",