@backstage/integration 1.1.0 → 1.2.0-next.0

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @backstage/integration
 
+## 1.2.0-next.0
+
+### Minor Changes
+
+- 6673babab9: Gerrit UrlReader: Implemented `readTree`
+- 1b4e1e2306: Split `bitbucket` integration into `bitbucketCloud` and `bitbucketServer`
+  (backwards compatible).
+
+  In order to migrate to the new integration configs,
+  move your configs from `integrations.bitbucket`
+  to `integrations.bitbucketCloud` or `integrations.bitbucketServer`.
+
+  Migration example:
+
+  **Before:**
+
+  ```yaml
+  integrations:
+    bitbucket:
+      - host: bitbucket.org
+        username: bitbucket_user
+        appPassword: app-password
+      - host: bitbucket-server.company.com
+        token: my-token
+  ```
+
+  **After:**
+
+  ```yaml
+  integrations:
+    bitbucketCloud:
+      - username: bitbucket_user
+        appPassword: app-password
+    bitbucketServer:
+      - host: bitbucket-server.company.com
+        token: my-token
+  ```
+
+- 566407bf8a: Gerrit Integration: Added the `getGerritProjectsApiUrl` function
+
 ## 1.1.0
 
 ### Minor Changes

package/config.d.ts

@@ -31,7 +31,10 @@ export interface Config {
       token?: string;
     }>;
 
