@teselagen/ui 0.8.5 → 0.8.6

package/DataTable/utils/filterLocalEntitiesToHasura.d.ts

@@ -0,0 +1,5 @@
+export function filterLocalEntitiesToHasura(records: any, { where, order_by, limit, offset, isInfinite }?: {}): {
+    entities: any[];
+    entitiesAcrossPages: any[];
+    entityCount: number;
+};

package/DataTable/utils/initializeHasuraWhereAndFilter.d.ts

@@ -0,0 +1,2 @@
+export function initializeHasuraWhereAndFilter(additionalFilter: any, where: {} | undefined, currentParams: any): void;
+export function addCustomColumnFilters(where: any, fields: any, currentParams: any): void;

package/DataTable/utils/tableQueryParamsToHasuraClauses.d.ts

@@ -0,0 +1,26 @@
+export function tableQueryParamsToHasuraClauses({ page, pageSize, searchTerm, filters, order, schema, additionalFilter }: {
+    page: any;
+    pageSize: any;
+    searchTerm: any;
+    filters: any;
+    order: any;
+    schema: any;
+    additionalFilter: any;
+}): {
+    where: {};
+    order_by: {};
+    limit: any;
+    offset: number;
+};
+/**
+ * Takes a schema and returns an object with the fields mapped by their camelCased display name.
+ * If the displayName is not set or is a jsx element, the path is used instead.
+ * The same conversion must be done when using the result of this method
+ */
+export function getFieldsMappedByCCDisplayName(schema: any): any;
+/**
+ *
+ * @param {object} field
+ * @returns the camelCase display name of the field, to be used for filters, sorting, etc
+ */
+export function getCCDisplayName(field: object): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teselagen/ui",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "main": "./src/index.js",
   "type": "module",
   "exports": {

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -0,0 +1,236 @@
+import {
+  isEmpty,
+  every,
+  some,
+  isEqual,
+  isString,
+  isNull,
+  isArray,
+  includes,
+  isObject,
+  has,
+  orderBy
+} from "lodash-es";
+
+export function filterLocalEntitiesToHasura(
+  records,
+  { where, order_by, limit, offset, isInfinite } = {}
+) {
+  let filteredRecords = [...records];
+
+  // Apply where clause if it exists
+  if (where) {
+    filteredRecords = applyWhereClause(filteredRecords, where);
+  }
+
+  // Apply order_by if it exists
+  if (order_by) {
+    filteredRecords = applyOrderBy(filteredRecords, order_by);
+  }
+
+  // Store the complete filtered and ordered records for pagination info
+  const allFilteredRecords = [...filteredRecords];
+
+  // Apply limit and offset
+  if (!isInfinite && offset !== undefined) {
+    filteredRecords = filteredRecords.slice(offset);
+  }
+
+  if (!isInfinite && limit !== undefined) {
+    filteredRecords = filteredRecords.slice(0, limit);
+  }
+
+  // For consistency, always return an object with entities, entitiesAcrossPages, and entityCount
+  return {
+    entities: filteredRecords,
+    entitiesAcrossPages: allFilteredRecords,
+    entityCount: allFilteredRecords.length
+  };
+}
+
+function applyWhereClause(records, where) {
+  function applyFilter(record, filter) {
+    if (isEmpty(filter)) {
+      return true; // No filter, all records pass
+    }
+
+    for (const key in filter) {
+      if (key === "_and") {
+        if (isEmpty(filter[key])) {
+          continue;
+        }
+        if (!every(filter[key], subFilter => applyFilter(record, subFilter))) {
+          return false;
+        }
+      } else if (key === "_or") {
+        if (isEmpty(filter[key])) {
+          continue;
+        }
+        if (!some(filter[key], subFilter => applyFilter(record, subFilter))) {
+          return false;
+        }
+      } else if (key === "_not") {
+        if (applyFilter(record, filter[key])) {
+          return false;
+        }
+      } else {
+        const value = record[key];
+        const conditions = filter[key];
+
+        // Handle nested object properties
+        if (
+          isObject(value) &&
+          isObject(conditions) &&
+          !hasOperator(conditions)
+        ) {
+          return applyFilter(value, conditions);
+        }
+
+        for (const operator in conditions) {
+          const conditionValue = conditions[operator];
+
+          // Handle range conditions (_gt/_lt or _gte/_lte combinations)
+          if (operator === "_gt" && conditions._lt) {
+            if (!(value > conditionValue && value < conditions._lt))
+              return false;
+            continue;
+          }
+          if (operator === "_gte" && conditions._lte) {
+            if (!(value >= conditionValue && value <= conditions._lte))
+              return false;
+            continue;
+          }
+
+          switch (operator) {
+            case "_eq":
+              if (!isEqual(value, conditionValue)) return false;
+              break;
+            case "_neq":
+              if (isEqual(value, conditionValue)) return false;
+              break;
+            case "_gt":
+              if (!(value > conditionValue)) return false;
+              break;
+            case "_gte":
+              if (!(value >= conditionValue)) return false;
+              break;
+            case "_lt":
+              if (!(value < conditionValue)) return false;
+              break;
+            case "_lte":
+              if (!(value <= conditionValue)) return false;
+              break;
+            case "_like":
+              if (
+                !isString(value) ||
+                !new RegExp(conditionValue.replace(/%/g, ".*")).test(value)
+              )
+                return false;
+              break;
+            case "_ilike":
+              if (
+                !isString(value) ||
+                !new RegExp(conditionValue.replace(/%/g, ".*"), "i").test(value)
+              )
+                return false;
+              break;
+            case "_nlike":
+              if (
+                !isString(value) ||
+                new RegExp(conditionValue.replace(/%/g, ".*")).test(value)
+              )
+                return false;
+              break;
+            case "_nilike":
+              if (
+                !isString(value) ||
+                new RegExp(conditionValue.replace(/%/g, ".*"), "i").test(value)
+              )
+                return false;
+              break;
+            case "_starts_with":
+              if (!isString(value) || !value.startsWith(conditionValue))
+                return false;
+              break;
+            case "_ends_with":
+              if (!isString(value) || !value.endsWith(conditionValue))
+                return false;
+              break;
+            case "_is_null":
+              if (
+                (conditionValue && !isNull(value)) ||
+                (!conditionValue && isNull(value))
+              )
+                return false;
+              break;
+            case "_contains":
+              if (
+                !isArray(value) ||
+                !every(conditionValue, item => includes(value, item))
+              )
+                return false;
+              break;
+            case "_contained_in":
+              if (
+                !isArray(value) ||
+                !every(value, item => includes(conditionValue, item))
+              )
+                return false;
+              break;
+            case "_has_key":
+              if (!isObject(value) || !has(value, conditionValue)) return false;
+              break;
+            case "_has_keys_any":
+              if (
+                !isObject(value) ||
+                !some(conditionValue, item => has(value, item))
+              )
+                return false;
+              break;
+            case "_has_keys_all":
+              if (
+                !isObject(value) ||
+                !every(conditionValue, item => has(value, item))
+              )
+                return false;
+              break;
+            case "_similar":
+              if (
+                !isString(value) ||
+                !new RegExp(conditionValue.replace(/%/g, ".*")).test(value)
+              )
+                return false;
+              break;
+            default:
+              if (operator.startsWith("_")) {
+                console.warn(`Unsupported operator: ${operator}`);
+                return false;
+              } else {
+                console.warn(`Unsupported operator: ${operator}`);
+                return false;
+              }
+          }
+        }
+      }
+    }
+
+    return true;
+  }
+
+  // Helper to check if an object contains any Hasura operators
+  function hasOperator(obj) {
+    return Object.keys(obj).some(key => key.startsWith("_"));
+  }
+
+  return records.filter(record => applyFilter(record, where));
+}
+
+function applyOrderBy(records, order_by) {
+  const keys = Object.keys(order_by);
+  if (keys.length > 0) {
+    const field = keys[0];
+    const direction = order_by[field] === "asc" ? "asc" : "desc";
+    return orderBy(records, [field], [direction]);
+  }
+  return records;
+}

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

@@ -0,0 +1,587 @@
+import { filterLocalEntitiesToHasura } from "./filterLocalEntitiesToHasura";
+
+describe("filterLocalEntitiesToHasura", () => {
+  const records = [
+    {
+      id: 123,
+      name: "John Doe",
+      age: 30,
+      is_active: true,
+      city: "London",
+
+      tags: ["programming", "javascript"],
+      email: "john@example.com",
+      data: { category: "A", type: "X" },
+      username: "john123"
+    },
+    {
+      id: 456,
+      name: "Jane Smith",
+      age: 25,
+      is_active: false,
+      city: "Paris",
+      tags: ["javascript", "python"],
+      email: null,
+      data: { category: "B", type: "Y" },
+      username: "jane456"
+    },
+    {
+      id: 789,
+      name: "Alice Johnson",
+      age: 35,
+      is_active: true,
+      city: "London",
+      tags: ["programming", "python", "java"],
+      email: "alice@example.com",
+      data: { category: "A", type: "Z" },
+      username: "alice789"
+    },
+    {
+      id: 101,
+      name: "Bob Williams",
+      age: 20,
+      is_active: false,
+      city: "New York",
+      tags: ["java"],
+      email: "bob@example.com",
+      data: { category: "C", type: "X" },
+      username: "bob101"
+    }
+  ];
+
+  it("should filter by _eq", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { id: { _eq: 123 } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _neq", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { id: { _neq: 123 } }
+    });
+    expect(result.entities).toEqual(records.slice(1));
+    expect(result.entitiesAcrossPages).toEqual(records.slice(1));
+    expect(result.entityCount).toBe(3);
+  });
+
+  it("should filter by _gt", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { age: { _gt: 30 } }
+    });
+    expect(result.entities).toEqual([records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[2]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _gte", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { age: { _gte: 30 } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _lt", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { age: { _lt: 25 } }
+    });
+    expect(result.entities).toEqual([records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[3]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _lte", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { age: { _lte: 25 } }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _like", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { name: { _like: "%John%" } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _ilike", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { name: { _ilike: "%john%" } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _nlike", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { name: { _nlike: "%John%" } }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _nilike", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { name: { _nilike: "%john%" } }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _starts_with", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { name: { _starts_with: "John" } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _ends_with", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { name: { _ends_with: "Doe" } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _is_null", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { email: { _is_null: true } }
+    });
+    expect(result.entities).toEqual([records[1]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _is_null false", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { email: { _is_null: false } }
+    });
+    expect(result.entities).toEqual([records[0], records[2], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[2],
+      records[3]
+    ]);
+    expect(result.entityCount).toBe(3);
+  });
+
+  it("should filter by _and", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        _and: [{ age: { _gt: 25 } }, { city: { _eq: "London" } }]
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _or", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        _or: [{ city: { _eq: "London" } }, { city: { _eq: "Paris" } }]
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[1], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[1],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(3);
+  });
+
+  it("should filter by _not", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        _not: { is_active: { _eq: true } }
+      }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _contains", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        tags: { _contains: ["programming", "javascript"] }
+      }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _contained_in", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        tags: { _contained_in: ["programming", "javascript", "python", "java"] }
+      }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _has_key", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { data: { _has_key: "category" } }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _has_keys_any", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        data: { _has_keys_any: ["category", "missingKey"] }
+      }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _has_keys_all", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        data: { _has_keys_all: ["category", "type"] }
+      }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _similar", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        username: { _similar: "(john|alice)%" }
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by range _gte and _lte", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { age: { _gte: 25, _lte: 30 } }
+    });
+    expect(result.entities).toEqual([records[0], records[1]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[1]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by range _gt and _lt", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { age: { _gt: 25, _lt: 35 } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+  it("should filter with nested filters in _and and _or properly ", () => {
+    const result = filterLocalEntitiesToHasura(
+      [
+        {
+          id: 1,
+          type: {
+            special: "01"
+          }
+        },
+        {
+          id: 2,
+          type: {
+            special: "02"
+          }
+        }
+      ],
+      {
+        where: {
+          _and: [
+            {
+              type: {
+                special: {
+                  _ilike: "%01%"
+                }
+              }
+            }
+          ],
+          _or: []
+        }
+      }
+    );
+    expect(result.entities).toEqual([
+      {
+        id: 1,
+        type: {
+          special: "01"
+        }
+      }
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      {
+        id: 1,
+        type: {
+          special: "01"
+        }
+      }
+    ]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should handle empty where clause", () => {
+    const result = filterLocalEntitiesToHasura(records, {});
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+  it("should handle empty _and and _or clauses", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { _and: [], _or: [] }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should handle nested _and and _or", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: {
+        _and: [
+          { _or: [{ city: { _eq: "London" } }, { city: { _eq: "Paris" } }] },
+          { age: { _gt: 20 } }
+        ]
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[1], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[1],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(3);
+  });
+  it("should order by age ascending", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      order_by: { age: "asc" }
+    });
+    expect(result.entities).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should order by age descending", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      order_by: { age: "desc" }
+    });
+    expect(result.entities).toEqual([
+      records[2],
+      records[0],
+      records[1],
+      records[3]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[2],
+      records[0],
+      records[1],
+      records[3]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should order by name ascending", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      order_by: { name: "asc" }
+    });
+    expect(result.entities).toEqual([
+      records[2],
+      records[3],
+      records[1],
+      records[0]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[2],
+      records[3],
+      records[1],
+      records[0]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should order by name descending", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      order_by: { name: "desc" }
+    });
+    expect(result.entities).toEqual([
+      records[0],
+      records[1],
+      records[3],
+      records[2]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[1],
+      records[3],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter and order", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } },
+      order_by: { age: "desc" }
+    });
+    expect(result.entities).toEqual([records[2], records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[2], records[0]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle empty order_by", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle order_by with empty where", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      order_by: { age: "asc" }
+    });
+    expect(result.entities).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply limit", () => {
+    const result = filterLocalEntitiesToHasura(records, { limit: 2 });
+    expect(result.entities).toEqual([records[0], records[1]]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply offset", () => {
+    const result = filterLocalEntitiesToHasura(records, { offset: 2 });
+    expect(result.entities).toEqual([records[2], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply limit and offset", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      limit: 1,
+      offset: 2
+    });
+    expect(result.entities).toEqual([records[2]]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply limit to filtered results", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } },
+      limit: 1
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should apply offset to filtered results", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } },
+      offset: 1
+    });
+    expect(result.entities).toEqual([records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should apply limit and offset to filtered and ordered results", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } },
+      order_by: { age: "desc" },
+      limit: 1,
+      offset: 1
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[2], records[0]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle offset greater than array length", () => {
+    const result = filterLocalEntitiesToHasura(records, { offset: 10 });
+    expect(result.entities).toEqual([]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should handle limit greater than array length", () => {
+    const result = filterLocalEntitiesToHasura(records, { limit: 10 });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should handle isInfinite option with filtering", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } },
+      isInfinite: true
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle isInfinite option with filtering, limit, and offset", () => {
+    const result = filterLocalEntitiesToHasura(records, {
+      where: { city: { _eq: "London" } },
+      limit: 1,
+      offset: 1,
+      isInfinite: true
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+});

package/src/DataTable/utils/initializeHasuraWhereAndFilter.js

@@ -0,0 +1,26 @@
+export function initializeHasuraWhereAndFilter(
+  additionalFilter,
+  where = {},
+  currentParams
+) {
+  where._and = where._and || [];
+  where._or = where._or || [];
+  if (typeof additionalFilter === "function") {
+    const newWhere = additionalFilter(where, currentParams);
+    if (newWhere) {
+      where = {
+        ...where,
+        ...newWhere
+      };
+    }
+  } else if (typeof additionalFilter === "object")
+    where._and.push(additionalFilter);
+}
+
+export const addCustomColumnFilters = (where, fields, currentParams) => {
+  fields.forEach(field => {
+    const { customColumnFilter, filterDisabled } = field;
+    if (filterDisabled || !customColumnFilter) return;
+    customColumnFilter(where, currentParams);
+  });
+};

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -0,0 +1,260 @@
+import { camelCase, set } from "lodash-es";
+
+export function tableQueryParamsToHasuraClauses({
+  page,
+  pageSize,
+  searchTerm,
+  filters,
+  order,
+  schema, // Add schema as a parameter
+  additionalFilter
+}) {
+  const ccFields = getFieldsMappedByCCDisplayName(schema);
+  let where = {};
+  const order_by = {};
+  const limit = pageSize || 25;
+  const offset = page && pageSize ? (page - 1) * pageSize : 0;
+
+  if (searchTerm) {
+    const searchTermFilters = [];
+    schema.fields.forEach(field => {
+      const { type, path, searchDisabled } = field;
+      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);
+          }
+        }
+      } else if (
+        (type === "number" || type === "integer") &&
+        !isNaN(filterValue)
+      ) {
+        const o = set({}, path, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o);
+      }
+    });
+    if (searchTermFilters.length > 0) {
+      if (Object.keys(where).length > 0) {
+        where = { _and: [where, { _or: searchTermFilters }] };
+      } else {
+        where = { _or: searchTermFilters };
+      }
+    }
+  }
+
+  if (filters && filters.length > 0) {
+    const filterClauses = filters
+      .map(filter => {
+        let { selectedFilter, filterOn, filterValue } = filter;
+        const fieldSchema = ccFields[filterOn] || {};
+
+        const { path, reference, type } = fieldSchema;
+        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 (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]: { _not_ilike: `%${filterValue}%` } };
+          case "isExactly":
+            return { [filterOn]: { _eq: filterValue } };
+          case "isEmpty":
+            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":
+            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 {};
+        }
+      })
+      .map(filter => {
+        const o = {};
+        set(o, Object.keys(filter)[0], filter[Object.keys(filter)[0]]);
+        return o;
+      });
+
+    if (filterClauses.length > 0) {
+      if (Object.keys(where).length > 0) {
+        where = { _and: [where, ...filterClauses] };
+      } else {
+        where = { _and: filterClauses };
+      }
+    }
+  }
+
+  if (order && order.length > 0) {
+    order.forEach(item => {
+      const field = item.startsWith("-") ? item.substring(1) : item;
+      const direction = item.startsWith("-") ? "desc" : "asc";
+      order_by[field] = direction;
+    });
+  }
+
+  if (additionalFilter) {
+    where = { _and: [where, additionalFilter] };
+  }
+  return { where, order_by, limit, offset };
+}
+
+/**
+ * Takes a schema and returns an object with the fields mapped by their camelCased display name.
+ * If the displayName is not set or is a jsx element, the path is used instead.
+ * The same conversion must be done when using the result of this method
+ */
+export function getFieldsMappedByCCDisplayName(schema) {
+  if (!schema || !schema.fields) return {};
+  return schema.fields.reduce((acc, field) => {
+    const ccDisplayName = getCCDisplayName(field);
+    acc[ccDisplayName] = field;
+    return acc;
+  }, {});
+}
+
+/**
+ *
+ * @param {object} field
+ * @returns the camelCase display name of the field, to be used for filters, sorting, etc
+ */
+export function getCCDisplayName(field) {
+  return camelCase(
+    typeof field.displayName === "string" ? field.displayName : field.path
+  );
+}

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

