@teselagen/ui 0.8.6-beta.2 → 0.8.6-beta.21

package/src/DataTable/utils/initializeHasuraWhereAndFilter.js

@@ -8,19 +8,8 @@ export function initializeHasuraWhereAndFilter(
   if (typeof additionalFilter === "function") {
     const newWhere = additionalFilter(where, currentParams);
     if (newWhere) {
-      where = {
-        ...where,
-        ...newWhere
-      };
+      Object.assign(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/queryParams.js

@@ -1,14 +1,11 @@
 import queryString from "qs";
-import { uniqBy, clone, camelCase } from "lodash-es";
+import { uniqBy, clone, camelCase, forEach } from "lodash-es";
 import {
   getFieldsMappedByCCDisplayName,
   tableQueryParamsToHasuraClauses
 } from "./tableQueryParamsToHasuraClauses";
 import { filterLocalEntitiesToHasura } from "./filterLocalEntitiesToHasura";
-import {
-  addCustomColumnFilters,
-  initializeHasuraWhereAndFilter
-} from "./initializeHasuraWhereAndFilter";
+import { initializeHasuraWhereAndFilter } from "./initializeHasuraWhereAndFilter";
 
 const defaultPageSizes = [5, 10, 15, 25, 50, 100, 200, 400];
 
@@ -56,7 +53,6 @@ function safeParse(val) {
     return val;
   }
 }
-
 export function getCurrentParamsFromUrl(location, isSimple) {
   let { search } = location;
   if (isSimple) {
@@ -242,9 +238,30 @@ export function makeDataTableHandlers({
   };
 }
 
+function cleanupFilters({ filters, ccFields }) {
+  (filters || []).forEach(filter => {
+    const { filterOn, filterValue } = filter;
+    const field = ccFields[filterOn];
+    if (field.type === "number" || field.type === "integer") {
+      filter.filterValue = Array.isArray(filterValue)
+        ? filterValue.map(val => Number(val))
+        : Number(filterValue);
+    }
+    if (
+      filter.selectedFilter === "inList" &&
+      typeof filter.filterValue === "number"
+    ) {
+      // if an inList value only has two items like
+      // 2.3 then it will get parsed to a number and
+      // break, convert it back to a string here
+      filter.filterValue = filter.filterValue.toString();
+    }
+  });
+}
+
 export function getQueryParams({
   currentParams,
-  // urlConnected,
+  urlConnected,
   defaults,
   schema,
   isInfinite,
@@ -253,98 +270,166 @@ export function getQueryParams({
   additionalFilter,
   doNotCoercePageSize,
   noOrderError,
-  // isCodeModel,
+  isCodeModel,
   ownProps
 }) {
-  Object.keys(currentParams).forEach(function (key) {
-    if (currentParams[key] === undefined) {
-      delete currentParams[key]; //we want to use the default value if any of these are undefined
-    }
-  });
-  const tableQueryParams = {
-    ...defaults,
-    ...currentParams
-  };
-  let { page, pageSize, searchTerm, filters, order } = tableQueryParams;
-  if (page <= 0 || isNaN(page)) {
-    page = undefined;
-  }
-  if (isInfinite) {
-    page = undefined;
-    pageSize = undefined;
-  }
-  if (pageSize !== undefined && !doNotCoercePageSize) {
-    //pageSize might come in as an unexpected number so we coerce it to be one of the nums in our pageSizes array
-    const closest = clone(window.tgPageSizes || defaultPageSizes).sort(
-      (a, b) => Math.abs(pageSize - a) - Math.abs(pageSize - b)
-    )[0];
-    pageSize = closest;
-  }
+  let errorParsingUrlString;
 
-  const cleanedOrder = [];
-  if (order && order.length) {
-    const ccFields = getFieldsMappedByCCDisplayName(schema);
-    order.forEach(orderVal => {
-      const ccDisplayName = orderVal.replace(/^-/gi, "");
-      const schemaForField = ccFields[ccDisplayName];
-      if (schemaForField) {
-        const { path } = schemaForField;
-        const reversed = ccDisplayName !== orderVal;
-        const prefix = reversed ? "-" : "";
-        cleanedOrder.push(prefix + path);
-      } else {
-        !noOrderError &&
-          console.error(
-            "No schema for field found!",
-            ccDisplayName,
-            JSON.stringify(schema.fields, null, 2)
-          );
+  try {
+    Object.keys(currentParams).forEach(function (key) {
+      if (currentParams[key] === undefined) {
+        delete currentParams[key]; //we want to use the default value if any of these are undefined
       }
     });
-  }
+    const tableQueryParams = {
+      ...defaults,
+      ...currentParams
+    };
+    let { page, pageSize, searchTerm, filters, order } = tableQueryParams;
+    const ccFields = getFieldsMappedByCCDisplayName(schema);
 
-  let toRet = {
-    //these are values that might be generally useful for the wrapped component
-    page,
-    pageSize: ownProps.controlled_pageSize || pageSize,
-    order: cleanedOrder,
-    filters,
-    searchTerm
-  };
+    cleanupFilters({ filters, ccFields });
 
-  const { where, order_by, limit, offset } = tableQueryParamsToHasuraClauses({
-    page,
-    pageSize,
-    searchTerm,
-    filters,
-    order: cleanedOrder,
-    schema
-  });
-  initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
-  addCustomColumnFilters(where, schema.fields, currentParams);
-  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
-    toRet = {
-      ...toRet,
-      ...filterLocalEntitiesToHasura(entities, {
-        where,
-        order_by,
-        limit,
-        offset,
-        isInfinite
-      })
+    if (page <= 0 || isNaN(page)) {
+      page = undefined;
+    }
+    if (isInfinite) {
+      page = undefined;
+      pageSize = undefined;
+    }
+    if (pageSize !== undefined && !doNotCoercePageSize) {
+      //pageSize might come in as an unexpected number so we coerce it to be one of the nums in our pageSizes array
+      const closest = clone(window.tgPageSizes || defaultPageSizes).sort(
+        (a, b) => Math.abs(pageSize - a) - Math.abs(pageSize - b)
+      )[0];
+      pageSize = closest;
+    }
+
+    const cleanedOrder = [];
+    if (order && order.length) {
+      order.forEach(orderVal => {
+        const ccDisplayName = orderVal.replace(/^-/gi, "");
+        const schemaForField = ccFields[ccDisplayName];
+        if (schemaForField) {
+          const { path } = schemaForField;
+          const reversed = ccDisplayName !== orderVal;
+          const prefix = reversed ? "-" : "";
+          cleanedOrder.push(prefix + path);
+        } 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: cleanedOrder,
+      filters,
+      searchTerm
     };
-    return toRet;
-  } else {
-    return {
-      ...toRet,
-      variables: {
-        where,
-        order_by,
-        limit,
-        offset
+
+    const { where, order_by, limit, offset } = tableQueryParamsToHasuraClauses({
+      page,
+      pageSize,
+      searchTerm,
+      filters,
+      order: cleanedOrder,
+      schema
+    });
+    initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
+    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 newEnts = filterLocalEntitiesToHasura(
+        prepEntitiesForLocalFilter({ entities, ccFields }),
+        {
+          where,
+          order_by: (Array.isArray(order_by) ? order_by : [order_by]).map(
+            obj => {
+              const path = Object.keys(obj)[0];
+              return {
+                path,
+                direction: obj[path],
+                ownProps,
+                ...ccFields[path]
+              };
+            }
+          ),
+          limit,
+          offset,
+          isInfinite
+        }
+      );
+
+      toRet = {
+        ...toRet,
+        ...newEnts
+      };
+      return toRet;
+    } else {
+      if (!order_by.length) {
+        // if no order by is specified, we will default to sorting by updatedAt
+        // this is useful for models that do not have a code field
+        order_by.push({ updatedAt: "desc" });
       }
-    };
+      // in case entries that have the same value in the column being sorted on
+      // fall back to id as a secondary sort to make sure ordering happens correctly
+      order_by.push(
+        isCodeModel ? { code: "desc" } : { [window.__sortId || "id"]: "desc" }
+      );
+
+      return {
+        ...toRet,
+        variables: {
+          where,
+          order_by,
+          limit,
+          offset
+        }
+      };
+    }
+  } catch (e) {
+    if (urlConnected) {
+      errorParsingUrlString = e;
+      console.error(
+        "The following error occurred when trying to build the query params. This is probably due to a malformed URL:",
+        e
+      );
+      return {
+        errorParsingUrlString,
+        variables: {
+          where: {},
+          order_by: [],
+          limit: 0,
+          offset: 0
+        }
+      };
+    } else {
+      console.error("Error building query params from filter:");
+      throw e;
+    }
   }
 }
+
+function prepEntitiesForLocalFilter({ entities, ccFields }) {
+  // Prepare entities for local filtering by mapping over them and applying necessary transformations
+  const r = entities.map(entity => {
+    const newEnt = { ...entity };
+    // Apply any necessary transformations using ccFields
+    forEach(ccFields, ({ getValueToFilterOn, path }) => {
+      if (getValueToFilterOn) {
+        newEnt["___original___" + path] = newEnt[path];
+        const value = getValueToFilterOn(newEnt);
+        newEnt[path] = value;
+      }
+    });
+    return newEnt;
+  });
+  return r;
+}