chore: resolve merge conflicts

backend/src/integrations/apps.ts

@@ -5,12 +5,16 @@ import {
   INTEGRATION_AWS_PARAMETER_STORE,
   INTEGRATION_AWS_SECRET_MANAGER,
   INTEGRATION_AZURE_KEY_VAULT,
+  INTEGRATION_BITBUCKET,
+  INTEGRATION_BITBUCKET_API_URL,
   INTEGRATION_CHECKLY,
   INTEGRATION_CHECKLY_API_URL,
   INTEGRATION_CIRCLECI,
   INTEGRATION_CIRCLECI_API_URL,
   INTEGRATION_CLOUDFLARE_PAGES,
   INTEGRATION_CLOUDFLARE_PAGES_API_URL,
+  INTEGRATION_CODEFRESH,
+  INTEGRATION_CODEFRESH_API_URL,
   INTEGRATION_FLYIO,
   INTEGRATION_FLYIO_API_URL,
   INTEGRATION_GITHUB,
@@ -56,11 +60,13 @@ const getApps = async ({
   accessToken,
   accessId,
   teamId,
+  workspaceSlug,
 }: {
   integrationAuth: IIntegrationAuth;
   accessToken: string;
   accessId?: string;
   teamId?: string;
+  workspaceSlug?: string;
 }) => {
   let apps: App[] = [];
   switch (integrationAuth.integration) {
@@ -152,6 +158,17 @@ const getApps = async ({
         accessToken,
       });
       break;
+    case INTEGRATION_BITBUCKET:
+      apps = await getAppsBitBucket({
+        accessToken,
+        workspaceSlug
+      });
+      break;
+    case INTEGRATION_CODEFRESH:
+      apps = await getAppsCodefresh({
+        accessToken,
+      });
+      break;
   }
 
   return apps;
@@ -203,10 +220,10 @@ const getAppsVercel = async ({
       },
       ...(integrationAuth?.teamId
         ? {
-            params: {
-              teamId: integrationAuth.teamId,
-            },
-          }
+          params: {
+            teamId: integrationAuth.teamId,
+          },
+        }
         : {}),
     })
   ).data;
