Add Machine Auth Templates

frontend/src/hooks/api/identities/mutations.tsx

@@ -1385,6 +1385,7 @@ export const useAddIdentityLdapAuth = () => {
   return useMutation<IdentityLdapAuth, object, AddIdentityLdapAuthDTO>({
     mutationFn: async ({
       identityId,
+      templateId,
       url,
       bindDN,
       bindPass,
@@ -1400,6 +1401,7 @@ export const useAddIdentityLdapAuth = () => {
       const { data } = await apiRequest.post<{ identityLdapAuth: IdentityLdapAuth }>(
         `/api/v1/auth/ldap-auth/identities/${identityId}`,
         {
+          templateId,
           url,
           bindDN,
           bindPass,
@@ -1432,6 +1434,7 @@ export const useUpdateIdentityLdapAuth = () => {
   return useMutation<IdentityLdapAuth, object, UpdateIdentityLdapAuthDTO>({
     mutationFn: async ({
       identityId,
+      templateId,
       url,
       bindDN,
       bindPass,
@@ -1447,6 +1450,7 @@ export const useUpdateIdentityLdapAuth = () => {
       const { data } = await apiRequest.patch<{ identityLdapAuth: IdentityLdapAuth }>(
         `/api/v1/auth/ldap-auth/identities/${identityId}`,
         {
+          templateId,
           url,
           bindDN,
           bindPass,

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

@@ -567,10 +567,11 @@ export type IdentityTokenAuth = {
 export type AddIdentityLdapAuthDTO = {
   organizationId: string;
   identityId: string;
-  url: string;
-  bindDN: string;
-  bindPass: string;
-  searchBase: string;
+  templateId?: string;
+  url?: string;
+  bindDN?: string;
+  bindPass?: string;
+  searchBase?: string;
   searchFilter: string;
   ldapCaCertificate?: string;
   allowedFields?: {
@@ -588,6 +589,7 @@ export type AddIdentityLdapAuthDTO = {
 export type UpdateIdentityLdapAuthDTO = {
   identityId: string;
   organizationId: string;
+  templateId?: string;
   url?: string;
   bindDN?: string;
   bindPass?: string;
@@ -612,10 +614,11 @@ export type DeleteIdentityLdapAuthDTO = {
 };
 
 export type IdentityLdapAuth = {
-  url: string;
-  bindDN: string;
-  bindPass: string;
-  searchBase: string;
+  url?: string;
+  bindDN?: string;
+  templateId?: string;
+  bindPass?: string;
+  searchBase?: string;
   searchFilter: string;
   ldapCaCertificate?: string;
   allowedFields?: {

frontend/src/hooks/api/identityAuthTemplates/index.tsx

@@ -0,0 +1,3 @@
+export * from "./mutations";
+export * from "./queries";
+export * from "./types";

frontend/src/hooks/api/identityAuthTemplates/mutations.tsx

@@ -0,0 +1,97 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { identityAuthTemplatesKeys } from "./queries";
+import {
+  CreateIdentityAuthTemplateDTO,
+  DeleteIdentityAuthTemplateDTO,
+  IdentityAuthTemplate,
+  MachineAuthTemplateUsage,
+  UnlinkTemplateUsageDTO,
+  UpdateIdentityAuthTemplateDTO
+} from "./types";
+
+export const useCreateIdentityAuthTemplate = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: CreateIdentityAuthTemplateDTO) => {
+      const { data } = await apiRequest.post<{ template: IdentityAuthTemplate }>(
+        "/api/v1/identities/templates",
+        dto
+      );
+      return data.template;
+    },
+    onSuccess: (_, { organizationId }) => {
+      queryClient.invalidateQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplates({ organizationId })
+      });
+    }
+  });
+};
+
+export const useUpdateIdentityAuthTemplate = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: UpdateIdentityAuthTemplateDTO) => {
+      const { data } = await apiRequest.patch<{ template: IdentityAuthTemplate }>(
+        `/api/v1/identities/templates/${dto.templateId}`,
+        dto
+      );
+      return data.template;
+    },
+    onSuccess: (_, { organizationId, templateId }) => {
+      queryClient.invalidateQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplates({ organizationId })
+      });
+      queryClient.invalidateQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplate(templateId)
+      });
+    }
+  });
+};
+
+export const useDeleteIdentityAuthTemplate = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: DeleteIdentityAuthTemplateDTO) => {
+      await apiRequest.delete(`/api/v1/identities/templates/${dto.templateId}`, {
+        params: { organizationId: dto.organizationId }
+      });
+    },
+    onSuccess: (_, { organizationId, templateId }) => {
+      queryClient.invalidateQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplates({ organizationId })
+      });
+      queryClient.removeQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplate(templateId)
+      });
+    }
+  });
+};
+
+export const useUnlinkTemplateUsage = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: UnlinkTemplateUsageDTO) => {
+      const { data } = await apiRequest.post<MachineAuthTemplateUsage[]>(
+        `/api/v1/identities/templates/${dto.templateId}/usage`,
+        { identityIds: dto.identityIds },
+        { params: { organizationId: dto.organizationId } }
+      );
+      return data;
+    },
+    onSuccess: (_, { templateId, organizationId }) => {
+      queryClient.invalidateQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplateUsages(templateId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: identityAuthTemplatesKeys.getTemplates({ organizationId })
+      });
+    }
+  });
+};

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