@@ -0,0 +1,206 @@
+import { tableQueryParamsToHasuraClauses } from "./tableQueryParamsToHasuraClauses";
+
+describe("tableQueryParamsToHasuraClauses", () => {
+  const schema = {
+    fields: [
+      { path: "name", type: "string" },
+      { path: "age", type: "number" },
+      { path: "isActive", type: "boolean" },
+      { path: "email", type: "string" }
+    ]
+  };
+
+  it("should handle empty query params", () => {
+    const result = tableQueryParamsToHasuraClauses({});
+    expect(result).toEqual({
+      where: {},
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle page and pageSize", () => {
+    const result = tableQueryParamsToHasuraClauses({ page: 2, pageSize: 10 });
+    expect(result).toEqual({
+      where: {},
+      order_by: {},
+      limit: 10,
+      offset: 10
+    });
+  });
+
+  it("should handle searchTerm with string fields", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      searchTerm: "test",
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _or: [{ name: { _ilike: "%test%" } }, { email: { _ilike: "%test%" } }]
+      },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle searchTerm with number fields", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      searchTerm: "30",
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _or: [
+          { name: { _ilike: "%30%" } },
+          { age: { _eq: 30 } },
+          { email: { _ilike: "%30%" } }
+        ]
+      },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle searchTerm with boolean fields", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      searchTerm: "true",
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _or: [
+          { name: { _ilike: "%true%" } },
+          { isActive: { _eq: true } },
+          { email: { _ilike: "%true%" } }
+        ]
+      },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle searchTerm with multiple field types", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      searchTerm: "test",
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _or: [{ name: { _ilike: "%test%" } }, { email: { _ilike: "%test%" } }]
+      },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle contains filter", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      filters: [
+        {
+          selectedFilter: "contains",
+          filterOn: "name",
+          filterValue: "test"
+        }
+      ]
+    });
+    expect(result).toEqual({
+      where: { _and: [{ name: { _ilike: "%test%" } }] },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle equalTo filter for number", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      filters: [
+        { selectedFilter: "equalTo", filterOn: "age", filterValue: "30" }
+      ],
+      schema
+    });
+    expect(result).toEqual({
+      where: { _and: [{ age: { _eq: 30 } }] },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should handle order", () => {
+    const result = tableQueryParamsToHasuraClauses({ order: ["name", "-age"] });
+    expect(result).toEqual({
+      where: {},
+      order_by: { name: "asc", age: "desc" },
+      limit: 25,
+      offset: 0
+    });
+  });
+
+  it("should combine all params", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      page: 2,
+      pageSize: 10,
+      searchTerm: "test",
+      filters: [
+        {
+          selectedFilter: "greaterThan",
+          filterOn: "age",
+          filterValue: "30"
+        }
+      ],
+      order: ["name"],
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _and: [
+          {
+            _or: [
+              { name: { _ilike: "%test%" } },
+              { email: { _ilike: "%test%" } }
+            ]
+          },
+          { age: { _gt: 30 } }
+        ]
+      },
+      order_by: { name: "asc" },
+      limit: 10,
+      offset: 10
+    });
+  });
+
+  it("should combine searchTerm and filters", () => {
+    const result = tableQueryParamsToHasuraClauses({
+      searchTerm: "test",
+      filters: [
+        {
+          selectedFilter: "greaterThan",
+          filterOn: "age",
+          filterValue: "30"
+        }
+      ],
+      schema
+    });
+    expect(result).toEqual({
+      where: {
+        _and: [
+          {
+            _or: [
+              { name: { _ilike: "%test%" } },
+              { email: { _ilike: "%test%" } }
+            ]
+          },
+          { age: { _gt: 30 } }
+        ]
+      },
+      order_by: {},
+      limit: 25,
+      offset: 0
+    });
+  });
+});