Merge branch 'main' into feat/remindersImprovement

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

@@ -170,7 +170,7 @@ export type TCreateAccessPolicyDTO = {
   approvers?: Approver[];
   bypassers?: Bypasser[];
   approvals?: number;
-  secretPath?: string;
+  secretPath: string;
   enforcementLevel?: EnforcementLevel;
   allowedSelfApprovals: boolean;
   approvalsRequired?: { numberOfApprovals: number; stepNumber: number }[];

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

@@ -10,6 +10,7 @@ import {
   AdminGetUsersFilters,
   AdminIntegrationsConfig,
   OrganizationWithProjects,
+  TGetEnvOverrides,
   TGetInvalidatingCacheStatus,
   TGetServerRootKmsEncryptionDetails,
   TServerConfig
@@ -31,7 +32,8 @@ export const adminQueryKeys = {
   getAdminSlackConfig: () => ["admin-slack-config"] as const,
   getServerEncryptionStrategies: () => ["server-encryption-strategies"] as const,
   getInvalidateCache: () => ["admin-invalidate-cache"] as const,
-  getAdminIntegrationsConfig: () => ["admin-integrations-config"] as const
+  getAdminIntegrationsConfig: () => ["admin-integrations-config"] as const,
+  getEnvOverrides: () => ["env-overrides"] as const
 };
 
 export const fetchServerConfig = async () => {
@@ -163,3 +165,13 @@ export const useGetInvalidatingCacheStatus = (enabled = true) => {
     refetchInterval: (data) => (data ? 3000 : false)
   });
 };
+
+export const useGetEnvOverrides = () => {
+  return useQuery({
+    queryKey: adminQueryKeys.getEnvOverrides(),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<TGetEnvOverrides>("/api/v1/admin/env-overrides");
+      return data;
+    }
+  });
+};

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