-    /** Integration configuration for Bitbucket */
+    /**
+     * Integration configuration for Bitbucket
+     * @deprecated replaced by bitbucketCloud and bitbucketServer
+     */
     bitbucket?: Array<{
       /**
        * The hostname of the given Bitbucket instance
@@ -60,6 +63,39 @@ export interface Config {
       appPassword?: string;
     }>;
 
+    /** Integration configuration for Bitbucket Cloud */
+    bitbucketCloud?: Array<{
+      /**
+       * The username to use for authenticated requests.
+       * @visibility secret
+       */
+      username: string;
+      /**
+       * Bitbucket Cloud app password used to authenticate requests.
+       * @visibility secret
+       */
+      appPassword: string;
+    }>;
+
+    /** Integration configuration for Bitbucket Server */
+    bitbucketServer?: Array<{
+      /**
+       * The hostname of the given Bitbucket Server instance
+       * @visibility frontend
+       */
+      host: string;
+      /**
+       * Token used to authenticate requests.
+       * @visibility secret
+       */
+      token?: string;
+      /**
+       * The base url for the Bitbucket Server API, for example https://<host>/rest/api/1.0
+       * @visibility frontend
+       */
+      apiBaseUrl?: string;
+    }>;
+
     /** Integration configuration for Gerrit */
     gerrit?: Array<{
       /**
@@ -72,6 +108,11 @@ export interface Config {
        * @visibility frontend
        */
       baseUrl?: string;
+      /**
+       * The base url for cloning repos.
+       * @visibility frontend
+       */
+      cloneUrl?: string;
       /**
        * The username to use for authenticated requests.
        * @visibility secret

package/dist/index.cjs.js

@@ -68,6 +68,79 @@ function defaultScmResolveUrl(options) {
   return updated.toString();
 }
 
+const AMAZON_AWS_HOST = "amazonaws.com";
+function readAwsS3IntegrationConfig(config) {
+  var _a;
+  const endpoint = config.getOptionalString("endpoint");
+  const s3ForcePathStyle = (_a = config.getOptionalBoolean("s3ForcePathStyle")) != null ? _a : false;
+  let host;
+  let pathname;
+  if (endpoint) {
+    try {
+      const url = new URL(endpoint);
+      host = url.host;
+      pathname = url.pathname;
+    } catch {
+      throw new Error(`invalid awsS3 integration config, endpoint '${endpoint}' is not a valid URL`);
+    }
+    if (pathname !== "/") {
+      throw new Error(`invalid awsS3 integration config, endpoints cannot contain path, got '${endpoint}'`);
+    }
+  } else {
+    host = AMAZON_AWS_HOST;
+  }
+  const accessKeyId = config.getOptionalString("accessKeyId");
+  const secretAccessKey = config.getOptionalString("secretAccessKey");
+  const roleArn = config.getOptionalString("roleArn");
+  const externalId = config.getOptionalString("externalId");
+  return {
+    host,
+    endpoint,
+    s3ForcePathStyle,
+    accessKeyId,
+    secretAccessKey,
+    roleArn,
+    externalId
+  };
+}
+function readAwsS3IntegrationConfigs(configs) {
+  const result = configs.map(readAwsS3IntegrationConfig);
+  if (!result.some((c) => c.host === AMAZON_AWS_HOST)) {
+    result.push({
+      host: AMAZON_AWS_HOST
+    });
+  }
+  return result;
+}
+
+const _AwsS3Integration = class {
+  constructor(integrationConfig) {
+    this.integrationConfig = integrationConfig;
+  }
+  get type() {
+    return "awsS3";
+  }
+  get title() {
+    return this.integrationConfig.host;
+  }
+  get config() {
+    return this.integrationConfig;
+  }
+  resolveUrl(options) {
+    const resolved = defaultScmResolveUrl(options);
+    return resolved;
+  }
+  resolveEditUrl(url) {
+    return url;
+  }
+};
+let AwsS3Integration = _AwsS3Integration;
+AwsS3Integration.factory = ({ config }) => {
+  var _a;
+  const configs = readAwsS3IntegrationConfigs((_a = config.getOptionalConfigArray("integrations.awsS3")) != null ? _a : []);
+  return basicIntegrations(configs.map((c) => new _AwsS3Integration(c)), (i) => i.config.host);
+};
+
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -371,8 +444,11 @@ let BitbucketIntegration = _BitbucketIntegration;
 BitbucketIntegration.factory = ({
   config
 }) => {
-  var _a;
-  const configs = readBitbucketIntegrationConfigs((_a = config.getOptionalConfigArray("integrations.bitbucket")) != null ? _a : []);
+  var _a, _b, _c;
+  const configs = readBitbucketIntegrationConfigs((_c = config.getOptionalConfigArray("integrations.bitbucket")) != null ? _c : [
+    ...(_a = config.getOptionalConfigArray("integrations.bitbucketCloud")) != null ? _a : [],
+    ...(_b = config.getOptionalConfigArray("integrations.bitbucketServer")) != null ? _b : []
+  ]);
   return basicIntegrations(configs.map((c) => new _BitbucketIntegration(c)), (i) => i.config.host);
 };
 
@@ -451,9 +527,242 @@ function getBitbucketRequestOptions(config) {
   };
 }
 
+const BITBUCKET_CLOUD_HOST = "bitbucket.org";
+const BITBUCKET_CLOUD_API_BASE_URL = "https://api.bitbucket.org/2.0";
+function readBitbucketCloudIntegrationConfig(config) {
+  const host = BITBUCKET_CLOUD_HOST;
+  const apiBaseUrl = BITBUCKET_CLOUD_API_BASE_URL;
+  const username = config.getString("username");
+  const appPassword = config.getString("appPassword");
+  return {
+    host,
+    apiBaseUrl,
+    username,
+    appPassword
+  };
+}
+function readBitbucketCloudIntegrationConfigs(configs) {
+  const result = configs.map(readBitbucketCloudIntegrationConfig);
+  if (result.length === 0) {
+    result.push({
+      host: BITBUCKET_CLOUD_HOST,
+      apiBaseUrl: BITBUCKET_CLOUD_API_BASE_URL
+    });
+  }
+  return result;
+}
+
+const _BitbucketCloudIntegration = class {
+  constructor(integrationConfig) {
+    this.integrationConfig = integrationConfig;
+  }
+  get type() {
+    return "bitbucketCloud";
+  }
+  get title() {
+    return this.integrationConfig.host;
+  }
+  get config() {
+    return this.integrationConfig;
+  }
+  resolveUrl(options) {
+    const resolved = defaultScmResolveUrl(options);
+    if (options.lineNumber) {
+      const url = new URL(resolved);
+      url.hash = `lines-${options.lineNumber}`;
+      return url.toString();
+    }
+    return resolved;
+  }
+  resolveEditUrl(url) {
+    const urlData = parseGitUrl__default["default"](url);
+    const editUrl = new URL(url);
+    editUrl.searchParams.set("mode", "edit");
+    editUrl.searchParams.set("at", urlData.ref);
+    return editUrl.toString();
+  }
+};
+let BitbucketCloudIntegration = _BitbucketCloudIntegration;
+BitbucketCloudIntegration.factory = ({
+  config
+}) => {
+  var _a;
+  const configs = readBitbucketCloudIntegrationConfigs((_a = config.getOptionalConfigArray("integrations.bitbucketCloud")) != null ? _a : []);
+  return basicIntegrations(configs.map((c) => new _BitbucketCloudIntegration(c)), (i) => i.config.host);
+};
+
+async function getBitbucketCloudDefaultBranch(url, config) {
+  const { name: repoName, owner: project } = parseGitUrl__default["default"](url);
+  const branchUrl = `${config.apiBaseUrl}/repositories/${project}/${repoName}`;
+  const response = await fetch__default["default"](branchUrl, getBitbucketCloudRequestOptions(config));
+  if (!response.ok) {
+    const message = `Failed to retrieve default branch from ${branchUrl}, ${response.status} ${response.statusText}`;
+    throw new Error(message);
+  }
+  const repoInfo = await response.json();
+  const defaultBranch = repoInfo.mainbranch.name;
+  if (!defaultBranch) {
+    throw new Error(`Failed to read default branch from ${branchUrl}. Response ${response.status} ${response.json()}`);
+  }
+  return defaultBranch;
+}
+async function getBitbucketCloudDownloadUrl(url, config) {
+  const {
+    name: repoName,
+    owner: project,
+    ref,
+    protocol,
+    resource
+  } = parseGitUrl__default["default"](url);
+  let branch = ref;
+  if (!branch) {
+    branch = await getBitbucketCloudDefaultBranch(url, config);
+  }
+  return `${protocol}://${resource}/${project}/${repoName}/get/${branch}.tar.gz`;
+}
+function getBitbucketCloudFileFetchUrl(url, config) {
+  try {
+    const { owner, name, ref, filepathtype, filepath } = parseGitUrl__default["default"](url);
+    if (!owner || !name || filepathtype !== "src" && filepathtype !== "raw") {
+      throw new Error("Invalid Bitbucket Cloud URL or file path");
+    }
+    const pathWithoutSlash = filepath.replace(/^\//, "");
+    if (!ref) {
+      throw new Error("Invalid Bitbucket Cloud URL or file path");
+    }
+    return `${config.apiBaseUrl}/repositories/${owner}/${name}/src/${ref}/${pathWithoutSlash}`;
+  } catch (e) {
+    throw new Error(`Incorrect URL: ${url}, ${e}`);
+  }
+}
+function getBitbucketCloudRequestOptions(config) {
+  const headers = {};
+  if (config.username && config.appPassword) {
+    const buffer = Buffer.from(`${config.username}:${config.appPassword}`, "utf8");
+    headers.Authorization = `Basic ${buffer.toString("base64")}`;
+  }
+  return {
+    headers
+  };
+}
+
+function readBitbucketServerIntegrationConfig(config) {
+  const host = config.getString("host");
+  let apiBaseUrl = config.getOptionalString("apiBaseUrl");
+  const token = config.getOptionalString("token");
+  if (!isValidHost(host)) {
+    throw new Error(`Invalid Bitbucket Server integration config, '${host}' is not a valid host`);
+  }
+  if (apiBaseUrl) {
+    apiBaseUrl = lodash.trimEnd(apiBaseUrl, "/");
+  } else {
+    apiBaseUrl = `https://${host}/rest/api/1.0`;
+  }
+  return {
+    host,
+    apiBaseUrl,
+    token
+  };
+}
+function readBitbucketServerIntegrationConfigs(configs) {
+  return configs.map(readBitbucketServerIntegrationConfig);
+}
+
+const _BitbucketServerIntegration = class {
+  constructor(integrationConfig) {
+    this.integrationConfig = integrationConfig;
+  }
+  get type() {
+    return "bitbucketServer";
+  }
+  get title() {
+    return this.integrationConfig.host;
+  }
+  get config() {
+    return this.integrationConfig;
+  }
+  resolveUrl(options) {
+    const resolved = defaultScmResolveUrl(options);
+    if (options.lineNumber) {
+      const url = new URL(resolved);
+      const filename = url.pathname.split("/").slice(-1)[0];
+      url.hash = `${filename}-${options.lineNumber}`;
+      return url.toString();
+    }
+    return resolved;
+  }
+  resolveEditUrl(url) {
+    const urlData = parseGitUrl__default["default"](url);
+    const editUrl = new URL(url);
+    editUrl.searchParams.set("mode", "edit");
+    editUrl.searchParams.set("spa", "0");
+    editUrl.searchParams.set("at", urlData.ref);
+    return editUrl.toString();
+  }
+};
+let BitbucketServerIntegration = _BitbucketServerIntegration;
+BitbucketServerIntegration.factory = ({
+  config
+}) => {
+  var _a;
+  const configs = readBitbucketServerIntegrationConfigs((_a = config.getOptionalConfigArray("integrations.bitbucketServer")) != null ? _a : []);
+  return basicIntegrations(configs.map((c) => new _BitbucketServerIntegration(c)), (i) => i.config.host);
+};
+
+async function getBitbucketServerDefaultBranch(url, config) {
+  const { name: repoName, owner: project } = parseGitUrl__default["default"](url);
+  let branchUrl = `${config.apiBaseUrl}/projects/${project}/repos/${repoName}/default-branch`;
+  let response = await fetch__default["default"](branchUrl, getBitbucketServerRequestOptions(config));
+  if (response.status === 404) {
+    branchUrl = `${config.apiBaseUrl}/projects/${project}/repos/${repoName}/branches/default`;
+    response = await fetch__default["default"](branchUrl, getBitbucketServerRequestOptions(config));
+  }
+  if (!response.ok) {
+    const message = `Failed to retrieve default branch from ${branchUrl}, ${response.status} ${response.statusText}`;
+    throw new Error(message);
+  }
+  const { displayId } = await response.json();
+  const defaultBranch = displayId;
+  if (!defaultBranch) {
+    throw new Error(`Failed to read default branch from ${branchUrl}. Response ${response.status} ${response.json()}`);
+  }
+  return defaultBranch;
+}
+async function getBitbucketServerDownloadUrl(url, config) {
+  const { name: repoName, owner: project, ref, filepath } = parseGitUrl__default["default"](url);
+  let branch = ref;
+  if (!branch) {
+    branch = await getBitbucketServerDefaultBranch(url, config);
+  }
+  const path = filepath ? `&path=${encodeURIComponent(filepath)}` : "";
+  return `${config.apiBaseUrl}/projects/${project}/repos/${repoName}/archive?format=tgz&at=${branch}&prefix=${project}-${repoName}${path}`;
+}
+function getBitbucketServerFileFetchUrl(url, config) {
+  try {
+    const { owner, name, ref, filepathtype, filepath } = parseGitUrl__default["default"](url);
+    if (!owner || !name || filepathtype !== "browse" && filepathtype !== "raw" && filepathtype !== "src") {
+      throw new Error("Invalid Bitbucket Server URL or file path");
+    }
+    const pathWithoutSlash = filepath.replace(/^\//, "");
+    return `${config.apiBaseUrl}/projects/${owner}/repos/${name}/raw/${pathWithoutSlash}?at=${ref}`;
+  } catch (e) {
+    throw new Error(`Incorrect URL: ${url}, ${e}`);
+  }
+}
+function getBitbucketServerRequestOptions(config) {
+  const headers = {};
+  if (config.token) {
+    headers.Authorization = `Bearer ${config.token}`;
+  }
+  return {
+    headers
+  };
+}
+
 function readGerritIntegrationConfig(config) {
   const host = config.getString("host");
   let baseUrl = config.getOptionalString("baseUrl");
+  let cloneUrl = config.getOptionalString("cloneUrl");
   let gitilesBaseUrl = config.getOptionalString("gitilesBaseUrl");
   const username = config.getOptionalString("username");
   const password = config.getOptionalString("password");
@@ -461,6 +770,8 @@ function readGerritIntegrationConfig(config) {
     throw new Error(`Invalid Gerrit integration config, '${host}' is not a valid host`);
   } else if (baseUrl && !isValidUrl(baseUrl)) {
     throw new Error(`Invalid Gerrit integration config, '${baseUrl}' is not a valid baseUrl`);
+  } else if (cloneUrl && !isValidUrl(cloneUrl)) {
+    throw new Error(`Invalid Gerrit integration config, '${cloneUrl}' is not a valid cloneUrl`);
   } else if (gitilesBaseUrl && !isValidUrl(gitilesBaseUrl)) {
     throw new Error(`Invalid Gerrit integration config, '${gitilesBaseUrl}' is not a valid gitilesBaseUrl`);
   }
@@ -474,9 +785,15 @@ function readGerritIntegrationConfig(config) {
   } else {
     gitilesBaseUrl = `https://${host}`;
   }
+  if (cloneUrl) {
+    cloneUrl = lodash.trimEnd(cloneUrl, "/");
+  } else {
+    cloneUrl = baseUrl;
+  }
   return {
     host,
     baseUrl,
+    cloneUrl,
     gitilesBaseUrl,
     username,
     password
@@ -524,7 +841,7 @@ GerritIntegration.factory = ({ config }) => {
 };
 
 const GERRIT_BODY_PREFIX = ")]}'";
-function parseGitilesUrl(config, url) {
+function parseGerritGitilesUrl(config, url) {
   const urlPath = url.replace(config.gitilesBaseUrl, "");
   const parts = urlPath.split("/").filter((p) => !!p);
   const projectEndIndex = parts.indexOf("+");
@@ -547,10 +864,21 @@ function parseGitilesUrl(config, url) {
 function getAuthenticationPrefix(config) {
   return config.password ? "/a/" : "/";
 }
+function getGerritBranchApiUrl(config, url) {
+  const { branch, project } = parseGerritGitilesUrl(config, url);
+  return `${config.baseUrl}${getAuthenticationPrefix(config)}projects/${encodeURIComponent(project)}/branches/${branch}`;
+}
+function getGerritCloneRepoUrl(config, url) {
+  const { project } = parseGerritGitilesUrl(config, url);
+  return `${config.cloneUrl}${getAuthenticationPrefix(config)}${project}`;
+}
 function getGerritFileContentsApiUrl(config, url) {
-  const { branch, filePath, project } = parseGitilesUrl(config, url);
+  const { branch, filePath, project } = parseGerritGitilesUrl(config, url);
   return `${config.baseUrl}${getAuthenticationPrefix(config)}projects/${encodeURIComponent(project)}/branches/${branch}/files/${encodeURIComponent(filePath)}/content`;
 }
+function getGerritProjectsApiUrl(config) {
+  return `${config.baseUrl}${getAuthenticationPrefix(config)}projects/`;
+}
 function getGerritRequestOptions(config) {
   const headers = {};
   if (!config.password) {
@@ -995,85 +1323,14 @@ function readGoogleGcsIntegrationConfig(config) {
   return { clientEmail, privateKey };
 }
 
-const AMAZON_AWS_HOST = "amazonaws.com";
-function readAwsS3IntegrationConfig(config) {
-  var _a;
-  const endpoint = config.getOptionalString("endpoint");
-  const s3ForcePathStyle = (_a = config.getOptionalBoolean("s3ForcePathStyle")) != null ? _a : false;
-  let host;
-  let pathname;
-  if (endpoint) {
-    try {
-      const url = new URL(endpoint);
-      host = url.host;
-      pathname = url.pathname;
-    } catch {
-      throw new Error(`invalid awsS3 integration config, endpoint '${endpoint}' is not a valid URL`);
-    }
-    if (pathname !== "/") {
-      throw new Error(`invalid awsS3 integration config, endpoints cannot contain path, got '${endpoint}'`);
-    }
-  } else {
-    host = AMAZON_AWS_HOST;
-  }
-  const accessKeyId = config.getOptionalString("accessKeyId");
-  const secretAccessKey = config.getOptionalString("secretAccessKey");
-  const roleArn = config.getOptionalString("roleArn");
-  const externalId = config.getOptionalString("externalId");
-  return {
-    host,
-    endpoint,
-    s3ForcePathStyle,
-    accessKeyId,
-    secretAccessKey,
-    roleArn,
-    externalId
-  };
-}
-function readAwsS3IntegrationConfigs(configs) {
-  const result = configs.map(readAwsS3IntegrationConfig);
-  if (!result.some((c) => c.host === AMAZON_AWS_HOST)) {
-    result.push({
-      host: AMAZON_AWS_HOST
-    });
-  }
-  return result;
-}
-
-const _AwsS3Integration = class {
-  constructor(integrationConfig) {
-    this.integrationConfig = integrationConfig;
-  }
-  get type() {
-    return "awsS3";
-  }
-  get title() {
-    return this.integrationConfig.host;
-  }
-  get config() {
-    return this.integrationConfig;
-  }
-  resolveUrl(options) {
-    const resolved = defaultScmResolveUrl(options);
-    return resolved;
-  }
-  resolveEditUrl(url) {
-    return url;
-  }
-};
-let AwsS3Integration = _AwsS3Integration;
-AwsS3Integration.factory = ({ config }) => {
-  var _a;
-  const configs = readAwsS3IntegrationConfigs((_a = config.getOptionalConfigArray("integrations.awsS3")) != null ? _a : []);
-  return basicIntegrations(configs.map((c) => new _AwsS3Integration(c)), (i) => i.config.host);
-};
-
 class ScmIntegrations {
   static fromConfig(config) {
     return new ScmIntegrations({
       awsS3: AwsS3Integration.factory({ config }),
       azure: AzureIntegration.factory({ config }),
       bitbucket: BitbucketIntegration.factory({ config }),
+      bitbucketCloud: BitbucketCloudIntegration.factory({ config }),
+      bitbucketServer: BitbucketServerIntegration.factory({ config }),
       gerrit: GerritIntegration.factory({ config }),
       github: GitHubIntegration.factory({ config }),
       gitlab: GitLabIntegration.factory({ config })
@@ -1091,6 +1348,12 @@ class ScmIntegrations {
   get bitbucket() {
     return this.byType.bitbucket;
   }
+  get bitbucketCloud() {
+    return this.byType.bitbucketCloud;
+  }
+  get bitbucketServer() {
+    return this.byType.bitbucketServer;
+  }
   get gerrit() {
     return this.byType.gerrit;
   }
@@ -1127,7 +1390,9 @@ class ScmIntegrations {
 
 exports.AwsS3Integration = AwsS3Integration;
 exports.AzureIntegration = AzureIntegration;
+exports.BitbucketCloudIntegration = BitbucketCloudIntegration;
 exports.BitbucketIntegration = BitbucketIntegration;
+exports.BitbucketServerIntegration = BitbucketServerIntegration;
 exports.DefaultGithubCredentialsProvider = DefaultGithubCredentialsProvider;
 exports.GerritIntegration = GerritIntegration;
 exports.GitHubIntegration = GitHubIntegration;
@@ -1140,23 +1405,39 @@ exports.getAzureCommitsUrl = getAzureCommitsUrl;
 exports.getAzureDownloadUrl = getAzureDownloadUrl;
 exports.getAzureFileFetchUrl = getAzureFileFetchUrl;
 exports.getAzureRequestOptions = getAzureRequestOptions;
+exports.getBitbucketCloudDefaultBranch = getBitbucketCloudDefaultBranch;
+exports.getBitbucketCloudDownloadUrl = getBitbucketCloudDownloadUrl;
+exports.getBitbucketCloudFileFetchUrl = getBitbucketCloudFileFetchUrl;
+exports.getBitbucketCloudRequestOptions = getBitbucketCloudRequestOptions;
 exports.getBitbucketDefaultBranch = getBitbucketDefaultBranch;
 exports.getBitbucketDownloadUrl = getBitbucketDownloadUrl;
 exports.getBitbucketFileFetchUrl = getBitbucketFileFetchUrl;
 exports.getBitbucketRequestOptions = getBitbucketRequestOptions;
+exports.getBitbucketServerDefaultBranch = getBitbucketServerDefaultBranch;
+exports.getBitbucketServerDownloadUrl = getBitbucketServerDownloadUrl;
+exports.getBitbucketServerFileFetchUrl = getBitbucketServerFileFetchUrl;
+exports.getBitbucketServerRequestOptions = getBitbucketServerRequestOptions;
+exports.getGerritBranchApiUrl = getGerritBranchApiUrl;
+exports.getGerritCloneRepoUrl = getGerritCloneRepoUrl;
 exports.getGerritFileContentsApiUrl = getGerritFileContentsApiUrl;
+exports.getGerritProjectsApiUrl = getGerritProjectsApiUrl;
 exports.getGerritRequestOptions = getGerritRequestOptions;
 exports.getGitHubFileFetchUrl = getGitHubFileFetchUrl;
 exports.getGitHubRequestOptions = getGitHubRequestOptions;
 exports.getGitLabFileFetchUrl = getGitLabFileFetchUrl;
 exports.getGitLabRequestOptions = getGitLabRequestOptions;
+exports.parseGerritGitilesUrl = parseGerritGitilesUrl;
 exports.parseGerritJsonResponse = parseGerritJsonResponse;
 exports.readAwsS3IntegrationConfig = readAwsS3IntegrationConfig;
 exports.readAwsS3IntegrationConfigs = readAwsS3IntegrationConfigs;
 exports.readAzureIntegrationConfig = readAzureIntegrationConfig;
 exports.readAzureIntegrationConfigs = readAzureIntegrationConfigs;
+exports.readBitbucketCloudIntegrationConfig = readBitbucketCloudIntegrationConfig;
+exports.readBitbucketCloudIntegrationConfigs = readBitbucketCloudIntegrationConfigs;
 exports.readBitbucketIntegrationConfig = readBitbucketIntegrationConfig;
 exports.readBitbucketIntegrationConfigs = readBitbucketIntegrationConfigs;
+exports.readBitbucketServerIntegrationConfig = readBitbucketServerIntegrationConfig;
+exports.readBitbucketServerIntegrationConfigs = readBitbucketServerIntegrationConfigs;
 exports.readGerritIntegrationConfig = readGerritIntegrationConfig;
 exports.readGerritIntegrationConfigs = readGerritIntegrationConfigs;
 exports.readGitHubIntegrationConfig = readGitHubIntegrationConfig;