feat: Uniform representation of entity repositories

src/repositories/repositories.ts

@@ -1,25 +1,31 @@
-import { Applicant, Review, PartialApplicant } from '../models/db';
 import { provide } from 'inversify-binding-decorators';
-import { TransactionRepository } from './transactionRepository';
-import { Repository } from 'typeorm';
+import { Repository, ObjectLiteral, EntityManager, ObjectType } from 'typeorm';
+import { decorate, injectable } from 'inversify';
+import { getEntityManagerOrTransactionManager } from 'typeorm-transactional-cls-hooked';
 
-@provide(ApplicantRepository)
-export class ApplicantRepository extends TransactionRepository<Applicant> {
-	public getRepository(): Repository<Applicant> {
-		return super.manager.getRepository(Applicant);
+// First decorate the TypeORM base class repository with the injectable() annotation to prevent this error:
+// Error: Missing required @injectable annotation in: Repository
+decorate(injectable(), Repository);
+
+@injectable()
+class TransactionRepository<Entity extends ObjectLiteral> extends Repository<Entity> {
+	private _connectionName = 'default';
+	private _manager: EntityManager | undefined;
+
+	public set manager(manager: EntityManager) {
+		this._manager = manager;
+		this._connectionName = manager.connection.name;
 	}
-}
 
-@provide(PartialApplicantRepository)
-export class PartialApplicantRepository extends TransactionRepository<PartialApplicant> {
-	public getRepository(): Repository<PartialApplicant> {
-		return super.manager.getRepository(PartialApplicant);
+	// Always get the entityManager from the cls namespace if active, otherwise, use the original or getManager(connectionName)
+	public get manager(): EntityManager {
+		return getEntityManagerOrTransactionManager(this._connectionName, this._manager);
 	}
 }
 
-@provide(ReviewRepository)
-export class ReviewRepository extends TransactionRepository<Review> {
-	public getRepository(): Repository<Review> {
-		return super.manager.getRepository(Review);
+@provide(InjectedRepository)
+export class InjectedRepository<T> extends TransactionRepository<T> {
+	public getRepository(type: ObjectType<T>): Repository<T> {
+		return super.manager.getRepository(type.name);
 	}
 }

src/services/applications/applicantService.ts

@@ -1,13 +1,13 @@
 import { provide } from 'inversify-binding-decorators';
 import { Applicant } from '../../models/db/applicant';
-import { ApplicantRepository } from '../../repositories';
 import { ObjectID, DeleteResult, Repository } from 'typeorm';
 import { validateOrReject } from 'class-validator';
 import { Review } from '../../models/db';
 import { ApplicantStatus } from './applicantStatus';
 import { logger } from '../../util';
 import { CloudStorageService } from '../cloudStorage';
 import { Transactional } from 'typeorm-transactional-cls-hooked';
+import { InjectedRepository } from '../../repositories';
 
 type ApplicationID = string | number | Date | ObjectID;
 
@@ -24,16 +24,17 @@ export interface ApplicantServiceInterface {
 	getKRandomToReview(reviewerID: string, chooseFromK: number): Promise<Applicant[]>;
 }
 
+type InjectableRepository<T> = (type: any) => Repository<T>;
 @provide(ApplicantService)
 export class ApplicantService implements ApplicantServiceInterface {
 	private readonly _applicantRepository: Repository<Applicant>;
 	private readonly _cloudStorageService: CloudStorageService;
 
 	public constructor(
-		applicantRepository: ApplicantRepository,
+		applicantRepository: InjectedRepository<Applicant>,
 		cloudStorageService: CloudStorageService
 	) {
-		this._applicantRepository = applicantRepository.getRepository();
+		this._applicantRepository = applicantRepository.getRepository(Applicant);
 		this._cloudStorageService = cloudStorageService;
 	}
 

src/services/applications/partialApplicantService.ts

@@ -1,6 +1,6 @@
 import { provide } from 'inversify-binding-decorators';
 import { PartialApplicant } from '../../models/db/applicant';
-import { PartialApplicantRepository } from '../../repositories';
+import { InjectedRepository } from '../../repositories';
 import { ObjectID, Repository, DeleteResult } from 'typeorm';
 import { Transactional } from 'typeorm-transactional-cls-hooked';
 
@@ -17,9 +17,9 @@ export class PartialApplicantService implements PartialApplicantServiceInterface
 	private readonly _partialApplicantRepository: Repository<PartialApplicant>;
 
 	public constructor(
-		partialApplicantRepository: PartialApplicantRepository
+		partialApplicantRepository: InjectedRepository<PartialApplicant>
 	) {
-		this._partialApplicantRepository = partialApplicantRepository.getRepository();
+		this._partialApplicantRepository = partialApplicantRepository.getRepository(PartialApplicant);
 	}
 
 	@Transactional()

src/services/review/reviewService.ts

@@ -1,7 +1,7 @@
 import { provide } from 'inversify-binding-decorators';
 import { Repository } from 'typeorm';
 import { Review, Applicant } from '../../models/db';
-import { ReviewRepository } from '../../repositories/repositories';
+import { InjectedRepository } from '../../repositories/repositories';
 import { ApplicantService } from '../applications/applicantService';
 
 export interface ReviewServiceInterface {
@@ -19,10 +19,10 @@ export class ReviewService implements ReviewServiceInterface {
 
 	public constructor(
 		applicantService: ApplicantService,
-		reviewRepository: ReviewRepository
+		reviewRepository: InjectedRepository<Review>
 	) {
 		this._applicantService = applicantService;
-		this._reviewRepository = reviewRepository.getRepository();
+		this._reviewRepository = reviewRepository.getRepository(Review);
 	}
 
 	public getAll = async (columns?: (keyof Review)[]): Promise<Review[]> => {

test/e2e/apply.test.ts

@@ -8,7 +8,7 @@ import { RequestAuthentication } from '../../src/util/auth';
 import { SettingLoader } from '../../src/util/fs';
 import { mock, instance, when, anything } from 'ts-mockito';
 import { Repository } from 'typeorm';
-import { ApplicantRepository } from '../../src/repositories';
+import { InjectedRepository } from '../../src/repositories';
 
 import container from '../../src/inversify.config';
 
@@ -78,7 +78,7 @@ beforeAll(async () => {
 
 	bApp = await new App().buildApp(getTestDatabaseOptions());
 	// After the application has been built and db connection established -- get the applicant repository
-	applicantRepository = container.get<ApplicantRepository>(ApplicantRepository).getRepository();
+	applicantRepository = container.get(InjectedRepository).getRepository(Applicant);
 });
 
 beforeEach(() => {

test/e2e/review.test.ts

@@ -8,7 +8,7 @@ import { RequestAuthentication } from '../../src/util/auth';
 import { SettingLoader } from '../../src/util/fs';
 import { mock, instance, when, anything, objectContaining } from 'ts-mockito';
 import { Repository } from 'typeorm';
-import { ReviewRepository } from '../../src/repositories';
+import { InjectedRepository } from '../../src/repositories';
 import { ApplicantService } from '../../src/services';
 
 import container from '../../src/inversify.config';
@@ -69,7 +69,7 @@ beforeAll(async () => {
 
 	bApp = await new App().buildApp(getTestDatabaseOptions());
 	// After the application has been built and db connection established -- get the applicant repository
-	reviewRepository = container.get<ReviewRepository>(ReviewRepository).getRepository();
+	reviewRepository = container.get<InjectedRepository<Review>>(InjectedRepository).getRepository(Review);
 });
 
 beforeEach(() => {

test/unit/services/applicantService.test.ts

@@ -3,7 +3,7 @@ setupTestingEnvironment();
 
 import { when, mock, instance, verify, anything, objectContaining, reset, resetCalls } from 'ts-mockito';
 import { ApplicantService } from '../../../src/services';
-import { ApplicantRepository } from '../../../src/repositories';
+import { InjectedRepository } from '../../../src/repositories';
 import { Repository, DeleteResult } from 'typeorm';
 import { Applicant } from '../../../src/models/db';
 
@@ -70,10 +70,10 @@ let mockApplicantRepository: Repository<Applicant>;
 class StubApplicationRepository extends Repository<Applicant> {}
 
 beforeAll(() => {
-	const stubApplicantRepository: ApplicantRepository = mock(ApplicantRepository);
+	const stubRepository: InjectedRepository<Applicant> = mock(InjectedRepository);
 	mockApplicantRepository = mock(StubApplicationRepository);
-	when(stubApplicantRepository.getRepository()).thenReturn(instance(mockApplicantRepository));
-	container.rebind(ApplicantRepository).toConstantValue(instance(stubApplicantRepository));
+	when(stubRepository.getRepository(Applicant)).thenReturn(instance(mockApplicantRepository));
+	container.rebind(InjectedRepository).toConstantValue(instance(stubRepository));
 
 	// Mock the POST Axios request for the cloud service requests
 	axiosMock.post.mockResolvedValue({ data: successResponse });

test/unit/services/partialApplicantService.test.ts

@@ -3,7 +3,7 @@ setupTestingEnvironment();
 
 import { when, mock, instance, reset, resetCalls, anything } from 'ts-mockito';
 import { PartialApplicantService } from '../../../src/services';
-import { PartialApplicantRepository } from '../../../src/repositories';
+import { InjectedRepository } from '../../../src/repositories';
 import { Repository, DeleteResult } from 'typeorm';
 import { PartialApplicant } from '../../../src/models/db';
 
@@ -26,10 +26,10 @@ class StubPartialApplicationRepository extends Repository<PartialApplicant> {}
 
 beforeAll(() => {
 	// Mock out the partial applicant repository
-	const stubPartialApplicantRepository: PartialApplicantRepository = mock(PartialApplicantRepository);
+	const stubRepository: InjectedRepository<PartialApplicant> = mock(InjectedRepository);
 	mockPartialApplicantRepository = mock(StubPartialApplicationRepository);
-	when(stubPartialApplicantRepository.getRepository()).thenReturn(instance(mockPartialApplicantRepository));
-	container.rebind(PartialApplicantRepository).toConstantValue(instance(stubPartialApplicantRepository));
+	when(stubRepository.getRepository(PartialApplicant)).thenReturn(instance(mockPartialApplicantRepository));
+	container.rebind(InjectedRepository).toConstantValue(instance(stubRepository));
 });
 
 beforeEach(() => {

test/unit/services/reviewService.test.ts

@@ -1,6 +1,6 @@
 import { when, mock, instance, reset, resetCalls, objectContaining } from 'ts-mockito';
 import { ApplicantService, ReviewService } from '../../../src/services';
-import { ReviewRepository } from '../../../src/repositories';
+import { InjectedRepository } from '../../../src/repositories';
 import { Repository } from 'typeorm';
 import { Applicant, Review } from '../../../src/models/db';
 
@@ -39,10 +39,10 @@ let mockReviewRepository: Repository<Review>;
 class StubReviewRepository extends Repository<Review> {}
 
 beforeAll(() => {
-	const stubReviewRepository: ReviewRepository = mock(ReviewRepository);
+	const stubRepository: InjectedRepository<Review> = mock(InjectedRepository);
 	mockReviewRepository = mock(StubReviewRepository);
-	when(stubReviewRepository.getRepository()).thenReturn(instance(mockReviewRepository));
-	container.rebind(ReviewRepository).toConstantValue(instance(stubReviewRepository));
+	when(stubRepository.getRepository(Review)).thenReturn(instance(mockReviewRepository));
+	container.rebind(InjectedRepository).toConstantValue(instance(stubRepository));
 
 	mockApplicantService = mock(ApplicantService);
 	container.rebind(ApplicantService).toConstantValue(instance(mockApplicantService));