@truedat/core 8.5.8 → 8.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/core",
-  "version": "8.5.8",
+  "version": "8.6.0",
   "description": "Truedat Web Core",
   "sideEffects": [
     "**/*.css",
@@ -54,7 +54,7 @@
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
-    "@truedat/test": "8.5.8",
+    "@truedat/test": "8.6.0",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^29.7.0",
     "redux-saga-test-plan": "^4.0.6"
@@ -69,7 +69,7 @@
     "@tiptap/starter-kit": "^3.20.0",
     "@xyflow/react": "^12.6.4",
     "axios": "^1.15.0",
-    "dompurify": "^3.3.3",
+    "dompurify": "^3.4.0",
     "elkjs": "^0.10.0",
     "graphql": "^16.11.0",
     "lodash": "^4.17.21",
@@ -95,5 +95,5 @@
     "swr": "^2.3.3",
     "turndown": "^7.2.2"
   },
-  "gitHead": "61ad9443b3d822d30dcfa977f5fad3494b3ed5b4"
+  "gitHead": "9aa93d0e27de7c0fcb472d58eb69aeaf6a2dd6bc"
 }

package/src/components/AddMemberForm.js

@@ -31,6 +31,8 @@ const roleOptions = (roles) =>
     _.map(roleOption)
   )(roles);
 
