@teselagen/ui 0.7.33-beta.5 → 0.7.33-beta.6

package/DataTable/utils/queryParams.d.ts

@@ -31,9 +31,11 @@ export function getQueryParams({ currentParams, defaults, schema, isInfinite, en
     noOrderError: any;
     ownProps: any;
 }): {
-    entities: any[];
-    entitiesAcrossPages: any[];
-    entityCount: number;
+    page: any;
+    pageSize: any;
+    order: any[];
+    filters: any;
+    searchTerm: any;
 } | {
     variables: {
         where: {};

package/index.cjs.js

@@ -19414,9 +19414,8 @@ function tableQueryParamsToHasuraClauses({
       if (searchDisabled || field.filterDisabled || type2 === "color") return;
       const filterValue = searchTerm;
       if (type2 === "string" || type2 === "lookup") {
-        searchTermFilters.push({
-          [path2]: { _ilike: `%${filterValue}%` }
-        });
+        const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
+        searchTermFilters.push(o2);
       } else if (type2 === "boolean") {
         let regex;
         try {
@@ -19425,19 +19424,16 @@ function tableQueryParamsToHasuraClauses({
         }
         if (regex) {
           if ("true".replace(regex, "") !== "true") {
-            searchTermFilters.push({
-              [path2]: { _eq: true }
-            });
+            const o2 = set$1({}, path2, { _eq: true });
+            searchTermFilters.push(o2);
           } else if ("false".replace(regex, "") !== "false") {
-            searchTermFilters.push({
-              [path2]: { _eq: false }
-            });
+            const o2 = set$1({}, path2, { _eq: false });
+            searchTermFilters.push(o2);
           }
         }
       } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
-        searchTermFilters.push({
-          [path2]: { _eq: parseFloat(filterValue) }
-        });
+        const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o2);
       }
     });
     if (searchTermFilters.length > 0) {
@@ -19522,7 +19518,9 @@ function tableQueryParamsToHasuraClauses({
               },
               {
                 [filterOn]: {
-                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+                  _gt: new Date(
+                    new Date(arrayFilterValue[1]).setHours(23, 59)
+                  )
                 }
               }
             ]
@@ -19572,6 +19570,10 @@ function tableQueryParamsToHasuraClauses({
           console.warn(`Unsupported filter type: ${selectedFilter}`);
           return {};
       }
+    }).map((filter2) => {
+      const o2 = {};
+      set$1(o2, Object.keys(filter2)[0], filter2[Object.keys(filter2)[0]]);
+      return o2;
     });
     if (filterClauses.length > 0) {
       if (Object.keys(where).length > 0) {
@@ -19658,6 +19660,9 @@ function applyWhereClause(records, where) {
       } else {
         const value = record[key];
         const conditions = filter2[key];
+        if (isObject$2(value) && isObject$2(conditions) && !hasOperator(conditions)) {
+          return applyFilter(value, conditions);
+        }
         for (const operator in conditions) {
           const conditionValue = conditions[operator];
           if (operator === "_gt" && conditions._lt) {
@@ -19755,6 +19760,10 @@ function applyWhereClause(records, where) {
     return true;
   }
   __name(applyFilter, "applyFilter");
+  function hasOperator(obj) {
+    return Object.keys(obj).some((key) => key.startsWith("_"));
+  }
+  __name(hasOperator, "hasOperator");
   return records.filter((record) => applyFilter(record, where));
 }
 __name(applyWhereClause, "applyWhereClause");
@@ -20015,7 +20024,7 @@ function getQueryParams({
       }
     });
   }
-  const toReturn = {
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
@@ -20034,16 +20043,16 @@ function getQueryParams({
   initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
   addCustomColumnFilters(where, schema.fields, currentParams);
   if (isLocalCall) {
-    const toRet = filterLocalEntitiesToHasura(entities, {
+    toRet = __spreadValues(__spreadValues({}, toRet), filterLocalEntitiesToHasura(entities, {
       where,
       order_by,
       limit,
       offset: offset3,
       isInfinite
-    });
+    }));
     return toRet;
   } else {
-    return __spreadProps(__spreadValues({}, toReturn), {
+    return __spreadProps(__spreadValues({}, toRet), {
       variables: {
         where,
         order_by,
@@ -56498,7 +56507,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             }) : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return __spreadProps(__spreadValues({}, field), {
             isHidden: true,
             isForcedHidden: true

package/index.es.js

@@ -19396,9 +19396,8 @@ function tableQueryParamsToHasuraClauses({
       if (searchDisabled || field.filterDisabled || type2 === "color") return;
       const filterValue = searchTerm;
       if (type2 === "string" || type2 === "lookup") {
-        searchTermFilters.push({
-          [path2]: { _ilike: `%${filterValue}%` }
-        });
+        const o2 = set$1({}, path2, { _ilike: `%${filterValue}%` });
+        searchTermFilters.push(o2);
       } else if (type2 === "boolean") {
         let regex;
         try {
@@ -19407,19 +19406,16 @@ function tableQueryParamsToHasuraClauses({
         }
         if (regex) {
           if ("true".replace(regex, "") !== "true") {
-            searchTermFilters.push({
-              [path2]: { _eq: true }
-            });
+            const o2 = set$1({}, path2, { _eq: true });
+            searchTermFilters.push(o2);
           } else if ("false".replace(regex, "") !== "false") {
-            searchTermFilters.push({
-              [path2]: { _eq: false }
-            });
+            const o2 = set$1({}, path2, { _eq: false });
+            searchTermFilters.push(o2);
           }
         }
       } else if ((type2 === "number" || type2 === "integer") && !isNaN(filterValue)) {
-        searchTermFilters.push({
-          [path2]: { _eq: parseFloat(filterValue) }
-        });
+        const o2 = set$1({}, path2, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o2);
       }
     });
     if (searchTermFilters.length > 0) {
@@ -19504,7 +19500,9 @@ function tableQueryParamsToHasuraClauses({
               },
               {
                 [filterOn]: {
-                  _gt: new Date(new Date(arrayFilterValue[1]).setHours(23, 59))
+                  _gt: new Date(
+                    new Date(arrayFilterValue[1]).setHours(23, 59)
+                  )
                 }
               }
             ]
@@ -19554,6 +19552,10 @@ function tableQueryParamsToHasuraClauses({
           console.warn(`Unsupported filter type: ${selectedFilter}`);
           return {};
       }
+    }).map((filter2) => {
+      const o2 = {};
+      set$1(o2, Object.keys(filter2)[0], filter2[Object.keys(filter2)[0]]);
+      return o2;
     });
     if (filterClauses.length > 0) {
       if (Object.keys(where).length > 0) {
@@ -19640,6 +19642,9 @@ function applyWhereClause(records, where) {
       } else {
         const value = record[key];
         const conditions = filter2[key];
+        if (isObject$2(value) && isObject$2(conditions) && !hasOperator(conditions)) {
+          return applyFilter(value, conditions);
+        }
         for (const operator in conditions) {
           const conditionValue = conditions[operator];
           if (operator === "_gt" && conditions._lt) {
@@ -19737,6 +19742,10 @@ function applyWhereClause(records, where) {
     return true;
   }
   __name(applyFilter, "applyFilter");
+  function hasOperator(obj) {
+    return Object.keys(obj).some((key) => key.startsWith("_"));
+  }
+  __name(hasOperator, "hasOperator");
   return records.filter((record) => applyFilter(record, where));
 }
 __name(applyWhereClause, "applyWhereClause");
@@ -19997,7 +20006,7 @@ function getQueryParams({
       }
     });
   }
-  const toReturn = {
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
@@ -20016,16 +20025,16 @@ function getQueryParams({
   initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
   addCustomColumnFilters(where, schema.fields, currentParams);
   if (isLocalCall) {
-    const toRet = filterLocalEntitiesToHasura(entities, {
+    toRet = __spreadValues(__spreadValues({}, toRet), filterLocalEntitiesToHasura(entities, {
       where,
       order_by,
       limit,
       offset: offset3,
       isInfinite
-    });
+    }));
     return toRet;
   } else {
-    return __spreadProps(__spreadValues({}, toReturn), {
+    return __spreadProps(__spreadValues({}, toRet), {
       variables: {
         where,
         order_by,
@@ -56480,7 +56489,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             }) : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return __spreadProps(__spreadValues({}, field), {
             isHidden: true,
             isForcedHidden: true

package/package.json

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

package/src/DataTable/index.js

@@ -603,7 +603,7 @@ const DataTable = ({
                 : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return {
             ...field,
             isHidden: true,

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -77,6 +77,15 @@ function applyWhereClause(records, where) {
         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];
 
@@ -208,6 +217,11 @@ function applyWhereClause(records, where) {
     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));
 }
 

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

@@ -297,6 +297,55 @@ describe("filterLocalEntitiesToHasura", () => {
     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, {});

package/src/DataTable/utils/queryParams.js

@@ -303,7 +303,7 @@ export function getQueryParams({
     });
   }
 
-  const toReturn = {
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
@@ -325,17 +325,20 @@ export function getQueryParams({
   if (isLocalCall) {
     //if the table is local (aka not directly connected to a db) then we need to
     //handle filtering/paging/sorting all on the front end
-    const toRet = filterLocalEntitiesToHasura(entities, {
-      where,
-      order_by,
-      limit,
-      offset,
-      isInfinite
-    });
+    toRet = {
+      ...toRet,
+      ...filterLocalEntitiesToHasura(entities, {
+        where,
+        order_by,
+        limit,
+        offset,
+        isInfinite
+      })
+    };
     return toRet;
   } else {
     return {
-      ...toReturn,
+      ...toRet,
       variables: {
         where,
         order_by,

package/src/DataTable/utils/tableQueryParamsToHasuraClauses.js

@@ -1,4 +1,4 @@
-import { camelCase } from "lodash-es";
+import { camelCase, set } from "lodash-es";
 
 export function tableQueryParamsToHasuraClauses({
   page,
@@ -23,9 +23,8 @@ export function tableQueryParamsToHasuraClauses({
       const filterValue = searchTerm; // No cleaning needed here, we're using _ilike
 
       if (type === "string" || type === "lookup") {
-        searchTermFilters.push({
-          [path]: { _ilike: `%${filterValue}%` }
-        });
+        const o = set({}, path, { _ilike: `%${filterValue}%` });
+        searchTermFilters.push(o);
       } else if (type === "boolean") {
         let regex;
         try {
@@ -35,22 +34,19 @@ export function tableQueryParamsToHasuraClauses({
         }
         if (regex) {
           if ("true".replace(regex, "") !== "true") {
-            searchTermFilters.push({
-              [path]: { _eq: true }
-            });
+            const o = set({}, path, { _eq: true });
+            searchTermFilters.push(o);
           } else if ("false".replace(regex, "") !== "false") {
-            searchTermFilters.push({
-              [path]: { _eq: false }
-            });
+            const o = set({}, path, { _eq: false });
+            searchTermFilters.push(o);
           }
         }
       } else if (
         (type === "number" || type === "integer") &&
         !isNaN(filterValue)
       ) {
-        searchTermFilters.push({
-          [path]: { _eq: parseFloat(filterValue) }
-        });
+        const o = set({}, path, { _eq: parseFloat(filterValue) });
+        searchTermFilters.push(o);
       }
     });
     if (searchTermFilters.length > 0) {
@@ -63,143 +59,150 @@ 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 } = 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);
-      }
+        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 (fieldSchema.normalizeFilter) {
-        filterValue = fieldSchema.normalizeFilter(
-          filterValue,
-          selectedFilter,
-          filterOn
-        );
-      }
+        if (type === "number" || type === "integer") {
+          filterValue = Array.isArray(filterValue)
+            ? filterValue.map(val => Number(val))
+            : Number(filterValue);
+        }
 
-      if (reference) {
-        filterOn = reference.sourceField;
-      } else {
-        filterOn = path || filterOn;
-      }
+        if (fieldSchema.normalizeFilter) {
+          filterValue = fieldSchema.normalizeFilter(
+            filterValue,
+            selectedFilter,
+            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))
+        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 "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 "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 "equalTo":
-          return { [filterOn]: { _eq: parseFloat(filterValue) } };
-        case "regex":
-          return { [filterOn]: { _regex: filterValue } };
-        default:
-          console.warn(`Unsupported filter type: ${selectedFilter}`);
-          return {};
-      }
-    });
+            };
+          case "outsideRange":
+            return {
+              _or: [
+                {
+                  [filterOn]: {
+                    _lt: parseFloat(arrayFilterValue[0])
+                  }
+                },
+                {
+                  [filterOn]: {
+                    _gt: parseFloat(arrayFilterValue[1])
+                  }
+                }
+              ]
+            };
+          case "equalTo":
+            return { [filterOn]: { _eq: parseFloat(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) {