[server] handle searchRepositories

Author: AlexTugarev

components/gitpod-protocol/src/public-api-converter.ts

@@ -43,7 +43,7 @@ import {
     EnvironmentVariableAdmission,
     UserEnvironmentVariable,
 } from "@gitpod/public-api/lib/gitpod/v1/envvar_pb";
-import { SCMToken } from "@gitpod/public-api/lib/gitpod/v1/scm_pb";
+import { SCMToken, SuggestedRepository } from "@gitpod/public-api/lib/gitpod/v1/scm_pb";
 import { ContextURL } from "./context-url";
 import { ApplicationError, ErrorCode, ErrorCodes } from "./messaging/error";
 import {
@@ -59,6 +59,7 @@ import {
     UserEnvVarValue,
     ProjectEnvVar,
     Token,
+    SuggestedRepository as SuggestedRepositoryProtocol,
 } from "./protocol";
 import {
     OrgMemberInfo,
@@ -556,4 +557,13 @@ export class PublicAPIConverter {
             idToken: t.idToken,
         });
     }
+
+    toSuggestedRepository(r: SuggestedRepositoryProtocol): SuggestedRepository {
+        return new SuggestedRepository({
+            url: r.url,
+            repoName: r.repositoryName,
+            configurationId: r.projectId,
+            configurationName: r.projectName,
+        });
+    }
 }

components/server/src/api/scm-service-api.ts

@@ -41,7 +41,7 @@ export class ScmServiceAPI implements ServiceImpl<typeof ScmServiceInterface> {
 
     async guessTokenScopes(
         request: GuessTokenScopesRequest,
-        context: HandlerContext,
+        _context: HandlerContext,
     ): Promise<GuessTokenScopesResponse> {
         const userId = ctxUserId();
         const { scopes, message } = await this.scmService.guessTokenScopes(userId, request);
@@ -53,14 +53,21 @@ export class ScmServiceAPI implements ServiceImpl<typeof ScmServiceInterface> {
 
     async searchRepositories(
         request: SearchRepositoriesRequest,
-        context: HandlerContext,
+        _context: HandlerContext,
     ): Promise<SearchRepositoriesResponse> {
-        throw new ConnectError("unimplemented", Code.Unimplemented);
+        const userId = ctxUserId();
+        const repos = await this.scmService.searchRepositories(userId, {
+            searchString: request.searchString,
+            limit: request.limit,
+        });
+        return new SearchRepositoriesResponse({
+            repositories: repos.map((r) => this.apiConverter.toSuggestedRepository(r)),
+        });
     }
 
     async listSuggestedRepositories(
         request: ListSuggestedRepositoriesRequest,
-        context: HandlerContext,
+        _context: HandlerContext,
     ): Promise<ListSuggestedRepositoriesResponse> {
         throw new ConnectError("unimplemented", Code.Unimplemented);
     }

components/server/src/scm/scm-service.ts

@@ -8,14 +8,19 @@ import { inject, injectable } from "inversify";
 import { Authorizer } from "../authorization/authorizer";
 import { Config } from "../config";
 import { TokenProvider } from "../user/token-provider";
-import { Project, Token, User } from "@gitpod/gitpod-protocol";
+import { Project, SuggestedRepository, Token, User } from "@gitpod/gitpod-protocol";
 import { HostContextProvider } from "../auth/host-context-provider";
 import { RepoURL } from "../repohost";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
 import { AuthProviderService } from "../auth/auth-provider-service";
 import { UserService } from "../user/user-service";
 import { GitTokenScopeGuesser } from "../workspace/git-token-scope-guesser";
 import { ApplicationError, ErrorCodes } from "@gitpod/gitpod-protocol/lib/messaging/error";
+import {
+    SuggestedRepositoryWithSorting,
+    sortSuggestedRepositories,
+    suggestionFromUserRepo,
+} from "../workspace/suggested-repos-sorter";
 
 @injectable()
 export class ScmService {
@@ -74,4 +79,45 @@ export class ScmService {
             currentToken,
         });
     }
+
+    public async searchRepositories(userId: string, params: { searchString: string; limit?: number }) {
+        const user = await this.userService.findUserById(userId, userId);
+        const hosts = (await this.authProviderService.getAuthProviderDescriptions(user)).map((p) => p.host);
+
+        const limit: number = params.limit || 30;
+
+        const providerRepos = await Promise.all(
+            hosts.map(async (host): Promise<SuggestedRepositoryWithSorting[]> => {
+                try {
+                    const hostContext = this.hostContextProvider.get(host);
+                    const services = hostContext?.services;
+                    if (!services) {
+                        return [];
+                    }
+                    const repos = await services.repositoryProvider.searchRepos(user, params.searchString, limit);
+
+                    return repos.map((r) =>
+                        suggestionFromUserRepo({
+                            url: r.url.replace(/\.git$/, ""),
+                            repositoryName: r.name,
+                        }),
+                    );
+                } catch (error) {
+                    log.warn("Could not search repositories from host " + host, error);
+                }
+
+                return [];
+            }),
+        );
+
+        const sortedRepos = sortSuggestedRepositories(providerRepos.flat());
+
+        //return only the first 'limit' results
+        return sortedRepos.slice(0, limit).map(
+            (repo): SuggestedRepository => ({
+                url: repo.url,
+                repositoryName: repo.repositoryName,
+            }),
+        );
+    }
 }

components/server/src/workspace/gitpod-server-impl.ts

@@ -1484,49 +1484,10 @@ export class GitpodServerImpl implements GitpodServerWithTracing, Disposable {
         ctx: TraceContext,
         params: SearchRepositoriesParams,
     ): Promise<SuggestedRepository[]> {
+        traceAPIParams(ctx, { params });
         const user = await this.checkAndBlockUser("searchRepositories");
 
-        const logCtx: LogContext = { userId: user.id };
-        const limit: number = params.limit || 30;
-
-        // Search repos across scm providers for this user
-        // Will search personal, and org repos
-        const authProviders = await this.getAuthProviders(ctx);
-
-        const providerRepos = await Promise.all(
-            authProviders.map(async (p): Promise<SuggestedRepositoryWithSorting[]> => {
-                try {
-                    const hostContext = this.hostContextProvider.get(p.host);
-                    const services = hostContext?.services;
-                    if (!services) {
-                        log.error(logCtx, "Unsupported repository host: " + p.host);
-                        return [];
-                    }
-                    const repos = await services.repositoryProvider.searchRepos(user, params.searchString, limit);
-
-                    return repos.map((r) =>
-                        suggestionFromUserRepo({
-                            url: r.url.replace(/\.git$/, ""),
-                            repositoryName: r.name,
-                        }),
-                    );
-                } catch (error) {
-                    log.warn(logCtx, "Could not search repositories from host " + p.host, error);
-                }
-
-                return [];
-            }),
-        );
-
-        const sortedRepos = sortSuggestedRepositories(providerRepos.flat());
-
-        //return only the first 'limit' results
-        return sortedRepos.slice(0, limit).map(
-            (repo): SuggestedRepository => ({
-                url: repo.url,
-                repositoryName: repo.repositoryName,
-            }),
-        );
+        return await this.scmService.searchRepositories(user.id, params);
     }
 
     public async setWorkspaceTimeout(