[GRPC] Organization API

components/dashboard/src/service/json-rpc-organization-client.ts

@@ -0,0 +1,219 @@
+/**
+ * Copyright (c) 2023 Gitpod GmbH. All rights reserved.
+ * Licensed under the GNU Affero General Public License (AGPL).
+ * See License.AGPL.txt in the project root for license information.
+ */
+
+import { PartialMessage } from "@bufbuild/protobuf";
+import { CallOptions, Code, ConnectError, PromiseClient } from "@connectrpc/connect";
+import { OrganizationService } from "@gitpod/public-api/lib/gitpod/experimental/v2/organization_connect";
+import {
+    CreateOrganizationRequest,
+    CreateOrganizationResponse,
+    DeleteOrganizationMemberRequest,
+    DeleteOrganizationMemberResponse,
+    DeleteOrganizationRequest,
+    DeleteOrganizationResponse,
+    GetOrganizationInvitationRequest,
+    GetOrganizationInvitationResponse,
+    GetOrganizationRequest,
+    GetOrganizationResponse,
+    GetOrganizationSettingsRequest,
+    GetOrganizationSettingsResponse,
+    JoinOrganizationRequest,
+    JoinOrganizationResponse,
+    ListOrganizationMembersRequest,
+    ListOrganizationMembersResponse,
+    ListOrganizationsRequest,
+    ListOrganizationsResponse,
+    ResetOrganizationInvitationRequest,
+    ResetOrganizationInvitationResponse,
+    UpdateOrganizationMemberRequest,
+    UpdateOrganizationMemberResponse,
+    UpdateOrganizationRequest,
+    UpdateOrganizationResponse,
+    UpdateOrganizationSettingsRequest,
+    UpdateOrganizationSettingsResponse,
+} from "@gitpod/public-api/lib/gitpod/experimental/v2/organization_pb";
+import { getGitpodService } from "./service";
+import { converter } from "./public-api";
+
+export class JsonRpcOrganizationClient implements PromiseClient<typeof OrganizationService> {
+    async createOrganization(
+        request: PartialMessage<CreateOrganizationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<CreateOrganizationResponse> {
+        if (!request.name) {
+            throw new ConnectError("name is required", Code.InvalidArgument);
+        }
+        const result = await getGitpodService().server.createTeam(request.name);
+        return new CreateOrganizationResponse({
+            organization: converter.toOrganization(result),
+        });
+    }
+
+    async getOrganization(
+        request: PartialMessage<GetOrganizationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<GetOrganizationResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        const result = await getGitpodService().server.getTeam(request.organizationId);
+
+        return new GetOrganizationResponse({
+            organization: converter.toOrganization(result),
+        });
+    }
+
+    async updateOrganization(
+        request: PartialMessage<UpdateOrganizationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<UpdateOrganizationResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        if (!request.name) {
+            throw new ConnectError("name is required", Code.InvalidArgument);
+        }
+        await getGitpodService().server.updateTeam(request.organizationId, {
+            name: request.name,
+        });
+        return new UpdateOrganizationResponse();
+    }
+
+    async listOrganizations(
+        request: PartialMessage<ListOrganizationsRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<ListOrganizationsResponse> {
+        const result = await getGitpodService().server.getTeams();
+        return new ListOrganizationsResponse({
+            organizations: result.map((team) => converter.toOrganization(team)),
+        });
+    }
+
+    async deleteOrganization(
+        request: PartialMessage<DeleteOrganizationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<DeleteOrganizationResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        await getGitpodService().server.deleteTeam(request.organizationId);
+        return new DeleteOrganizationResponse();
+    }
+
+    async getOrganizationInvitation(
+        request: PartialMessage<GetOrganizationInvitationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<GetOrganizationInvitationResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        const result = await getGitpodService().server.getGenericInvite(request.organizationId);
+        return new GetOrganizationInvitationResponse({
+            invitationId: result.id,
+        });
+    }
+
+    async joinOrganization(
+        request: PartialMessage<JoinOrganizationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<JoinOrganizationResponse> {
+        if (!request.invitationId) {
+            throw new ConnectError("invitationId is required", Code.InvalidArgument);
+        }
+        const result = await getGitpodService().server.joinTeam(request.invitationId);
+        return new JoinOrganizationResponse({
+            organizationId: result.id,
+        });
+    }
+
+    async resetOrganizationInvitation(
+        request: PartialMessage<ResetOrganizationInvitationRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<ResetOrganizationInvitationResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        const newInvite = await getGitpodService().server.resetGenericInvite(request.organizationId);
+        return new ResetOrganizationInvitationResponse({
+            invitationId: newInvite.id,
+        });
+    }
+
+    async listOrganizationMembers(
+        request: PartialMessage<ListOrganizationMembersRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<ListOrganizationMembersResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        const result = await getGitpodService().server.getTeamMembers(request.organizationId);
+        return new ListOrganizationMembersResponse({
+            members: result.map((member) => converter.toOrganizationMember(member)),
+        });
+    }
+
+    async updateOrganizationMember(
+        request: PartialMessage<UpdateOrganizationMemberRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<UpdateOrganizationMemberResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        if (!request.userId) {
+            throw new ConnectError("userId is required", Code.InvalidArgument);
+        }
+        if (!request.role) {
+            throw new ConnectError("role is required", Code.InvalidArgument);
+        }
+        await getGitpodService().server.setTeamMemberRole(
+            request.organizationId,
+            request.userId,
+            converter.fromOrgMemberRole(request.role),
+        );
+        return new UpdateOrganizationMemberResponse();
+    }
+
+    async deleteOrganizationMember(
+        request: PartialMessage<DeleteOrganizationMemberRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<DeleteOrganizationMemberResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        if (!request.userId) {
+            throw new ConnectError("userId is required", Code.InvalidArgument);
+        }
+        await getGitpodService().server.removeTeamMember(request.organizationId, request.userId);
+        return new DeleteOrganizationMemberResponse();
+    }
+
+    async getOrganizationSettings(
+        request: PartialMessage<GetOrganizationSettingsRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<GetOrganizationSettingsResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        const result = await getGitpodService().server.getOrgSettings(request.organizationId);
+        return new GetOrganizationSettingsResponse({
+            settings: converter.toOrganizationSettings(result),
+        });
+    }
+
+    async updateOrganizationSettings(
+        request: PartialMessage<UpdateOrganizationSettingsRequest>,
+        options?: CallOptions | undefined,
+    ): Promise<UpdateOrganizationSettingsResponse> {
+        if (!request.organizationId) {
+            throw new ConnectError("id is required", Code.InvalidArgument);
+        }
+        await getGitpodService().server.updateOrgSettings(request.organizationId, {
+            workspaceSharingDisabled: request.settings?.workspaceSharingDisabled,
+            defaultWorkspaceImage: request.settings?.defaultWorkspaceImage,
+        });
+        return new UpdateOrganizationSettingsResponse();
+    }
+}

components/dashboard/src/service/public-api.ts

@@ -22,6 +22,8 @@ import { WorkspaceService } from "@gitpod/public-api/lib/gitpod/experimental/v2/
 import { getMetricsInterceptor } from "@gitpod/public-api/lib/metrics";
 import { getExperimentsClient } from "../experiments/client";
 import { JsonRpcWorkspaceClient } from "./json-rpc-workspace-client";
+import { JsonRpcOrganizationClient } from "./json-rpc-organization-client";
+import { OrganizationService } from "@gitpod/public-api/lib/gitpod/experimental/v2/organization_connect";
 
 const transport = createConnectTransport({
     baseUrl: `${window.location.protocol}//${window.location.host}/public-api`,
@@ -41,6 +43,7 @@ export const workspacesService = createPromiseClient(WorkspaceV1Service, transpo
 export const oidcService = createPromiseClient(OIDCService, transport);
 
 export const workspaceClient = createServiceClient(WorkspaceService, new JsonRpcWorkspaceClient());
+export const organizationClient = createServiceClient(OrganizationService, new JsonRpcOrganizationClient());
 
 export function publicApiTeamToProtocol(team: Team): ProtocolTeam {
     return {

components/gitpod-protocol/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+    "mochaExplorer.files": [
+        "dist/**/*.spec.js",
+        "dist/**/*.spec.db.js"
+    ],
+    "mochaExplorer.require": [
+        "source-map-support/register",
+        "reflect-metadata/Reflect"
+    ],
+    "mochaExplorer.watch": [
+        "dist/**/*.spec.js",
+        "dist/**/*.spec.db.js"
+    ],
+    "mochaExplorer.exit": true,
+    "mochaExplorer.timeout": 60000
+}

components/gitpod-protocol/BUILD.yaml

@@ -20,6 +20,9 @@ packages:
       packaging: library
       yarnLock: ${coreYarnLockBase}/yarn.lock
       tsconfig: tsconfig.json
+      commands:
+        # leeway executes the build and test step in the wrong order, so we need to call a special script that builds before testing
+        test: ["yarn", "test:leeway"]
   - name: gitpod-schema
     type: generic
     srcs:

components/gitpod-protocol/package.json

@@ -41,8 +41,9 @@
         "build": "yarn lint && tsc",
         "lint": "yarn eslint src/*.ts src/**/*.ts",
         "lint:fix": "yarn eslint src/*.ts src/**/*.ts --fix",
-        "test": "mocha './**/*.spec.ts' --exclude './node_modules/**'",
-        "test-debug": "mocha --inspect-brk './**/*.spec.ts' --exclude './node_modules/**' --exit",
+        "test": "mocha './**/*.spec.js' --exclude './node_modules/**' --exit",
+        "test:leeway": "yarn build && yarn test",
+        "test-debug": "mocha --inspect-brk './**/*.spec.js' --exclude './node_modules/**' --exit",
         "watch": "leeway exec --package .:lib --transitive-dependencies --filter-type yarn --components --parallel -- tsc -w --preserveWatchOutput"
     },
     "mocha": {