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

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

@@ -0,0 +1,515 @@
+import { filterLocalEntitiesToHasura as filterRecords } from "./filterLocalEntitiesToHasura";
+
+describe("filterRecords", () => {
+  const records = [
+    {
+      id: 123,
+      name: "John Doe",
+      age: 30,
+      is_active: true,
+      city: "London",
+
+      tags: ["programming", "javascript"],
+      email: "john@example.com",
+      data: { category: "A", type: "X" },
+      username: "john123"
+    },
+    {
+      id: 456,
+      name: "Jane Smith",
+      age: 25,
+      is_active: false,
+      city: "Paris",
+      tags: ["javascript", "python"],
+      email: null,
+      data: { category: "B", type: "Y" },
+      username: "jane456"
+    },
+    {
+      id: 789,
+      name: "Alice Johnson",
+      age: 35,
+      is_active: true,
+      city: "London",
+      tags: ["programming", "python", "java"],
+      email: "alice@example.com",
+      data: { category: "A", type: "Z" },
+      username: "alice789"
+    },
+    {
+      id: 101,
+      name: "Bob Williams",
+      age: 20,
+      is_active: false,
+      city: "New York",
+      tags: ["java"],
+      email: "bob@example.com",
+      data: { category: "C", type: "X" },
+      username: "bob101"
+    }
+  ];
+
+  it("should filter by _eq", () => {
+    const result = filterRecords(records, { where: { id: { _eq: 123 } } });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _neq", () => {
+    const result = filterRecords(records, { where: { id: { _neq: 123 } } });
+    expect(result.entities).toEqual(records.slice(1));
+    expect(result.entitiesAcrossPages).toEqual(records.slice(1));
+    expect(result.entityCount).toBe(3);
+  });
+
+  it("should filter by _gt", () => {
+    const result = filterRecords(records, { where: { age: { _gt: 30 } } });
+    expect(result.entities).toEqual([records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[2]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _gte", () => {
+    const result = filterRecords(records, { where: { age: { _gte: 30 } } });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _lt", () => {
+    const result = filterRecords(records, { where: { age: { _lt: 25 } } });
+    expect(result.entities).toEqual([records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[3]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _lte", () => {
+    const result = filterRecords(records, { where: { age: { _lte: 25 } } });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _like", () => {
+    const result = filterRecords(records, {
+      where: { name: { _like: "%John%" } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _ilike", () => {
+    const result = filterRecords(records, {
+      where: { name: { _ilike: "%john%" } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _nlike", () => {
+    const result = filterRecords(records, {
+      where: { name: { _nlike: "%John%" } }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _nilike", () => {
+    const result = filterRecords(records, {
+      where: { name: { _nilike: "%john%" } }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _starts_with", () => {
+    const result = filterRecords(records, {
+      where: { name: { _starts_with: "John" } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _ends_with", () => {
+    const result = filterRecords(records, {
+      where: { name: { _ends_with: "Doe" } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _is_null", () => {
+    const result = filterRecords(records, {
+      where: { email: { _is_null: true } }
+    });
+    expect(result.entities).toEqual([records[1]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _is_null false", () => {
+    const result = filterRecords(records, {
+      where: { email: { _is_null: false } }
+    });
+    expect(result.entities).toEqual([records[0], records[2], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[2],
+      records[3]
+    ]);
+    expect(result.entityCount).toBe(3);
+  });
+
+  it("should filter by _and", () => {
+    const result = filterRecords(records, {
+      where: {
+        _and: [{ age: { _gt: 25 } }, { city: { _eq: "London" } }]
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _or", () => {
+    const result = filterRecords(records, {
+      where: {
+        _or: [{ city: { _eq: "London" } }, { city: { _eq: "Paris" } }]
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[1], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[1],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(3);
+  });
+
+  it("should filter by _not", () => {
+    const result = filterRecords(records, {
+      where: {
+        _not: { is_active: { _eq: true } }
+      }
+    });
+    expect(result.entities).toEqual([records[1], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual([records[1], records[3]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by _contains", () => {
+    const result = filterRecords(records, {
+      where: {
+        tags: { _contains: ["programming", "javascript"] }
+      }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should filter by _contained_in", () => {
+    const result = filterRecords(records, {
+      where: {
+        tags: { _contained_in: ["programming", "javascript", "python", "java"] }
+      }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _has_key", () => {
+    const result = filterRecords(records, {
+      where: { data: { _has_key: "category" } }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _has_keys_any", () => {
+    const result = filterRecords(records, {
+      where: {
+        data: { _has_keys_any: ["category", "missingKey"] }
+      }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _has_keys_all", () => {
+    const result = filterRecords(records, {
+      where: {
+        data: { _has_keys_all: ["category", "type"] }
+      }
+    });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter by _similar", () => {
+    const result = filterRecords(records, {
+      where: {
+        username: { _similar: "(john|alice)%" }
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by range _gte and _lte", () => {
+    const result = filterRecords(records, {
+      where: { age: { _gte: 25, _lte: 30 } }
+    });
+    expect(result.entities).toEqual([records[0], records[1]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[1]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should filter by range _gt and _lt", () => {
+    const result = filterRecords(records, {
+      where: { age: { _gt: 25, _lt: 35 } }
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0]]);
+    expect(result.entityCount).toBe(1);
+  });
+
+  it("should handle empty where clause", () => {
+    const result = filterRecords(records, {});
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should handle nested _and and _or", () => {
+    const result = filterRecords(records, {
+      where: {
+        _and: [
+          { _or: [{ city: { _eq: "London" } }, { city: { _eq: "Paris" } }] },
+          { age: { _gt: 20 } }
+        ]
+      }
+    });
+    expect(result.entities).toEqual([records[0], records[1], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[1],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(3);
+  });
+  it("should order by age ascending", () => {
+    const result = filterRecords(records, {
+      order_by: { age: "asc" }
+    });
+    expect(result.entities).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should order by age descending", () => {
+    const result = filterRecords(records, {
+      order_by: { age: "desc" }
+    });
+    expect(result.entities).toEqual([
+      records[2],
+      records[0],
+      records[1],
+      records[3]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[2],
+      records[0],
+      records[1],
+      records[3]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should order by name ascending", () => {
+    const result = filterRecords(records, {
+      order_by: { name: "asc" }
+    });
+    expect(result.entities).toEqual([
+      records[2],
+      records[3],
+      records[1],
+      records[0]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[2],
+      records[3],
+      records[1],
+      records[0]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should order by name descending", () => {
+    const result = filterRecords(records, {
+      order_by: { name: "desc" }
+    });
+    expect(result.entities).toEqual([
+      records[0],
+      records[1],
+      records[3],
+      records[2]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[0],
+      records[1],
+      records[3],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should filter and order", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } },
+      order_by: { age: "desc" }
+    });
+    expect(result.entities).toEqual([records[2], records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[2], records[0]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle empty order_by", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } }
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle order_by with empty where", () => {
+    const result = filterRecords(records, {
+      order_by: { age: "asc" }
+    });
+    expect(result.entities).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entitiesAcrossPages).toEqual([
+      records[3],
+      records[1],
+      records[0],
+      records[2]
+    ]);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply limit", () => {
+    const result = filterRecords(records, { limit: 2 });
+    expect(result.entities).toEqual([records[0], records[1]]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply offset", () => {
+    const result = filterRecords(records, { offset: 2 });
+    expect(result.entities).toEqual([records[2], records[3]]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply limit and offset", () => {
+    const result = filterRecords(records, { limit: 1, offset: 2 });
+    expect(result.entities).toEqual([records[2]]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should apply limit to filtered results", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } },
+      limit: 1
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should apply offset to filtered results", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } },
+      offset: 1
+    });
+    expect(result.entities).toEqual([records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should apply limit and offset to filtered and ordered results", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } },
+      order_by: { age: "desc" },
+      limit: 1,
+      offset: 1
+    });
+    expect(result.entities).toEqual([records[0]]);
+    expect(result.entitiesAcrossPages).toEqual([records[2], records[0]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle offset greater than array length", () => {
+    const result = filterRecords(records, { offset: 10 });
+    expect(result.entities).toEqual([]);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should handle limit greater than array length", () => {
+    const result = filterRecords(records, { limit: 10 });
+    expect(result.entities).toEqual(records);
+    expect(result.entitiesAcrossPages).toEqual(records);
+    expect(result.entityCount).toBe(4);
+  });
+
+  it("should handle isInfinite option with filtering", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } },
+      isInfinite: true
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+
+  it("should handle isInfinite option with filtering, limit, and offset", () => {
+    const result = filterRecords(records, {
+      where: { city: { _eq: "London" } },
+      limit: 1,
+      offset: 1,
+      isInfinite: true
+    });
+    expect(result.entities).toEqual([records[0], records[2]]);
+    expect(result.entitiesAcrossPages).toEqual([records[0], records[2]]);
+    expect(result.entityCount).toBe(2);
+  });
+});

package/src/DataTable/utils/index.js

@@ -0,0 +1,55 @@
+import { isEntityClean } from "./isEntityClean";
+import { getSelectedRowsFromEntities } from "./selection";
+import { removeCleanRows } from "./removeCleanRows";
+import { getIdOrCodeOrIndex } from "./getIdOrCodeOrIndex";
+import { getRecordsFromIdMap } from "./withSelectedEntities";
+import { formatPasteData } from "./formatPasteData";
+import { getFieldPathToField } from "./getFieldPathToField";
+import {
+  defaultParsePaste,
+  getEntityIdToEntity,
+  getFieldPathToIndex,
+  getNumberStrAtEnd,
+  stripNumberAtEnd
+} from "./utils";
+import { getAllRows } from "./getAllRows";
+import { getNewEntToSelect } from "./getNewEntToSelect";
+import { getLastSelectedEntity } from "./getLastSelectedEntity";
+import { getCellInfo } from "./getCellInfo";
+import { getCellCopyText } from "./getCellCopyText";
+import { getRowCopyText } from "./getRowCopyText";
+import { handleCopyHelper } from "./handleCopyHelper";
+import { handleCopyRows } from "./handleCopyRows";
+import { handleCopyColumn } from "./handleCopyColumn";
+import { isBottomRightCornerOfRectangle } from "./isBottomRightCornerOfRectangle";
+import { handleCopyTable } from "./handleCopyTable";
+import { PRIMARY_SELECTED_VAL } from "./primarySelectedValue";
+import { useTableEntities } from "./useTableEntities";
+
+export {
+  defaultParsePaste,
+  formatPasteData,
+  getAllRows,
+  getCellCopyText,
+  getCellInfo,
+  getEntityIdToEntity,
+  getFieldPathToIndex,
+  getFieldPathToField,
+  getIdOrCodeOrIndex,
+  getLastSelectedEntity,
+  getNewEntToSelect,
+  getNumberStrAtEnd,
+  getRecordsFromIdMap,
+  getRowCopyText,
+  getSelectedRowsFromEntities,
+  handleCopyColumn,
+  handleCopyHelper,
+  handleCopyRows,
+  handleCopyTable,
+  isBottomRightCornerOfRectangle,
+  isEntityClean,
+  PRIMARY_SELECTED_VAL,
+  removeCleanRows,
+  stripNumberAtEnd,
+  useTableEntities
+};

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

@@ -0,0 +1,73 @@
+import { simplifyHasuraWhere } from "./simplifyHasuraWhere";
+
+describe("simplifyHasuraWhere", () => {
+  it("should handle empty where clause", () => {
+    expect(simplifyHasuraWhere({})).toEqual({});
+  });
+
+  it("should simplify simple _eq where clauses", () => {
+    const input = { id: 123, name: "John Doe" };
+    const expected = { id: { _eq: 123 }, name: { _eq: "John Doe" } };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+
+  it("should handle existing _eq where clauses without simplification", () => {
+    const input = { id: { _eq: 123 }, name: { _eq: "John Doe" } };
+    const expected = { id: { _eq: 123 }, name: { _eq: "John Doe" } };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+
+  it("should handle other Hasura operators", () => {
+    const input = { age: { _gt: 30 }, isActive: { _eq: true } };
+    const expected = { age: { _gt: 30 }, isActive: { _eq: true } };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+
+  it("should handle dot-nested where clauses", () => {
+    const input = { "address.city": { _eq: "New York" }, "address.zip": 10001 };
+    const expected = {
+      address: { city: { _eq: "New York" }, zip: { _eq: 10001 } }
+    };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+
+  it("should handle deeply nested dot-nested where clauses", () => {
+    const input = { "nested.prop.value": { _eq: "test" } };
+    const expected = { nested: { prop: { value: { _eq: "test" } } } };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+
+  it("should handle a mix of simple, nested, and operator clauses", () => {
+    const input = {
+      id: 123,
+      name: "John Doe",
+      "address.city": { _eq: "New York" },
+      age: { _gt: 30 },
+      "nested.prop.value": { _eq: "test" }
+    };
+    const expected = {
+      id: { _eq: 123 },
+      name: { _eq: "John Doe" },
+      address: { city: { _eq: "New York" } },
+      age: { _gt: 30 },
+      nested: { prop: { value: { _eq: "test" } } }
+    };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+
+  it("should handle already nested objects with operators", () => {
+    const input = {
+      address: {
+        city: { _eq: "London" },
+        country: "UK"
+      }
+    };
+    const expected = {
+      address: {
+        city: { _eq: "London" },
+        country: { _eq: "UK" }
+      }
+    };
+    expect(simplifyHasuraWhere(input)).toEqual(expected);
+  });
+});