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

package/index.es.js

@@ -19384,6 +19384,7 @@ function tableQueryParamsToHasuraClauses({
   // Add schema as a parameter
   additionalFilter
 }) {
+  const ccFields = getFieldsMappedByCCDisplayName(schema);
   let where = {};
   const order_by = {};
   const limit = pageSize || 25;
@@ -19395,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 {
@@ -19406,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) {
@@ -19431,32 +19428,134 @@ function tableQueryParamsToHasuraClauses({
   }
   if (filters && filters.length > 0) {
     const filterClauses = filters.map((filter2) => {
-      const { selectedFilter, filterOn, filterValue } = filter2;
+      let { selectedFilter, filterOn, filterValue } = filter2;
+      const fieldSchema = ccFields[filterOn] || {};
+      const { path: path2, reference: reference2, type: type2 } = fieldSchema;
+      let stringFilterValue = filterValue && filterValue.toString ? filterValue.toString() : filterValue;
+      if (stringFilterValue === false) {
+        stringFilterValue = "false";
+      } else {
+        stringFilterValue = stringFilterValue || "";
+      }
+      const arrayFilterValue = Array.isArray(filterValue) ? filterValue : stringFilterValue.split(";");
+      if (type2 === "number" || type2 === "integer") {
+        filterValue = Array.isArray(filterValue) ? filterValue.map((val) => Number(val)) : Number(filterValue);
+      }
+      if (fieldSchema.normalizeFilter) {
+        filterValue = fieldSchema.normalizeFilter(
+          filterValue,
+          selectedFilter,
+          filterOn
+        );
+      }
+      if (reference2) {
+        filterOn = reference2.sourceField;
+      } else {
+        filterOn = path2 || filterOn;
+      }
       switch (selectedFilter) {
-        case "textContains":
+        case "none":
+          return {};
+        case "startsWith":
+          return { [filterOn]: { _ilike: `${filterValue}%` } };
+        case "endsWith":
+          return { [filterOn]: { _ilike: `%${filterValue}` } };
+        case "contains":
           return { [filterOn]: { _ilike: `%${filterValue}%` } };
-        case "textEquals":
+        case "notContains":
+          return { [filterOn]: { _not_ilike: `%${filterValue}%` } };
+        case "isExactly":
           return { [filterOn]: { _eq: filterValue } };
-        case "textNotEquals":
-          return { [filterOn]: { _neq: filterValue } };
-        case "numberEquals":
-          return { [filterOn]: { _eq: parseFloat(filterValue) } };
-        case "numberGreaterThan":
+        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 "numberLessThan":
+        case "lessThan":
           return { [filterOn]: { _lt: parseFloat(filterValue) } };
-        case "numberGreaterThanEquals":
-          return { [filterOn]: { _gte: parseFloat(filterValue) } };
-        case "numberLessThanEquals":
-          return { [filterOn]: { _lte: parseFloat(filterValue) } };
-        case "isNull":
-          return { [filterOn]: { _is_null: true } };
-        case "isNotNull":
-          return { [filterOn]: { _is_null: false } };
+        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: parseFloat(filterValue) } };
+        case "regex":
+          return { [filterOn]: { _regex: filterValue } };
         default:
           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) {
@@ -19479,6 +19578,21 @@ function tableQueryParamsToHasuraClauses({
   return { where, order_by, limit, offset: offset3 };
 }
 __name(tableQueryParamsToHasuraClauses, "tableQueryParamsToHasuraClauses");
+function getFieldsMappedByCCDisplayName(schema) {
+  if (!schema || !schema.fields) return {};
+  return schema.fields.reduce((acc, field) => {
+    const ccDisplayName = getCCDisplayName(field);
+    acc[ccDisplayName] = field;
+    return acc;
+  }, {});
+}
+__name(getFieldsMappedByCCDisplayName, "getFieldsMappedByCCDisplayName");
+function getCCDisplayName(field) {
+  return camelCase(
+    typeof field.displayName === "string" ? field.displayName : field.path
+  );
+}
+__name(getCCDisplayName, "getCCDisplayName");
 function filterLocalEntitiesToHasura(records, { where, order_by, limit, offset: offset3, isInfinite } = {}) {
   let filteredRecords = [...records];
   if (where) {
@@ -19508,10 +19622,16 @@ function applyWhereClause(records, where) {
     }
     for (const key in filter2) {
       if (key === "_and") {
+        if (isEmpty$1(filter2[key])) {
+          continue;
+        }
         if (!every(filter2[key], (subFilter) => applyFilter(record, subFilter))) {
           return false;
         }
       } else if (key === "_or") {
+        if (isEmpty$1(filter2[key])) {
+          continue;
+        }
         if (!some(filter2[key], (subFilter) => applyFilter(record, subFilter))) {
           return false;
         }
@@ -19522,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) {
@@ -19619,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");
@@ -19667,12 +19794,6 @@ function safeParse(val) {
   }
 }
 __name(safeParse, "safeParse");
-function getCCDisplayName(field) {
-  return camelCase(
-    typeof field.displayName === "string" ? field.displayName : field.path
-  );
-}
-__name(getCCDisplayName, "getCCDisplayName");
 function getCurrentParamsFromUrl(location2, isSimple) {
   let { search: search2 } = location2;
   if (isSimple) {
@@ -19841,7 +19962,7 @@ function getQueryParams({
   isLocalCall,
   additionalFilter,
   doNotCoercePageSize,
-  // noOrderError,
+  noOrderError,
   // isCodeModel,
   ownProps
 }) {
@@ -19865,11 +19986,31 @@ function getQueryParams({
     )[0];
     pageSize = closest;
   }
-  const toReturn = {
+  const cleanedOrder = [];
+  if (order2 && order2.length) {
+    const ccFields = getFieldsMappedByCCDisplayName(schema);
+    order2.forEach((orderVal) => {
+      const ccDisplayName = orderVal.replace(/^-/gi, "");
+      const schemaForField = ccFields[ccDisplayName];
+      if (schemaForField) {
+        const { path: path2 } = schemaForField;
+        const reversed = ccDisplayName !== orderVal;
+        const prefix2 = reversed ? "-" : "";
+        cleanedOrder.push(prefix2 + path2);
+      } else {
+        !noOrderError && console.error(
+          "No schema for field found!",
+          ccDisplayName,
+          JSON.stringify(schema.fields, null, 2)
+        );
+      }
+    });
+  }
+  let toRet = {
     //these are values that might be generally useful for the wrapped component
     page,
     pageSize: ownProps.controlled_pageSize || pageSize,
-    order: order2,
+    order: cleanedOrder,
     filters,
     searchTerm
   };
@@ -19878,21 +20019,22 @@ function getQueryParams({
     pageSize,
     searchTerm,
     filters,
-    order: order2,
+    order: cleanedOrder,
     schema
   });
   initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
   addCustomColumnFilters(where, schema.fields, currentParams);
   if (isLocalCall) {
-    return 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,
@@ -56347,7 +56489,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             }) : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return __spreadProps(__spreadValues({}, field), {
             isHidden: true,
             isForcedHidden: true
@@ -71610,6 +71752,7 @@ const useTableParams = /* @__PURE__ */ __name((props) => {
       isInfinite: isInfinite || isSimple && !withPaging,
       isLocalCall,
       additionalFilter,
+      noOrderError,
       ownProps: passingProps
     });
   }, [

package/package.json

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

package/src/DataTable/Columns.js

@@ -33,10 +33,10 @@ import getTextFromEl from "../utils/getTextFromEl";
 import rowClick, { finalizeSelection } from "./utils/rowClick";
 import { editCellHelper } from "./editCellHelper";
 import { getCellVal } from "./getCellVal";
-import { getCCDisplayName } from "./utils/queryParams";
 import { useDispatch } from "react-redux";
 import { change as _change } from "redux-form";
 import { RenderCell } from "./RenderCell";
+import { getCCDisplayName } from "./utils/tableQueryParamsToHasuraClauses";
 
 dayjs.extend(localizedFormat);
 

package/src/DataTable/DisplayOptions.js

@@ -10,7 +10,7 @@ import {
   Popover,
   Switch
 } from "@blueprintjs/core";
-import { getCCDisplayName } from "./utils/queryParams";
+import { getCCDisplayName } from "./utils/tableQueryParamsToHasuraClauses";
 
 const DisplayOptions = ({
   compact,

package/src/DataTable/index.js

@@ -92,7 +92,6 @@ import { viewColumn, openColumn, multiViewColumn } from "./viewColumn";
 import convertSchema from "./utils/convertSchema";
 import TableFormTrackerContext from "./TableFormTrackerContext";
 import {
-  getCCDisplayName,
   getCurrentParamsFromUrl,
   getQueryParams,
   makeDataTableHandlers,
@@ -103,6 +102,7 @@ import { formValueSelector, change as _change } from "redux-form";
 import { throwFormError } from "../throwFormError";
 import { isObservableArray, toJS } from "mobx";
 import { isBeingCalledExcessively } from "../utils/isBeingCalledExcessively";
+import { getCCDisplayName } from "./utils/tableQueryParamsToHasuraClauses";
 
 enablePatches();
 const IS_LINUX = window.navigator.platform.toLowerCase().search("linux") > -1;
@@ -603,7 +603,7 @@ const DataTable = ({
                 : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return {
             ...field,
             isHidden: true,

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -56,10 +56,16 @@ function applyWhereClause(records, where) {
 
     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;
         }
@@ -71,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];
 
@@ -202,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));
 }