feat(ui): updated ui with identity privilege hooks and new role form

frontend/src/hooks/api/identities/types.ts

@@ -29,30 +29,30 @@ export type IdentityMembershipOrg = {
 export type IdentityMembership = {
   id: string;
   identity: Identity;
-  roles: {
-    id: string;
-    role: "owner" | "admin" | "member" | "no-access" | "custom";
-    customRoleId: string;
-    customRoleName: string;
-    customRoleSlug: string;
-    isTemporary: boolean;
-    temporaryMode: string | null;
-    temporaryRange: string | null;
-    temporaryAccessStartTime: string | null;
-    temporaryAccessEndTime: string | null;
-  }[];
-  additionalPrivileges: {
-    id: string;
-    name: string;
-    description: string | null | undefined;
-    slug: string;
-    temporaryRange: string | null | undefined;
-    temporaryMode: string | null | undefined;
-    temporaryAccessEndTime: string | null | undefined;
-    temporaryAccessStartTime: string | null | undefined;
-    isTemporary: boolean;
-    createdAt: string;
-  }[];
+  roles: Array<
+    {
+      id: string;
+      role: "owner" | "admin" | "member" | "no-access" | "custom";
+      customRoleId: string;
+      customRoleName: string;
+      customRoleSlug: string;
+    } & (
+      | {
+        isTemporary: false;
+        temporaryRange: null;
+        temporaryMode: null;
+        temporaryAccessEndTime: null;
+        temporaryAccessStartTime: null;
+      }
+      | {
+        isTemporary: true;
+        temporaryRange: string;
+        temporaryMode: string;
+        temporaryAccessEndTime: string;
+        temporaryAccessStartTime: string;
+      }
+    )
+  >;
   createdAt: string;
   updatedAt: string;
 };

frontend/src/hooks/api/identityProjectAdditionalPrivilege/mutation.tsx

@@ -3,7 +3,7 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
-import { workspaceKeys } from "../workspace/queries";
+import { identitiyProjectPrivilegeKeys } from "./queries";
 import {
   TCreateIdentityProjectPrivilegeDTO,
   TDeleteIdentityProjectPrivilegeDTO,
@@ -14,20 +14,19 @@ import {
 export const useCreateIdentityProjectAdditionalPrivilege = () => {
   const queryClient = useQueryClient();
 
-  return useMutation<
-    { privilege: TIdentityProjectPrivilege },
-    {},
-    TCreateIdentityProjectPrivilegeDTO
-  >({
+  return useMutation<TIdentityProjectPrivilege, {}, TCreateIdentityProjectPrivilegeDTO>({
     mutationFn: async (dto) => {
       const { data } = await apiRequest.post("/api/v1/additional-privilege/identity", {
         ...dto,
+        isPackedPermission: true,
         permissions: packRules(dto.permissions)
       });
       return data.privilege;
     },
-    onSuccess: (_, { projectId }) => {
-      queryClient.invalidateQueries(workspaceKeys.getWorkspaceIdentityMemberships(projectId));
+    onSuccess: (_, { projectSlug, identityId }) => {
+      queryClient.invalidateQueries(
+        identitiyProjectPrivilegeKeys.list({ projectSlug, identityId })
+      );
     }
   });
 };
@@ -35,20 +34,24 @@ export const useCreateIdentityProjectAdditionalPrivilege = () => {
 export const useUpdateIdentityProjectAdditionalPrivilege = () => {
   const queryClient = useQueryClient();
 
-  return useMutation<
-    { privilege: TIdentityProjectPrivilege },
-    {},
-    TUpdateIdentityProjectPrivlegeDTO
-  >({
-    mutationFn: async (dto) => {
-      const { data } = await apiRequest.patch(
-        `/api/v1/additional-privilege/identity/${dto.privilegeId}`,
-        { ...dto, permissions: dto.permissions ? packRules(dto.permissions) : undefined }
-      );
-      return data.privilege;
+  return useMutation<TIdentityProjectPrivilege, {}, TUpdateIdentityProjectPrivlegeDTO>({
+    mutationFn: async ({ slug, projectSlug, identityId, data }) => {
+      const { data: res } = await apiRequest.patch("/api/v1/additional-privilege/identity", {
+        slug,
+        projectSlug,
+        identityId,
+        data: {
+          isPackedPermission: true,
+          ...data,
+          permissions: data.permissions ? packRules(data.permissions) : undefined
+        }
+      });
+      return res.privilege;
     },
-    onSuccess: (_, { projectId }) => {
-      queryClient.invalidateQueries(workspaceKeys.getWorkspaceIdentityMemberships(projectId));
+    onSuccess: (_, { projectSlug, identityId }) => {
+      queryClient.invalidateQueries(
+        identitiyProjectPrivilegeKeys.list({ projectSlug, identityId })
+      );
     }
   });
 };
@@ -56,19 +59,21 @@ export const useUpdateIdentityProjectAdditionalPrivilege = () => {
 export const useDeleteIdentityProjectAdditionalPrivilege = () => {
   const queryClient = useQueryClient();
 
-  return useMutation<
-    { privilege: TIdentityProjectPrivilege },
-    {},
-    TDeleteIdentityProjectPrivilegeDTO
-  >({
-    mutationFn: async (dto) => {
-      const { data } = await apiRequest.delete(
-        `/api/v1/additional-privilege/identity/${dto.privilegeId}`
-      );
+  return useMutation<TIdentityProjectPrivilege, {}, TDeleteIdentityProjectPrivilegeDTO>({
+    mutationFn: async ({ identityId, projectSlug, slug }) => {
+      const { data } = await apiRequest.delete("/api/v1/additional-privilege/identity", {
+        data: {
+          identityId,
+          projectSlug,
+          slug
+        }
+      });
       return data.privilege;
     },
-    onSuccess: (_, { projectId }) => {
-      queryClient.invalidateQueries(workspaceKeys.getWorkspaceIdentityMemberships(projectId));
+    onSuccess: (_, { projectSlug, identityId }) => {
+      queryClient.invalidateQueries(
+        identitiyProjectPrivilegeKeys.list({ projectSlug, identityId })
+      );
     }
   });
 };

frontend/src/hooks/api/identityProjectAdditionalPrivilege/queries.tsx

@@ -4,28 +4,74 @@ import { useQuery } from "@tanstack/react-query";
 import { apiRequest } from "@app/config/request";
 
 import { TProjectPermission } from "../roles/types";
-import { TIdentityProjectPrivilege } from "./types";
+import {
+  TGetIdentityProejctPrivilegeDetails as TGetIdentityProjectPrivilegeDetails,
+  TIdentityProjectPrivilege,
+  TListIdentityUserPrivileges as TListIdentityProjectPrivileges
+} from "./types";
 
 export const identitiyProjectPrivilegeKeys = {
-  details: (privilegeId: string) => ["project-user-privilege", { privilegeId }] as const
+  details: ({ identityId, slug, projectSlug }: TGetIdentityProjectPrivilegeDetails) =>
+    [
+      "identity-user-privilege",
+      {
+        identityId,
+        projectSlug,
+        slug
+      }
+    ] as const,
+  list: ({ projectSlug, identityId }: TListIdentityProjectPrivileges) =>
+    ["identity-user-privileges", { identityId, projectSlug }] as const
 };
 
-const fetchIdentityProjectPrivilegeDetails = async (privilegeId: string) => {
-  const {
-    data: { privilege }
-  } = await apiRequest.get<{
-    privilege: Omit<TIdentityProjectPrivilege, "permissions"> & { permissions: unknown };
-  }>(`/api/v1/additional-privilege/identity/${privilegeId}`);
-  return {
-    ...privilege,
-    permissions: unpackRules(privilege.permissions as PackRule<TProjectPermission>[])
-  };
-};
-
-export const useGetIdentityProjectPrivilegeDetails = (privilegeId: string) => {
+export const useGetIdentityProjectPrivilegeDetails = ({
+  projectSlug,
+  identityId,
+  slug
+}: TGetIdentityProjectPrivilegeDetails) => {
   return useQuery({
-    enabled: Boolean(privilegeId),
-    queryKey: identitiyProjectPrivilegeKeys.details(privilegeId),
-    queryFn: () => fetchIdentityProjectPrivilegeDetails(privilegeId)
+    enabled: Boolean(projectSlug && identityId && slug),
+    queryKey: identitiyProjectPrivilegeKeys.details({ projectSlug, slug, identityId }),
+    queryFn: async () => {
+      const {
+        data: { privilege }
+      } = await apiRequest.get<{
+        privilege: Omit<TIdentityProjectPrivilege, "permissions"> & { permissions: unknown };
+      }>(`/api/v1/additional-privilege/identity/${slug}`, {
+        params: {
+          identityId,
+          projectSlug
+        }
+      });
+      return {
+        ...privilege,
+        permissions: unpackRules(privilege.permissions as PackRule<TProjectPermission>[])
+      };
+    }
+  });
+};
+
+export const useListIdentityProjectPrivileges = ({
+  projectSlug,
+  identityId
+}: TListIdentityProjectPrivileges) => {
+  return useQuery({
+    enabled: Boolean(projectSlug && identityId),
+    queryKey: identitiyProjectPrivilegeKeys.list({ projectSlug, identityId }),
+    queryFn: async () => {
+      const {
+        data: { privileges }
+      } = await apiRequest.get<{
+        privileges: Array<
+          Omit<TIdentityProjectPrivilege, "permissions"> & { permissions: unknown }
+        >;
+      }>("/api/v1/additional-privilege/identity", {
+        params: { identityId, projectSlug, unpacked: false }
+      });
+      return privileges.map((el) => ({
+        ...el,
+        permissions: unpackRules(el.permissions as PackRule<TProjectPermission>[])
+      }));
+    }
   });
 };

frontend/src/hooks/api/identityProjectAdditionalPrivilege/types.tsx

@@ -7,25 +7,31 @@ export enum IdentityProjectAdditionalPrivilegeTemporaryMode {
 export type TIdentityProjectPrivilege = {
   projectMembershipId: string;
   slug: string;
-  name: string;
-  isTemporary: boolean;
   id: string;
   createdAt: Date;
   updatedAt: Date;
-  description?: string | null | undefined;
-  temporaryMode?: string | null | undefined;
-  temporaryRange?: string | null | undefined;
-  temporaryAccessStartTime?: string | null | undefined;
-  temporaryAccessEndTime?: Date | null | undefined;
   permissions?: TProjectPermission[];
-};
+} & (
+    | {
+      isTemporary: true;
+      temporaryMode: string;
+      temporaryRange: string;
+      temporaryAccessStartTime: string;
+      temporaryAccessEndTime?: string;
+    }
+    | {
+      isTemporary: false;
+      temporaryMode?: null;
+      temporaryRange?: null;
+      temporaryAccessStartTime?: null;
+      temporaryAccessEndTime?: null;
+    }
+  );
 
 export type TCreateIdentityProjectPrivilegeDTO = {
   identityId: string;
-  projectId: string;
-  slug: string;
-  name: string;
-  description?: string;
+  projectSlug: string;
+  slug?: string;
   isTemporary?: boolean;
   temporaryMode?: IdentityProjectAdditionalPrivilegeTemporaryMode;
   temporaryRange?: string;
@@ -34,15 +40,25 @@ export type TCreateIdentityProjectPrivilegeDTO = {
 };
 
 export type TUpdateIdentityProjectPrivlegeDTO = {
-  privilegeId: string;
-  projectId: string;
-} & Partial<Omit<TCreateIdentityProjectPrivilegeDTO, "projectMembershipId" | "projectId">>;
+  projectSlug: string;
+  identityId: string;
+  slug: string;
+  data: Partial<Omit<TCreateIdentityProjectPrivilegeDTO, "projectMembershipId" | "projectId">>;
+};
 
 export type TDeleteIdentityProjectPrivilegeDTO = {
-  privilegeId: string;
-  projectId: string;
+  projectSlug: string;
+  identityId: string;
+  slug: string;
+};
+
+export type TListIdentityUserPrivileges = {
+  projectSlug: string;
+  identityId: string;
 };
 
 export type TGetIdentityProejctPrivilegeDetails = {
-  privilegeId: string;
+  projectSlug: string;
+  identityId: string;
+  slug: string;
 };