@teselagen/ui 0.8.6-beta.11 → 0.8.6-beta.13

package/index.cjs.js

@@ -19422,34 +19422,37 @@ function tableQueryParamsToHasuraClauses({
   if (searchTerm) {
     const searchTermFilters = [];
     const uniqueFieldsByPath = {};
+    const searchTerms = searchTerm.split(",");
     schema.fields.forEach((field) => {
       const { type: type2, path: path2, searchDisabled } = field;
       if (uniqueFieldsByPath[path2]) return;
       uniqueFieldsByPath[path2] = true;
       if (searchDisabled || field.filterDisabled || type2 === "color") return;
-      const filterValue = searchTerm;
-      if (type2 === "string" || type2 === "lookup") {
-        const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
-        searchTermFilters.push(o2);
-      } else if (type2 === "boolean") {
-        let regex;
-        try {
-          regex = new RegExp("^" + searchTerm, "ig");
-        } catch (error) {
-        }
-        if (regex) {
-          if ("true".replace(regex, "") !== "true") {
-            const o2 = set$1({}, path2, { _eq: true });
-            searchTermFilters.push(o2);
-          } else if ("false".replace(regex, "") !== "false") {
-            const o2 = set$1({}, path2, { _eq: false });
-            searchTermFilters.push(o2);
+      searchTerms.forEach((term) => {
+        const filterValue = term.trim();
+        if (type2 === "string" || type2 === "lookup") {
+          const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
+          searchTermFilters.push(o2);
+        } else if (type2 === "boolean") {
+          let regex;
+          try {
+            regex = new RegExp("^" + filterValue, "ig");
+          } catch (error) {
+          }
+          if (regex) {
+            if ("true".replace(regex, "") !== "true") {
+              const o2 = set$1({}, path2, { _eq: true });
+              searchTermFilters.push(o2);
+            } else if ("false".replace(regex, "") !== "false") {
+              const o2 = set$1({}, path2, { _eq: false });
+              searchTermFilters.push(o2);
+            }
           }
+        } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
+          const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
+          searchTermFilters.push(o2);
         }
-      } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
-        const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
-        searchTermFilters.push(o2);
-      }
+      });
     });
     if (searchTermFilters.length > 0) {
       if (Object.keys(where).length > 0) {
@@ -19543,9 +19546,7 @@ function tableQueryParamsToHasuraClauses({
               },
               {
                 [filterOn]: {
-                  _gt: new Date(
-                    new Date(arrayFilterValue[1]).setHours(23, 59)
-                  )
+                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
                 }
               }
             ]
@@ -22227,13 +22228,27 @@ function applyOrderBy(records, _order_by) {
       directions.push(direction);
       iteratees.push((record) => {
         const value = record[field];
+        if (isNull(value) || value === void 0) {
+          return direction === "asc" ? -Infinity : -Infinity;
+        }
         if (isString$1(value) && /\d/.test(value)) {
           return value.replace(/(\d+)/g, (num) => num.padStart(10, "0"));
         }
         return value;
       });
     });
-    records = orderBy$1(records, iteratees, directions);
+    let sortedRecords = orderBy$1(records, iteratees, directions);
+    order_by.forEach((item) => {
+      const field = Object.keys(item)[0];
+      const direction = item[field];
+      if (direction === "desc") {
+        sortedRecords = [
+          ...sortedRecords.filter((record) => !isNull(record[field]) && record[field] !== void 0),
+          ...sortedRecords.filter((record) => isNull(record[field]) || record[field] === void 0)
+        ];
+      }
+    });
+    records = sortedRecords;
   }
   return records;
 }

package/index.es.js

@@ -19404,34 +19404,37 @@ function tableQueryParamsToHasuraClauses({
   if (searchTerm) {
     const searchTermFilters = [];
     const uniqueFieldsByPath = {};
+    const searchTerms = searchTerm.split(",");
     schema.fields.forEach((field) => {
       const { type: type2, path: path2, searchDisabled } = field;
       if (uniqueFieldsByPath[path2]) return;
       uniqueFieldsByPath[path2] = true;
       if (searchDisabled || field.filterDisabled || type2 === "color") return;
-      const filterValue = searchTerm;
-      if (type2 === "string" || type2 === "lookup") {
-        const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
-        searchTermFilters.push(o2);
-      } else if (type2 === "boolean") {
-        let regex;
-        try {
-          regex = new RegExp("^" + searchTerm, "ig");
-        } catch (error) {
-        }
-        if (regex) {
-          if ("true".replace(regex, "") !== "true") {
-            const o2 = set$1({}, path2, { _eq: true });
-            searchTermFilters.push(o2);
-          } else if ("false".replace(regex, "") !== "false") {
-            const o2 = set$1({}, path2, { _eq: false });
-            searchTermFilters.push(o2);
+      searchTerms.forEach((term) => {
+        const filterValue = term.trim();
+        if (type2 === "string" || type2 === "lookup") {
+          const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
+          searchTermFilters.push(o2);
+        } else if (type2 === "boolean") {
+          let regex;
+          try {
+            regex = new RegExp("^" + filterValue, "ig");
+          } catch (error) {
+          }
+          if (regex) {
+            if ("true".replace(regex, "") !== "true") {
+              const o2 = set$1({}, path2, { _eq: true });
+              searchTermFilters.push(o2);
+            } else if ("false".replace(regex, "") !== "false") {
+              const o2 = set$1({}, path2, { _eq: false });
+              searchTermFilters.push(o2);
+            }
           }
+        } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
+          const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
+          searchTermFilters.push(o2);
         }
-      } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
-        const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
-        searchTermFilters.push(o2);
-      }
+      });
     });
     if (searchTermFilters.length > 0) {
       if (Object.keys(where).length > 0) {
@@ -19525,9 +19528,7 @@ function tableQueryParamsToHasuraClauses({
               },
               {
                 [filterOn]: {
-                  _gt: new Date(
-                    new Date(arrayFilterValue[1]).setHours(23, 59)
-                  )
+                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
                 }
               }
             ]
@@ -22209,13 +22210,27 @@ function applyOrderBy(records, _order_by) {
       directions.push(direction);
       iteratees.push((record) => {
         const value = record[field];
+        if (isNull(value) || value === void 0) {
+          return direction === "asc" ? -Infinity : -Infinity;
+        }
         if (isString$1(value) && /\d/.test(value)) {
           return value.replace(/(\d+)/g, (num) => num.padStart(10, "0"));
         }
         return value;
       });
     });
-    records = orderBy$1(records, iteratees, directions);
+    let sortedRecords = orderBy$1(records, iteratees, directions);
+    order_by.forEach((item) => {
+      const field = Object.keys(item)[0];
+      const direction = item[field];
+      if (direction === "desc") {
+        sortedRecords = [
+          ...sortedRecords.filter((record) => !isNull(record[field]) && record[field] !== void 0),
+          ...sortedRecords.filter((record) => isNull(record[field]) || record[field] === void 0)
+        ];
+      }
+    });
+    records = sortedRecords;
   }
   return records;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ui",
-  "version": "0.8.6-beta.11",
+  "version": "0.8.6-beta.13",
   "main": "./src/index.js",
   "type": "module",
   "exports": {
@@ -17,7 +17,6 @@
     "@dnd-kit/core": "^6.1.0",
     "@dnd-kit/modifiers": "^7.0.0",
     "@dnd-kit/sortable": "^8.0.0",
-    "@teselagen/react-table": "6.10.16",
     "classnames": "^2.3.2",
     "color": "^3.2.1",
     "copy-to-clipboard": "^3.3.1",

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -230,6 +230,8 @@ function applyWhereClause(records, where) {
 // order_by looks like this: [{ some_field: "asc" }, { some_other_field: "desc" }] or {some_field: "asc"}
 // returns the records sorted by the order_by clause
 function applyOrderBy(records, _order_by) {
+  // console.log('records start:', records)
+  // console.log('_order_by:', _order_by)
   const order_by = isArray(_order_by)
     ? _order_by
     : isEmpty(_order_by)
@@ -251,6 +253,10 @@ function applyOrderBy(records, _order_by) {
       // Create a custom iteratee function for natural sorting
       iteratees.push(record => {
         const value = record[field];
+        // Handle null values based on sort direction
+        if (isNull(value) || value === undefined) {
+          return direction === 'asc' ? -Infinity : -Infinity;
+        }
         // Use natural sorting only for strings that contain numbers
         if (isString(value) && /\d/.test(value)) {
           // Return the value in a format that can be naturally sorted
@@ -260,9 +266,26 @@ function applyOrderBy(records, _order_by) {
         return value;
       });
     });
-
-    // Use the custom iteratees for natural sorting
-    records = orderBy(records, iteratees, directions);
+    
+    // First sort normally
+    let sortedRecords = orderBy(records, iteratees, directions);
+    
+    // Then ensure entries with a value for the field come before entries without a value
+    // for any field sorted in descending order
+    order_by.forEach((item) => {
+      const field = Object.keys(item)[0];
+      const direction = item[field];
+      
+      if (direction === 'desc') {
+        // For descending sorts, we want entries with values to appear before entries without values
+        sortedRecords = [
+          ...sortedRecords.filter(record => !isNull(record[field]) && record[field] !== undefined),
+          ...sortedRecords.filter(record => isNull(record[field]) || record[field] === undefined)
+        ];
+      }
+    });
+    
+    records = sortedRecords;
   }
   return records;
 }

package/src/DataTable/utils/filterLocalEntitiesToHasura.test.js

@@ -379,42 +379,152 @@ describe("filterLocalEntitiesToHasura", () => {
     ]);
     expect(result.entityCount).toBe(3);
   });
-  it("should order by age ascending", () => {
-    const result = filterLocalEntitiesToHasura(records, {
-      order_by: { age: "asc" }
-    });
+  it("should order by age ascending and put null vals last by default", () => {
+    const result = filterLocalEntitiesToHasura(
+      [{ id: 111, name: "Null Age", age: null, city: "Unknown" }, ...records],
+      {
+        order_by: { age: "asc" }
+      }
+    );
     expect(result.entities).toEqual([
       records[3],
       records[1],
       records[0],
-      records[2]
+      records[2],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" }
     ]);
     expect(result.entitiesAcrossPages).toEqual([
       records[3],
       records[1],
       records[0],
-      records[2]
+      records[2],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" }
     ]);
-    expect(result.entityCount).toBe(4);
+    expect(result.entityCount).toBe(5);
   });
-
-  it("should order by age descending", () => {
-    const result = filterLocalEntitiesToHasura(records, {
-      order_by: { age: "desc" }
-    });
+  it("should order by age desc and put null/undefined vals last by default", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        { id: 111, name: "Null Age", age: null, city: "Unknown" },
+        { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" },
+        ...records
+      ],
+      {
+        order_by: { age: "desc" }
+      }
+    );
     expect(result.entities).toEqual([
       records[2],
       records[0],
       records[1],
-      records[3]
+      records[3],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" },
+      { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" }
     ]);
-    expect(result.entitiesAcrossPages).toEqual([
+    expect(result.entityCount).toBe(6);
+  });
+
+  it.only("should order by updatedAt descending, putting null/undefined vals last ", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        {
+          name: "-10_signal",
+          color: "#4ECDC4",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+        {
+          name: "-35_signal",
+          color: "#F7FFF7",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+        {
+          name: "3'clip",
+          color: "#FF6B6B",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+        {
+          name: "3'UTR",
+          color: "#FFE66D",
+          isGenbankStandardType: true,
+          __typename: "featureTypeOverride"
+        },
+
+        {
+          __typename: "featureTypeOverride",
+          id: "33a90fcb-fc26-406f-a6d5-41ac4ba8ea64",
+          name: "lalala",
+          description: null,
+          color: "#81bb41",
+          genbankEquivalentType: null,
+          updatedAt: "2025-06-03T01:02:24.737499+00:00",
+          isHidden: false,
+          isCustomType: true
+        }
+      ],
+      {
+        order_by: [{ updatedAt: "desc" }]
+      }
+    );
+    expect(result.entities).toEqual([
+      {
+        __typename: "featureTypeOverride",
+        id: "33a90fcb-fc26-406f-a6d5-41ac4ba8ea64",
+        name: "lalala",
+        description: null,
+        color: "#81bb41",
+        genbankEquivalentType: null,
+        updatedAt: "2025-06-03T01:02:24.737499+00:00",
+        isHidden: false,
+        isCustomType: true
+      },
+      {
+        name: "-10_signal",
+        color: "#4ECDC4",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      },
+      {
+        name: "-35_signal",
+        color: "#F7FFF7",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      },
+      {
+        name: "3'clip",
+        color: "#FF6B6B",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      },
+      {
+        name: "3'UTR",
+        color: "#FFE66D",
+        isGenbankStandardType: true,
+        __typename: "featureTypeOverride"
+      }
+    ]);
+  });
+  it("should order by age descending, putting null/undefined vals last ", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        { id: 111, name: "Null Age", age: null, city: "Unknown" },
+        { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" },
+        ...records
+      ],
+      {
+        order_by: { age: "desc" }
+      }
+    );
+    expect(result.entities).toEqual([
       records[2],
       records[0],
       records[1],
-      records[3]
+      records[3],
+      { id: 111, name: "Null Age", age: null, city: "Unknown" },
+      { id: 1121, name: "Undefined Age", age: undefined, city: "Unknown" }
     ]);
-    expect(result.entityCount).toBe(4);
   });
 
   it("should order by name ascending", () => {

package/src/DataTable/utils/initializeHasuraWhereAndFilter.js

@@ -12,4 +12,4 @@ export function initializeHasuraWhereAndFilter(
     }
   } else if (typeof additionalFilter === "object")
     where._and.push(additionalFilter);
-}
+}

package/src/DataTable/utils/queryParams.js

@@ -5,9 +5,7 @@ import {
   tableQueryParamsToHasuraClauses
 } from "./tableQueryParamsToHasuraClauses";
 import { filterLocalEntitiesToHasura } from "./filterLocalEntitiesToHasura";
-import {
-  initializeHasuraWhereAndFilter
-} from "./initializeHasuraWhereAndFilter";
+import { initializeHasuraWhereAndFilter } from "./initializeHasuraWhereAndFilter";
 
 const defaultPageSizes = [5, 10, 15, 25, 50, 100, 200, 400];
 

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -20,39 +20,46 @@ export function tableQueryParamsToHasuraClauses({
     // Create a map to deduplicate fields by path
     const uniqueFieldsByPath = {};
 
+    // Split the search term by comma to support multi-term searching
+    const searchTerms = searchTerm.split(",");
+
     schema.fields.forEach(field => {
       const { type, path, searchDisabled } = field;
       if (uniqueFieldsByPath[path]) return; // Skip if already added
       uniqueFieldsByPath[path] = true;
       if (searchDisabled || field.filterDisabled || type === "color") return;
-      const filterValue = searchTerm; // No cleaning needed here, we're using _ilike
 
-      if (type === "string" || type === "lookup") {
-        const o = set({}, path, { _ilike: `%${filterValue}%` });
-        searchTermFilters.push(o);
-      } else if (type === "boolean") {
-        let regex;
-        try {
-          regex = new RegExp("^" + searchTerm, "ig");
-        } catch (error) {
-          //ignore
-        }
-        if (regex) {
-          if ("true".replace(regex, "") !== "true") {
-            const o = set({}, path, { _eq: true });
-            searchTermFilters.push(o);
-          } else if ("false".replace(regex, "") !== "false") {
-            const o = set({}, path, { _eq: false });
-            searchTermFilters.push(o);
+      // Process each search term
+      searchTerms.forEach(term => {
+        const filterValue = term.trim(); // Trim the term to handle spaces after commas
+
+        if (type === "string" || type === "lookup") {
+          const o = set({}, path, { _ilike: `%${filterValue}%` });
+          searchTermFilters.push(o);
+        } else if (type === "boolean") {
+          let regex;
+          try {
+            regex = new RegExp("^" + filterValue, "ig");
+          } catch (error) {
+            //ignore
           }
+          if (regex) {
+            if ("true".replace(regex, "") !== "true") {
+              const o = set({}, path, { _eq: true });
+              searchTermFilters.push(o);
+            } else if ("false".replace(regex, "") !== "false") {
+              const o = set({}, path, { _eq: false });
+              searchTermFilters.push(o);
+            }
+          }
+        } else if (
+          (type === "number" || type === "integer") &&
+          !isNaN(filterValue)
+        ) {
+          const o = set({}, path, { _eq: parseFloat(filterValue) });
+          searchTermFilters.push(o);
         }
-      } else if (
-        (type === "number" || type === "integer") &&
-        !isNaN(filterValue)
-      ) {
-        const o = set({}, path, { _eq: parseFloat(filterValue) });
-        searchTermFilters.push(o);
-      }
+      });
     });
 
     if (searchTermFilters.length > 0) {
@@ -65,164 +72,161 @@ export function tableQueryParamsToHasuraClauses({
   }
 
   if (filters && filters.length > 0) {
-    const filterClauses = filters
-      .map(filter => {
-        let { selectedFilter, filterOn, filterValue } = filter;
-        const fieldSchema = ccFields[filterOn] || {};
+    const filterClauses = filters.map(filter => {
+      let { selectedFilter, filterOn, filterValue } = filter;
+      const fieldSchema = ccFields[filterOn] || {};
 
-        const { path, reference, type, customColumnFilter } = fieldSchema;
-        if (customColumnFilter) {
-          return customColumnFilter(filterValue);
-        }
-        let stringFilterValue =
-          filterValue && filterValue.toString
-            ? filterValue.toString()
-            : filterValue;
-        if (stringFilterValue === false) {
-          // we still want to be able to search for the string "false" which will get parsed to false
-          stringFilterValue = "false";
-        } else {
-          stringFilterValue = stringFilterValue || "";
-        }
-        const arrayFilterValue = Array.isArray(filterValue)
-          ? filterValue
-          : stringFilterValue.split(";");
+      const { path, reference, type, customColumnFilter } = fieldSchema;
+      if (customColumnFilter) {
+        return customColumnFilter(filterValue);
+      }
+      let stringFilterValue =
+        filterValue && filterValue.toString
+          ? filterValue.toString()
+          : filterValue;
+      if (stringFilterValue === false) {
+        // we still want to be able to search for the string "false" which will get parsed to false
+        stringFilterValue = "false";
+      } else {
+        stringFilterValue = stringFilterValue || "";
+      }
+      const arrayFilterValue = Array.isArray(filterValue)
+        ? filterValue
+        : stringFilterValue.split(";");
 
-        if (type === "number" || type === "integer") {
-          filterValue = Array.isArray(filterValue)
-            ? filterValue.map(val => Number(val))
-            : Number(filterValue);
-        }
+      if (type === "number" || type === "integer") {
+        filterValue = Array.isArray(filterValue)
+          ? filterValue.map(val => Number(val))
+          : Number(filterValue);
+      }
 
-        if (fieldSchema.normalizeFilter) {
-          filterValue = fieldSchema.normalizeFilter(
-            filterValue,
-            selectedFilter,
-            filterOn
-          );
-        }
+      if (fieldSchema.normalizeFilter) {
+        filterValue = fieldSchema.normalizeFilter(
+          filterValue,
+          selectedFilter,
+          filterOn
+        );
+      }
 
-        if (reference) {
-          filterOn = reference.sourceField;
-        } else {
-          filterOn = path || filterOn;
-        }
-        switch (selectedFilter) {
-          case "none":
-            return {};
-          case "startsWith":
-            return { [filterOn]: { _ilike: `${filterValue}%` } };
-          case "endsWith":
-            return { [filterOn]: { _ilike: `%${filterValue}` } };
-          case "contains":
-            return { [filterOn]: { _ilike: `%${filterValue}%` } };
-          case "notContains":
-            return { [filterOn]: { _nilike: `%${filterValue}%` } };
-          case "isExactly":
-            return { [filterOn]: { _eq: filterValue } };
-          case "isEmpty":
-            if (filterOn.includes(".")) {
-              // if we're filtering on a nested field, like a sequence table with parts.name
-              // we really want to just query on the top level field's existence
-              return {
-                _not: {
-                  [filterOn.split(".")[0]]: {}
-                }
-              };
-            }
-            return {
-              _or: [
-                { [filterOn]: { _eq: "" } },
-                { [filterOn]: { _is_null: true } }
-              ]
-            };
-          case "notEmpty":
-            return {
-              _and: [
-                { [filterOn]: { _neq: "" } },
-                { [filterOn]: { _is_null: false } }
-              ]
-            };
-          case "inList":
-            return { [filterOn]: { _in: filterValue } };
-          case "notInList":
-            return { [filterOn]: { _nin: filterValue } };
-          case "true":
-            return { [filterOn]: { _eq: true } };
-          case "false":
-            return { [filterOn]: { _eq: false } };
-          case "dateIs":
-            return { [filterOn]: { _eq: filterValue } };
-          case "notBetween":
-            return {
-              _or: [
-                {
-                  [filterOn]: {
-                    _lt: new Date(arrayFilterValue[0])
-                  }
-                },
-                {
-                  [filterOn]: {
-                    _gt: new Date(
-                      new Date(arrayFilterValue[1]).setHours(23, 59)
-                    )
-                  }
-                }
-              ]
-            };
-          case "isBetween":
+      if (reference) {
+        filterOn = reference.sourceField;
+      } else {
+        filterOn = path || filterOn;
+      }
+      switch (selectedFilter) {
+        case "none":
+          return {};
+        case "startsWith":
+          return { [filterOn]: { _ilike: `${filterValue}%` } };
+        case "endsWith":
+          return { [filterOn]: { _ilike: `%${filterValue}` } };
+        case "contains":
+          return { [filterOn]: { _ilike: `%${filterValue}%` } };
+        case "notContains":
+          return { [filterOn]: { _nilike: `%${filterValue}%` } };
+        case "isExactly":
+          return { [filterOn]: { _eq: filterValue } };
+        case "isEmpty":
+          if (filterOn.includes(".")) {
+            // if we're filtering on a nested field, like a sequence table with parts.name
+            // we really want to just query on the top level field's existence
             return {
-              [filterOn]: {
-                _gte: new Date(arrayFilterValue[0]),
-                _lte: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+              _not: {
+                [filterOn.split(".")[0]]: {}
               }
             };
-          case "isBefore":
-            return { [filterOn]: { _lt: new Date(filterValue) } };
-          case "isAfter":
-            return { [filterOn]: { _gt: new Date(filterValue) } };
-          case "greaterThan":
-            return { [filterOn]: { _gt: parseFloat(filterValue) } };
-          case "lessThan":
-            return { [filterOn]: { _lt: parseFloat(filterValue) } };
-          case "inRange":
-            return {
-              [filterOn]: {
-                _gte: parseFloat(arrayFilterValue[0]),
-                _lte: parseFloat(arrayFilterValue[1])
+          }
+          return {
+            _or: [
+              { [filterOn]: { _eq: "" } },
+              { [filterOn]: { _is_null: true } }
+            ]
+          };
+        case "notEmpty":
+          return {
+            _and: [
+              { [filterOn]: { _neq: "" } },
+              { [filterOn]: { _is_null: false } }
+            ]
+          };
+        case "inList":
+          return { [filterOn]: { _in: filterValue } };
+        case "notInList":
+          return { [filterOn]: { _nin: filterValue } };
+        case "true":
+          return { [filterOn]: { _eq: true } };
+        case "false":
+          return { [filterOn]: { _eq: false } };
+        case "dateIs":
+          return { [filterOn]: { _eq: filterValue } };
+        case "notBetween":
+          return {
+            _or: [
+              {
+                [filterOn]: {
+                  _lt: new Date(arrayFilterValue[0])
+                }
+              },
+              {
+                [filterOn]: {
+                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+                }
               }
-            };
-          case "outsideRange":
-            return {
-              _or: [
-                {
-                  [filterOn]: {
-                    _lt: parseFloat(arrayFilterValue[0])
-                  }
-                },
-                {
-                  [filterOn]: {
-                    _gt: parseFloat(arrayFilterValue[1])
-                  }
+            ]
+          };
+        case "isBetween":
+          return {
+            [filterOn]: {
+              _gte: new Date(arrayFilterValue[0]),
+              _lte: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+            }
+          };
+        case "isBefore":
+          return { [filterOn]: { _lt: new Date(filterValue) } };
+        case "isAfter":
+          return { [filterOn]: { _gt: new Date(filterValue) } };
+        case "greaterThan":
+          return { [filterOn]: { _gt: parseFloat(filterValue) } };
+        case "lessThan":
+          return { [filterOn]: { _lt: parseFloat(filterValue) } };
+        case "inRange":
+          return {
+            [filterOn]: {
+              _gte: parseFloat(arrayFilterValue[0]),
+              _lte: parseFloat(arrayFilterValue[1])
+            }
+          };
+        case "outsideRange":
+          return {
+            _or: [
+              {
+                [filterOn]: {
+                  _lt: parseFloat(arrayFilterValue[0])
+                }
+              },
+              {
+                [filterOn]: {
+                  _gt: parseFloat(arrayFilterValue[1])
                 }
-              ]
-            };
-          case "equalTo":
-            return {
-              [filterOn]: {
-                _eq:
-                  type === "number" || type === "integer"
-                    ? parseFloat(filterValue)
-                    : filterValue
               }
-            };
-          case "regex":
-            return { [filterOn]: { _regex: filterValue } };
-          default:
-            console.warn(`Unsupported filter type: ${selectedFilter}`);
-            return {};
-        }
-      })
+            ]
+          };
+        case "equalTo":
+          return {
+            [filterOn]: {
+              _eq:
+                type === "number" || type === "integer"
+                  ? parseFloat(filterValue)
+                  : filterValue
+            }
+          };
+        case "regex":
+          return { [filterOn]: { _regex: filterValue } };
+        default:
+          console.warn(`Unsupported filter type: ${selectedFilter}`);
+          return {};
+      }
+    });
 
     if (filterClauses.length > 0) {
       if (Object.keys(where).length > 0) {

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.test.js

@@ -44,6 +44,25 @@ describe("tableQueryParamsToHasuraClauses", () => {
       offset: 0
     });
   });
+  it("should handle searchTerm with string fields with a comma in them", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      searchTerm: "test,test2",
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _or: [
+          { name: { _ilike: "%test%" } },
+          { name: { _ilike: "%test2%" } },
+          { email: { _ilike: "%test%" } },
+          { email: { _ilike: "%test2%" } }
+        ]
+      },
+      order_by: [],
+      limit: 25,
+      offset: 0
+    });
+  });
   it("should flatten queries with dup paths", () => {
     const result = tableQueryParamsToHasuraClauses({
       searchTerm: "test",