Merge branch 'main' into ft/focus-targets

Author: filiptronicek

components/gitpod-db/src/typeorm/project-db-impl.ts

@@ -4,17 +4,18 @@
  * See License.AGPL.txt in the project root for license information.
  */
 
+import { PartialProject, Project, ProjectEnvVar, ProjectEnvVarWithValue, ProjectUsage } from "@gitpod/gitpod-protocol";
+import { EncryptionService } from "@gitpod/gitpod-protocol/lib/encryption/encryption-service";
 import { inject, injectable, optional } from "inversify";
 import { EntityManager, Repository } from "typeorm";
 import { v4 as uuidv4 } from "uuid";
-import { PartialProject, Project, ProjectEnvVar, ProjectEnvVarWithValue, ProjectUsage } from "@gitpod/gitpod-protocol";
-import { EncryptionService } from "@gitpod/gitpod-protocol/lib/encryption/encryption-service";
 import { ProjectDB } from "../project-db";
 import { DBProject } from "./entity/db-project";
 import { DBProjectEnvVar } from "./entity/db-project-env-vars";
 import { DBProjectInfo } from "./entity/db-project-info";
 import { DBProjectUsage } from "./entity/db-project-usage";
-import { TransactionalDBImpl, UndefinedEntityManager } from "./transactional-db-impl";
+import { TransactionalDBImpl } from "./transactional-db-impl";
+import { TypeORM } from "./typeorm";
 
 function toProjectEnvVar(envVarWithValue: ProjectEnvVarWithValue): ProjectEnvVar {
     const envVar = { ...envVarWithValue };
@@ -25,29 +26,30 @@ function toProjectEnvVar(envVarWithValue: ProjectEnvVarWithValue): ProjectEnvVar
 @injectable()
 export class ProjectDBImpl extends TransactionalDBImpl<ProjectDB> implements ProjectDB {
     constructor(
-        @inject(EncryptionService) protected readonly encryptionService: EncryptionService,
-        @inject(UndefinedEntityManager) @optional() transactionalEM: EntityManager | undefined,
+        @inject(TypeORM) typeorm: TypeORM,
+        @inject(EncryptionService) private readonly encryptionService: EncryptionService,
+        @optional() transactionalEM?: EntityManager,
     ) {
-        super(transactionalEM);
+        super(typeorm, transactionalEM);
     }
 
     protected createTransactionalDB(transactionalEM: EntityManager): ProjectDB {
-        return new ProjectDBImpl(this.encryptionService, transactionalEM);
+        return new ProjectDBImpl(this.typeorm, this.encryptionService, transactionalEM);
     }
 
-    protected async getRepo(): Promise<Repository<DBProject>> {
+    private async getRepo(): Promise<Repository<DBProject>> {
         return (await this.getEntityManager()).getRepository<DBProject>(DBProject);
     }
 
-    protected async getProjectEnvVarRepo(): Promise<Repository<DBProjectEnvVar>> {
+    private async getProjectEnvVarRepo(): Promise<Repository<DBProjectEnvVar>> {
         return (await this.getEntityManager()).getRepository<DBProjectEnvVar>(DBProjectEnvVar);
     }
 
-    protected async getProjectInfoRepo(): Promise<Repository<DBProjectInfo>> {
+    private async getProjectInfoRepo(): Promise<Repository<DBProjectInfo>> {
         return (await this.getEntityManager()).getRepository<DBProjectInfo>(DBProjectInfo);
     }
 
-    protected async getProjectUsageRepo(): Promise<Repository<DBProjectUsage>> {
+    private async getProjectUsageRepo(): Promise<Repository<DBProjectUsage>> {
         return (await this.getEntityManager()).getRepository<DBProjectUsage>(DBProjectUsage);
     }
 

components/gitpod-db/src/typeorm/team-db-impl.ts

@@ -5,55 +5,56 @@
  */
 
 import {
+    OrganizationSettings,
     Team,
     TeamMemberInfo,
     TeamMemberRole,
     TeamMembershipInvite,
-    OrganizationSettings,
     User,
 } from "@gitpod/gitpod-protocol";
+import { ErrorCodes } from "@gitpod/gitpod-protocol/lib/messaging/error";
+import { randomBytes } from "crypto";
 import { inject, injectable, optional } from "inversify";
+import slugify from "slugify";
 import { EntityManager, Repository } from "typeorm";
 import { v4 as uuidv4 } from "uuid";
-import { randomBytes } from "crypto";
+import { ResponseError } from "vscode-jsonrpc";
 import { TeamDB } from "../team-db";
 import { DBTeam } from "./entity/db-team";
 import { DBTeamMembership } from "./entity/db-team-membership";
-import { DBUser } from "./entity/db-user";
 import { DBTeamMembershipInvite } from "./entity/db-team-membership-invite";
-import { ResponseError } from "vscode-jsonrpc";
-import { ErrorCodes } from "@gitpod/gitpod-protocol/lib/messaging/error";
-import slugify from "slugify";
 import { DBOrgSettings } from "./entity/db-team-settings";
-import { TransactionalDBImpl, UndefinedEntityManager } from "./transactional-db-impl";
+import { DBUser } from "./entity/db-user";
+import { TransactionalDBImpl } from "./transactional-db-impl";
+import { TypeORM } from "./typeorm";
 
 @injectable()
 export class TeamDBImpl extends TransactionalDBImpl<TeamDB> implements TeamDB {
-    constructor(@inject(UndefinedEntityManager) @optional() transactionalEM: EntityManager | undefined) {
-        super(transactionalEM);
+    constructor(@inject(TypeORM) typeorm: TypeORM, @optional() transactionalEM?: EntityManager) {
+        super(typeorm, transactionalEM);
     }
 
     protected createTransactionalDB(transactionalEM: EntityManager): TeamDB {
-        return new TeamDBImpl(transactionalEM);
+        return new TeamDBImpl(this.typeorm, transactionalEM);
     }
 
-    protected async getTeamRepo(): Promise<Repository<DBTeam>> {
+    private async getTeamRepo(): Promise<Repository<DBTeam>> {
         return (await this.getEntityManager()).getRepository<DBTeam>(DBTeam);
     }
 
-    protected async getMembershipRepo(): Promise<Repository<DBTeamMembership>> {
+    private async getMembershipRepo(): Promise<Repository<DBTeamMembership>> {
         return (await this.getEntityManager()).getRepository<DBTeamMembership>(DBTeamMembership);
     }
 
-    protected async getMembershipInviteRepo(): Promise<Repository<DBTeamMembershipInvite>> {
+    private async getMembershipInviteRepo(): Promise<Repository<DBTeamMembershipInvite>> {
         return (await this.getEntityManager()).getRepository<DBTeamMembershipInvite>(DBTeamMembershipInvite);
     }
 
-    protected async getOrgSettingsRepo(): Promise<Repository<DBOrgSettings>> {
+    private async getOrgSettingsRepo(): Promise<Repository<DBOrgSettings>> {
         return (await this.getEntityManager()).getRepository<DBOrgSettings>(DBOrgSettings);
     }
 
-    protected async getUserRepo(): Promise<Repository<DBUser>> {
+    private async getUserRepo(): Promise<Repository<DBUser>> {
         return (await this.getEntityManager()).getRepository<DBUser>(DBUser);
     }
 

components/gitpod-db/src/typeorm/transactional-db-impl.ts

@@ -12,15 +12,11 @@ export interface TransactionalDB<DB> {
     transaction<R>(code: (db: DB) => Promise<R>): Promise<R>;
 }
 
-// A symbol we never bind to
-export const UndefinedEntityManager = Symbol("UndefinedEntityManager");
-
 @injectable()
 export abstract class TransactionalDBImpl<DB> implements TransactionalDB<DB> {
-    @inject(TypeORM) protected readonly typeorm: TypeORM;
-
     constructor(
-        @optional() protected transactionalEM: EntityManager | undefined, // will be undefined when constructed with inversify, which is inteded
+        @inject(TypeORM) protected readonly typeorm: TypeORM,
+        @optional() private transactionalEM?: EntityManager,
     ) {}
 
     protected async getEntityManager(): Promise<EntityManager> {

components/gitpod-db/src/typeorm/user-db-impl.ts

@@ -43,11 +43,11 @@ import { DBIdentity } from "./entity/db-identity";
 import { DBTokenEntry } from "./entity/db-token-entry";
 import { DBUser } from "./entity/db-user";
 import { DBUserEnvVar } from "./entity/db-user-env-vars";
-import { DBWorkspace } from "./entity/db-workspace";
 import { DBUserSshPublicKey } from "./entity/db-user-ssh-public-key";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
 import { DataCache } from "../data-cache";
 import { TransactionalDBImpl } from "./transactional-db-impl";
+import { TypeORM } from "./typeorm";
 
 // OAuth token expiry
 const tokenExpiryInFuture = new DateInterval("7d");
@@ -63,11 +63,12 @@ function getUserCacheKey(id: string): string {
 @injectable()
 export class TypeORMUserDBImpl extends TransactionalDBImpl<UserDB> implements UserDB {
     constructor(
-        @inject(EncryptionService) protected readonly encryptionService: EncryptionService,
-        @inject(DataCache) protected readonly cache: DataCache,
-        @optional() transactionalEM: EntityManager,
+        @inject(TypeORM) typeorm: TypeORM,
+        @inject(EncryptionService) private readonly encryptionService: EncryptionService,
+        @inject(DataCache) private readonly cache: DataCache,
+        @optional() transactionalEM?: EntityManager,
     ) {
-        super(transactionalEM);
+        super(typeorm, transactionalEM);
     }
 
     @postConstruct()
@@ -77,33 +78,26 @@ export class TypeORMUserDBImpl extends TransactionalDBImpl<UserDB> implements Us
     }
 
     protected createTransactionalDB(transactionalEM: EntityManager): UserDB {
-        return new TypeORMUserDBImpl(this.encryptionService, this.cache, transactionalEM);
+        return new TypeORMUserDBImpl(this.typeorm, this.encryptionService, this.cache, transactionalEM);
     }
 
     async getUserRepo(): Promise<Repository<DBUser>> {
         return (await this.getEntityManager()).getRepository<DBUser>(DBUser);
     }
-    protected async getWorkspaceRepo(): Promise<Repository<DBWorkspace>> {
-        return (await this.getEntityManager()).getRepository<DBWorkspace>(DBWorkspace);
-    }
 
-    protected async getTokenRepo(): Promise<Repository<DBTokenEntry>> {
+    private async getTokenRepo(): Promise<Repository<DBTokenEntry>> {
         return (await this.getEntityManager()).getRepository<DBTokenEntry>(DBTokenEntry);
     }
 
-    protected async getIdentitiesRepo(): Promise<Repository<DBIdentity>> {
-        return (await this.getEntityManager()).getRepository<DBIdentity>(DBIdentity);
-    }
-
-    protected async getGitpodTokenRepo(): Promise<Repository<DBGitpodToken>> {
+    private async getGitpodTokenRepo(): Promise<Repository<DBGitpodToken>> {
         return (await this.getEntityManager()).getRepository<DBGitpodToken>(DBGitpodToken);
     }
 
-    protected async getUserEnvVarRepo(): Promise<Repository<DBUserEnvVar>> {
+    private async getUserEnvVarRepo(): Promise<Repository<DBUserEnvVar>> {
         return (await this.getEntityManager()).getRepository<DBUserEnvVar>(DBUserEnvVar);
     }
 
-    protected async getSSHPublicKeyRepo(): Promise<Repository<DBUserSshPublicKey>> {
+    private async getSSHPublicKeyRepo(): Promise<Repository<DBUserSshPublicKey>> {
         return (await this.getEntityManager()).getRepository<DBUserSshPublicKey>(DBUserSshPublicKey);
     }