@truedat/auth 8.14.1 → 8.14.3

package/src/groups/hooks/__tests__/useGroupOperation.spec.js

@@ -0,0 +1,167 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { SWRConfig } from "swr";
+import {
+  apiJson,
+  apiJsonPost,
+  apiJsonPut,
+  apiJsonDelete,
+} from "@truedat/core/services/api";
+import { useGroupOperation } from "../useGroupOperation";
+import { useGroup, useGroups } from "../useGroups";
+
+jest.mock("@truedat/core/services/api", () => ({
+  apiJson: jest.fn(),
+  apiJsonPost: jest.fn(),
+  apiJsonPut: jest.fn(),
+  apiJsonDelete: jest.fn(),
+  JSON_OPTS: {},
+}));
+
+const setup = (action, onSuccess = jest.fn()) => {
+  const cache = new Map();
+  const wrapper = ({ children }) => (
+    <SWRConfig
+      value={{
+        provider: () => cache,
+        dedupingInterval: 0,
+        shouldRetryOnError: false,
+      }}
+    >
+      {children}
+    </SWRConfig>
+  );
+  return {
+    ...renderHook(() => useGroupOperation(action, 1, onSuccess), { wrapper }),
+    cache,
+    onSuccess,
+    wrapper,
+  };
+};
+
+beforeEach(() => jest.resetAllMocks());
+
+describe("useGroupOperation", () => {
+  it("blocks duplicate submissions", async () => {
+    const deferred = {};
+    apiJsonPost.mockReturnValue(
+      new Promise((resolve) => {
+        deferred.resolve = resolve;
+      }),
+    );
+    const { result } = setup("create");
+    act(() => {
+      result.current.submit({ name: "Team" });
+      result.current.submit({ name: "Team" });
+    });
+    expect(apiJsonPost).toHaveBeenCalledTimes(1);
+    await act(async () => deferred.resolve({ data: { data: { id: 1 } } }));
+  });
+
+  it("exposes write errors without invoking success", async () => {
+    apiJsonPost.mockRejectedValue(new Error("offline"));
+    const { result, onSuccess } = setup("create");
+    await act(async () => result.current.submit({ name: "Team" }));
+    expect(result.current.failed).toBe(true);
+    expect(onSuccess).not.toHaveBeenCalled();
+  });
+
+  it("allows retry after a failed write", async () => {
+    apiJsonPost
+      .mockRejectedValueOnce(new Error("offline"))
+      .mockResolvedValueOnce({ data: { data: { id: 1 } } });
+    const { result, onSuccess } = setup("create");
+    await act(async () => result.current.submit({ name: "Team" }));
+    await act(async () => result.current.submit({ name: "Team" }));
+    expect(onSuccess).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps pending and errors independent between mutation instances", async () => {
+    apiJsonPost.mockRejectedValue(new Error("offline"));
+    const { result, wrapper } = setup("create");
+    const second = renderHook(
+      () => useGroupOperation("create", null, jest.fn()),
+      { wrapper },
+    );
+    await act(async () => result.current.submit({ name: "Team" }));
+    expect(second.result.current.failed).toBe(false);
+    expect(second.result.current.pending).toBe(false);
+  });
+
+  it("removes a member using freshly fetched membership", async () => {
+    apiJson.mockResolvedValue({
+      data: { data: { id: 1, name: "Team", users: [{ id: 2 }, { id: 3 }] } },
+    });
+    apiJsonPut.mockResolvedValue({
+      data: { data: { id: 1, users: [{ id: 3 }] } },
+    });
+    const { result } = setup("removeMember");
+    await act(async () => result.current.submit({ id: "2" }));
+    expect(apiJsonPut).toHaveBeenCalledWith(
+      "/api/groups/1",
+      { group: { id: 1, name: "Team", user_ids: [3] } },
+      {},
+    );
+  });
+
+  it("evicts deleted group detail", async () => {
+    apiJsonDelete.mockResolvedValue({});
+    const { result, cache } = setup("delete");
+    cache.set("/api/groups/1", { data: { data: { data: { id: 1 } } } });
+    await act(async () => result.current.submit());
+    expect(cache.get("/api/groups/1").data).toBeUndefined();
+  });
+
+  it("refreshes active list and detail caches after updating", async () => {
+    const group = { id: 1, name: "Team", users: [] };
+    apiJson.mockImplementation((url) =>
+      Promise.resolve({
+        data: { data: url === "/api/groups" ? [group] : group },
+      }),
+    );
+    apiJsonPut.mockImplementation(async () => {
+      group.name = "Updated";
+      return { data: { data: group } };
+    });
+    const { result, wrapper } = setup("update");
+    const readers = renderHook(
+      () => ({ list: useGroups(), detail: useGroup(1) }),
+      { wrapper },
+    );
+    await waitFor(() =>
+      expect(readers.result.current.list.loading).toBe(false),
+    );
+    await act(async () => result.current.submit({ id: 1, name: "Updated" }));
+    expect(readers.result.current.list.groups[0].name).toBe("Updated");
+    expect(readers.result.current.detail.group.name).toBe("Updated");
+  });
+
+  it("reports write success even when list refresh fails", async () => {
+    apiJson
+      .mockResolvedValueOnce({ data: { data: [] } })
+      .mockRejectedValue(new Error("refresh failed"));
+    apiJsonPost.mockResolvedValue({ data: { data: { id: 1 } } });
+    const { result, wrapper, onSuccess } = setup("create");
+    const list = renderHook(() => useGroups(), { wrapper });
+    await waitFor(() => expect(list.result.current.loading).toBe(false));
+    await act(async () => result.current.submit({ name: "Team" }));
+    expect(onSuccess).toHaveBeenCalledTimes(1);
+    expect(result.current.failed).toBe(false);
+  });
+
+  it("finishes the write while the background list refresh is still pending", async () => {
+    const refresh = {};
+    apiJson.mockReturnValue(
+      new Promise((resolve) => {
+        refresh.resolve = resolve;
+      }),
+    );
+    apiJsonPost.mockResolvedValue({ data: { data: { id: 1 } } });
+    const { result, onSuccess } = setup("create");
+    await act(async () => result.current.submit({ name: "Team" }));
+    expect(onSuccess).toHaveBeenCalledTimes(1);
+    expect(result.current.pending).toBe(false);
+    await act(async () =>
+      refresh.resolve({ data: { data: [{ id: 1, name: "Team" }] } }),
+    );
+  });
+});

