@red-hat-developer-hub/backstage-plugin-bulk-import-backend 6.2.0 → 6.4.0

package/dist/gitlab/gitlabApiService.cjs.js

@@ -0,0 +1,660 @@
+'use strict';
+
+var integration = require('@backstage/integration');
+var gitUrlParse = require('git-url-parse');
+var catalogUtils = require('../catalog/catalogUtils.cjs.js');
+require('@backstage/errors');
+require('@backstage/plugin-permission-common');
+require('@red-hat-developer-hub/backstage-plugin-bulk-import-common');
+require('just-kebab-case');
+var loggingUtils = require('../helpers/loggingUtils.cjs.js');
+var utils$1 = require('../helpers/utils.cjs.js');
+var handlers = require('../service/handlers/handlers.cjs.js');
+var GitlabAppManager = require('./GitlabAppManager.cjs.js');
+var glUtils = require('./utils/glUtils.cjs.js');
+var orgUtils = require('./utils/orgUtils.cjs.js');
+var prUtils = require('./utils/prUtils.cjs.js');
+var repoUtils = require('./utils/repoUtils.cjs.js');
+var utils = require('./utils/utils.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var gitUrlParse__default = /*#__PURE__*/_interopDefaultCompat(gitUrlParse);
+
+class GitlabApiService {
+  logger;
+  integrations;
+  gitlabCredentialsProvider;
+  config;
+  // Cache for storing ETags (used for efficient caching of unchanged data returned by GitHub)
+  cache;
+  constructor(logger, config, cacheService) {
+    this.logger = logger;
+    this.config = config;
+    this.integrations = integration.ScmIntegrations.fromConfig(config);
+    this.gitlabCredentialsProvider = GitlabAppManager.CustomGitlabCredentialsProvider.fromIntegrations(this.integrations);
+    this.cache = cacheService;
+  }
+  async getRepositoryFromIntegrations(repoUrl) {
+    const gitUrl = gitUrlParse__default.default(repoUrl);
+    const glConfig = this.integrations.gitlab.byUrl(repoUrl)?.config;
+    if (!glConfig) {
+      throw new Error(
+        `No Gitlab integration config found for repo ${repoUrl}. Please add a configuration entry under 'integrations.gitlab`
+      );
+    }
+    const credentials = await utils.getCredentialsForConfig(
+      this.gitlabCredentialsProvider,
+      glConfig
+    );
+    let repository = undefined;
+    for (const credential of credentials) {
+      const glKit = glUtils.buildGitlab(
+        {
+          logger: this.logger,
+          cache: this.cache
+        },
+        { credential, owner: gitUrl.owner },
+        glConfig.baseUrl
+      );
+      const repo = await glKit.Projects.show(`${gitUrl.owner}/${gitUrl.name}`);
+      if (!repo) {
+        continue;
+      }
+      repository = {
+        name: repo.name,
+        full_name: repo.path_with_namespace,
+        url: repo._links.self,
+        html_url: repo.web_url,
+        default_branch: repo.default_branch,
+        updated_at: repo.updated_at
+      };
+      break;
+    }
+    return {
+      repository,
+      errors: []
+    };
+  }
+  async getOrganizationsFromIntegrations(search, pageNumber = handlers.DefaultPageNumber, pageSize = handlers.DefaultPageSize) {
+    const groups = /* @__PURE__ */ new Map();
+    const result = await utils.fetchFromAllIntegrations(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        dataFetcher: async (glApi, credential, glConfig) => {
+          const dataFetchErrors = /* @__PURE__ */ new Map();
+          const resp = await orgUtils.addGitlabTokenGroups(
+            {
+              logger: this.logger
+            },
+            glApi,
+            credential,
+            {
+              search,
+              groups,
+              pageNumber,
+              pageSize,
+              errors: dataFetchErrors
+            }
+          );
+          this.logger.debug(
+            `Got ${resp.totalCount} groups(s) for ${glConfig.host}`
+          );
+          return {
+            result: resp.totalCount ?? 0,
+            errors: Array.from(dataFetchErrors.values())
+          };
+        }
+      }
+    );
+    const groupList = Array.from(groups.values());
+    const totalCount = utils$1.computeTotalCount(groupList, result.data, pageSize);
+    return {
+      organizations: groupList,
+      errors: Array.from(result.errors?.values() ?? []),
+      totalCount
+    };
+  }
+  async getOrgRepositoriesFromIntegrations(orgName, search, pageNumber = handlers.DefaultPageNumber, pageSize = handlers.DefaultPageSize) {
+    const orgRepositories = /* @__PURE__ */ new Map();
+    const result = await utils.fetchFromAllIntegrations(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        dataFetcher: async (glApi, credential, glConfig) => {
+          const dataFetchErrors = /* @__PURE__ */ new Map();
+          const resp = await repoUtils.addGitlabTokenOrgRepositories(
+            {
+              logger: this.logger
+            },
+            glApi,
+            credential,
+            orgName,
+            orgRepositories,
+            dataFetchErrors,
+            {
+              search,
+              pageNumber,
+              pageSize
+            }
+          );
+          this.logger.debug(
+            `Got ${resp.totalCount} org repo(s) for ${glConfig.host}`
+          );
+          return {
+            stopFetchingData: true,
+            result: resp.totalCount ?? 0,
+            errors: Array.from(dataFetchErrors.values())
+          };
+        }
+      }
+    );
+    const repoList = Array.from(orgRepositories.values());
+    const totalCount = utils$1.computeTotalCount(repoList, result.data, pageSize);
+    return {
+      repositories: repoList,
+      errors: Array.from(result.errors?.values() ?? []),
+      totalCount
+    };
+  }
+  /**
+   * Returns GitlabRepositoryResponse containing:
+   *   - a list of unique repositories the gitlab integrations have access to
+   *   - a list of errors encountered by each token (if any exist)
+   */
+  async getRepositoriesFromIntegrations(search, pageNumber = handlers.DefaultPageNumber, pageSize = handlers.DefaultPageSize) {
+    const repositories = /* @__PURE__ */ new Map();
+    const result = await utils.fetchFromAllIntegrations(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        dataFetcher: async (glApi, credential, glConfig) => {
+          const dataFetchErrors = /* @__PURE__ */ new Map();
+          const resp = await repoUtils.addGitlabTokenRepositories(
+            {
+              logger: this.logger
+            },
+            glApi,
+            credential,
+            repositories,
+            dataFetchErrors,
+            {
+              search,
+              pageNumber,
+              pageSize
+            }
+          );
+          this.logger.debug(
+            `Got ${resp.totalCount} repo(s) for ${glConfig.host}`
+          );
+          return {
+            result: resp.totalCount ?? 0,
+            errors: Array.from(dataFetchErrors.values())
+          };
+        }
+      }
+    );
+    const repoList = Array.from(repositories.values());
+    const totalCount = utils$1.computeTotalCount(repoList, result.data, pageSize);
+    return {
+      repositories: repoList,
+      errors: Array.from(result.errors?.values() ?? []),
+      totalCount
+    };
+  }
+  async filterLocationsAccessibleFromIntegrations(locationUrls) {
+    const locationGitOwnerMap = utils$1.extractLocationOwnerMap(locationUrls);
+    const allAccessibleTokenOrgs = /* @__PURE__ */ new Set();
+    const allAccessibleUsernames = /* @__PURE__ */ new Set();
+    await utils.fetchFromAllIntegrations(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        dataFetcher: async (gitlab) => {
+          const username = (await gitlab.Users.showCurrentUser()).username;
+          if (username) {
+            allAccessibleUsernames.add(username);
+          }
+          const allGroups = await gitlab.Groups.all({
+            allAvailable: false
+          });
+          allGroups.map((org) => org.path)?.forEach((orgName) => allAccessibleTokenOrgs.add(orgName));
+          return {};
+        }
+      }
+    );
+    return locationUrls.filter((loc) => {
+      if (!locationGitOwnerMap.has(loc)) {
+        return false;
+      }
+      const owner = locationGitOwnerMap.get(loc);
+      return allAccessibleTokenOrgs.has(owner) || allAccessibleUsernames.has(owner);
+    });
+  }
+  async findImportOpenPr(logger, input) {
+    const glConfig = this.integrations.gitlab.byUrl(input.repoUrl)?.config;
+    if (!glConfig) {
+      throw new Error(`Could not find GL integration from ${input.repoUrl}`);
+    }
+    const gitUrl = gitUrlParse__default.default(input.repoUrl);
+    const owner = gitUrl.organization;
+    const repo = gitUrl.name;
+    const credentials = await this.gitlabCredentialsProvider.getAllCredentials({
+      host: glConfig.host
+    });
+    if (credentials.length === 0) {
+      throw new Error(`No credentials for GL integration`);
+    }
+    const branchName = catalogUtils.getBranchName(this.config);
+    for (const credential of credentials) {
+      const glKit = glUtils.buildGitlab(
+        {
+          logger: this.logger,
+          cache: this.cache
+        },
+        { credential, owner },
+        glConfig.baseUrl
+      );
+      try {
+        return await prUtils.findOpenPRForBranch(
+          logger,
+          this.config,
+          glKit,
+          owner,
+          repo,
+          branchName,
+          input.includeCatalogInfoContent
+        );
+      } catch (error) {
+        loggingUtils.logErrorIfNeeded(this.logger, "Error fetching pull requests", error);
+      }
+    }
+    return {};
+  }
+  async submitPrToRepo(logger, input) {
+    const fileName = catalogUtils.getCatalogFilename(this.config);
+    const errors = [];
+    const result = await utils.executeFunctionOnFirstSuccessfulIntegration(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        config: this.config,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        repoUrl: input.repoUrl,
+        fn: async (validatedRepo, gitlab) => {
+          const { owner, repo, branchName } = validatedRepo;
+          try {
+            const catalogInfoFileExists = await repoUtils.fileExistsInDefaultBranch(
+              logger,
+              gitlab,
+              owner,
+              repo,
+              fileName,
+              input.defaultBranch
+            );
+            if (catalogInfoFileExists) {
+              return {
+                successful: true,
+                result: {
+                  hasChanges: false
+                }
+              };
+            }
+            const existingPrForBranch = await prUtils.findOpenPRForBranch(
+              logger,
+              this.config,
+              gitlab,
+              owner,
+              repo,
+              branchName
+            );
+            const repoData = await gitlab.Projects.show(`${owner}/${repo}`);
+            const parentRef = await gitlab.Branches.show(
+              `${owner}/${repo}`,
+              repoData.default_branch
+            );
+            if (existingPrForBranch.prNum) {
+              await repoUtils.createOrUpdateFileInBranch(
+                gitlab,
+                owner,
+                repo,
+                branchName,
+                fileName,
+                input.catalogInfoContent
+              );
+              const pullRequestResponse2 = await gitlab.MergeRequests.edit(
+                `${owner}/${repo}`,
+                existingPrForBranch.prNum,
+                {
+                  description: input.prBody,
+                  title: input.prTitle,
+                  targetBranch: repoData.default_branch
+                }
+              );
+              return {
+                successful: true,
+                result: {
+                  prNumber: existingPrForBranch.prNum,
+                  prUrl: pullRequestResponse2.web_url,
+                  lastUpdate: pullRequestResponse2.updated_at
+                }
+              };
+            }
+            try {
+              await gitlab.Branches.show(`${owner}/${repo}`, branchName);
+            } catch (error) {
+              if (error.cause.response.status === 404) {
+                await gitlab.Branches.create(
+                  `${owner}/${repo}`,
+                  branchName,
+                  parentRef.name
+                );
+              } else {
+                throw error;
+              }
+            }
+            await repoUtils.createOrUpdateFileInBranch(
+              gitlab,
+              owner,
+              repo,
+              branchName,
+              fileName,
+              input.catalogInfoContent
+            );
+            const pullRequestResponse = await gitlab.MergeRequests.create(
+              `${owner}/${repo}`,
+              branchName,
+              repoData.default_branch,
+              input.prTitle,
+              {
+                description: input.prBody
+              }
+            );
+            return {
+              successful: true,
+              result: {
+                prNumber: pullRequestResponse.iid,
+                prUrl: pullRequestResponse.web_url,
+                lastUpdate: pullRequestResponse.updated_at,
+                hasChanges: true
+              }
+            };
+          } catch (e) {
+            loggingUtils.logErrorIfNeeded(
+              this.logger,
+              `Couldn't create PR in ${input.repoUrl}`,
+              e
+            );
+            errors.push(e.message);
+            return { successful: false };
+          }
+        }
+      }
+    );
+    if (result) {
+      return result;
+    }
+    logger.warn(
+      `Tried all possible Gitlab credentials, but could not create PR in ${input.repoUrl}. Please try again later...`
+    );
+    return {
+      errors
+    };
+  }
+  async hasFileInRepo(input) {
+    const fileExists = await utils.executeFunctionOnFirstSuccessfulIntegration(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        config: this.config,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        repoUrl: input.repoUrl,
+        fn: async (validatedRepo, gitlab) => {
+          const { owner, repo } = validatedRepo;
+          const exists = await repoUtils.fileExistsInDefaultBranch(
+            this.logger,
+            gitlab,
+            owner,
+            repo,
+            input.fileName,
+            input.defaultBranch
+          );
+          if (exists === undefined) {
+            return { successful: false };
+          }
+          return { successful: true, result: exists };
+        }
+      }
+    );
+    if (fileExists === undefined) {
+      throw new Error(
+        `Could not determine if repo at ${input.repoUrl} already has a file named ${input.fileName} in its default branch (${input.defaultBranch})`
+      );
+    }
+    return fileExists;
+  }
+  async closeImportPR(logger, input) {
+    await utils.executeFunctionOnFirstSuccessfulIntegration(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        config: this.config,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        repoUrl: input.repoUrl,
+        fn: async (validatedRepo, gitlab) => {
+          const { owner, repo, branchName } = validatedRepo;
+          try {
+            const existingPrForBranch = await prUtils.findOpenPRForBranch(
+              logger,
+              this.config,
+              gitlab,
+              owner,
+              repo,
+              branchName
+            );
+            if (existingPrForBranch.prNum) {
+              await prUtils.closePRWithComment(
+                gitlab,
+                owner,
+                repo,
+                existingPrForBranch.prNum,
+                input.comment
+              );
+            }
+            return { successful: true };
+          } catch (e) {
+            loggingUtils.logErrorIfNeeded(
+              this.logger,
+              `Couldn't close PR in ${input.repoUrl}`,
+              e
+            );
+            return { successful: false };
+          }
+        }
+      }
+    );
+  }
+  async deleteImportBranch(input) {
+    await utils.executeFunctionOnFirstSuccessfulIntegration(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        config: this.config,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        repoUrl: input.repoUrl,
+        fn: async (validatedRepo, gitlab) => {
+          const { owner, repo, branchName } = validatedRepo;
+          try {
+            await gitlab.Branches.remove(`${owner}/${repo}`, branchName);
+            return { successful: true };
+          } catch (e) {
+            loggingUtils.logErrorIfNeeded(
+              this.logger,
+              `Couldn't close import PR and/or delete import branch in ${input.repoUrl}`,
+              e
+            );
+            return { successful: false };
+          }
+        }
+      }
+    );
+  }
+  async isRepoEmpty(input) {
+    return await utils.executeFunctionOnFirstSuccessfulIntegration(
+      {
+        logger: this.logger,
+        cache: this.cache,
+        config: this.config,
+        gitlabCredentialsProvider: this.gitlabCredentialsProvider
+      },
+      this.integrations,
+      {
+        repoUrl: input.repoUrl,
+        fn: async (validatedRepo, gitlab) => {
+          const { owner, repo } = validatedRepo;
+          const resp = await gitlab.Repositories.allContributors(
+            `${owner}/${repo}`,
+            {
+              showExpanded: true
+            }
+          );
+          return { successful: true, result: resp?.data?.length < 1 };
+        }
+      }
+    );
+  }
+  async getPullRequest(repoUrl, pullRequestNumber) {
+    const glConfig = this.integrations.gitlab.byUrl(repoUrl)?.config;
+    if (!glConfig) {
+      this.logger.error(
+        `No Gitlab integration config found for repo ${repoUrl}`
+      );
+      return {};
+    }
+    const gitUrl = gitUrlParse__default.default(repoUrl);
+    const owner = gitUrl.owner;
+    const repo = gitUrl.name;
+    const credentials = await this.gitlabCredentialsProvider.getAllCredentials({
+      host: glConfig.host
+    });
+    if (credentials.length === 0) {
+      this.logger.error(`No credentials for GL integration`);
+      return {};
+    }
+    for (const credential of credentials) {
+      const glKit = glUtils.buildGitlab(
+        {
+          logger: this.logger,
+          cache: this.cache
+        },
+        { credential, owner },
+        glConfig.baseUrl
+      );
+      try {
+        const pr = await glKit.MergeRequests.show(
+          `${owner}/${repo}`,
+          pullRequestNumber
+        );
+        return {
+          title: pr.title,
+          body: pr.description || void 0,
+          merged: pr.state === "merged",
+          lastUpdated: pr.updated_at,
+          prSha: pr.sha,
+          prBranch: pr.source_branch
+        };
+      } catch (error) {
+        this.logger.error(
+          `Error fetching pull request ${pullRequestNumber} from ${repoUrl}`,
+          error
+        );
+      }
+    }
+    return {};
+  }
+  async getCatalogInfoFile(logger, input) {
+    const glConfig = this.integrations.gitlab.byUrl(input.repoUrl)?.config;
+    if (!glConfig) {
+      logger.error(
+        `No Gitlab integration config found for repo ${input.repoUrl}`
+      );
+      return undefined;
+    }
+    const gitUrl = gitUrlParse__default.default(input.repoUrl);
+    const owner = gitUrl.owner;
+    const repo = gitUrl.name;
+    const credentials = await this.gitlabCredentialsProvider.getAllCredentials({
+      host: glConfig.host
+    });
+    if (credentials.length === 0) {
+      logger.error(`No credentials for GL integration`);
+      return undefined;
+    }
+    for (const credential of credentials) {
+      const glKit = glUtils.buildGitlab(
+        {
+          logger: this.logger,
+          cache: this.cache
+        },
+        { credential, owner },
+        glConfig.baseUrl
+      );
+      try {
+        const file = await glKit.RepositoryFiles.show(
+          `${owner}/${repo}`,
+          catalogUtils.getCatalogFilename(this.config),
+          input.prHeadSha
+        );
+        if (file) {
+          const content = Buffer.from(file.content, "base64").toString("utf-8");
+          return content;
+        }
+      } catch (error) {
+        if (error.cause?.response?.status === 404) {
+          logger.warn(
+            `catalog-info.yaml not found in PR ${input.prNumber} of ${input.repoUrl}`
+          );
+          return undefined;
+        }
+        logger.error(
+          `Error fetching catalog-info.yaml from PR ${input.prNumber} of ${input.repoUrl}`,
+          error
+        );
+        return undefined;
+      }
+    }
+    return undefined;
+  }
+}
+
+exports.GitlabApiService = GitlabApiService;
+//# sourceMappingURL=gitlabApiService.cjs.js.map