+const selectOption = _.pick(["key", "text", "value", "id", "icon"]);
+
 export const AddMemberForm = ({ resource, onSuccess, roles, options }) => {
   const { trigger: addDomainMember, isMutating: isSubmitting } =
     useAclEntryCreate(resource);
@@ -83,7 +85,7 @@ export const AddMemberForm = ({ resource, onSuccess, roles, options }) => {
             onSearchChange={onSearch}
             search={_.identity}
             selection
-            options={options}
+            options={_.map(selectOption)(options)}
             required
             label={{
               children: formatMessage({ id: "domain.member" }),

package/src/components/ResourceMember.js

@@ -20,7 +20,7 @@ const memberTypeToPopup = {
 const retrieveNameFromMember = (principal_type, principal) => {
   switch (principal_type) {
     case "group":
-      return null;
+      return principal.alias ? principal.name : null;
     case "user":
       return principal.user_name;
   }
@@ -29,7 +29,7 @@ const retrieveNameFromMember = (principal_type, principal) => {
 const retrieveFullNameFromMember = (principal_type, principal) => {
   switch (principal_type) {
     case "group":
-      return principal.name;
+      return principal.alias ? principal.alias : principal.name;
     case "user":
       return principal.full_name;
   }
@@ -121,11 +121,11 @@ export const ResourceMember = ({
   const fullName = retrieveFullNameFromMember(principal_type, principal);
   const canDelete = _.flow(
     _.path("self.methods"),
-    _.includes("DELETE")
+    _.includes("DELETE"),
   )(_links);
   const canUpdate = _.flow(
     _.path("self.methods"),
-    _.includes("UPDATE")
+    _.includes("UPDATE"),
   )(_links);
   return (
     <Card className="domain-member">
@@ -159,7 +159,7 @@ export const ResourceMember = ({
                     id: acl_entry_id,
                     acl_entry: { description },
                   },
-                  { onSuccess: onUpdate }
+                  { onSuccess: onUpdate },
                 );
               }}
             />

package/src/components/__tests__/AddMemberForm.spec.js

@@ -25,6 +25,14 @@ describe("<AddMemberForm />", () => {
   const options = [
     { key: 1, text: "john", value: "user_1", id: "1" },
     { key: 2, text: "mambo", value: "group_2", id: "2" },
+    {
+      key: 3,
+      text: "Group Alias",
+      value: "group_3",
+      id: "3",
+      name: "actual_group_name",
+      alias: "Group Alias",
+    },
   ];
   const roles = [
     { key: 1, text: "role1", value: "role1" },
@@ -46,8 +54,8 @@ describe("<AddMemberForm />", () => {
     // Submit button should initially be disabled
     await waitFor(async () =>
       expect(
-        await rendered.findByRole("button", { name: /add_member/i })
-      ).toBeDisabled()
+        await rendered.findByRole("button", { name: /add_member/i }),
+      ).toBeDisabled(),
     );
 
     // Description
@@ -57,12 +65,12 @@ describe("<AddMemberForm />", () => {
     // Submit button should now be enabled
     await waitFor(async () =>
       expect(
-        await rendered.findByRole("button", { name: /add_member/i })
-      ).not.toBeDisabled()
+        await rendered.findByRole("button", { name: /add_member/i }),
+      ).not.toBeDisabled(),
     );
 
     await user.click(
-      await rendered.findByRole("button", { name: /add_member/i })
+      await rendered.findByRole("button", { name: /add_member/i }),
     );
 
     await waitFor(() =>
@@ -74,7 +82,31 @@ describe("<AddMemberForm />", () => {
           principal_id: 1,
           description: "",
         },
-      })
+      }),
     );
   });
+
+  it("displays group alias in dropdown when available", async () => {
+    const rendered = render(<AddMemberForm {...props} />);
+    await waitForLoad(rendered);
+
+    const [dropdown] = rendered.getAllByRole("combobox");
+    await user.click(dropdown);
+
+    // Should display the alias "Group Alias" in the dropdown, not the actual name
+    expect(rendered.getByText(/group alias/i)).toBeInTheDocument();
+    // And the group without alias should display its name
+    expect(rendered.getByText(/mambo/i)).toBeInTheDocument();
+  });
+
+  it("displays group name when alias is not available", async () => {
+    const rendered = render(<AddMemberForm {...props} />);
+    await waitForLoad(rendered);
+
+    const [dropdown] = rendered.getAllByRole("combobox");
+    await user.click(dropdown);
+
+    // Group "mambo" without alias should be displayed
+    expect(rendered.getByText(/mambo/i)).toBeInTheDocument();
+  });
 });

package/src/components/__tests__/ResourceMembers.spec.js

@@ -1,4 +1,3 @@
-import { waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { render, waitForLoad } from "@truedat/test/render";
 import { useAclEntries } from "@truedat/core/hooks/useAclEntries";
@@ -27,9 +26,26 @@ describe("<ResourceMembers />", () => {
         principal_type: "group",
         role_id: 2,
         role_name: "data_owner",
-        principal: { description: "aaa bbb cc d", id: 2, name: "grupo1 " },
+        principal: {
+          description: "aaa bbb cc d",
+          id: 2,
+          name: "grupo1 ",
+          alias: "Group Alias 1",
+        },
         acl_entry_id: 1,
       },
+      {
+        principal_type: "group",
+        role_id: 2,
+        role_name: "data_owner",
+        principal: {
+          description: "bbb ccc dd e",
+          id: 3,
+          name: "grupo2",
+          alias: null,
+        },
+        acl_entry_id: 5,
+      },
       {
         principal: {
           email: "test@test.com",
@@ -91,7 +107,7 @@ describe("<ResourceMembers />", () => {
     const user = userEvent.setup({ delay: null });
 
     await user.type(input, "data");
-    expect(document.getElementsByClassName("card").length).toBe(2);
+    expect(document.getElementsByClassName("card").length).toBe(3);
 
     await user.type(input, " owner");
     expect(document.getElementsByClassName("card").length).toBe(1);
@@ -122,4 +138,23 @@ describe("<ResourceMembers />", () => {
     expect(rendered.queryByRole("heading", { name: /datos a/i })).toBeNull();
     expect(rendered.queryByRole("heading", { name: /last r/i })).toBeNull();
   });
+
+  it("displays group alias when available", async () => {
+    const rendered = render(<ResourceMembers {...props} />);
+    await waitForLoad(rendered);
+
+    // Group with alias should display "Group Alias 1" as header
+    expect(rendered.getByText(/group alias 1/i)).toBeInTheDocument();
+    // And the actual group name should be in the description
+    expect(rendered.getByText(/grupo1/i)).toBeInTheDocument();
+  });
+
+  it("displays group name when alias is not available", async () => {
+    const rendered = render(<ResourceMembers {...props} />);
+    await waitForLoad(rendered);
+
+    // Group without alias should display only the name
+    const grupo2Cards = rendered.queryAllByText(/grupo2/i);
+    expect(grupo2Cards.length).toBeGreaterThan(0);
+  });
 });

package/src/components/__tests__/__snapshots__/AddMemberForm.spec.js.snap

@@ -71,6 +71,20 @@ exports[`<AddMemberForm /> matches the latest snapshot 1`] = `
               mambo
             </span>
           </div>
+          <div
+            aria-checked="false"
+            aria-selected="false"
+            class="item"
+            id="3"
+            role="option"
+            style="pointer-events: all;"
+          >
+            <span
+              class="text"
+            >
+              Group Alias
+            </span>
+          </div>
         </div>
       </div>
     </div>

package/src/components/__tests__/__snapshots__/ResourceMembers.spec.js.snap

@@ -56,8 +56,30 @@ exports[`<ResourceMembers /> matches the latest snapshot 1`] = `
             aria-hidden="true"
             class="users icon"
           />
+          Group Alias 1
+        </div>
+        <div
+          class="description"
+        >
           grupo1 
         </div>
+      </div>
+    </div>
+    <div
+      class="ui card domain-member"
+    >
+      <div
+        class="content domain-member__content"
+      >
+        <div
+          class="header"
+        >
+          <i
+            aria-hidden="true"
+            class="users icon"
+          />
+          grupo2
+        </div>
         <div
           class="description"
         />

package/src/selectors/__tests__/getRecipients.spec.js

@@ -0,0 +1,365 @@
+import { getRecipients } from "../getRecipients";
+
+describe("getRecipients", () => {
+  it("transforms users correctly", () => {
+    const state = {
+      usersSearch: [
+        { id: 1, full_name: "John Doe" },
+        { id: 2, full_name: "Jane Smith" },
+      ],
+      groupsSearch: [],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 1,
+          full_name: "John Doe",
+          role: "user",
+          text: "John Doe",
+          value: "user_1",
+          icon: "user",
+        }),
+        expect.objectContaining({
+          id: 2,
+          full_name: "Jane Smith",
+          role: "user",
+          text: "Jane Smith",
+          value: "user_2",
+          icon: "user",
+        }),
+      ]),
+    );
+  });
+
+  it("displays group alias when available", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [
+        { id: 1, name: "group1", alias: "Group Alias 1", users: [] },
+      ],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toContainEqual(
+      expect.objectContaining({
+        id: 1,
+        name: "group1",
+        alias: "Group Alias 1",
+        role: "group",
+        text: "Group Alias 1",
+        value: "group_1",
+        icon: "group",
+      }),
+    );
+  });
+
+  it("displays group name when alias is not available", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [{ id: 2, name: "group2", alias: null, users: [] }],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toContainEqual(
+      expect.objectContaining({
+        id: 2,
+        name: "group2",
+        alias: null,
+        role: "group",
+        text: "group2",
+        value: "group_2",
+        icon: "group",
+      }),
+    );
+  });
+
+  it("displays group name when alias is empty string", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [{ id: 3, name: "group3", alias: "", users: [] }],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toContainEqual(
+      expect.objectContaining({
+        id: 3,
+        name: "group3",
+        alias: "",
+        role: "group",
+        text: "group3",
+        value: "group_3",
+        icon: "group",
+      }),
+    );
+  });
+
+  it("combines users and groups correctly", () => {
+    const state = {
+      usersSearch: [{ id: 1, full_name: "John Doe" }],
+      groupsSearch: [
+        { id: 1, name: "group1", alias: "Group Alias", users: [] },
+        { id: 2, name: "group2", alias: null, users: [] },
+      ],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(3);
+    expect(result).toContainEqual(
+      expect.objectContaining({
+        id: 1,
+        full_name: "John Doe",
+        role: "user",
+        text: "John Doe",
+        value: "user_1",
+      }),
+    );
+    expect(result).toContainEqual(
+      expect.objectContaining({
+        id: 1,
+        name: "group1",
+        alias: "Group Alias",
+        role: "group",
+        text: "Group Alias",
+        value: "group_1",
+      }),
+    );
+    expect(result).toContainEqual(
+      expect.objectContaining({
+        id: 2,
+        name: "group2",
+        alias: null,
+        role: "group",
+        text: "group2",
+        value: "group_2",
+      }),
+    );
+  });
+
+  it("handles empty users and groups", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toEqual([]);
+  });
+
+  it("handles missing usersSearch and groupsSearch properties", () => {
+    const state = {};
+
+    const result = getRecipients(state);
+
+    expect(result).toEqual([]);
+  });
+
+  it("filters out unwanted properties from users", () => {
+    const state = {
+      usersSearch: [
+        {
+          id: 1,
+          full_name: "John Doe",
+          email: "john@example.com",
+          password: "secret",
+          extra_field: "should_be_ignored",
+        },
+      ],
+      groupsSearch: [],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toHaveProperty("id");
+    expect(result[0]).toHaveProperty("full_name");
+    expect(result[0]).not.toHaveProperty("email");
+    expect(result[0]).not.toHaveProperty("password");
+    expect(result[0]).not.toHaveProperty("extra_field");
+  });
+
+  it("filters out unwanted properties from groups", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [
+        {
+          id: 1,
+          name: "group1",
+          alias: "Group Alias",
+          description: "should_be_ignored",
+          users: [],
+          created_at: "2024-01-01",
+        },
+      ],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(1);
+    expect(result[0]).toHaveProperty("id");
+    expect(result[0]).toHaveProperty("name");
+    expect(result[0]).toHaveProperty("alias");
+    expect(result[0]).toHaveProperty("users");
+    expect(result[0]).not.toHaveProperty("description");
+    expect(result[0]).not.toHaveProperty("created_at");
+  });
+
+  it("preserves order of users and groups", () => {
+    const state = {
+      usersSearch: [
+        { id: 1, full_name: "User 1" },
+        { id: 2, full_name: "User 2" },
+        { id: 3, full_name: "User 3" },
+      ],
+      groupsSearch: [
+        { id: 1, name: "Group 1", alias: null, users: [] },
+        { id: 2, name: "Group 2", alias: "GA 2", users: [] },
+      ],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(5);
+    expect(result[0].value).toBe("user_1");
+    expect(result[1].value).toBe("user_2");
+    expect(result[2].value).toBe("user_3");
+    expect(result[3].value).toBe("group_1");
+    expect(result[4].value).toBe("group_2");
+  });
+
+  it("handles groups with special characters in names", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [
+        { id: 1, name: "group-with-dashes", alias: "Group & Co.", users: [] },
+        { id: 2, name: "group/with/slashes", alias: null, users: [] },
+      ],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(2);
+    expect(result[0].text).toBe("Group & Co.");
+    expect(result[1].text).toBe("group/with/slashes");
+  });
+
+  it("handles users with whitespace in names", () => {
+    const state = {
+      usersSearch: [
+        { id: 1, full_name: "  John  Doe  " },
+        { id: 2, full_name: "Jane\nSmith" },
+      ],
+      groupsSearch: [],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(2);
+    expect(result[0].text).toBe("  John  Doe  ");
+    expect(result[1].text).toBe("Jane\nSmith");
+  });
+
+  it("converts numeric IDs to string values correctly", () => {
+    const state = {
+      usersSearch: [{ id: 123, full_name: "Test" }],
+      groupsSearch: [{ id: 456, name: "TestGroup", alias: null, users: [] }],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result[0].value).toBe("user_123");
+    expect(result[1].value).toBe("group_456");
+  });
+
+  it("handles undefined alias correctly", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [{ id: 1, name: "group1", alias: undefined, users: [] }],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].text).toBe("group1");
+  });
+
+  it("memoizes results for same state", () => {
+    const state = {
+      usersSearch: [{ id: 1, full_name: "John" }],
+      groupsSearch: [{ id: 1, name: "group1", alias: "GA1", users: [] }],
+    };
+
+    const result1 = getRecipients(state);
+    const result2 = getRecipients(state);
+
+    expect(result1).toBe(result2);
+  });
+
+  it("returns different results for different state", () => {
+    const state1 = {
+      usersSearch: [{ id: 1, full_name: "John" }],
+      groupsSearch: [],
+    };
+
+    const state2 = {
+      usersSearch: [{ id: 1, full_name: "Jane" }],
+      groupsSearch: [],
+    };
+
+    const result1 = getRecipients(state1);
+    const result2 = getRecipients(state2);
+
+    expect(result1).not.toBe(result2);
+    expect(result1[0].full_name).toBe("John");
+    expect(result2[0].full_name).toBe("Jane");
+  });
+
+  it("includes all required fields for users", () => {
+    const state = {
+      usersSearch: [{ id: 1, full_name: "John Doe" }],
+      groupsSearch: [],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result[0]).toEqual(
+      expect.objectContaining({
+        id: 1,
+        full_name: "John Doe",
+        role: "user",
+        text: "John Doe",
+        value: "user_1",
+        icon: "user",
+      }),
+    );
+  });
+
+  it("includes all required fields for groups", () => {
+    const state = {
+      usersSearch: [],
+      groupsSearch: [{ id: 1, name: "group1", alias: "GA1", users: [] }],
+    };
+
+    const result = getRecipients(state);
+
+    expect(result[0]).toEqual(
+      expect.objectContaining({
+        id: 1,
+        name: "group1",
+        alias: "GA1",
+        users: [],
+        role: "group",
+        text: "GA1",
+        value: "group_1",
+        icon: "group",
+      }),
+    );
+  });
+});

package/src/selectors/getRecipients.js

@@ -18,11 +18,11 @@ const usersAsOptions = (users) =>
 
 const groupsAsOptions = (groups) =>
   _.flow(
-    _.map(_.pick(["id", "name", "users"])),
+    _.map(_.pick(["id", "name", "alias", "users"])),
     _.map((g) => ({
       ...g,
       role: "group",
-      text: _.prop("name")(g),
+      text: _.prop("alias")(g) || _.prop("name")(g),
       value: `group_${_.prop("id")(g)}`,
       icon: "group",
     }))