package/src/groups/hooks/__tests__/useGroups.spec.js

@@ -0,0 +1,90 @@
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { SWRConfig } from "swr";
+import { apiJson, apiJsonPost } from "@truedat/core/services/api";
+import { groupKey, useGroup, useFilteredGroupUsers } from "../useGroups";
+
+jest.mock("@truedat/core/services/api", () => ({
+  apiJson: jest.fn(),
+  apiJsonPost: jest.fn(),
+  JSON_OPTS: {},
+}));
+const setup = (hook, initialProps) => {
+  const cache = new Map();
+  const wrapper = ({ children }) => (
+    <SWRConfig
+      value={{
+        provider: () => cache,
+        shouldRetryOnError: false,
+        dedupingInterval: 0,
+      }}
+    >
+      {children}
+    </SWRConfig>
+  );
+  return renderHook(hook, { wrapper, initialProps });
+};
+beforeEach(() => jest.resetAllMocks());
+
+describe("useGroup", () => {
+  it("does not fetch without an ID", () => {
+    setup(() => useGroup(null));
+    expect(apiJson).not.toHaveBeenCalled();
+  });
+
+  it("does not reuse another group's detail while changing IDs", async () => {
+    apiJson
+      .mockResolvedValueOnce({ data: { data: { id: 1 } } })
+      .mockReturnValue(new Promise(() => {}));
+    const { result, rerender } = setup((id) => useGroup(id), 1);
+    await waitFor(() => expect(result.current.group?.id).toBe(1));
+    rerender(2);
+    expect(result.current.group).toBeUndefined();
+    expect(result.current.loading).toBe(true);
+  });
+
+  it("encodes concrete group keys", () => {
+    expect(groupKey("a/b")).toBe("/api/groups/a%2Fb");
+  });
+});
+
+describe("useFilteredGroupUsers", () => {
+  it("does not fetch disabled filters", () => {
+    setup(() => useFilteredGroupUsers(false, "1", ["2"]));
+    expect(apiJsonPost).not.toHaveBeenCalled();
+  });
+
+  it("normalizes domain order and duplicates in the cache key", async () => {
+    apiJsonPost.mockResolvedValue({ data: { data: [{ id: 1 }] } });
+    const { result, rerender } = setup(
+      (domains) => useFilteredGroupUsers(true, "", domains),
+      ["2", "1", "2"],
+    );
+    await waitFor(() => expect(result.current.users).toEqual([{ id: 1 }]));
+    rerender(["1", "2"]);
+    expect(apiJsonPost).toHaveBeenCalledTimes(1);
+    expect(apiJsonPost).toHaveBeenCalledWith(
+      "/api/users/search",
+      { domains: ["1", "2"] },
+      {},
+    );
+  });
+
+  it("ignores a late response for a previous filter", async () => {
+    const deferred = {};
+    apiJsonPost.mockImplementation((_url, { roles }) =>
+      roles[0] === "1"
+        ? new Promise((resolve) => {
+            deferred.resolve = resolve;
+          })
+        : Promise.resolve({ data: { data: [{ id: 2 }] } }),
+    );
+    const { result, rerender } = setup(
+      (role) => useFilteredGroupUsers(true, role, []),
+      "1",
+    );
+    rerender("2");
+    await waitFor(() => expect(result.current.users).toEqual([{ id: 2 }]));
+    await act(async () => deferred.resolve({ data: { data: [{ id: 1 }] } }));
+    expect(result.current.users).toEqual([{ id: 2 }]);
+  });
+});

