Fix merge conflicts

frontend/src/hooks/api/admin/index.ts

@@ -4,13 +4,12 @@ export {
   useAdminRemoveIdentitySuperAdminAccess,
   useCreateAdminUser,
   useRemoveUserServerAdminAccess,
-  useUpdateAdminSlackConfig,
   useUpdateServerConfig,
   useUpdateServerEncryptionStrategy
 } from "./mutation";
 export {
   useAdminGetUsers,
-  useGetAdminSlackConfig,
+  useGetAdminIntegrationsConfig,
   useGetServerConfig,
   useGetServerRootKmsEncryptionDetails
 } from "./queries";

frontend/src/hooks/api/admin/mutation.ts

@@ -6,11 +6,10 @@ import { organizationKeys } from "../organization/queries";
 import { User } from "../users/types";
 import { adminQueryKeys, adminStandaloneKeys } from "./queries";
 import {
-  AdminSlackConfig,
   RootKeyEncryptionStrategy,
   TCreateAdminUserDTO,
   TServerConfig,
-  TUpdateAdminSlackConfigDTO
+  TUpdateServerConfigDTO
 } from "./types";
 
 export const useCreateAdminUser = () => {
@@ -34,11 +33,7 @@ export const useCreateAdminUser = () => {
 export const useUpdateServerConfig = () => {
   const queryClient = useQueryClient();
 
-  return useMutation<
-    TServerConfig,
-    object,
-    Partial<TServerConfig & { slackClientId: string; slackClientSecret: string }>
-  >({
+  return useMutation<TServerConfig, object, TUpdateServerConfigDTO>({
     mutationFn: async (opt) => {
       const { data } = await apiRequest.patch<{ config: TServerConfig }>(
         "/api/v1/admin/config",
@@ -48,6 +43,7 @@ export const useUpdateServerConfig = () => {
     },
     onSuccess: (data) => {
       queryClient.setQueryData(adminQueryKeys.serverConfig(), data);
+      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getAdminIntegrationsConfig() });
       queryClient.invalidateQueries({ queryKey: adminQueryKeys.serverConfig() });
       queryClient.invalidateQueries({ queryKey: organizationKeys.getUserOrganizations });
     }
@@ -119,23 +115,6 @@ export const useAdminGrantServerAdminAccess = () => {
   });
 };
 
-export const useUpdateAdminSlackConfig = () => {
-  const queryClient = useQueryClient();
-  return useMutation<AdminSlackConfig, object, TUpdateAdminSlackConfigDTO>({
-    mutationFn: async (dto) => {
-      const { data } = await apiRequest.put<AdminSlackConfig>(
-        "/api/v1/admin/integrations/slack/config",
-        dto
-      );
-
-      return data;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getAdminSlackConfig() });
-    }
-  });
-};
-
 export const useUpdateServerEncryptionStrategy = () => {
   const queryClient = useQueryClient();
   return useMutation({

frontend/src/hooks/api/admin/queries.ts

@@ -7,7 +7,7 @@ import { User } from "../types";
 import {
   AdminGetIdentitiesFilters,
   AdminGetUsersFilters,
-  AdminSlackConfig,
+  AdminIntegrationsConfig,
   TGetServerRootKmsEncryptionDetails,
   TServerConfig
 } from "./types";
@@ -22,7 +22,7 @@ export const adminQueryKeys = {
   getUsers: (filters: AdminGetUsersFilters) => [adminStandaloneKeys.getUsers, { filters }] as const,
   getIdentities: (filters: AdminGetIdentitiesFilters) =>
     [adminStandaloneKeys.getIdentities, { filters }] as const,
-  getAdminSlackConfig: () => ["admin-slack-config"] as const,
+  getAdminIntegrationsConfig: () => ["admin-integrations-config"] as const,
   getServerEncryptionStrategies: () => ["server-encryption-strategies"] as const
 };
 
@@ -95,13 +95,11 @@ export const useAdminGetIdentities = (filters: AdminGetIdentitiesFilters) => {
   });
 };
 
-export const useGetAdminSlackConfig = () => {
+export const useGetAdminIntegrationsConfig = () => {
   return useQuery({
-    queryKey: adminQueryKeys.getAdminSlackConfig(),
+    queryKey: adminQueryKeys.getAdminIntegrationsConfig(),
     queryFn: async () => {
-      const { data } = await apiRequest.get<AdminSlackConfig>(
-        "/api/v1/admin/integrations/slack/config"
-      );
+      const { data } = await apiRequest.get<AdminIntegrationsConfig>("/api/v1/admin/integrations");
 
       return data;
     }

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

@@ -26,6 +26,14 @@ export type TServerConfig = {
   pageFrameContent?: string;
 };
 
+export type TUpdateServerConfigDTO = {
+  slackClientId?: string;
+  slackClientSecret?: string;
+  microsoftTeamsAppId?: string;
+  microsoftTeamsClientSecret?: string;
+  microsoftTeamsBotId?: string;
+} & Partial<TServerConfig>;
+
 export type TCreateAdminUserDTO = {
   email: string;
   password: string;
@@ -42,11 +50,6 @@ export type TCreateAdminUserDTO = {
   salt: string;
 };
 
-export type TUpdateAdminSlackConfigDTO = {
-  clientId: string;
-  clientSecret: string;
-};
-
 export type AdminGetUsersFilters = {
   limit: number;
   searchTerm: string;
@@ -58,9 +61,16 @@ export type AdminGetIdentitiesFilters = {
   searchTerm: string;
 };
 
-export type AdminSlackConfig = {
-  clientId: string;
-  clientSecret: string;
+export type AdminIntegrationsConfig = {
+  slack: {
+    clientId: string;
+    clientSecret: string;
+  };
+  microsoftTeams: {
+    appId: string;
+    clientSecret: string;
+    botId: string;
+  };
 };
 
 export type TGetServerRootKmsEncryptionDetails = {

frontend/src/hooks/api/appConnections/enums.ts

@@ -14,6 +14,7 @@ export enum AppConnection {
   Camunda = "camunda",
   Windmill = "windmill",
   Auth0 = "auth0",
+  HCVault = "hashicorp-vault",
   LDAP = "ldap",
   TeamCity = "teamcity"
 }

frontend/src/hooks/api/appConnections/hc-vault/index.ts

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

frontend/src/hooks/api/appConnections/hc-vault/queries.tsx

@@ -0,0 +1,36 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { appConnectionKeys } from "../queries";
+
+const hcVaultConnectionKeys = {
+  all: [...appConnectionKeys.all, "hcvault"] as const,
+  listMounts: (connectionId: string) =>
+    [...hcVaultConnectionKeys.all, "mounts", connectionId] as const
+};
+
+export const useHCVaultConnectionListMounts = (
+  connectionId: string,
+  options?: Omit<
+    UseQueryOptions<
+      string[],
+      unknown,
+      string[],
+      ReturnType<typeof hcVaultConnectionKeys.listMounts>
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  return useQuery({
+    queryKey: hcVaultConnectionKeys.listMounts(connectionId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<string[]>(
+        `/api/v1/app-connections/hashicorp-vault/${connectionId}/mounts`
+      );
+
+      return data;
+    },
+    ...options
+  });
+};

frontend/src/hooks/api/appConnections/types/app-options.ts

@@ -72,6 +72,10 @@ export type TAuth0ConnectionOption = TAppConnectionOptionBase & {
   app: AppConnection.Auth0;
 };
 
+export type THCVaultConnectionOption = TAppConnectionOptionBase & {
+  app: AppConnection.HCVault;
+};
+
 export type TLdapConnectionOption = TAppConnectionOptionBase & {
   app: AppConnection.LDAP;
 };
@@ -96,6 +100,7 @@ export type TAppConnectionOption =
   | TCamundaConnectionOption
   | TWindmillConnectionOption
   | TAuth0ConnectionOption
+  | THCVaultConnectionOption
   | TTeamCityConnectionOption;
 
 export type TAppConnectionOptionMap = {
@@ -114,6 +119,7 @@ export type TAppConnectionOptionMap = {
   [AppConnection.Camunda]: TCamundaConnectionOption;
   [AppConnection.Windmill]: TWindmillConnectionOption;
   [AppConnection.Auth0]: TAuth0ConnectionOption;
+  [AppConnection.HCVault]: THCVaultConnectionOption;
   [AppConnection.LDAP]: TLdapConnectionOption;
   [AppConnection.TeamCity]: TTeamCityConnectionOption;
 };

frontend/src/hooks/api/appConnections/types/hc-vault-connection.ts

@@ -0,0 +1,27 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { TRootAppConnection } from "@app/hooks/api/appConnections/types/root-connection";
+
+export enum HCVaultConnectionMethod {
+  AccessToken = "access-token",
+  AppRole = "app-role"
+}
+
+export type THCVaultConnection = TRootAppConnection & { app: AppConnection.HCVault } & (
+    | {
+        method: HCVaultConnectionMethod.AccessToken;
+        credentials: {
+          instanceUrl: string;
+          namespace?: string;
+          accessToken: string;
+        };
+      }
+    | {
+        method: HCVaultConnectionMethod.AppRole;
+        credentials: {
+          instanceUrl: string;
+          namespace?: string;
+          roleId: string;
+          secretId: string;
+        };
+      }
+  );

frontend/src/hooks/api/appConnections/types/index.ts

@@ -9,6 +9,7 @@ import { TCamundaConnection } from "./camunda-connection";
 import { TDatabricksConnection } from "./databricks-connection";
 import { TGcpConnection } from "./gcp-connection";
 import { TGitHubConnection } from "./github-connection";
+import { THCVaultConnection } from "./hc-vault-connection";
 import { THumanitecConnection } from "./humanitec-connection";
 import { TLdapConnection } from "./ldap-connection";
 import { TMsSqlConnection } from "./mssql-connection";
@@ -27,6 +28,7 @@ export * from "./camunda-connection";
 export * from "./databricks-connection";
 export * from "./gcp-connection";
 export * from "./github-connection";
+export * from "./hc-vault-connection";
 export * from "./humanitec-connection";
 export * from "./ldap-connection";
 export * from "./mssql-connection";
@@ -52,6 +54,7 @@ export type TAppConnection =
   | TCamundaConnection
   | TWindmillConnection
   | TAuth0Connection
+  | THCVaultConnection
   | TLdapConnection
   | TTeamCityConnection;
 
@@ -96,6 +99,7 @@ export type TAppConnectionMap = {
   [AppConnection.Camunda]: TCamundaConnection;
   [AppConnection.Windmill]: TWindmillConnection;
   [AppConnection.Auth0]: TAuth0Connection;
+  [AppConnection.HCVault]: THCVaultConnection;
   [AppConnection.LDAP]: TLdapConnection;
   [AppConnection.TeamCity]: TTeamCityConnection;
 };

frontend/src/hooks/api/auditLogs/constants.tsx

@@ -94,8 +94,10 @@ export const eventToNameMap: { [K in EventType]: string } = {
     "Create certificate template EST configuration",
   [EventType.UPDATE_CERTIFICATE_TEMPLATE_EST_CONFIG]:
     "Update certificate template EST configuration",
-  [EventType.UPDATE_PROJECT_SLACK_CONFIG]: "Update project slack configuration",
-  [EventType.GET_PROJECT_SLACK_CONFIG]: "Get project slack configuration",
+  [EventType.UPDATE_PROJECT_WORKFLOW_INTEGRATION_CONFIG]:
+    "Update project workflow integration configuration",
+  [EventType.GET_PROJECT_WORKFLOW_INTEGRATION_CONFIG]:
+    "Get project workflow integration configuration",
   [EventType.INTEGRATION_SYNCED]: "Integration sync",
   [EventType.CREATE_SHARED_SECRET]: "Create shared secret",
   [EventType.DELETE_SHARED_SECRET]: "Delete shared secret",
@@ -163,7 +165,22 @@ export const eventToNameMap: { [K in EventType]: string } = {
   [EventType.CREATE_SECRET_ROTATION]: "Create Secret Rotation",
   [EventType.UPDATE_SECRET_ROTATION]: "Update Secret Rotation",
   [EventType.DELETE_SECRET_ROTATION]: "Delete Secret Rotation",
-  [EventType.SECRET_ROTATION_ROTATE_SECRETS]: "Secret Rotation secrets rotated"
+  [EventType.SECRET_ROTATION_ROTATE_SECRETS]: "Secret Rotation secrets rotated",
+
+  [EventType.GET_PROJECT_SLACK_CONFIG]: "Get Project Slack Config",
+  [EventType.UPDATE_PROJECT_SLACK_CONFIG]: "Update Project Slack Config",
+
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CREATE]:
+    "Create Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_DELETE]:
+    "Delete Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_UPDATE]:
+    "Update Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CHECK_INSTALLATION_STATUS]:
+    "Microsoft Teams Workflow Integration Check Installation Status",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET_TEAMS]: "Get Microsoft Teams tenant teams",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET]: "Get Microsoft Teams Workflow Integration",
+  [EventType.MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_LIST]: "List Microsoft Teams Workflow Integration"
 };
 
 export const userAgentTTypeoNameMap: { [K in UserAgentType]: string } = {

frontend/src/hooks/api/auditLogs/enums.tsx

@@ -98,8 +98,8 @@ export enum EventType {
   CREATE_CERTIFICATE_TEMPLATE_EST_CONFIG = "create-certificate-template-est-config",
   UPDATE_CERTIFICATE_TEMPLATE_EST_CONFIG = "update-certificate-template-est-config",
   GET_CERTIFICATE_TEMPLATE_EST_CONFIG = "get-certificate-template-est-config",
-  UPDATE_PROJECT_SLACK_CONFIG = "update-project-slack-config",
-  GET_PROJECT_SLACK_CONFIG = "get-project-slack-config",
+  UPDATE_PROJECT_WORKFLOW_INTEGRATION_CONFIG = "update-project-workflow-integration-config",
+  GET_PROJECT_WORKFLOW_INTEGRATION_CONFIG = "get-project-workflow-integration-config",
   INTEGRATION_SYNCED = "integration-synced",
   CREATE_SHARED_SECRET = "create-shared-secret",
   DELETE_SHARED_SECRET = "delete-shared-secret",
@@ -163,5 +163,16 @@ export enum EventType {
   CREATE_SECRET_ROTATION = "create-secret-rotation",
   UPDATE_SECRET_ROTATION = "update-secret-rotation",
   DELETE_SECRET_ROTATION = "delete-secret-rotation",
-  SECRET_ROTATION_ROTATE_SECRETS = "secret-rotation-rotate-secrets"
+  SECRET_ROTATION_ROTATE_SECRETS = "secret-rotation-rotate-secrets",
+
+  GET_PROJECT_SLACK_CONFIG = "get-project-slack-config",
+  UPDATE_PROJECT_SLACK_CONFIG = "update-project-slack-config",
+
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CREATE = "microsoft-teams-workflow-integration-create",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_DELETE = "microsoft-teams-workflow-integration-delete",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_UPDATE = "microsoft-teams-workflow-integration-update",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_CHECK_INSTALLATION_STATUS = "microsoft-teams-workflow-integration-check-installation-status",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET_TEAMS = "microsoft-teams-workflow-integration-get-teams",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_GET = "microsoft-teams-workflow-integration-get",
+  MICROSOFT_TEAMS_WORKFLOW_INTEGRATION_LIST = "microsoft-teams-workflow-integration-list"
 }

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

@@ -1,6 +1,7 @@
 import { CaStatus } from "../ca";
 import { IdentityTrustedIp } from "../identities/types";
 import { PkiItemType } from "../pkiCollections/constants";
+import { WorkflowIntegration } from "../workflowIntegrations/types";
 import { ActorType, EventType, UserAgentType } from "./enums";
 
 export type TGetAuditLogsFilter = {
@@ -786,11 +787,12 @@ interface GetCertificateTemplateEstConfig {
   };
 }
 
-interface UpdateProjectSlackConfig {
-  type: EventType.UPDATE_PROJECT_SLACK_CONFIG;
+interface UpdateProjectWorkflowIntegrationConfig {
+  type: EventType.UPDATE_PROJECT_WORKFLOW_INTEGRATION_CONFIG;
   metadata: {
     id: string;
-    slackIntegrationId: string;
+    integrationId: string;
+    integration: WorkflowIntegration;
     isAccessRequestNotificationEnabled: boolean;
     accessRequestChannels: string;
     isSecretRequestNotificationEnabled: boolean;
@@ -798,10 +800,11 @@ interface UpdateProjectSlackConfig {
   };
 }
 
-interface GetProjectSlackConfig {
-  type: EventType.GET_PROJECT_SLACK_CONFIG;
+interface GetProjectWorkflowIntegrationConfig {
+  type: EventType.GET_PROJECT_WORKFLOW_INTEGRATION_CONFIG;
   metadata: {
     id: string;
+    integration: WorkflowIntegration;
   };
 }
 
@@ -898,8 +901,8 @@ export type Event =
   | UpdateCertificateTemplateEstConfig
   | CreateCertificateTemplateEstConfig
   | GetCertificateTemplateEstConfig
-  | UpdateProjectSlackConfig
-  | GetProjectSlackConfig
+  | UpdateProjectWorkflowIntegrationConfig
+  | GetProjectWorkflowIntegrationConfig
   | IntegrationSyncedEvent;
 
 export type AuditLog = {

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

@@ -107,6 +107,7 @@ export type CompleteAccountSignupDTO = CompleteAccountDTO & {
   providerAuthToken?: string;
   attributionSource?: string;
   organizationName: string;
+  useDefaultOrg?: boolean;
 };
 
 export type VerifySignupInviteDTO = {

frontend/src/hooks/api/secretSyncs/enums.ts

@@ -11,6 +11,7 @@ export enum SecretSync {
   Camunda = "camunda",
   Vercel = "vercel",
   Windmill = "windmill",
+  HCVault = "hashicorp-vault",
   TeamCity = "teamcity"
 }
 

frontend/src/hooks/api/secretSyncs/types/hc-vault-sync.ts

@@ -0,0 +1,16 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { SecretSync } from "@app/hooks/api/secretSyncs";
+import { TRootSecretSync } from "@app/hooks/api/secretSyncs/types/root-sync";
+
+export type THCVaultSync = TRootSecretSync & {
+  destination: SecretSync.HCVault;
+  destinationConfig: {
+    mount: string;
+    path: string;
+  };
+  connection: {
+    app: AppConnection.HCVault;
+    name: string;
+    id: string;
+  };
+};

frontend/src/hooks/api/secretSyncs/types/index.ts

@@ -9,6 +9,7 @@ import { TCamundaSync } from "./camunda-sync";
 import { TDatabricksSync } from "./databricks-sync";
 import { TGcpSync } from "./gcp-sync";
 import { TGitHubSync } from "./github-sync";
+import { THCVaultSync } from "./hc-vault-sync";
 import { THumanitecSync } from "./humanitec-sync";
 import { TTeamCitySync } from "./teamcity-sync";
 import { TTerraformCloudSync } from "./terraform-cloud-sync";
@@ -34,6 +35,7 @@ export type TSecretSync =
   | TCamundaSync
   | TVercelSync
   | TWindmillSync
+  | THCVaultSync
   | TTeamCitySync;
 
 export type TListSecretSyncs = { secretSyncs: TSecretSync[] };

frontend/src/hooks/api/workflowIntegrations/index.ts

@@ -1,13 +1,2 @@
-export {
-  useDeleteSlackIntegration,
-  useUpdateProjectSlackConfig,
-  useUpdateSlackIntegration
-} from "./mutation";
-export {
-  fetchSlackInstallUrl,
-  fetchSlackReinstallUrl,
-  useGetSlackIntegrationById,
-  useGetSlackIntegrationChannels,
-  useGetSlackIntegrations,
-  useGetWorkflowIntegrations
-} from "./queries";
+export * from "./mutation";
+export * from "./queries";

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

@@ -5,8 +5,13 @@ import { apiRequest } from "@app/config/request";
 import { workspaceKeys } from "../workspace/query-keys";
 import { workflowIntegrationKeys } from "./queries";
 import {
+  TCheckMicrosoftTeamsIntegrationInstallationStatusDTO,
+  TCreateMicrosoftTeamsIntegrationDTO,
+  TDeleteMicrosoftTeamsIntegrationDTO,
+  TDeleteProjectWorkflowIntegrationDTO,
   TDeleteSlackIntegrationDTO,
-  TUpdateProjectSlackConfigDTO,
+  TUpdateMicrosoftTeamsIntegrationDTO,
+  TUpdateProjectWorkflowIntegrationConfigDTO,
   TUpdateSlackIntegrationDTO
 } from "./types";
 
@@ -28,6 +33,47 @@ export const useUpdateSlackIntegration = () => {
   });
 };
 
+export const useUpdateMicrosoftTeamsIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<object, object, TUpdateMicrosoftTeamsIntegrationDTO>({
+    mutationFn: async (dto) => {
+      const { data } = await apiRequest.patch(
+        `/api/v1/workflow-integrations/microsoft-teams/${dto.id}`,
+        dto
+      );
+
+      return data;
+    },
+    onSuccess: (_, { orgId, id }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(id)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};
+export const useCreateMicrosoftTeamsIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<object, object, TCreateMicrosoftTeamsIntegrationDTO>({
+    mutationFn: async (dto) => {
+      const { data } = await apiRequest.post("/api/v1/workflow-integrations/microsoft-teams", dto);
+
+      return data;
+    },
+    onSuccess: (_, { orgId }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};
+
 export const useDeleteSlackIntegration = () => {
   const queryClient = useQueryClient();
 
@@ -44,21 +90,86 @@ export const useDeleteSlackIntegration = () => {
   });
 };
 
-export const useUpdateProjectSlackConfig = () => {
+export const useDeleteMicrosoftTeamsIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<object, object, TDeleteMicrosoftTeamsIntegrationDTO>({
+    mutationFn: async (dto) => {
+      const { data } = await apiRequest.delete(
+        `/api/v1/workflow-integrations/microsoft-teams/${dto.id}`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { orgId, id }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(id)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};
+
+export const useUpdateProjectWorkflowIntegrationConfig = () => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async (dto: TUpdateProjectSlackConfigDTO) => {
+    mutationFn: async (dto: TUpdateProjectWorkflowIntegrationConfigDTO) => {
       const { data } = await apiRequest.put(
-        `/api/v1/workspace/${dto.workspaceId}/slack-config`,
+        `/api/v1/workspace/${dto.workspaceId}/workflow-integration`,
         dto
       );
 
       return data;
     },
-    onSuccess: (_, { workspaceId }) => {
+    onSuccess: (_, { workspaceId, integration }) => {
       queryClient.invalidateQueries({
-        queryKey: workspaceKeys.getWorkspaceSlackConfig(workspaceId)
+        queryKey: workspaceKeys.getWorkspaceWorkflowIntegrationConfig(workspaceId, integration)
       });
     }
   });
 };
+
+export const useDeleteProjectWorkflowIntegration = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: TDeleteProjectWorkflowIntegrationDTO) => {
+      const { data } = await apiRequest.delete(
+        `/api/v1/workspace/${dto.projectId}/workflow-integration/${dto.integration}/${dto.integrationId}`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { projectId, integration }) => {
+      queryClient.invalidateQueries({
+        queryKey: workspaceKeys.getWorkspaceWorkflowIntegrationConfig(projectId, integration)
+      });
+    }
+  });
+};
+
+export const useCheckMicrosoftTeamsIntegrationInstallationStatus = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (dto: TCheckMicrosoftTeamsIntegrationInstallationStatusDTO) => {
+      const { data } = await apiRequest.post(
+        `/api/v1/workflow-integrations/microsoft-teams/${dto.workflowIntegrationId}/installation-status`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { workflowIntegrationId, orgId }) => {
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(workflowIntegrationId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId)
+      });
+      queryClient.invalidateQueries({ queryKey: workflowIntegrationKeys.getIntegrations(orgId) });
+    }
+  });
+};

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

@@ -2,13 +2,29 @@ import { useQuery } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
-import { SlackIntegration, SlackIntegrationChannel, WorkflowIntegration } from "./types";
+import {
+  MicrosoftTeamsIntegration,
+  MicrosoftTeamsIntegrationTeam,
+  SlackIntegration,
+  SlackIntegrationChannel,
+  WorkflowIntegration
+} from "./types";
 
 export const workflowIntegrationKeys = {
   getIntegrations: (orgId?: string) => [{ orgId }, "workflow-integrations"],
   getSlackIntegrations: (orgId?: string) => [{ orgId }, "slack-workflow-integrations"],
   getSlackIntegration: (id?: string) => [{ id }, "slack-workflow-integration"],
-  getSlackIntegrationChannels: (id?: string) => [{ id }, "slack-workflow-integration-channels"]
+  getMicrosoftTeamsIntegrations: (orgId?: string) => [
+    { orgId },
+    "microsoft-teams-workflow-integrations"
+  ],
+  getMicrosoftTeamsIntegration: (id?: string) => [{ id }, "microsoft-teams-workflow-integration"],
+  getMicrosoftTeamsIntegrationTeams: (id?: string) => [
+    { id },
+    "microsoft-teams-workflow-integration-teams"
+  ],
+  getSlackIntegrationChannels: (id?: string) => [{ id }, "slack-workflow-integration-channels"],
+  getMicrosoftTeamsClientId: () => ["microsoft-teams-client-id"]
 };
 
 export const fetchSlackInstallUrl = async ({
@@ -66,13 +82,58 @@ export const fetchWorkflowIntegrations = async () => {
   return data;
 };
 
-export const useGetSlackIntegrations = (orgId?: string) =>
+export const fetchMicrosoftTeamsIntegrations = async () => {
+  const { data } = await apiRequest.get<MicrosoftTeamsIntegration[]>(
+    "/api/v1/workflow-integrations/microsoft-teams"
+  );
+
+  return data;
+};
+
+export const fetchMicrosoftTeamsIntegrationById = async (id?: string) => {
+  const { data } = await apiRequest.get<MicrosoftTeamsIntegration>(
+    `/api/v1/workflow-integrations/microsoft-teams/${id}`
+  );
+
+  return data;
+};
+export const fetchMicrosoftTeamsIntegrationTeams = async (id?: string) => {
+  const { data } = await apiRequest.get<MicrosoftTeamsIntegrationTeam[]>(
+    `/api/v1/workflow-integrations/microsoft-teams/${id}/teams`
+  );
+
+  return data;
+};
+
+export const fetchMicrosoftTeamsClientId = async () => {
+  const { data } = await apiRequest.get<{ clientId: string }>(
+    "/api/v1/workflow-integrations/microsoft-teams/client-id"
+  );
+
+  return data;
+};
+
+export const useGetMicrosoftTeamsIntegrations = (orgId?: string) =>
   useQuery({
-    queryKey: workflowIntegrationKeys.getSlackIntegrations(orgId),
-    queryFn: () => fetchSlackIntegrations(),
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrations(orgId),
+    queryFn: () => fetchMicrosoftTeamsIntegrations(),
     enabled: Boolean(orgId)
   });
 
+export const useGetMicrosoftTeamsIntegrationById = (id?: string) =>
+  useQuery({
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegration(id),
+    queryFn: () => fetchMicrosoftTeamsIntegrationById(id),
+    enabled: Boolean(id)
+  });
+
+export const useGetMicrosoftTeamsIntegrationTeams = (id?: string) =>
+  useQuery({
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsIntegrationTeams(id),
+    queryFn: () => fetchMicrosoftTeamsIntegrationTeams(id),
+    enabled: Boolean(id)
+  });
+
 export const useGetSlackIntegrationById = (id?: string) =>
   useQuery({
     queryKey: workflowIntegrationKeys.getSlackIntegration(id),
@@ -93,3 +154,10 @@ export const useGetWorkflowIntegrations = (id?: string) =>
     queryFn: () => fetchWorkflowIntegrations(),
     enabled: Boolean(id)
   });
+
+export const useGetMicrosoftTeamsClientId = () =>
+  useQuery({
+    queryKey: workflowIntegrationKeys.getMicrosoftTeamsClientId(),
+    queryFn: () => fetchMicrosoftTeamsClientId(),
+    enabled: true
+  });

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

@@ -1,14 +1,25 @@
 export enum WorkflowIntegrationPlatform {
-  SLACK = "slack"
+  SLACK = "slack",
+  MICROSOFT_TEAMS = "microsoft-teams"
 }
 
 export type WorkflowIntegration = {
   id: string;
   slug: string;
   description: string;
+  status: WorkflowIntegrationStatus;
   integration: WorkflowIntegrationPlatform;
 };
 
+export type MicrosoftTeamsIntegrationTeam = {
+  teamId: string;
+  teamName: string;
+  channels: {
+    channelId: string;
+    channelName: string;
+  }[];
+};
+
 export type SlackIntegration = {
   id: string;
   slug: string;
@@ -16,6 +27,18 @@ export type SlackIntegration = {
   teamName: string;
 };
 
+export enum WorkflowIntegrationStatus {
+  Pending = "pending",
+  Installed = "installed"
+}
+
+export type MicrosoftTeamsIntegration = {
+  id: string;
+  slug: string;
+  description: string;
+  tenantId: string;
+};
+
 export type SlackIntegrationChannel = {
   id: string;
   name: string;
@@ -28,25 +51,90 @@ export type TUpdateSlackIntegrationDTO = {
   description?: string;
 };
 
+export type TUpdateMicrosoftTeamsIntegrationDTO = {
+  id: string;
+  orgId: string;
+  slug?: string;
+  description?: string;
+};
+
+export type TCreateMicrosoftTeamsIntegrationDTO = {
+  code: string;
+  tenantId: string;
+  slug: string;
+  description?: string;
+  redirectUri: string;
+  orgId: string;
+};
+
 export type TDeleteSlackIntegrationDTO = {
   id: string;
   orgId: string;
 };
 
-export type ProjectSlackConfig = {
+export type TDeleteMicrosoftTeamsIntegrationDTO = {
   id: string;
-  slackIntegrationId: string;
-  isAccessRequestNotificationEnabled: boolean;
-  accessRequestChannels: string;
-  isSecretRequestNotificationEnabled: boolean;
-  secretRequestChannels: string;
+  orgId: string;
 };
 
-export type TUpdateProjectSlackConfigDTO = {
-  workspaceId: string;
-  slackIntegrationId: string;
-  isAccessRequestNotificationEnabled: boolean;
-  accessRequestChannels: string;
-  isSecretRequestNotificationEnabled: boolean;
-  secretRequestChannels: string;
+export type ProjectWorkflowIntegrationConfig =
+  | {
+      id: string;
+      integration: WorkflowIntegrationPlatform.SLACK;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      accessRequestChannels: string;
+      isSecretRequestNotificationEnabled: boolean;
+      secretRequestChannels: string;
+    }
+  | {
+      id: string;
+      integration: WorkflowIntegrationPlatform.MICROSOFT_TEAMS;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      isSecretRequestNotificationEnabled: boolean;
+      accessRequestChannels: {
+        teamId: string;
+        channelIds: string[];
+      };
+      secretRequestChannels: {
+        teamId: string;
+        channelIds: string[];
+      };
+    };
+
+export type TUpdateProjectWorkflowIntegrationConfigDTO =
+  | {
+      integration: WorkflowIntegrationPlatform.SLACK;
+      workspaceId: string;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      accessRequestChannels: string;
+      isSecretRequestNotificationEnabled: boolean;
+      secretRequestChannels: string;
+    }
+  | {
+      integration: WorkflowIntegrationPlatform.MICROSOFT_TEAMS;
+      workspaceId: string;
+      integrationId: string;
+      isAccessRequestNotificationEnabled: boolean;
+      isSecretRequestNotificationEnabled: boolean;
+      accessRequestChannels?: {
+        teamId: string;
+        channelIds: string[];
+      };
+      secretRequestChannels?: {
+        teamId: string;
+        channelIds: string[];
+      };
+    };
+export type TDeleteProjectWorkflowIntegrationDTO = {
+  projectId: string;
+  integration: WorkflowIntegrationPlatform;
+  integrationId: string;
+};
+
+export type TCheckMicrosoftTeamsIntegrationInstallationStatusDTO = {
+  workflowIntegrationId: string;
+  orgId: string;
 };

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

@@ -26,9 +26,9 @@ export {
   useGetWorkspaceIndexStatus,
   useGetWorkspaceIntegrations,
   useGetWorkspaceSecrets,
-  useGetWorkspaceSlackConfig,
   useGetWorkspaceUserDetails,
   useGetWorkspaceUsers,
+  useGetWorkspaceWorkflowIntegrationConfig,
   useListWorkspaceCas,
   useListWorkspaceCertificates,
   useListWorkspaceCertificateTemplates,

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

@@ -21,7 +21,10 @@ import { TSshHost } from "../sshHost/types";
 import { TSshHostGroup } from "../sshHostGroup/types";
 import { userKeys } from "../users/query-keys";
 import { TWorkspaceUser } from "../users/types";
-import { ProjectSlackConfig } from "../workflowIntegrations/types";
+import {
+  ProjectWorkflowIntegrationConfig,
+  WorkflowIntegrationPlatform
+} from "../workflowIntegrations/types";
 import { workspaceKeys } from "./query-keys";
 import {
   CreateEnvironmentDTO,
@@ -899,13 +902,27 @@ export const useListWorkspaceSshCertificateTemplates = (projectId: string) => {
   });
 };
 
-export const useGetWorkspaceSlackConfig = ({ workspaceId }: { workspaceId: string }) => {
+export const useGetWorkspaceWorkflowIntegrationConfig = ({
+  workspaceId,
+  integration
+}: {
+  workspaceId: string;
+  integration: WorkflowIntegrationPlatform;
+}) => {
   return useQuery({
-    queryKey: workspaceKeys.getWorkspaceSlackConfig(workspaceId),
+    queryKey: workspaceKeys.getWorkspaceWorkflowIntegrationConfig(workspaceId, integration),
     queryFn: async () => {
-      const { data } = await apiRequest.get<ProjectSlackConfig>(
-        `/api/v1/workspace/${workspaceId}/slack-config`
-      );
+      const { data } = await apiRequest
+        .get<ProjectWorkflowIntegrationConfig>(
+          `/api/v1/workspace/${workspaceId}/workflow-integration-config/${integration}`
+        )
+        .catch((err) => {
+          if (err.response.status === 404) {
+            return { data: null };
+          }
+
+          throw err;
+        });
 
       return data;
     },

frontend/src/hooks/api/workspace/query-keys.tsx

@@ -1,6 +1,7 @@
 import { TListProjectIdentitiesDTO, TSearchProjectsDTO } from "@app/hooks/api/workspace/types";
 
 import type { CaStatus } from "../ca";
+import { WorkflowIntegrationPlatform } from "../workflowIntegrations/types";
 
 export const workspaceKeys = {
   getWorkspaceById: (workspaceId: string) => ["workspaces", { workspaceId }] as const,
@@ -54,8 +55,10 @@ export const workspaceKeys = {
     [{ workspaceId }, "workspace-pki-collections"] as const,
   getWorkspaceCertificateTemplates: (workspaceId: string) =>
     [{ workspaceId }, "workspace-certificate-templates"] as const,
-  getWorkspaceSlackConfig: (workspaceId: string) =>
-    [{ workspaceId }, "workspace-slack-config"] as const,
+  getWorkspaceWorkflowIntegrationConfig: (
+    workspaceId: string,
+    integration: WorkflowIntegrationPlatform
+  ) => [{ workspaceId, integration }, "workspace-workflow-integration-config"] as const,
   getWorkspaceSshCas: (projectId: string) => [{ projectId }, "workspace-ssh-cas"] as const,
   allWorkspaceSshCertificates: (projectId: string) =>
     [{ projectId }, "workspace-ssh-certificates"] as const,