@@ -702,15 +719,76 @@ const getAppsCheckly = async ({ accessToken }: { accessToken: string }) => {
  * @returns {Object[]} apps - Cloudflare Pages projects
  * @returns {String} apps.name - name of Cloudflare Pages project
  */
-const getAppsCloudflarePages = async ({ 
-    accessToken,
-    accountId
+const getAppsCloudflarePages = async ({
+  accessToken,
+  accountId
 }: {
-    accessToken: string;
-    accountId?: string;
+  accessToken: string;
+  accountId?: string;
 }) => {
-    const { data } = await standardRequest.get(
-        `${INTEGRATION_CLOUDFLARE_PAGES_API_URL}/client/v4/accounts/${accountId}/pages/projects`,
+  const { data } = await standardRequest.get(
+    `${INTEGRATION_CLOUDFLARE_PAGES_API_URL}/client/v4/accounts/${accountId}/pages/projects`,
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Accept": "application/json",
+      },
+    }
+  );
+
+  const apps = data.result.map((a: any) => {
+    return {
+      name: a.name,
+      appId: a.id,
+    };
+  });
+  return apps;
+}
+
+/**
+ * Return list of repositories for the BitBucket integration based on provided BitBucket workspace
+ * @param {Object} obj
+ * @param {String} obj.accessToken - access token for BitBucket API
+ * @param {String} obj.workspaceSlug - Workspace identifier for fetching BitBucket repositories
+ * @returns {Object[]} apps - BitBucket repositories
+ * @returns {String} apps.name - name of BitBucket repository
+ */
+const getAppsBitBucket = async ({ 
+  accessToken,
+  workspaceSlug,
+}: {
+  accessToken: string;
+  workspaceSlug?: string;
+}) => {
+  interface RepositoriesResponse {
+    size: number;
+    page: number;
+    pageLen: number;
+    next: string;
+    previous: string;
+    values: Array<Repository>;
+  }
+
+  interface Repository {
+    type: string;
+    uuid: string;
+    name: string;
+    is_private: boolean;
+    created_on: string;
+    updated_on: string;
+  }
+
+  if (!workspaceSlug) {
+    return []
+  }
+  
+  const repositories: Repository[] = [];
+  let hasNextPage = true;
+  let repositoriesUrl = `${INTEGRATION_BITBUCKET_API_URL}/2.0/repositories/${workspaceSlug}`
+
+  while (hasNextPage) {
+    const { data }: { data: RepositoriesResponse } = await standardRequest.get(
+        repositoriesUrl,
         {
             headers: {
                 Authorization: `Bearer ${accessToken}`,
@@ -719,13 +797,26 @@ const getAppsCloudflarePages = async ({
         }
     );
 
-    const apps = data.result.map((a: any) => {
-        return {
-            name: a.name,
-            appId: a.id,
-        };
-    });
-    return apps;
+    if (data?.values.length > 0) {
+      data.values.forEach((repository) => {
+        repositories.push(repository)
+      })
+    }
+
+    if (data.next) {
+      repositoriesUrl = data.next
+    } else {
+      hasNextPage = false
+    }
+  }
+
+  const apps = repositories.map((repository) => {
+      return {
+          name: repository.name,
+          appId: repository.uuid,
+      };
+  });
+  return apps;
 }
  /* Return list of projects for Northflank integration
  * @param {Object} obj
@@ -786,4 +877,34 @@ const getAppsNorthflank = async ({ accessToken }: { accessToken: string }) => {
   return apps;
 };
 
+/**
+ * Return list of projects for Supabase integration
+ * @param {Object} obj
+ * @param {String} obj.accessToken - access token for Supabase API
+ * @returns {Object[]} apps - names of Supabase apps
+ * @returns {String} apps.name - name of Supabase app
+ */
+
+const getAppsCodefresh = async ({
+  accessToken,
+}: {
+  accessToken: string;
+}) => {
+  const res = (
+    await standardRequest.get(`${INTEGRATION_CODEFRESH_API_URL}/projects`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Accept-Encoding": "application/json",
+      },
+    })
+  ).data;
+
+  const apps = res.projects.map((a: any) => ({
+    name: a.projectName,
+    appId: a.id,
+  }));
+
+  return apps;
+
+};
 export { getApps };

backend/src/integrations/exchange.ts

@@ -2,6 +2,8 @@ import { standardRequest } from "../config/request";
 import {
   INTEGRATION_AZURE_KEY_VAULT,
   INTEGRATION_AZURE_TOKEN_URL,
+  INTEGRATION_BITBUCKET,
+  INTEGRATION_BITBUCKET_TOKEN_URL,
   INTEGRATION_GITHUB,
   INTEGRATION_GITHUB_TOKEN_URL,
   INTEGRATION_GITLAB,
@@ -15,11 +17,13 @@ import {
 } from "../variables";
 import {
   getClientIdAzure,
+  getClientIdBitBucket,
   getClientIdGitHub,
   getClientIdGitLab,
   getClientIdNetlify,
   getClientIdVercel,
   getClientSecretAzure,
+  getClientSecretBitBucket,
   getClientSecretGitHub,
   getClientSecretGitLab,
   getClientSecretHeroku,
@@ -78,6 +82,15 @@ interface ExchangeCodeGitlabResponse {
   created_at: number;
 }
 
+interface ExchangeCodeBitBucketResponse {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+  refresh_token: string;
+  scopes: string;
+  state: string;
+}
+
 /**
  * Return [accessToken], [accessExpiresAt], and [refreshToken] for OAuth2
  * code-token exchange for integration named [integration]
@@ -129,6 +142,12 @@ const exchangeCode = async ({
       obj = await exchangeCodeGitlab({
         code,
       });
+      break;
+    case INTEGRATION_BITBUCKET:
+      obj = await exchangeCodeBitBucket({
+        code,
+      });
+      break;
   }
 
   return obj;
@@ -347,4 +366,43 @@ const exchangeCodeGitlab = async ({ code }: { code: string }) => {
   };
 };
 
+/**
+ * Return [accessToken], [accessExpiresAt], and [refreshToken] for BitBucket
+ * code-token exchange
+ * @param {Object} obj1
+ * @param {Object} obj1.code - code for code-token exchange
+ * @returns {Object} obj2
+ * @returns {String} obj2.accessToken - access token for BitBucket API
+ * @returns {String} obj2.refreshToken - refresh token for BitBucket API
+ * @returns {Date} obj2.accessExpiresAt - date of expiration for access token
+ */
+const exchangeCodeBitBucket = async ({ code }: { code: string }) => {
+  const accessExpiresAt = new Date();
+  const res: ExchangeCodeBitBucketResponse = (
+    await standardRequest.post(
+      INTEGRATION_BITBUCKET_TOKEN_URL,
+      new URLSearchParams({
+        grant_type: "authorization_code",
+        code: code,
+        client_id: await getClientIdBitBucket(),
+        client_secret: await getClientSecretBitBucket(),
+        redirect_uri: `${await getSiteURL()}/integrations/bitbucket/oauth2/callback`,
+      } as any),
+      {
+        headers: {
+          "Accept-Encoding": "application/json",
+        },
+      }
+    )
+  ).data;
+
+  accessExpiresAt.setSeconds(accessExpiresAt.getSeconds() + res.expires_in);
+
+  return {
+    accessToken: res.access_token,
+    refreshToken: res.refresh_token,
+    accessExpiresAt,
+  };
+};
+
 export { exchangeCode };

backend/src/integrations/refresh.ts

@@ -2,6 +2,8 @@ import { standardRequest } from "../config/request";
 import { IIntegrationAuth } from "../models";
 import {
   INTEGRATION_AZURE_KEY_VAULT,
+  INTEGRATION_BITBUCKET,
+  INTEGRATION_BITBUCKET_TOKEN_URL,
   INTEGRATION_GITLAB,
   INTEGRATION_HEROKU,
 } from "../variables";
@@ -13,8 +15,10 @@ import {
 import { IntegrationService } from "../services";
 import {
   getClientIdAzure,
+  getClientIdBitBucket,
   getClientIdGitLab,
   getClientSecretAzure,
+  getClientSecretBitBucket,
   getClientSecretGitLab,
   getClientSecretHeroku,
   getSiteURL,
@@ -46,6 +50,15 @@ interface RefreshTokenGitLabResponse {
   created_at: number;
 }
 
+interface RefreshTokenBitBucketResponse {
+  access_token: string;
+  token_type: string;
+  expires_in: number;
+  refresh_token: string;
+  scopes: string;
+  state: string;
+}
+
 /**
  * Return new access token by exchanging refresh token [refreshToken] for integration
  * named [integration]
@@ -83,6 +96,11 @@ const exchangeRefresh = async ({
         refreshToken,
       });
       break;
+    case INTEGRATION_BITBUCKET:
+      tokenDetails = await exchangeRefreshBitBucket({
+        refreshToken,
+      });
+      break;
     default:
       throw new Error("Failed to exchange token for incompatible integration");
   }
@@ -218,4 +236,46 @@ const exchangeRefreshGitLab = async ({
   };
 };
 
+/**
+ * Return new access token by exchanging refresh token [refreshToken] for the
+ * BitBucket integration
+ * @param {Object} obj
+ * @param {String} obj.refreshToken - refresh token to use to get new access token for BitBucket
+ * @returns
+ */
+const exchangeRefreshBitBucket = async ({
+  refreshToken,
+}: {
+  refreshToken: string;
+}) => {
+  const accessExpiresAt = new Date();
+  const {
+    data,
+  }: {
+    data: RefreshTokenBitBucketResponse;
+  } = await standardRequest.post(
+    INTEGRATION_BITBUCKET_TOKEN_URL,
+    new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: refreshToken,
+      client_id: await getClientIdBitBucket(),
+      client_secret: await getClientSecretBitBucket(),
+      redirect_uri: `${await getSiteURL()}/integrations/bitbucket/oauth2/callback`,
+    } as any),
+    {
+      headers: {
+        "Accept-Encoding": "application/json",
+      },
+    }
+  );
+
+  accessExpiresAt.setSeconds(accessExpiresAt.getSeconds() + data.expires_in);
+
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    accessExpiresAt,
+  };
+};
+
 export { exchangeRefresh };

backend/src/integrations/revoke.ts

@@ -18,7 +18,6 @@ const revokeAccess = async ({
   integrationAuth: IIntegrationAuth;
   accessToken: string;
 }) => {
-  let deletedIntegrationAuth;
   // add any integration-specific revocation logic
   switch (integrationAuth.integration) {
     case INTEGRATION_HEROKU:
@@ -33,7 +32,7 @@ const revokeAccess = async ({
       break;
   }
 
-  deletedIntegrationAuth = await IntegrationAuth.findOneAndDelete({
+  const deletedIntegrationAuth = await IntegrationAuth.findOneAndDelete({
     _id: integrationAuth._id,
   });
 

backend/src/integrations/sync.ts

@@ -1,7 +1,7 @@
 import _ from "lodash";
 import AWS from "aws-sdk";
-import { 
-  CreateSecretCommand, 
+import {
+  CreateSecretCommand,
   GetSecretValueCommand,
   ResourceNotFoundException,
   SecretsManagerClient,
@@ -14,12 +14,16 @@ import {
   INTEGRATION_AWS_PARAMETER_STORE,
   INTEGRATION_AWS_SECRET_MANAGER,
   INTEGRATION_AZURE_KEY_VAULT,
+  INTEGRATION_BITBUCKET,
+  INTEGRATION_BITBUCKET_API_URL,
   INTEGRATION_CHECKLY,
   INTEGRATION_CHECKLY_API_URL,
   INTEGRATION_CIRCLECI,
   INTEGRATION_CIRCLECI_API_URL,
   INTEGRATION_CLOUDFLARE_PAGES,
   INTEGRATION_CLOUDFLARE_PAGES_API_URL,
+  INTEGRATION_CODEFRESH,
+  INTEGRATION_CODEFRESH_API_URL,
   INTEGRATION_FLYIO,
   INTEGRATION_FLYIO_API_URL,
   INTEGRATION_GITHUB,
@@ -43,9 +47,9 @@ import {
   INTEGRATION_TRAVISCI,
   INTEGRATION_TRAVISCI_API_URL,
   INTEGRATION_VERCEL,
-  INTEGRATION_VERCEL_API_URL,
+  INTEGRATION_VERCEL_API_URL
 } from "../variables";
-import { standardRequest} from "../config/request";
+import { standardRequest } from "../config/request";
 
 /**
  * Sync/push [secrets] to [app] in integration named [integration]
@@ -175,11 +179,11 @@ const syncSecrets = async ({
       break;
     case INTEGRATION_SUPABASE:
       await syncSecretsSupabase({
-          integration,
-          secrets,
-          accessToken,
-        });
-        break;
+        integration,
+        secrets,
+        accessToken,
+      });
+      break;
     case INTEGRATION_CHECKLY:
       await syncSecretsCheckly({
         integration,
@@ -198,10 +202,24 @@ const syncSecrets = async ({
       break;
     case INTEGRATION_CLOUDFLARE_PAGES:
       await syncSecretsCloudflarePages({
-          integration,
-          secrets,
-          accessId,
-          accessToken
+        integration,
+        secrets,
+        accessId,
+        accessToken
+      });
+      break;
+    case INTEGRATION_CODEFRESH:
+      await syncSecretsCodefresh({
+        integration,
+        secrets,
+        accessToken,
+      });
+      break;
+    case INTEGRATION_BITBUCKET:
+      await syncSecretsBitBucket({
+        integration,
+        secrets,
+        accessToken,
       });
       break;
     case INTEGRATION_NORTHFLANK:
@@ -211,7 +229,7 @@ const syncSecrets = async ({
         accessToken
       });
       break;
-    }
+  }
 };
 
 /**
@@ -240,11 +258,11 @@ const syncSecretsAzureKeyVault = async ({
       recoverableDays: number;
     }
   }
-  
+
   interface AzureKeyVaultSecret extends GetAzureKeyVaultSecret {
     key: string;
   }
-  
+
   /**
    * Return all secrets from Azure Key Vault by paginating through URL [url]
    * @param {String} url - pagination URL to get next set of secrets from Azure Key Vault
@@ -258,23 +276,23 @@ const syncSecretsAzureKeyVault = async ({
           Authorization: `Bearer ${accessToken}`,
         },
       });
-      
+
       result = result.concat(res.data.value);
-      
+
       url = res.data.nextLink;
     }
-    
+
     return result;
   }
-  
+
   const getAzureKeyVaultSecrets = await paginateAzureKeyVaultSecrets(`${integration.app}/secrets?api-version=7.3`);
-  
+
   let lastSlashIndex: number;
   const res = (await Promise.all(getAzureKeyVaultSecrets.map(async (getAzureKeyVaultSecret) => {
     if (!lastSlashIndex) {
       lastSlashIndex = getAzureKeyVaultSecret.id.lastIndexOf("/");
     }
-    
+
     const azureKeyVaultSecret = await standardRequest.get(`${getAzureKeyVaultSecret.id}?api-version=7.3`, {
       headers: {
         "Authorization": `Bearer ${accessToken}`,
@@ -286,11 +304,11 @@ const syncSecretsAzureKeyVault = async ({
       key: getAzureKeyVaultSecret.id.substring(lastSlashIndex + 1),
     });
   })))
-  .reduce((obj: any, secret: any) => ({
+    .reduce((obj: any, secret: any) => ({
       ...obj,
       [secret.key]: secret,
-  }), {});
-  
+    }), {});
+
   const setSecrets: {
     key: string;
     value: string;
@@ -314,9 +332,9 @@ const syncSecretsAzureKeyVault = async ({
       }
     }
   });
-  
+
   const deleteSecrets: AzureKeyVaultSecret[] = [];
-  
+
   Object.keys(res).forEach((key) => {
     const underscoredKey = key.replace(/-/g, "_");
     if (!(underscoredKey in secrets)) {
@@ -337,7 +355,7 @@ const syncSecretsAzureKeyVault = async ({
   }) => {
     let isSecretSet = false;
     let maxTries = 6;
-    
+
     while (!isSecretSet && maxTries > 0) {
       // try to set secret
       try {
@@ -354,7 +372,7 @@ const syncSecretsAzureKeyVault = async ({
         );
 
         isSecretSet = true;
-      
+
       } catch (err) {
         const error: any = err;
         if (error?.response?.data?.error?.innererror?.code === "ObjectIsDeletedButRecoverable") {
@@ -374,7 +392,7 @@ const syncSecretsAzureKeyVault = async ({
       }
     }
   }
-  
+
   // Sync/push set secrets
   for await (const setSecret of setSecrets) {
     const { key, value } = setSecret;
@@ -385,7 +403,7 @@ const syncSecretsAzureKeyVault = async ({
       accessToken,
     });
   }
-  
+
   for await (const deleteSecret of deleteSecrets) {
     const { key } = deleteSecret;
     await standardRequest.delete(`${integration.app}/secrets/${key}?api-version=7.3`, {
@@ -427,7 +445,7 @@ const syncSecretsAWSParameterStore = async ({
     apiVersion: "2014-11-06",
     region: integration.region,
   });
-  
+
   const params = {
     Path: integration.path,
     Recursive: true,
@@ -435,61 +453,61 @@ const syncSecretsAWSParameterStore = async ({
   };
 
   const parameterList = (await ssm.getParametersByPath(params).promise()).Parameters
-  
+
   let awsParameterStoreSecretsObj: {
     [key: string]: any // TODO: fix type
   } = {};
 
   if (parameterList) {
     awsParameterStoreSecretsObj = parameterList.reduce((obj: any, secret: any) => ({
-        ...obj,
-        [secret.Name.split("/").pop()]: secret,
+      ...obj,
+      [secret.Name.split("/").pop()]: secret,
     }), {});
   }
 
   // Identify secrets to create
   Object.keys(secrets).map(async (key) => {
-      if (!(key in awsParameterStoreSecretsObj)) {
-        // case: secret does not exist in AWS parameter store
-        // -> create secret
+    if (!(key in awsParameterStoreSecretsObj)) {
+      // case: secret does not exist in AWS parameter store
+      // -> create secret
+      await ssm.putParameter({
+        Name: `${integration.path}${key}`,
+        Type: "SecureString",
+        Value: secrets[key],
+        Overwrite: true,
+      }).promise();
+    } else {
+      // case: secret exists in AWS parameter store
+
+      if (awsParameterStoreSecretsObj[key].Value !== secrets[key]) {
+        // case: secret value doesn't match one in AWS parameter store
+        // -> update secret
         await ssm.putParameter({
           Name: `${integration.path}${key}`,
           Type: "SecureString",
           Value: secrets[key],
           Overwrite: true,
         }).promise();
-      } else {
-        // case: secret exists in AWS parameter store
-        
-        if (awsParameterStoreSecretsObj[key].Value !== secrets[key]) {
-          // case: secret value doesn't match one in AWS parameter store
-          // -> update secret
-          await ssm.putParameter({
-            Name: `${integration.path}${key}`,
-            Type: "SecureString",
-            Value: secrets[key],
-            Overwrite: true,
-          }).promise();
-        }
       }
+    }
   });
 
   // Identify secrets to delete
   Object.keys(awsParameterStoreSecretsObj).map(async (key) => {
-      if (!(key in secrets)) {
-        // case: 
-        // -> delete secret
-        await ssm.deleteParameter({
-          Name: awsParameterStoreSecretsObj[key].Name,
-        }).promise();
-      }
+    if (!(key in secrets)) {
+      // case: 
+      // -> delete secret
+      await ssm.deleteParameter({
+        Name: awsParameterStoreSecretsObj[key].Name,
+      }).promise();
+    }
   });
 
   AWS.config.update({
     region: undefined,
     accessKeyId: undefined,
     secretAccessKey: undefined,
-  }); 
+  });
 }
 
 /**
@@ -520,7 +538,7 @@ const syncSecretsAWSSecretManager = async ({
       accessKeyId: accessId,
       secretAccessKey: accessToken,
     });
-    
+
     secretsManager = new SecretsManagerClient({
       region: integration.region,
       credentials: {
@@ -534,13 +552,13 @@ const syncSecretsAWSSecretManager = async ({
         SecretId: integration.app,
       })
     );
-    
+
     let awsSecretManagerSecretObj: { [key: string]: any } = {};
-    
+
     if (awsSecretManagerSecret?.SecretString) {
       awsSecretManagerSecretObj = JSON.parse(awsSecretManagerSecret.SecretString);
     }
-    
+
     if (!_.isEqual(awsSecretManagerSecretObj, secrets)) {
       await secretsManager.send(new UpdateSecretCommand({
         SecretId: integration.app,
@@ -552,19 +570,19 @@ const syncSecretsAWSSecretManager = async ({
       region: undefined,
       accessKeyId: undefined,
       secretAccessKey: undefined,
-    }); 
+    });
   } catch (err) {
     if (err instanceof ResourceNotFoundException && secretsManager) {
       await secretsManager.send(new CreateSecretCommand({
         Name: integration.app,
         SecretString: JSON.stringify(secrets),
       }));
-    } 
+    }
     AWS.config.update({
       region: undefined,
       accessKeyId: undefined,
       secretAccessKey: undefined,
-    }); 
+    });
   }
 }
 
@@ -647,38 +665,36 @@ const syncSecretsVercel = async ({
     decrypt: "true",
     ...(integrationAuth?.teamId
       ? {
-          teamId: integrationAuth.teamId,
-        }
+        teamId: integrationAuth.teamId,
+      }
       : {}),
   };
-    
+
   const vercelSecrets: VercelSecret[] = (await standardRequest.get(
     `${INTEGRATION_VERCEL_API_URL}/v9/projects/${integration.app}/env`,
     {
       params,
       headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Accept-Encoding": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "Accept-Encoding": "application/json",
       },
     }
   ))
-  .data
-  .envs
-  .filter((secret: VercelSecret) => { 
-    if (!secret.target.includes(integration.targetEnvironment)) {
-      // case: secret does not have the same target environment
-      return false;
-    }
+    .data
+    .envs
+    .filter((secret: VercelSecret) => {
+      if (!secret.target.includes(integration.targetEnvironment)) {
+        // case: secret does not have the same target environment
+        return false;
+      }
 
-    if (integration.targetEnvironment === "preview" && integration.path && integration.path !== secret.gitBranch) {
-      // case: secret on preview environment does not have same target git branch
-      return false;
-    }
+      if (integration.targetEnvironment === "preview" && integration.path && integration.path !== secret.gitBranch) {
+        // case: secret on preview environment does not have same target git branch
+        return false;
+      }
 
-    return true;
-  });
-
-  // return secret.target.includes(integration.targetEnvironment);
+      return true;
+    });
 
   const res: { [key: string]: VercelSecret } = {};
 
@@ -686,14 +702,14 @@ const syncSecretsVercel = async ({
     if (vercelSecret.type === "encrypted") {
       // case: secret is encrypted -> need to decrypt
       const decryptedSecret = (await standardRequest.get(
-          `${INTEGRATION_VERCEL_API_URL}/v9/projects/${integration.app}/env/${vercelSecret.id}`,
-          {
-            params,
-            headers: {
-                Authorization: `Bearer ${accessToken}`,
-                "Accept-Encoding": "application/json",
-            },
-          }
+        `${INTEGRATION_VERCEL_API_URL}/v9/projects/${integration.app}/env/${vercelSecret.id}`,
+        {
+          params,
+          headers: {
+            Authorization: `Bearer ${accessToken}`,
+            "Accept-Encoding": "application/json",
+          },
+        }
       )).data;
 
       res[vercelSecret.key] = decryptedSecret;
@@ -701,7 +717,7 @@ const syncSecretsVercel = async ({
       res[vercelSecret.key] = vercelSecret;
     }
   }
-  
+
   const updateSecrets: VercelSecret[] = [];
   const deleteSecrets: VercelSecret[] = [];
   const newSecrets: VercelSecret[] = [];
@@ -732,9 +748,9 @@ const syncSecretsVercel = async ({
           key: key,
           value: secrets[key],
           type: res[key].type,
-          target: res[key].target.includes(integration.targetEnvironment) 
-          ? [...res[key].target] 
-          : [...res[key].target, integration.targetEnvironment],
+          target: res[key].target.includes(integration.targetEnvironment)
+            ? [...res[key].target]
+            : [...res[key].target, integration.targetEnvironment],
           ...(integration.path ? {
             gitBranch: integration.path,
           } : {}),
@@ -784,7 +800,7 @@ const syncSecretsVercel = async ({
           },
         }
       );
-    } 
+    }
   }
 
   for await (const secret of deleteSecrets) {
@@ -797,7 +813,7 @@ const syncSecretsVercel = async ({
           "Accept-Encoding": "application/json",
         },
       }
-    ); 
+    );
   }
 };
 
@@ -1384,7 +1400,7 @@ const syncSecretsCircleCI = async ({
   integration: IIntegration;
   secrets: any;
   accessToken: string;
-}) => {  
+}) => {
   const circleciOrganizationDetail = (
     await standardRequest.get(`${INTEGRATION_CIRCLECI_API_URL}/v2/me/collaborations`, {
       headers: {
@@ -1471,13 +1487,13 @@ const syncSecretsTravisCI = async ({
       }
     )
   )
-  .data
-  ?.env_vars
-  .reduce((obj: any, secret: any) => ({
+    .data
+    ?.env_vars
+    .reduce((obj: any, secret: any) => ({
       ...obj,
       [secret.name]: secret,
-  }), {});
-  
+    }), {});
+
   // add secrets
   for await (const key of Object.keys(secrets)) {
     if (!(key in getSecretsRes)) {
@@ -1522,7 +1538,7 @@ const syncSecretsTravisCI = async ({
   }
 
   for await (const key of Object.keys(getSecretsRes)) {
-    if (!(key in secrets)){
+    if (!(key in secrets)) {
       // delete secret
       await standardRequest.delete(
         `${INTEGRATION_TRAVISCI_API_URL}/settings/env_vars/${getSecretsRes[key].id}?repository_id=${getSecretsRes[key].repository_id}`,
@@ -1567,29 +1583,29 @@ const syncSecretsGitLab = async ({
       "Authorization": `Bearer ${accessToken}`,
       "Accept-Encoding": "application/json",
     };
-  
+
     let allEnvVariables: GitLabSecret[] = [];
     let url: string | null = `${gitLabApiUrl}?per_page=100`;
-  
+
     while (url) {
       const response: any = await standardRequest.get(url, { headers });
       allEnvVariables = [...allEnvVariables, ...response.data];
-  
+
       const linkHeader = response.headers.link;
       const nextLink = linkHeader?.split(",").find((part: string) => part.includes('rel="next"'));
-  
+
       if (nextLink) {
         url = nextLink.trim().split(";")[0].slice(1, -1);
       } else {
         url = null;
       }
     }
-  
+
     return allEnvVariables;
   };
 
   const allEnvVariables = await getAllEnvVariables(integration?.appId, accessToken);
-  const getSecretsRes: GitLabSecret[] = allEnvVariables.filter((secret: GitLabSecret) => 
+  const getSecretsRes: GitLabSecret[] = allEnvVariables.filter((secret: GitLabSecret) =>
     secret.environment_scope === integration.targetEnvironment
   );
 
@@ -1671,8 +1687,8 @@ const syncSecretsSupabase = async ({
     `${INTEGRATION_SUPABASE_API_URL}/v1/projects/${integration.appId}/secrets`,
     {
       headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Accept-Encoding": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "Accept-Encoding": "application/json",
       },
     }
   );
@@ -1681,8 +1697,8 @@ const syncSecretsSupabase = async ({
   const modifiedFormatForSecretInjection = Object.keys(secrets).map(
     (key) => {
       return {
-          name: key,
-          value: secrets[key],
+        name: key,
+        value: secrets[key],
       };
     }
   );
@@ -1692,8 +1708,8 @@ const syncSecretsSupabase = async ({
     modifiedFormatForSecretInjection,
     {
       headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Accept-Encoding": "application/json",
+        Authorization: `Bearer ${accessToken}`,
+        "Accept-Encoding": "application/json",
       },
     }
   );
@@ -1701,7 +1717,7 @@ const syncSecretsSupabase = async ({
   const secretsToDelete: any = [];
   getSecretsRes?.forEach((secretObj: any) => {
     if (!(secretObj.name in secrets)) {
-        secretsToDelete.push(secretObj.name);
+      secretsToDelete.push(secretObj.name);
     }
   });
 
@@ -1748,18 +1764,18 @@ const syncSecretsCheckly = async ({
       }
     )
   )
-  .data
-  .reduce((obj: any, secret: any) => ({
+    .data
+    .reduce((obj: any, secret: any) => ({
       ...obj,
       [secret.key]: secret.value,
-  }), {});
-  
+    }), {});
+
   // add secrets
   for await (const key of Object.keys(secrets)) {
     if (!(key in getSecretsRes)) {
       // case: secret does not exist in checkly
       // -> add secret
-      
+
       await standardRequest.post(
         `${INTEGRATION_CHECKLY_API_URL}/v1/variables`,
         {
@@ -1778,7 +1794,7 @@ const syncSecretsCheckly = async ({
     } else {
       // case: secret exists in checkly
       // -> update/set secret
-      
+
       if (secrets[key] !== getSecretsRes[key]) {
         await standardRequest.put(
           `${INTEGRATION_CHECKLY_API_URL}/v1/variables/${key}`,
@@ -1799,7 +1815,7 @@ const syncSecretsCheckly = async ({
   }
 
   for await (const key of Object.keys(getSecretsRes)) {
-    if (!(key in secrets)){
+    if (!(key in secrets)) {
       // delete secret
       await standardRequest.delete(
         `${INTEGRATION_CHECKLY_API_URL}/v1/variables/${key}`,
@@ -1836,13 +1852,13 @@ const syncSecretsHashiCorpVault = async ({
   accessToken: string;
 }) => {
   if (!accessId) return;
-  
+
   interface LoginAppRoleRes {
     auth: {
       client_token: string;
     }
   }
-  
+
   // get Vault client token (could be optimized)
   const { data }: { data: LoginAppRoleRes } = await standardRequest.post(
     `${integrationAuth.url}/v1/auth/approle/login`,
@@ -1856,7 +1872,7 @@ const syncSecretsHashiCorpVault = async ({
       },
     }
   );
-  
+
   const clientToken = data.auth.client_token;
 
   await standardRequest.post(
@@ -1884,46 +1900,46 @@ const syncSecretsHashiCorpVault = async ({
  * @param {String} obj.accessToken - API token for Cloudflare
  */
 const syncSecretsCloudflarePages = async ({
-    integration,
-    secrets,
-    accessId,
-    accessToken,
+  integration,
+  secrets,
+  accessId,
+  accessToken,
 }: {
-    integration: IIntegration;
-    secrets: any;
-    accessId: string | null;
-    accessToken: string;
+  integration: IIntegration;
+  secrets: any;
+  accessId: string | null;
+  accessToken: string;
 }) => {
 
   // get secrets from cloudflare pages
   const getSecretsRes = (
-      await standardRequest.get(
-          `${INTEGRATION_CLOUDFLARE_PAGES_API_URL}/client/v4/accounts/${accessId}/pages/projects/${integration.app}`,
-          {
-              headers: {
-                  Authorization: `Bearer ${accessToken}`,
-                  "Accept": "application/json",
-              },
-          }
-      )
+    await standardRequest.get(
+      `${INTEGRATION_CLOUDFLARE_PAGES_API_URL}/client/v4/accounts/${accessId}/pages/projects/${integration.app}`,
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Accept": "application/json",
+        },
+      }
+    )
   )
   .data.result["deployment_configs"][integration.targetEnvironment]["env_vars"];
 
   // copy the secrets object, so we can set deleted keys to null
-  const secretsObj: any = {...secrets};
+  const secretsObj: any = { ...secrets };
 
   for (const [key, val] of Object.entries(secretsObj)) {
-      secretsObj[key] = { type: "secret_text", value: val };
+    secretsObj[key] = { type: "secret_text", value: val };
   }
 
   if (getSecretsRes) {
-      for await (const key of Object.keys(getSecretsRes)) {
-          if (!(key in secrets)) {
-              // case: secret does not exist in infisical
-              // -> delete secret from cloudflare pages
-              secretsObj[key] = null;
-          }
+    for await (const key of Object.keys(getSecretsRes)) {
+      if (!(key in secrets)) {
+        // case: secret does not exist in infisical
+        // -> delete secret from cloudflare pages
+        secretsObj[key] = null;
       }
+    }
   }
 
   const data = {
@@ -1935,16 +1951,164 @@ const syncSecretsCloudflarePages = async ({
   };
 
   await standardRequest.patch(
-      `${INTEGRATION_CLOUDFLARE_PAGES_API_URL}/client/v4/accounts/${accessId}/pages/projects/${integration.app}`,
-      data,
-      {
-          headers: {
-              Authorization: `Bearer ${accessToken}`,
-              "Accept": "application/json",
-          },
-      }
+    `${INTEGRATION_CLOUDFLARE_PAGES_API_URL}/client/v4/accounts/${accessId}/pages/projects/${integration.app}`,
+    data,
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Accept": "application/json",
+      },
+    }
   );
 }
+
+/**
+ * Sync/push [secrets] to BitBucket repo with name [integration.app]
+ * @param {Object} obj
+ * @param {IIntegration} obj.integration - integration details
+ * @param {IIntegrationAuth} obj.integrationAuth - integration auth details
+ * @param {Object} obj.secrets - secrets to push to integration (object where keys are secret keys and values are secret values)
+ * @param {String} obj.accessToken - access token for BitBucket integration
+ */
+const syncSecretsBitBucket = async ({
+  integration,
+  secrets,
+  accessToken,
+}: {
+  integration: IIntegration;
+  secrets: any;
+  accessToken: string;
+}) => {
+  interface VariablesResponse {
+    size: number;
+    page: number;
+    pageLen: number;
+    next: string;
+    previous: string;
+    values: Array<BitbucketVariable>;
+  }
+
+  interface BitbucketVariable {
+    type: string;
+    uuid: string;
+    key: string;
+    value: string;
+    secured: boolean;
+  }
+
+  const res: { [key: string]: BitbucketVariable } = {};
+
+  let hasNextPage = true;
+  let variablesUrl = `${INTEGRATION_BITBUCKET_API_URL}/2.0/repositories/${integration.targetEnvironmentId}/${integration.appId}/pipelines_config/variables`
+
+  while (hasNextPage) {
+    const { data }: { data: VariablesResponse } = await standardRequest.get(
+        variablesUrl,
+        {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Accept": "application/json",
+            },
+        }
+    );
+
+    if (data?.values.length > 0) {
+      data.values.forEach((variable) => {
+        res[variable.key] = variable;
+      });
+    }
+
+    if (data.next) {
+      variablesUrl = data.next
+    } else {
+      hasNextPage = false
+    }
+  }
+
+  for await (const key of Object.keys(secrets)) {
+    if (key in res) {
+      // update existing secret
+      await standardRequest.put(
+          `${variablesUrl}/${res[key].uuid}`,
+          {
+            key,
+            value: secrets[key],
+            secured: true
+          },
+          {
+              headers: {
+                  Authorization: `Bearer ${accessToken}`,
+                  "Accept": "application/json",
+              },
+          }
+      );
+    } else {
+      // create new secret
+      await standardRequest.post(
+          variablesUrl,
+          {
+            key,
+            value: secrets[key],
+            secured: true
+          },
+          {
+              headers: {
+                  Authorization: `Bearer ${accessToken}`,
+                  "Accept": "application/json",
+              },
+          }
+      );
+    }
+  }
+
+  for await (const key of Object.keys(res)) {
+    if (!(key in secrets)) {
+      // delete secret
+      await standardRequest.delete(
+        `${variablesUrl}/${res[key].uuid}`,
+        {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Accept": "application/json",
+            }
+        }
+      );
+    }
+  }
+}
+
+/*
+ * Sync/push [secrets] to Codefresh with name [integration.app]
+ * @param {Object} obj
+ * @param {IIntegration} obj.integration - integration details
+ * @param {Object} obj.secrets - secrets to push to integration (object where keys are secret keys and values are secret values)
+ * @param {String} obj.accessToken - access token for Codefresh integration
+ */
+const syncSecretsCodefresh = async ({
+  integration,
+  secrets,
+  accessToken,
+}: {
+  integration: IIntegration;
+  secrets: any;
+  accessToken: string;
+}) => {
+  await standardRequest.patch(
+    `${INTEGRATION_CODEFRESH_API_URL}/projects/${integration.appId}`,
+    {
+      variables: Object.keys(secrets).map((key) => ({
+        key,
+        value: secrets[key]
+      }))
+    },
+    {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Accept": "application/json",
+      },
+    }
+  ); 
+};
  /* Sync/push [secrets] to Northflank
  * @param {Object} obj
  * @param {IIntegration} obj.integration - integration details