@teselagen/ui 0.8.6 → 0.9.1

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -9,7 +9,10 @@ import {
   includes,
   isObject,
   has,
-  orderBy
+  orderBy,
+  endsWith,
+  get,
+  forEach
 } from "lodash-es";
 
 export function filterLocalEntitiesToHasura(
@@ -27,6 +30,7 @@ export function filterLocalEntitiesToHasura(
   if (order_by) {
     filteredRecords = applyOrderBy(filteredRecords, order_by);
   }
+  filteredRecords = restoreEntitiesFromLocalFilter(filteredRecords);
 
   // Store the complete filtered and ordered records for pagination info
   const allFilteredRecords = [...filteredRecords];
@@ -74,7 +78,7 @@ function applyWhereClause(records, where) {
           return false;
         }
       } else {
-        const value = record[key];
+        const value = get(record, key);
         const conditions = filter[key];
 
         // Handle nested object properties
@@ -225,12 +229,128 @@ function applyWhereClause(records, where) {
   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]);
+// takes in an array of records and an order_by clause
+// order_by looks like this: [{ some_field: "asc" }, { some_other_field: "desc" }] or {some_field: "asc"}
+// returns the records sorted by the order_by clause
+function applyOrderBy(records, _order_by) {
+  const order_by = isArray(_order_by)
+    ? _order_by
+    : isEmpty(_order_by)
+      ? []
+      : [_order_by];
+
+  if (order_by.length > 0) {
+    const orderFuncs = [];
+    const ascOrDescArray = [];
+
+    order_by.forEach(
+      ({ path, direction, type, sortFn, getValueToFilterOn, ownProps }) => {
+        // Default direction is "desc" if not specified
+        direction = direction || "desc";
+
+        if (sortFn) {
+          // Allow sortFn to be a function, a string, or an array of functions/strings
+          const sortFnArray = Array.isArray(sortFn) ? sortFn : [sortFn];
+
+          sortFnArray.forEach(fn => {
+            // If fn is a string, treat it as a path to get from the record
+            const getter = typeof fn === "function" ? fn : r => get(r, fn);
+
+            // First handle null check for this function's/string's values
+            orderFuncs.push(r => {
+              const val = getter(r);
+              return val !== null && val !== undefined ? 1 : 0;
+            });
+            ascOrDescArray.push("desc"); // Always push nulls to the bottom
+
+            // Then the actual sort function or path getter
+            orderFuncs.push(getter);
+            ascOrDescArray.push(direction);
+          });
+        } else if (getValueToFilterOn) {
+          // Custom getValue function
+          // First handle null check
+          orderFuncs.push(r => {
+            const val = getValueToFilterOn(r, ownProps);
+            return val !== null && val !== undefined ? 1 : 0;
+          });
+          ascOrDescArray.push("desc"); // Always push nulls to the bottom
+
+          // Then the actual value getter function
+          orderFuncs.push(r => getValueToFilterOn(r, ownProps));
+          ascOrDescArray.push(direction);
+        } else if (type === "timestamp") {
+          // Sort nulls/undefined to the bottom regardless of sort direction
+          orderFuncs.push(r => {
+            const val = get(r, path);
+            // First check if value exists, this ensures nulls go to the bottom
+            return val ? 1 : 0;
+          });
+          ascOrDescArray.push("desc"); // always put nulls at the bottom
+
+          // Then actual timestamp sorting
+          orderFuncs.push(r => {
+            const val = get(r, path);
+            return val ? new Date(val).getTime() : -Infinity;
+          });
+          ascOrDescArray.push(direction);
+        } else if (path && endsWith(path.toLowerCase(), "id")) {
+          // Handle ID fields - sort numerically
+          // First handle null check
+          orderFuncs.push(r => {
+            const val = get(r, path);
+            return val !== null && val !== undefined ? 1 : 0;
+          });
+          ascOrDescArray.push("desc"); // Always push nulls to the bottom
+
+          // Then the actual ID parsing
+          orderFuncs.push(o => {
+            const val = get(o, path);
+            if (val === null || val === undefined) return -Infinity;
+            return parseInt(val, 10) || 0;
+          });
+          ascOrDescArray.push(direction);
+        } else {
+          // Default sorting
+          // First sort by existence (non-nulls first)
+          orderFuncs.push(r => {
+            const val = get(r, path);
+            return val !== null && val !== undefined ? 1 : 0;
+          });
+          ascOrDescArray.push("desc"); // Always put nulls at the bottom
+
+          // Then sort by actual value
+          orderFuncs.push(r => {
+            const val = get(r, path);
+            if (val === null || val === undefined) return -Infinity;
+
+            // For string sorting, implement natural sort
+            if (isString(val)) {
+              return val.toLowerCase().replace(/(\d+)/g, num =>
+                // Pad numbers with leading zeros for proper natural sort
+                num.padStart(10, "0")
+              );
+            }
+            return val;
+          });
+          ascOrDescArray.push(direction);
+        }
+      }
+    );
+
+    records = orderBy(records, orderFuncs, ascOrDescArray);
   }
   return records;
 }
+
+function restoreEntitiesFromLocalFilter(ents) {
+  return ents.map(entity => {
+    forEach(entity, (val, key) => {
+      if (key.startsWith?.("___original___")) {
+        entity[key.slice("___original___".length)] = val;
+        delete entity[key];
+      }
+    });
+    return entity;
+  });
+}