@@ -0,0 +1,90 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import {
+  GetIdentityAuthTemplatesDTO,
+  GetTemplateUsagesDTO,
+  IdentityAuthTemplate,
+  MachineAuthTemplateUsage
+} from "./types";
+
+export const identityAuthTemplatesKeys = {
+  all: ["identity-auth-templates"] as const,
+  getTemplates: (dto: GetIdentityAuthTemplatesDTO) =>
+    [...identityAuthTemplatesKeys.all, "list", dto] as const,
+  getTemplate: (templateId: string) =>
+    [...identityAuthTemplatesKeys.all, "single", templateId] as const,
+  getTemplatesByOrgId: (authMethod: string) =>
+    [...identityAuthTemplatesKeys.all, "list", authMethod] as const,
+  getTemplateUsages: (templateId: string) =>
+    [...identityAuthTemplatesKeys.all, "usages", templateId] as const
+};
+
+export const useGetIdentityAuthTemplates = (dto: GetIdentityAuthTemplatesDTO) => {
+  return useQuery({
+    queryKey: identityAuthTemplatesKeys.getTemplates(dto),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{
+        templates: IdentityAuthTemplate[];
+        totalCount: number;
+      }>("/api/v1/identities/templates/search", {
+        params: {
+          organizationId: dto.organizationId,
+          limit: dto.limit || 50,
+          offset: dto.offset || 0
+        }
+      });
+      return data;
+    },
+    enabled: Boolean(dto.organizationId)
+  });
+};
+
+export const useGetIdentityAuthTemplate = (templateId: string, organizationId: string) => {
+  return useQuery({
+    queryKey: identityAuthTemplatesKeys.getTemplate(templateId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{ template: IdentityAuthTemplate }>(
+        `/api/v1/identities/templates/${templateId}`,
+        {
+          params: { organizationId }
+        }
+      );
+      return data.template;
+    },
+    enabled: Boolean(templateId) && Boolean(organizationId)
+  });
+};
+
+export const useGetIdentityAuthTemplatesByOrgId = (authMethod: string) => {
+  return useQuery({
+    queryKey: identityAuthTemplatesKeys.getTemplatesByOrgId(authMethod),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<IdentityAuthTemplate[]>(
+        "/api/v1/identities/templates",
+        {
+          params: { authMethod }
+        }
+      );
+      return data;
+    },
+    enabled: Boolean(authMethod)
+  });
+};
+
+export const useGetTemplateUsages = (dto: GetTemplateUsagesDTO) => {
+  return useQuery({
+    queryKey: identityAuthTemplatesKeys.getTemplateUsages(dto.templateId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<MachineAuthTemplateUsage[]>(
+        `/api/v1/identities/templates/${dto.templateId}/usage`,
+        {
+          params: { organizationId: dto.organizationId }
+        }
+      );
+      return data;
+    },
+    enabled: Boolean(dto.templateId) && Boolean(dto.organizationId)
+  });
+};

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

@@ -0,0 +1,76 @@
+export enum MachineIdentityAuthMethod {
+  LDAP = "ldap"
+}
+
+export interface LdapTemplateFields {
+  url: string;
+  bindDN: string;
+  bindPass: string;
+  searchBase: string;
+}
+
+export interface IdentityAuthTemplate {
+  id: string;
+  name: string;
+  authMethod: MachineIdentityAuthMethod;
+  organizationId: string;
+  templateFields: LdapTemplateFields;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateIdentityAuthTemplateDTO {
+  organizationId: string;
+  name: string;
+  authMethod: MachineIdentityAuthMethod;
+  templateFields: LdapTemplateFields;
+}
+
+export interface UpdateIdentityAuthTemplateDTO {
+  templateId: string;
+  organizationId: string;
+  name?: string;
+  templateFields?: Partial<LdapTemplateFields>;
+}
+
+export interface DeleteIdentityAuthTemplateDTO {
+  templateId: string;
+  organizationId: string;
+}
+
+export interface GetIdentityAuthTemplatesDTO {
+  organizationId: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface MachineAuthTemplateUsage {
+  identityId: string;
+  identityName: string;
+}
+
+export interface GetTemplateUsagesDTO {
+  templateId: string;
+  organizationId: string;
+}
+
+export interface UnlinkTemplateUsageDTO {
+  templateId: string;
+  identityIds: string[];
+  organizationId: string;
+}
+
+export const TEMPLATE_ERROR_MESSAGES = {
+  UNLINK_SUCCESS: "Successfully unlinked template usages",
+  UNLINK_FAILED: "Failed to unlink template usages",
+  SINGLE_UNLINK_SUCCESS: "Successfully unlinked template usage",
+  SINGLE_UNLINK_FAILED: "Failed to unlink template usage"
+} as const;
+
+export const TEMPLATE_UI_LABELS = {
+  VIEW_USAGES: "View Usages",
+  EDIT_TEMPLATE: "Edit Template",
+  DELETE_TEMPLATE: "Delete Template",
+  UNLINK: "Unlink",
+  UNSELECT_ALL: "Unselect All"
+} as const;

frontend/src/hooks/api/index.tsx

@@ -15,6 +15,7 @@ export * from "./gateways";
 export * from "./githubOrgSyncConfig";
 export * from "./groups";
 export * from "./identities";
+export * from "./identityAuthTemplates";
 export * from "./identityProjectAdditionalPrivilege";
 export * from "./incidentContacts";
 export * from "./integrationAuth";

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

@@ -53,4 +53,5 @@ export type SubscriptionPlan = {
   secretScanning: boolean;
   enterpriseSecretSyncs: boolean;
   enterpriseAppConnections: boolean;
+  machineIdentityAuthTemplates: boolean;
 };