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

package/DataTable/utils/queryParams.d.ts

@@ -3,12 +3,6 @@ export function getMergedOpts(topLevel?: {}, instanceLevel?: {}): {
     defaults: any;
     formName: string;
 };
-/**
- *
- * @param {object} field
- * @returns the camelCase display name of the field, to be used for filters, sorting, etc
- */
-export function getCCDisplayName(field: object): string;
 export function getCurrentParamsFromUrl(location: any, isSimple: any): any;
 export function setCurrentParamsOnUrl(newParams: any, replace: any, isSimple: any): void;
 export function makeDataTableHandlers({ setNewParams, defaults, onlyOneFilter }: {
@@ -25,7 +19,7 @@ export function makeDataTableHandlers({ setNewParams, defaults, onlyOneFilter }:
     setOrder: (order: any, isRemove: any, shiftHeld: any) => any;
     setNewParams: any;
 };
-export function getQueryParams({ currentParams, defaults, schema, isInfinite, entities, isLocalCall, additionalFilter, doNotCoercePageSize, ownProps }: {
+export function getQueryParams({ currentParams, defaults, schema, isInfinite, entities, isLocalCall, additionalFilter, doNotCoercePageSize, noOrderError, ownProps }: {
     currentParams: any;
     defaults: any;
     schema: any;
@@ -34,11 +28,14 @@ export function getQueryParams({ currentParams, defaults, schema, isInfinite, en
     isLocalCall: any;
     additionalFilter: any;
     doNotCoercePageSize: any;
+    noOrderError: any;
     ownProps: any;
 }): {
-    entities: any[];
-    entitiesAcrossPages: any[];
-    entityCount: number;
+    page: any;
+    pageSize: any;
+    order: any[];
+    filters: any;
+    searchTerm: any;
 } | {
     variables: {
         where: {};
@@ -48,7 +45,7 @@ export function getQueryParams({ currentParams, defaults, schema, isInfinite, en
     };
     page: any;
     pageSize: any;
-    order: any;
+    order: any[];
     filters: any;
     searchTerm: any;
 };

package/DataTable/utils/tableQueryParamsToHasuraClauses.d.ts

@@ -12,3 +12,15 @@ export function tableQueryParamsToHasuraClauses({ page, pageSize, searchTerm, fi
     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/index.cjs.js

@@ -19402,6 +19402,7 @@ function tableQueryParamsToHasuraClauses({
   // Add schema as a parameter
   additionalFilter
 }) {
+  const ccFields = getFieldsMappedByCCDisplayName(schema);
   let where = {};
   const order_by = {};
   const limit = pageSize || 25;
@@ -19413,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 {
@@ -19424,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) {
@@ -19449,32 +19446,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) {
@@ -19497,6 +19596,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) {
@@ -19526,10 +19640,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;
         }
@@ -19540,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) {
@@ -19637,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");
@@ -19685,12 +19812,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) {
@@ -19859,7 +19980,7 @@ function getQueryParams({
   isLocalCall,
   additionalFilter,
   doNotCoercePageSize,
-  // noOrderError,
+  noOrderError,
   // isCodeModel,
   ownProps
 }) {
@@ -19883,11 +20004,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
   };
@@ -19896,21 +20037,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,
@@ -56365,7 +56507,7 @@ const DataTable = /* @__PURE__ */ __name((_I) => {
             }) : !val;
           });
         }
-        if (noValsForField) {
+        if (noValsForField && entities.length) {
           return __spreadProps(__spreadValues({}, field), {
             isHidden: true,
             isForcedHidden: true
@@ -71628,6 +71770,7 @@ const useTableParams = /* @__PURE__ */ __name((props) => {
       isInfinite: isInfinite || isSimple && !withPaging,
       isLocalCall,
       additionalFilter,
+      noOrderError,
       ownProps: passingProps
     });
   }, [