@teselagen/ui 0.8.6-beta.16 → 0.8.6-beta.17

package/index.cjs.js

@@ -19654,6 +19654,7 @@ function filterLocalEntitiesToHasura(records, { where, order_by, limit, offset:
   if (order_by) {
     filteredRecords = applyOrderBy(filteredRecords, order_by);
   }
+  filteredRecords = restoreEntitiesFromLocalFilter(filteredRecords);
   const allFilteredRecords = [...filteredRecords];
   if (!isInfinite && offset3 !== void 0) {
     filteredRecords = filteredRecords.slice(offset3);
@@ -19881,6 +19882,18 @@ function applyOrderBy(records, _order_by) {
   return records;
 }
 __name(applyOrderBy, "applyOrderBy");
+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;
+  });
+}
+__name(restoreEntitiesFromLocalFilter, "restoreEntitiesFromLocalFilter");
 function initializeHasuraWhereAndFilter(additionalFilter, where = {}, currentParams) {
   where._and = where._and || [];
   where._or = where._or || [];
@@ -20155,20 +20168,25 @@ function getQueryParams({
     });
     initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
     if (isLocalCall) {
-      const newEnts = filterLocalEntitiesToHasura(entities, {
-        where,
-        order_by: (Array.isArray(order_by) ? order_by : [order_by]).map((obj) => {
-          const path2 = Object.keys(obj)[0];
-          return __spreadValues({
-            path: path2,
-            direction: obj[path2],
-            ownProps
-          }, ccFields[path2]);
-        }),
-        limit,
-        offset: offset3,
-        isInfinite
-      });
+      const newEnts = filterLocalEntitiesToHasura(
+        prepEntitiesForLocalFilter({ entities, ccFields }),
+        {
+          where,
+          order_by: (Array.isArray(order_by) ? order_by : [order_by]).map(
+            (obj) => {
+              const path2 = Object.keys(obj)[0];
+              return __spreadValues({
+                path: path2,
+                direction: obj[path2],
+                ownProps
+              }, ccFields[path2]);
+            }
+          ),
+          limit,
+          offset: offset3,
+          isInfinite
+        }
+      );
       toRet = __spreadValues(__spreadValues({}, toRet), newEnts);
       return toRet;
     } else {
@@ -20210,6 +20228,20 @@ function getQueryParams({
   }
 }
 __name(getQueryParams, "getQueryParams");
+function prepEntitiesForLocalFilter({ entities, ccFields }) {
+  const r2 = entities.map((entity) => {
+    forEach(ccFields, ({ getValueToFilterOn, path: path2 }) => {
+      if (getValueToFilterOn) {
+        entity["___original___" + path2] = entity[path2];
+        const value = getValueToFilterOn(entity);
+        entity[path2] = value;
+      }
+    });
+    return entity;
+  });
+  return r2;
+}
+__name(prepEntitiesForLocalFilter, "prepEntitiesForLocalFilter");
 function PagingInput({ disabled, onBlur, defaultPage }) {
   const [page, setPage] = React.useState(defaultPage);
   const defaultValue2 = React.useRef(defaultPage);

package/index.es.js

@@ -19636,6 +19636,7 @@ function filterLocalEntitiesToHasura(records, { where, order_by, limit, offset:
   if (order_by) {
     filteredRecords = applyOrderBy(filteredRecords, order_by);
   }
+  filteredRecords = restoreEntitiesFromLocalFilter(filteredRecords);
   const allFilteredRecords = [...filteredRecords];
   if (!isInfinite && offset3 !== void 0) {
     filteredRecords = filteredRecords.slice(offset3);
@@ -19863,6 +19864,18 @@ function applyOrderBy(records, _order_by) {
   return records;
 }
 __name(applyOrderBy, "applyOrderBy");
+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;
+  });
+}
+__name(restoreEntitiesFromLocalFilter, "restoreEntitiesFromLocalFilter");
 function initializeHasuraWhereAndFilter(additionalFilter, where = {}, currentParams) {
   where._and = where._and || [];
   where._or = where._or || [];
@@ -20137,20 +20150,25 @@ function getQueryParams({
     });
     initializeHasuraWhereAndFilter(additionalFilter, where, currentParams);
     if (isLocalCall) {
-      const newEnts = filterLocalEntitiesToHasura(entities, {
-        where,
-        order_by: (Array.isArray(order_by) ? order_by : [order_by]).map((obj) => {
-          const path2 = Object.keys(obj)[0];
-          return __spreadValues({
-            path: path2,
-            direction: obj[path2],
-            ownProps
-          }, ccFields[path2]);
-        }),
-        limit,
-        offset: offset3,
-        isInfinite
-      });
+      const newEnts = filterLocalEntitiesToHasura(
+        prepEntitiesForLocalFilter({ entities, ccFields }),
+        {
+          where,
+          order_by: (Array.isArray(order_by) ? order_by : [order_by]).map(
+            (obj) => {
+              const path2 = Object.keys(obj)[0];
+              return __spreadValues({
+                path: path2,
+                direction: obj[path2],
+                ownProps
+              }, ccFields[path2]);
+            }
+          ),
+          limit,
+          offset: offset3,
+          isInfinite
+        }
+      );
       toRet = __spreadValues(__spreadValues({}, toRet), newEnts);
       return toRet;
     } else {
@@ -20192,6 +20210,20 @@ function getQueryParams({
   }
 }
 __name(getQueryParams, "getQueryParams");
+function prepEntitiesForLocalFilter({ entities, ccFields }) {
+  const r2 = entities.map((entity) => {
+    forEach(ccFields, ({ getValueToFilterOn, path: path2 }) => {
+      if (getValueToFilterOn) {
+        entity["___original___" + path2] = entity[path2];
+        const value = getValueToFilterOn(entity);
+        entity[path2] = value;
+      }
+    });
+    return entity;
+  });
+  return r2;
+}
+__name(prepEntitiesForLocalFilter, "prepEntitiesForLocalFilter");
 function PagingInput({ disabled, onBlur, defaultPage }) {
   const [page, setPage] = useState(defaultPage);
   const defaultValue2 = useRef(defaultPage);

package/package.json

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

package/src/DataTable/utils/filterLocalEntitiesToHasura.js

@@ -11,7 +11,8 @@ import {
   has,
   orderBy,
   endsWith,
-  get
+  get,
+  forEach
 } from "lodash-es";
 
 export function filterLocalEntitiesToHasura(
@@ -29,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];
@@ -339,3 +341,15 @@ function applyOrderBy(records, _order_by) {
   }
   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;
+  });
+}

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

@@ -1216,139 +1216,5 @@ describe("filterLocalEntitiesToHasura", () => {
     ]);
     expect(result.entityCount).toBe(5);
   });
-  it("should order using getValueToFilterOn", () => {
-    // Create a function that returns a value to sort by
-    const getCustomSortValue = record => {
-      // Sort by the first letter of the name
-      return record.name.charAt(0);
-    };
-
-    const result = filterLocalEntitiesToHasura(records, {
-      order_by: { getValueToFilterOn: getCustomSortValue, direction: "asc" }
-    });
-
-    // Expected order based on first letter: A, B, J, J
-    // Since J appears twice, their original order should be preserved
-    expect(result.entities).toEqual([
-      records[2], // Alice
-      records[3], // Bob
-      records[0], // John
-      records[1] // Jane
-    ]);
-    expect(result.entityCount).toBe(4);
-  });
-
-  it("should order using getValueToFilterOn with ownProps", () => {
-    // Create a function that uses ownProps for customized sorting
-    const getWeightedValue = (record, ownProps) => {
-      // Create a weighted value based on age and a multiplier from ownProps
-      return record.age * (ownProps.multiplier || 1);
-    };
-
-    const result = filterLocalEntitiesToHasura(records, {
-      order_by: {
-        getValueToFilterOn: getWeightedValue,
-        direction: "desc",
-        ownProps: { multiplier: 2 }
-      }
-    });
-
-    // Expected order based on age * 2: 35*2, 30*2, 25*2, 20*2
-    expect(result.entities).toEqual([
-      records[2], // Alice Johnson (age: 35 * 2 = 70)
-      records[0], // John Doe (age: 30 * 2 = 60)
-      records[1], // Jane Smith (age: 25 * 2 = 50)
-      records[3] // Bob Williams (age: 20 * 2 = 40)
-    ]);
-    expect(result.entityCount).toBe(4);
-  });
-
-  it("should handle null/undefined values in getValueToFilterOn", () => {
-    const recordsWithMissingProps = [
-      { id: 1, name: "Alice", customProp: 100 },
-      { id: 2, name: "Bob", customProp: null },
-      { id: 3, name: "Charlie" }, // customProp is undefined
-      { id: 4, name: "Dave", customProp: 200 }
-    ];
-
-    // Function that uses a property that might be missing
-    const getCustomPropValue = record => {
-      return record.customProp;
-    };
-
-    const result = filterLocalEntitiesToHasura(recordsWithMissingProps, {
-      order_by: { getValueToFilterOn: getCustomPropValue, direction: "desc" }
-    });
-
-    // Should order with valid values first, then nulls/undefined at the end
-    expect(result.entities).toEqual([
-      recordsWithMissingProps[3], // customProp: 200
-      recordsWithMissingProps[0], // customProp: 100
-      recordsWithMissingProps[2], // customProp: undefined
-      recordsWithMissingProps[1] // customProp: null
-    ]);
-    expect(result.entityCount).toBe(4);
-  });
-
-  it("should combine getValueToFilterOn with multiple sort criteria", () => {
-    // Additional records with same category but different priority
-    const extendedRecords = [
-      ...records,
-      {
-        id: 111,
-        name: "Tom Jones",
-        age: 40,
-        is_active: true,
-        city: "London",
-        tags: ["sql", "management"],
-        email: "tom@example.com",
-        data: { category: "A", type: "X", priority: 2 },
-        username: "tom111"
-      },
-      {
-        id: 222,
-        name: "Emma Brown",
-        age: 28,
-        is_active: true,
-        city: "London",
-        tags: ["design", "javascript"],
-        email: "emma@example.com",
-        data: { category: "A", type: "X", priority: 1 },
-        username: "emma222"
-      }
-    ];
-
-    // First sort by category
-    const getCategoryValue = record => {
-      return record.data.category;
-    };
-
-    // Then sort by priority if available, putting records without priority at the end
-    const getPriorityValue = record => {
-      return record.data.priority !== undefined
-        ? record.data.priority
-        : Number.MAX_SAFE_INTEGER;
-    };
-
-    const result = filterLocalEntitiesToHasura(extendedRecords, {
-      order_by: [
-        { getValueToFilterOn: getCategoryValue, direction: "asc" },
-        { getValueToFilterOn: getPriorityValue, direction: "asc" }
-      ]
-    });
-
-    // All category A records, ordered by priority if available
-    const categoryARecords = [
-      extendedRecords[5], // Emma (category A, priority 1)
-      extendedRecords[4], // Tom (category A, priority 2)
-      extendedRecords[0], // John (category A, no priority)
-      extendedRecords[2] // Alice (category A, no priority)
-    ];
-
-    // Then category B, then category C
-    expect(result.entities.slice(0, 4)).toEqual(categoryARecords);
-    expect(result.entities[4]).toBe(extendedRecords[1]); // Jane (category B)
-    expect(result.entities[5]).toBe(extendedRecords[3]); // Bob (category C)
-    expect(result.entityCount).toBe(6);
-  });
+  
 });

package/src/DataTable/utils/queryParams.js

@@ -1,5 +1,5 @@
 import queryString from "qs";
-import { uniqBy, clone, camelCase } from "lodash-es";
+import { uniqBy, clone, camelCase, forEach } from "lodash-es";
 import {
   getFieldsMappedByCCDisplayName,
   tableQueryParamsToHasuraClauses
@@ -346,21 +346,26 @@ 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 newEnts = filterLocalEntitiesToHasura(entities, {
-        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
-      });
+      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,
@@ -411,3 +416,19 @@ export function getQueryParams({
     }
   }
 }
+
+function prepEntitiesForLocalFilter({ entities, ccFields }) {
+  // Prepare entities for local filtering by mapping over them and applying necessary transformations
+  const r = entities.map(entity => {
+    // Apply any necessary transformations using ccFields
+    forEach(ccFields, ({ getValueToFilterOn, path }) => {
+      if (getValueToFilterOn) {
+        entity["___original___" + path] = entity[path]
+        const value = getValueToFilterOn(entity);
+        entity[path] = value;
+      }
+    });
+    return entity;
+  });
+  return r;
+}