@@ -40,6 +40,7 @@ export type TServerConfig = {
   trustLdapEmails: boolean;
   trustOidcEmails: boolean;
   isSecretScanningDisabled: boolean;
+  kubernetesAutoFetchServiceAccountToken: boolean;
   defaultAuthOrgSlug: string | null;
   defaultAuthOrgId: string | null;
   defaultAuthOrgAuthMethod?: string | null;
@@ -48,6 +49,7 @@ export type TServerConfig = {
   authConsentContent?: string;
   pageFrameContent?: string;
   invalidatingCache: boolean;
+  envOverrides?: Record<string, string>;
 };
 
 export type TUpdateServerConfigDTO = {
@@ -61,6 +63,7 @@ export type TUpdateServerConfigDTO = {
   gitHubAppConnectionSlug?: string;
   gitHubAppConnectionId?: string;
   gitHubAppConnectionPrivateKey?: string;
+  envOverrides?: Record<string, string>;
 } & Partial<TServerConfig>;
 
 export type TCreateAdminUserDTO = {
@@ -138,3 +141,10 @@ export type TInvalidateCacheDTO = {
 export type TGetInvalidatingCacheStatus = {
   invalidating: boolean;
 };
+
+export interface TGetEnvOverrides {
+  [key: string]: {
+    name: string;
+    fields: { key: string; value: string; hasEnvEntry: boolean; description?: string }[];
+  };
+}

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

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

frontend/src/hooks/api/appConnections/bitbucket/queries.tsx

@@ -0,0 +1,70 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { appConnectionKeys } from "../queries";
+import {
+  TBitbucketConnectionListRepositoriesResponse,
+  TBitbucketConnectionListWorkspacesResponse,
+  TBitbucketRepo,
+  TBitbucketWorkspace
+} from "./types";
+
+const bitbucketConnectionKeys = {
+  all: [...appConnectionKeys.all, "bitbucket"] as const,
+  listRepos: (connectionId: string, workspaceSlug: string) =>
+    [...bitbucketConnectionKeys.all, "repos", connectionId, workspaceSlug] as const,
+  listWorkspaces: (connectionId: string) =>
+    [...bitbucketConnectionKeys.all, "workspaces", connectionId] as const
+};
+
+export const useBitbucketConnectionListWorkspaces = (
+  connectionId: string,
+  options?: Omit<
+    UseQueryOptions<
+      TBitbucketWorkspace[],
+      unknown,
+      TBitbucketWorkspace[],
+      ReturnType<typeof bitbucketConnectionKeys.listWorkspaces>
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  return useQuery({
+    queryKey: bitbucketConnectionKeys.listWorkspaces(connectionId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<TBitbucketConnectionListWorkspacesResponse>(
+        `/api/v1/app-connections/bitbucket/${connectionId}/workspaces`
+      );
+
+      return data.workspaces;
+    },
+    ...options
+  });
+};
+
+export const useBitbucketConnectionListRepositories = (
+  connectionId: string,
+  workspaceSlug: string,
+  options?: Omit<
+    UseQueryOptions<
+      TBitbucketRepo[],
+      unknown,
+      TBitbucketRepo[],
+      ReturnType<typeof bitbucketConnectionKeys.listRepos>
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  return useQuery({
+    queryKey: bitbucketConnectionKeys.listRepos(connectionId, workspaceSlug),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<TBitbucketConnectionListRepositoriesResponse>(
+        `/api/v1/app-connections/bitbucket/${connectionId}/repositories?workspaceSlug=${encodeURIComponent(workspaceSlug)}`
+      );
+
+      return data.repositories;
+    },
+    ...options
+  });
+};

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

@@ -0,0 +1,17 @@
+export type TBitbucketWorkspace = {
+  slug: string;
+};
+
+export type TBitbucketRepo = {
+  uuid: string;
+  slug: string;
+  full_name: string; // workspace-slug/repo-slug
+};
+
+export type TBitbucketConnectionListWorkspacesResponse = {
+  workspaces: TBitbucketWorkspace[];
+};
+
+export type TBitbucketConnectionListRepositoriesResponse = {
+  repositories: TBitbucketRepo[];
+};

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

@@ -27,5 +27,8 @@ export enum AppConnection {
   Render = "render",
   Flyio = "flyio",
   Gitlab = "gitlab",
-  Cloudflare = "cloudflare"
+  Cloudflare = "cloudflare",
+  Bitbucket = "bitbucket",
+  Zabbix = "zabbix",
+  Railway = "railway"
 }

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

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

frontend/src/hooks/api/appConnections/railway/queries.tsx

@@ -0,0 +1,37 @@
+import { useQuery, UseQueryOptions } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+import { appConnectionKeys } from "@app/hooks/api/appConnections";
+
+import { TRailwayProject } from "./types";
+
+const railwayConnectionKeys = {
+  all: [...appConnectionKeys.all, "railway"] as const,
+  listSecretScopes: (connectionId: string) =>
+    [...railwayConnectionKeys.all, "workspace-scopes", connectionId] as const
+};
+
+export const useRailwayConnectionListProjects = (
+  connectionId: string,
+  options?: Omit<
+    UseQueryOptions<
+      TRailwayProject[],
+      unknown,
+      TRailwayProject[],
+      ReturnType<typeof railwayConnectionKeys.listSecretScopes>
+    >,
+    "queryKey" | "queryFn"
+  >
+) => {
+  return useQuery({
+    queryKey: railwayConnectionKeys.listSecretScopes(connectionId),
+    queryFn: async () => {
+      const { data } = await apiRequest.get<{ projects: TRailwayProject[] }>(
+        `/api/v1/app-connections/railway/${connectionId}/projects`
+      );
+
+      return data.projects;
+    },
+    ...options
+  });
+};

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

@@ -0,0 +1,12 @@
+export type TRailwayProject = {
+  id: string;
+  name: string;
+  environments: Array<{
+    id: string;
+    name: string;
+  }>;
+  services: Array<{
+    id: string;
+    name: string;
+  }>;
+};

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

@@ -132,6 +132,18 @@ export type TCloudflareConnectionOption = TAppConnectionOptionBase & {
   app: AppConnection.Cloudflare;
 };
 
+export type TBitbucketConnectionOption = TAppConnectionOptionBase & {
+  app: AppConnection.Bitbucket;
+};
+
+export type TZabbixConnectionOption = TAppConnectionOptionBase & {
+  app: AppConnection.Zabbix;
+};
+
+export type TRailwayConnectionOption = TAppConnectionOptionBase & {
+  app: AppConnection.Railway;
+};
+
 export type TAppConnectionOption =
   | TAwsConnectionOption
   | TGitHubConnectionOption
@@ -159,7 +171,10 @@ export type TAppConnectionOption =
   | TRenderConnectionOption
   | TFlyioConnectionOption
   | TGitlabConnectionOption
-  | TCloudflareConnectionOption;
+  | TCloudflareConnectionOption
+  | TBitbucketConnectionOption
+  | TZabbixConnectionOption
+  | TRailwayConnectionOption;
 
 export type TAppConnectionOptionMap = {
   [AppConnection.AWS]: TAwsConnectionOption;
@@ -191,4 +206,7 @@ export type TAppConnectionOptionMap = {
   [AppConnection.Flyio]: TFlyioConnectionOption;
   [AppConnection.Gitlab]: TGitlabConnectionOption;
   [AppConnection.Cloudflare]: TCloudflareConnectionOption;
+  [AppConnection.Bitbucket]: TBitbucketConnectionOption;
+  [AppConnection.Zabbix]: TZabbixConnectionOption;
+  [AppConnection.Railway]: TRailwayConnectionOption;
 };

frontend/src/hooks/api/appConnections/types/bitbucket-connection.ts

@@ -0,0 +1,14 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { TRootAppConnection } from "@app/hooks/api/appConnections/types/root-connection";
+
+export enum BitbucketConnectionMethod {
+  ApiToken = "api-token"
+}
+
+export type TBitbucketConnection = TRootAppConnection & { app: AppConnection.Bitbucket } & {
+  method: BitbucketConnectionMethod.ApiToken;
+  credentials: {
+    email: string;
+    apiToken: string;
+  };
+};

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

@@ -7,6 +7,7 @@ import { TAzureAppConfigurationConnection } from "./azure-app-configuration-conn
 import { TAzureClientSecretsConnection } from "./azure-client-secrets-connection";
 import { TAzureDevOpsConnection } from "./azure-devops-connection";
 import { TAzureKeyVaultConnection } from "./azure-key-vault-connection";
+import { TBitbucketConnection } from "./bitbucket-connection";
 import { TCamundaConnection } from "./camunda-connection";
 import { TCloudflareConnection } from "./cloudflare-connection";
 import { TDatabricksConnection } from "./databricks-connection";
@@ -24,11 +25,13 @@ import { TMySqlConnection } from "./mysql-connection";
 import { TOCIConnection } from "./oci-connection";
 import { TOracleDBConnection } from "./oracledb-connection";
 import { TPostgresConnection } from "./postgres-connection";
+import { TRailwayConnection } from "./railway-connection";
 import { TRenderConnection } from "./render-connection";
 import { TTeamCityConnection } from "./teamcity-connection";
 import { TTerraformCloudConnection } from "./terraform-cloud-connection";
 import { TVercelConnection } from "./vercel-connection";
 import { TWindmillConnection } from "./windmill-connection";
+import { TZabbixConnection } from "./zabbix-connection";
 
 export * from "./1password-connection";
 export * from "./auth0-connection";
@@ -37,6 +40,7 @@ export * from "./azure-app-configuration-connection";
 export * from "./azure-client-secrets-connection";
 export * from "./azure-devops-connection";
 export * from "./azure-key-vault-connection";
+export * from "./bitbucket-connection";
 export * from "./camunda-connection";
 export * from "./cloudflare-connection";
 export * from "./databricks-connection";
@@ -59,6 +63,7 @@ export * from "./teamcity-connection";
 export * from "./terraform-cloud-connection";
 export * from "./vercel-connection";
 export * from "./windmill-connection";
+export * from "./zabbix-connection";
 
 export type TAppConnection =
   | TAwsConnection
@@ -89,7 +94,10 @@ export type TAppConnection =
   | TRenderConnection
   | TFlyioConnection
   | TGitLabConnection
-  | TCloudflareConnection;
+  | TCloudflareConnection
+  | TBitbucketConnection
+  | TZabbixConnection
+  | TRailwayConnection;
 
 export type TAvailableAppConnection = Pick<TAppConnection, "name" | "id">;
 
@@ -146,4 +154,7 @@ export type TAppConnectionMap = {
   [AppConnection.Flyio]: TFlyioConnection;
   [AppConnection.Gitlab]: TGitLabConnection;
   [AppConnection.Cloudflare]: TCloudflareConnection;
+  [AppConnection.Bitbucket]: TBitbucketConnection;
+  [AppConnection.Zabbix]: TZabbixConnection;
+  [AppConnection.Railway]: TRailwayConnection;
 };

frontend/src/hooks/api/appConnections/types/railway-connection.ts

@@ -0,0 +1,15 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { TRootAppConnection } from "@app/hooks/api/appConnections/types/root-connection";
+
+export enum RailwayConnectionMethod {
+  AccountToken = "account-token",
+  ProjectToken = "project-token",
+  TeamToken = "team-token"
+}
+
+export type TRailwayConnection = TRootAppConnection & { app: AppConnection.Railway } & {
+  method: RailwayConnectionMethod;
+  credentials: {
+    apiToken: string;
+  };
+};

frontend/src/hooks/api/appConnections/types/zabbix-connection.ts

@@ -0,0 +1,14 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+import { TRootAppConnection } from "@app/hooks/api/appConnections/types/root-connection";
+
+export enum ZabbixConnectionMethod {
+  ApiToken = "api-token"
+}
+
+export type TZabbixConnection = TRootAppConnection & { app: AppConnection.Zabbix } & {
+  method: ZabbixConnectionMethod.ApiToken;
+  credentials: {
+    apiToken: string;
+    instanceUrl: string;
+  };
+};

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

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

frontend/src/hooks/api/appConnections/zabbix/queries.tsx

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

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

@@ -0,0 +1,25 @@
+export type TZabbixHost = {
+  host: string;
+  hostId: string;
+};
+
+export enum ZabbixSyncScope {
+  Host = "host",
+  Global = "global"
+}
+
+export enum ZabbixMacroType {
+  Text = 0,
+  Secret = 1
+}
+
+export const ZABBIX_SYNC_SCOPES = {
+  [ZabbixSyncScope.Host]: {
+    name: "Host",
+    description: "Sync secrets to a specific host in Zabbix."
+  },
+  [ZabbixSyncScope.Global]: {
+    name: "Global",
+    description: "Sync secrets to a global scope in Zabbix."
+  }
+};

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

@@ -30,8 +30,8 @@ export const useGetAuditLogs = (
             params: {
               ...filters,
               offset: pageParam,
-              startDate: filters?.startDate?.toISOString(),
-              endDate: filters?.endDate?.toISOString(),
+              startDate: filters.startDate.toISOString(),
+              endDate: filters.endDate.toISOString(),
               ...(filters.eventMetadata && Object.keys(filters.eventMetadata).length
                 ? {
                     eventMetadata: Object.entries(filters.eventMetadata)

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

@@ -14,8 +14,8 @@ export type TGetAuditLogsFilter = {
   actor?: string; // user ID format
   secretPath?: string;
   secretKey?: string;
-  startDate?: Date;
-  endDate?: Date;
+  startDate: Date;
+  endDate: Date;
   limit: number;
 };
 

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

@@ -54,7 +54,8 @@ export enum SqlProviders {
 
 export enum DynamicSecretAwsIamAuth {
   AssumeRole = "assume-role",
-  AccessKey = "access-key"
+  AccessKey = "access-key",
+  IRSA = "irsa"
 }
 
 export type TDynamicSecretProvider =
@@ -111,6 +112,14 @@ export type TDynamicSecretProvider =
             policyDocument?: string;
             userGroups?: string;
             policyArns?: string;
+          }
+        | {
+            method: DynamicSecretAwsIamAuth.IRSA;
+            region: string;
+            awsPath?: string;
+            policyDocument?: string;
+            userGroups?: string;
+            policyArns?: string;
           };
     }
   | {

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

@@ -4,7 +4,7 @@ export {
   useDeleteIntegrationAuth,
   useDeleteIntegrationAuths,
   useGetIntegrationAuthApps,
-  useGetIntegrationAuthBitBucketWorkspaces,
+  useGetIntegrationAuthBitbucketWorkspaces,
   useGetIntegrationAuthById,
   useGetIntegrationAuthChecklyGroups,
   useGetIntegrationAuthCircleCIOrganizations,

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

@@ -6,8 +6,8 @@ import { TReactQueryOptions } from "@app/types/reactQuery";
 import { workspaceKeys } from "../workspace";
 import {
   App,
-  BitBucketEnvironment,
-  BitBucketWorkspace,
+  BitbucketEnvironment,
+  BitbucketWorkspace,
   ChecklyGroup,
   CircleCIOrganization,
   Environment,
@@ -98,9 +98,9 @@ const integrationAuthKeys = {
     integrationAuthId: string;
     appId: string;
   }) => [{ integrationAuthId, appId }, "integrationAuthRailwayServices"] as const,
-  getIntegrationAuthBitBucketWorkspaces: (integrationAuthId: string) =>
+  getIntegrationAuthBitbucketWorkspaces: (integrationAuthId: string) =>
     [{ integrationAuthId }, "integrationAuthBitbucketWorkspaces"] as const,
-  getIntegrationAuthBitBucketEnvironments: (
+  getIntegrationAuthBitbucketEnvironments: (
     integrationAuthId: string,
     workspaceSlug: string,
     repoSlug: string
@@ -446,23 +446,23 @@ const fetchIntegrationAuthRailwayServices = async ({
   return services;
 };
 
-const fetchIntegrationAuthBitBucketWorkspaces = async (integrationAuthId: string) => {
+const fetchIntegrationAuthBitbucketWorkspaces = async (integrationAuthId: string) => {
   const {
     data: { workspaces }
-  } = await apiRequest.get<{ workspaces: BitBucketWorkspace[] }>(
+  } = await apiRequest.get<{ workspaces: BitbucketWorkspace[] }>(
     `/api/v1/integration-auth/${integrationAuthId}/bitbucket/workspaces`
   );
   return workspaces;
 };
 
-const fetchIntegrationAuthBitBucketEnvironments = async (
+const fetchIntegrationAuthBitbucketEnvironments = async (
   integrationAuthId: string,
   workspaceSlug: string,
   repoSlug: string
 ) => {
   const {
     data: { environments }
-  } = await apiRequest.get<{ environments: BitBucketEnvironment[] }>(
+  } = await apiRequest.get<{ environments: BitbucketEnvironment[] }>(
     `/api/v1/integration-auth/${integrationAuthId}/bitbucket/environments`,
     {
       params: {
@@ -833,10 +833,10 @@ export const useGetIntegrationAuthRailwayServices = ({
   });
 };
 
-export const useGetIntegrationAuthBitBucketWorkspaces = (integrationAuthId: string) => {
+export const useGetIntegrationAuthBitbucketWorkspaces = (integrationAuthId: string) => {
   return useQuery({
-    queryKey: integrationAuthKeys.getIntegrationAuthBitBucketWorkspaces(integrationAuthId),
-    queryFn: () => fetchIntegrationAuthBitBucketWorkspaces(integrationAuthId),
+    queryKey: integrationAuthKeys.getIntegrationAuthBitbucketWorkspaces(integrationAuthId),
+    queryFn: () => fetchIntegrationAuthBitbucketWorkspaces(integrationAuthId),
     enabled: true
   });
 };
@@ -858,7 +858,7 @@ export const useGetIntegrationAuthOctopusDeployScopeValues = (
     ...options
   });
 
-export const useGetIntegrationAuthBitBucketEnvironments = (
+export const useGetIntegrationAuthBitbucketEnvironments = (
   {
     integrationAuthId,
     workspaceSlug,
@@ -871,13 +871,13 @@ export const useGetIntegrationAuthBitBucketEnvironments = (
   options?: TReactQueryOptions["options"]
 ) => {
   return useQuery({
-    queryKey: integrationAuthKeys.getIntegrationAuthBitBucketEnvironments(
+    queryKey: integrationAuthKeys.getIntegrationAuthBitbucketEnvironments(
       integrationAuthId,
       workspaceSlug,
       repoSlug
     ),
     queryFn: () =>
-      fetchIntegrationAuthBitBucketEnvironments(integrationAuthId, workspaceSlug, repoSlug),
+      fetchIntegrationAuthBitbucketEnvironments(integrationAuthId, workspaceSlug, repoSlug),
     ...options
   });
 };

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

@@ -78,13 +78,13 @@ export type Service = {
   serviceId: string;
 };
 
-export type BitBucketWorkspace = {
+export type BitbucketWorkspace = {
   uuid: string;
   name: string;
   slug: string;
 };
 
-export type BitBucketEnvironment = {
+export type BitbucketEnvironment = {
   uuid: string;
   name: string;
   slug: string;

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

@@ -21,7 +21,7 @@ export const useUpdateOIDCConfig = () => {
       clientId,
       clientSecret,
       isActive,
-      orgSlug,
+      organizationId,
       manageGroupMemberships,
       jwtSignatureAlgorithm
     }: {
@@ -36,7 +36,7 @@ export const useUpdateOIDCConfig = () => {
       clientSecret?: string;
       isActive?: boolean;
       configurationType?: string;
-      orgSlug: string;
+      organizationId: string;
       manageGroupMemberships?: boolean;
       jwtSignatureAlgorithm?: OIDCJWTSignatureAlgorithm;
     }) => {
@@ -50,7 +50,7 @@ export const useUpdateOIDCConfig = () => {
         tokenEndpoint,
         userinfoEndpoint,
         clientId,
-        orgSlug,
+        organizationId,
         clientSecret,
         isActive,
         manageGroupMemberships,
@@ -60,7 +60,7 @@ export const useUpdateOIDCConfig = () => {
       return data;
     },
     onSuccess(_, dto) {
-      queryClient.invalidateQueries({ queryKey: oidcConfigKeys.getOIDCConfig(dto.orgSlug) });
+      queryClient.invalidateQueries({ queryKey: oidcConfigKeys.getOIDCConfig(dto.organizationId) });
       queryClient.invalidateQueries({ queryKey: organizationKeys.getUserOrganizations });
     }
   });
@@ -81,7 +81,7 @@ export const useCreateOIDCConfig = () => {
       clientId,
       clientSecret,
       isActive,
-      orgSlug,
+      organizationId,
       manageGroupMemberships,
       jwtSignatureAlgorithm
     }: {
@@ -95,7 +95,7 @@ export const useCreateOIDCConfig = () => {
       clientId: string;
       clientSecret: string;
       isActive: boolean;
-      orgSlug: string;
+      organizationId: string;
       allowedEmailDomains?: string;
       manageGroupMemberships?: boolean;
       jwtSignatureAlgorithm?: OIDCJWTSignatureAlgorithm;
@@ -112,7 +112,7 @@ export const useCreateOIDCConfig = () => {
         clientId,
         clientSecret,
         isActive,
-        orgSlug,
+        organizationId,
         manageGroupMemberships,
         jwtSignatureAlgorithm
       });
@@ -120,7 +120,7 @@ export const useCreateOIDCConfig = () => {
       return data;
     },
     onSuccess(_, dto) {
-      queryClient.invalidateQueries({ queryKey: oidcConfigKeys.getOIDCConfig(dto.orgSlug) });
+      queryClient.invalidateQueries({ queryKey: oidcConfigKeys.getOIDCConfig(dto.organizationId) });
     }
   });
 };

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

@@ -5,18 +5,18 @@ import { apiRequest } from "@app/config/request";
 import { OIDCConfigData } from "./types";
 
 export const oidcConfigKeys = {
-  getOIDCConfig: (orgSlug: string) => [{ orgSlug }, "organization-oidc"] as const,
+  getOIDCConfig: (orgId: string) => [{ orgId }, "organization-oidc"] as const,
   getOIDCManageGroupMembershipsEnabled: (orgId: string) =>
     ["oidc-manage-group-memberships", orgId] as const
 };
 
-export const useGetOIDCConfig = (orgSlug: string) => {
+export const useGetOIDCConfig = (orgId: string) => {
   return useQuery({
-    queryKey: oidcConfigKeys.getOIDCConfig(orgSlug),
+    queryKey: oidcConfigKeys.getOIDCConfig(orgId),
     queryFn: async () => {
       try {
         const { data } = await apiRequest.get<OIDCConfigData>(
-          `/api/v1/sso/oidc/config?orgSlug=${orgSlug}`
+          `/api/v1/sso/oidc/config?organizationId=${orgId}`
         );
 
         return data;

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

@@ -49,7 +49,7 @@ export type TCreateSecretPolicyDTO = {
   workspaceId: string;
   name?: string;
   environment: string;
-  secretPath?: string | null;
+  secretPath: string;
   approvers?: Approver[];
   bypassers?: Bypasser[];
   approvals?: number;
@@ -62,7 +62,7 @@ export type TUpdateSecretPolicyDTO = {
   name?: string;
   approvers?: Approver[];
   bypassers?: Bypasser[];
-  secretPath?: string | null;
+  secretPath?: string;
   approvals?: number;
   allowedSelfApprovals?: boolean;
   enforcementLevel?: EnforcementLevel;

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

@@ -1,5 +1,6 @@
 export enum SecretScanningDataSource {
-  GitHub = "github"
+  GitHub = "github",
+  Bitbucket = "bitbucket"
 }
 
 export enum SecretScanningScanStatus {

frontend/src/hooks/api/secretScanningV2/types/bitbucket-data-source.ts

@@ -0,0 +1,18 @@
+import { AppConnection } from "@app/hooks/api/appConnections/enums";
+
+import { SecretScanningDataSource } from "../enums";
+import { TSecretScanningDataSourceBase } from "./shared";
+
+export type TBitbucketDataSource = TSecretScanningDataSourceBase & {
+  type: SecretScanningDataSource.Bitbucket;
+  config: {
+    workspaceSlug: string;
+    includeRepos: string[];
+  };
+};
+
+export type TBitbucketDataSourceOption = {
+  name: string;
+  type: SecretScanningDataSource.Bitbucket;
+  connection: AppConnection.Bitbucket;
+};

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

@@ -8,9 +8,10 @@ import {
   SecretScanningScanStatus,
   SecretScanningScanType
 } from "../enums";
+import { TBitbucketDataSource, TBitbucketDataSourceOption } from "./bitbucket-data-source";
 import { TGitHubDataSource, TGitHubDataSourceOption } from "./github-data-source";
 
-export type TSecretScanningDataSource = TGitHubDataSource;
+export type TSecretScanningDataSource = TGitHubDataSource | TBitbucketDataSource;
 
 export type TSecretScanningDataSourceWithDetails = TSecretScanningDataSource & {
   lastScannedAt: string | null;
@@ -23,7 +24,7 @@ export type TListSecretScanningDataSources = {
   dataSources: TSecretScanningDataSourceWithDetails[];
 };
 
-export type TSecretScanningDataSourceOption = TGitHubDataSourceOption;
+export type TSecretScanningDataSourceOption = TGitHubDataSourceOption | TBitbucketDataSourceOption;
 
 export type TListSecretScanningDataSourceOptions = {
   dataSourceOptions: TSecretScanningDataSourceOption[];

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

@@ -20,7 +20,9 @@ export enum SecretSync {
   Render = "render",
   Flyio = "flyio",
   GitLab = "gitlab",
-  CloudflarePages = "cloudflare-pages"
+  CloudflarePages = "cloudflare-pages",
+  Zabbix = "zabbix",
+  Railway = "railway"
 }
 
 export enum SecretSyncStatus {

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

@@ -19,10 +19,12 @@ import { THCVaultSync } from "./hc-vault-sync";
 import { THerokuSync } from "./heroku-sync";
 import { THumanitecSync } from "./humanitec-sync";
 import { TOCIVaultSync } from "./oci-vault-sync";
+import { TRailwaySync } from "./railway-sync";
 import { TTeamCitySync } from "./teamcity-sync";
 import { TTerraformCloudSync } from "./terraform-cloud-sync";
 import { TVercelSync } from "./vercel-sync";
 import { TWindmillSync } from "./windmill-sync";
+import { TZabbixSync } from "./zabbix-sync";
 
 export type TSecretSyncOption = {
   name: string;
@@ -53,7 +55,9 @@ export type TSecretSync =
   | TRenderSync
   | TFlyioSync
   | TGitLabSync
-  | TCloudflarePagesSync;
+  | TCloudflarePagesSync
+  | TZabbixSync
+  | TRailwaySync;
 
 export type TListSecretSyncs = { secretSyncs: TSecretSync[] };
 

frontend/src/hooks/api/secretSyncs/types/railway-sync.ts

@@ -0,0 +1,22 @@
+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 TRailwaySync = TRootSecretSync & {
+  destination: SecretSync.Railway;
+  destinationConfig: {
+    projectId: string;
+    projectName: string;
+
+    environmentName: string;
+    environmentId: string;
+
+    serviceId?: string;
+    serviceName?: string;
+  };
+  connection: {
+    app: AppConnection.Railway;
+    name: string;
+    id: string;
+  };
+};

frontend/src/hooks/api/secretSyncs/types/zabbix-sync.ts

@@ -0,0 +1,25 @@
+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";
+
+import { ZabbixSyncScope } from "../../appConnections/zabbix";
+
+export type TZabbixSync = TRootSecretSync & {
+  destination: SecretSync.Zabbix;
+  destinationConfig:
+    | {
+        scope: ZabbixSyncScope.Host;
+        hostId: string;
+        hostName: string;
+        macroType: number;
+      }
+    | {
+        scope: ZabbixSyncScope.Global;
+        macroType: number;
+      };
+  connection: {
+    app: AppConnection.Zabbix;
+    name: string;
+    id: string;
+  };
+};

frontend/src/hooks/index.ts

@@ -5,6 +5,7 @@ export { usePagination } from "./usePagination";
 export { usePersistentState } from "./usePersistentState";
 export { usePopUp } from "./usePopUp";
 export { useResetPageHelper } from "./useResetPageHelper";
+export * from "./useResizableHeaderHeight";
 export { useSyntaxHighlight } from "./useSyntaxHighlight";
 export { useTimedReset } from "./useTimedReset";
 export { useToggle } from "./useToggle";

frontend/src/hooks/useResizableHeaderHeight.tsx

@@ -0,0 +1,71 @@
+import { MouseEvent, useCallback, useEffect, useRef, useState } from "react";
+
+type Params = {
+  minHeight: number;
+  maxHeight: number;
+  initialHeight: number;
+};
+
+export const useResizableHeaderHeight = ({ minHeight, maxHeight, initialHeight }: Params) => {
+  const [headerHeight, setHeaderHeight] = useState(initialHeight);
+  const [isResizing, setIsResizing] = useState(false);
+  const startY = useRef(0);
+  const startHeight = useRef(0);
+
+  const handleMouseDown = useCallback(
+    (e: MouseEvent<HTMLDivElement>) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setIsResizing(true);
+      startY.current = e.clientY;
+      startHeight.current = headerHeight;
+    },
+    [headerHeight]
+  );
+
+  const handleMouseMove = useCallback(
+    (e: MouseEvent) => {
+      if (!isResizing) return;
+
+      const deltaY = e.clientY - startY.current;
+      const newHeight = Math.max(minHeight, Math.min(maxHeight, startHeight.current + deltaY));
+
+      setHeaderHeight(newHeight);
+    },
+    [isResizing]
+  );
+
+  const handleMouseUp = useCallback(() => {
+    setIsResizing(false);
+  }, []);
+
+  useEffect(() => {
+    if (isResizing) {
+      document.addEventListener(
+        "mousemove",
+        // @ts-expect-error native discrepancy
+        handleMouseMove
+      );
+      document.addEventListener("mouseup", handleMouseUp);
+      document.body.style.cursor = "ns-resize";
+      document.body.style.userSelect = "none";
+    }
+
+    return () => {
+      document.removeEventListener(
+        "mousemove",
+        // @ts-expect-error native discrepancy
+        handleMouseMove
+      );
+      document.removeEventListener("mouseup", handleMouseUp);
+      document.body.style.cursor = "";
+      document.body.style.userSelect = "";
+    };
+  }, [isResizing, handleMouseMove, handleMouseUp]);
+
+  return {
+    headerHeight,
+    handleMouseDown,
+    isResizing
+  };
+};