package/src/groups/hooks/useGroupOperation.js

@@ -0,0 +1,83 @@
+import { useRef, useState } from "react";
+import { useSWRConfig } from "swr";
+import useSWRMutation from "swr/mutation";
+import {
+  apiJson,
+  apiJsonDelete,
+  apiJsonPost,
+  apiJsonPut,
+  JSON_OPTS,
+} from "@truedat/core/services/api";
+import { API_GROUPS } from "../api";
+import { groupKey } from "./useGroups";
+
+const writeGroup = async (url, { arg: { action, values } }) => {
+  if (action === "delete") return apiJsonDelete(url, JSON_OPTS);
+  const normalizeResponse = (response) =>
+    response.data?.data
+      ? { ...response, data: { ...response.data, data: response.data.data } }
+      : response;
+  if (action === "removeMember") {
+    const { data } = await apiJson(url, JSON_OPTS);
+    const { users, ...group } = data.data;
+    const response = await apiJsonPut(
+      url,
+      {
+        group: {
+          ...group,
+          user_ids: users
+            .filter(({ id }) => String(id) !== String(values.id))
+            .map(({ id }) => id),
+        },
+      },
+      JSON_OPTS,
+    );
+    return normalizeResponse(response);
+  }
+  const request = action === "create" ? apiJsonPost : apiJsonPut;
+  const response = await request(url, { group: values }, JSON_OPTS);
+  return normalizeResponse(response);
+};
+
+export const useGroupOperation = (action, id, onSuccess) => {
+  const { mutate } = useSWRConfig();
+  const active = useRef(false);
+  const [pending, setPending] = useState(false);
+  const key = action === "create" ? API_GROUPS : groupKey(id);
+  const { trigger, error } = useSWRMutation(key, writeGroup);
+  const submit = async (values) => {
+    if (active.current) return;
+    active.current = true;
+    setPending(true);
+    try {
+      const response = await trigger({ action, values }, { revalidate: false });
+      // A failed cache refresh must not turn a successful write into a retry.
+      await Promise.all([
+        ...(action === "create"
+          ? []
+          : [
+              action === "delete"
+                ? mutate(key, undefined, { revalidate: false })
+                : mutate(key, response, { revalidate: false }),
+            ]),
+      ]);
+      // Refresh the list in the background; its latency must not block the
+      // completed write or keep the confirmation dialog pending.
+      mutate(
+        API_GROUPS,
+        async (current) => {
+          const result = await apiJson(API_GROUPS, JSON_OPTS);
+          return result ?? current;
+        },
+        { revalidate: false },
+      ).catch(() => {});
+      onSuccess?.();
+    } catch {
+      // SWR exposes the write error; leave the dialog and its draft open.
+    } finally {
+      active.current = false;
+      setPending(false);
+    }
+  };
+  return { submit, pending, failed: Boolean(error) };
+};

package/src/groups/hooks/useGroups.js

@@ -0,0 +1,64 @@
+import useSWR from "swr";
+import { compile } from "path-to-regexp";
+import { apiJson, apiJsonPost, JSON_OPTS } from "@truedat/core/services/api";
+import { API_GROUP, API_GROUPS } from "../api";
+import { API_USERS, API_USERS_SEARCH } from "../../users/api";
+
+const EMPTY = [];
+export const groupKey = (id) =>
+  id == null ? null : compile(API_GROUP)({ id: String(id) });
+
+export const useGroups = () => {
+  const { data, error, isLoading, mutate } = useSWR(API_GROUPS, apiJson);
+  return {
+    groups: data?.data?.data ?? EMPTY,
+    hasData: data !== undefined,
+    error,
+    loading: isLoading,
+    retry: mutate,
+  };
+};
+
+export const useGroup = (id) => {
+  const { data, error, isLoading, mutate } = useSWR(groupKey(id), apiJson);
+  const group = data?.data?.data;
+  return {
+    group,
+    members: group?.users ?? EMPTY,
+    hasData: data !== undefined,
+    error,
+    loading: isLoading,
+    retry: mutate,
+  };
+};
+
+export const useGroupUsers = () => {
+  const { data, error, isLoading, mutate } = useSWR(API_USERS, apiJson);
+  return {
+    users: data?.data?.data ?? EMPTY,
+    hasData: data !== undefined,
+    error,
+    loading: isLoading,
+    retry: mutate,
+  };
+};
+
+export const useFilteredGroupUsers = (enabled, role, domains) => {
+  const payload = {
+    ...(role ? { roles: [String(role)] } : {}),
+    ...(domains.length
+      ? { domains: [...new Set(domains.map(String))].sort() }
+      : {}),
+  };
+  const key =
+    enabled && (role || domains.length) ? [API_USERS_SEARCH, payload] : null;
+  const { data, error, isLoading, mutate } = useSWR(key, ([url, filters]) =>
+    apiJsonPost(url, filters, JSON_OPTS),
+  );
+  return {
+    users: key ? (data?.data?.data ?? EMPTY) : null,
+    error,
+    loading: isLoading,
+    retry: mutate,
+  };
+};

package/src/groups/reducers/index.js

@@ -1,5 +1 @@
-export * from "./group";
-export * from "./groups";
 export * from "./groupsSearch";
-export * from "./groupRedirect";
-export { groupUsers } from "./groupUsers";

package/src/groups/routines.js

@@ -1,11 +1,4 @@
 import { createRoutine } from "redux-saga-routines";
 
-export const clearGroup = createRoutine("CLEAR_GROUP");
 export const clearGroupsSearch = createRoutine("CLEAR_GROUPS_SEARCH");
-export const createGroup = createRoutine("CREATE_GROUP");
-export const deleteGroup = createRoutine("DELETE_GROUP");
-export const deleteGroupUser = createRoutine("DELETE_GROUP_USER");
-export const fetchGroup = createRoutine("FETCH_GROUP");
-export const fetchGroups = createRoutine("FETCH_GROUPS");
 export const searchGroups = createRoutine("SEARCH_GROUPS");
-export const updateGroup = createRoutine("UPDATE_GROUP");

package/src/groups/sagas/index.js

@@ -1,27 +1,5 @@
-import { createGroupRequestSaga } from "./createGroup";
-import { deleteGroupRequestSaga } from "./deleteGroup";
-import { fetchGroupRequestSaga } from "./fetchGroup";
-import { fetchGroupsRequestSaga } from "./fetchGroups";
-import { updateGroupRequestSaga } from "./updateGroup";
-import { deleteGroupUserRequestSaga } from "./deleteGroupUser";
 import { searchGroupsRequestSaga } from "./searchGroups";
 
-export {
-  createGroupRequestSaga,
-  fetchGroupRequestSaga,
-  updateGroupRequestSaga,
-  deleteGroupRequestSaga,
-  fetchGroupsRequestSaga,
-  deleteGroupUserRequestSaga,
-  searchGroupsRequestSaga,
-};
+export { searchGroupsRequestSaga };
 
-export default [
-  createGroupRequestSaga(),
-  fetchGroupRequestSaga(),
-  updateGroupRequestSaga(),
-  deleteGroupRequestSaga(),
-  fetchGroupsRequestSaga(),
-  deleteGroupUserRequestSaga(),
-  searchGroupsRequestSaga(),
-];
+export default [searchGroupsRequestSaga()];

package/src/hooks/useRoles.js

@@ -2,7 +2,10 @@ import useSWR from "swr";
 import { apiJson } from "@truedat/core/services/api";
 import { API_ROLES } from "../roles/api";
 
-export const useRoles = () => {
-  const { data, error } = useSWR(API_ROLES, apiJson);
-  return { data: data?.data?.data, error, loading: !error && !data };
+export const useRoles = (enabled = true) => {
+  const { data, error, isLoading, mutate } = useSWR(
+    enabled ? API_ROLES : null,
+    apiJson,
+  );
+  return { data: data?.data?.data, error, loading: isLoading, retry: mutate };
 };