refactor: remove explicit return types for TypeScript inference

src/core/primitives/entity.base.ts

@@ -25,7 +25,7 @@ export abstract class Entity<
   static hydrate<Constructor extends new (...args: any) => any>(
     this: Constructor,
     ...args: ConstructorParameters<Constructor>
-  ): InstanceType<Constructor> {
+  ) {
     return new this(...args);
   }
 

src/identity-and-access/infrastructure/repositories/drizzle-account.repository.ts

@@ -30,7 +30,7 @@ export class DrizzleAccountRepository implements AccountRepository {
     });
   }
 
-  async isEmailTaken(email: string): Promise<boolean> {
+  async isEmailTaken(email: string) {
     const [record] = await this.database
       .select({
         count: count(),
@@ -42,7 +42,7 @@ export class DrizzleAccountRepository implements AccountRepository {
     return record.count > 0;
   }
 
-  async save(account: Account): Promise<void> {
+  async save(account: Account) {
     await this.database
       .insert(accountSchema)
       .values(account.properties)

src/identity-and-access/infrastructure/repositories/drizzle-forgot-password-request.repository.ts

@@ -17,7 +17,7 @@ export class DrizzleForgotPasswordRequestRepository
     private readonly database: IdentityAndAccessDatabase
   ) {}
 
-  async hasPendingRequest(accountId: string): Promise<boolean> {
+  async hasPendingRequest(accountId: string) {
     const results = await this.database
       .select({ count: count() })
       .from(ForgotPasswordRequestSchema)
@@ -27,7 +27,7 @@ export class DrizzleForgotPasswordRequestRepository
     return results[0].count > 0;
   }
 
-  async save(request: ForgotPasswordRequest): Promise<void> {
+  async save(request: ForgotPasswordRequest) {
     const values = {
       ...request.properties,
       expiresAt: request.properties.expiresAt.toJSDate(),

src/identity-and-access/infrastructure/repositories/in-memory-account.repository.ts

@@ -4,7 +4,7 @@ import type { AccountRepository } from "@identity-and-access/domain/account/repo
 export class InMemoryAccountRepository implements AccountRepository {
   snapshots = new Map();
 
-  async findByEmail(email: string): Promise<Account | null> {
+  async findByEmail(email: string) {
     for (const [id, properties] of this.snapshots.entries()) {
       if (properties.email !== email) continue;
 
@@ -17,13 +17,13 @@ export class InMemoryAccountRepository implements AccountRepository {
     return null;
   }
 
-  async isEmailTaken(email: string): Promise<boolean> {
+  async isEmailTaken(email: string) {
     return Array.from(this.snapshots.values()).some(
       (properties) => properties.email === email
     );
   }
 
-  async save(account: Account): Promise<void> {
+  async save(account: Account) {
     this.snapshots.set(account.id, account.properties);
   }
 }

src/identity-and-access/infrastructure/repositories/in-memory-forgot-password-request.repository.ts

@@ -6,13 +6,13 @@ export class InMemoryForgotPasswordRequestRepository
 {
   snapshots = new Map();
 
-  async hasPendingRequest(accountId: string): Promise<boolean> {
+  async hasPendingRequest(accountId: string) {
     return [...this.snapshots.values()].some(
       (request) => request.accountId === accountId
     );
   }
 
-  async save(request: ForgotPasswordRequest): Promise<void> {
+  async save(request: ForgotPasswordRequest) {
     this.snapshots.set(request.id, request.properties);
   }
 }

src/shared-kernel/infrastructure/console-mailer.adapter.ts

@@ -8,7 +8,7 @@ export class ConsoleMailer implements Mailer {
     to: string,
     templateId: string,
     variables: Record<string, unknown>
-  ): Promise<void> {
+  ) {
     this.logger.log(
       `Sending email to ${to} using template ${templateId} with variables: ${JSON.stringify(
         variables

src/shared-kernel/infrastructure/http-logger.interceptor.ts

@@ -5,14 +5,13 @@ import {
   Logger,
   NestInterceptor,
 } from "@nestjs/common";
-import { Observable } from "rxjs";
 import { tap } from "rxjs/operators";
 
 @Injectable()
 export class HttpLoggerInterceptor implements NestInterceptor {
   private readonly logger = new Logger(HttpLoggerInterceptor.name);
 
-  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(context: ExecutionContext, next: CallHandler) {
     const request = context.switchToHttp().getRequest();
     const response = context.switchToHttp().getResponse();
     const start = Date.now();

src/shared-kernel/infrastructure/map-error-to-rfc9457-http-exception.interceptor.ts

@@ -13,20 +13,20 @@ import {
   NotFoundException,
 } from "@nestjs/common";
 import { DateTime } from "luxon";
-import { Observable, throwError } from "rxjs";
+import { throwError } from "rxjs";
 import { catchError } from "rxjs/operators";
 
 @Injectable()
 export class MapErrorToRfc9457HttpException implements NestInterceptor {
   private readonly logger = new Logger(MapErrorToRfc9457HttpException.name);
 
-  intercept(_context: ExecutionContext, next: CallHandler): Observable<any> {
+  intercept(_context: ExecutionContext, next: CallHandler) {
     return next
       .handle()
       .pipe(catchError((error) => this.throwAsHttpException(error)));
   }
 
-  private throwAsHttpException(error: unknown): Observable<never> {
+  private throwAsHttpException(error: unknown) {
     this.logger.error(error);
 
     // @TODO: Map ValidationErrors to RFC9457

src/shared-kernel/infrastructure/repositories/drizzle-outbox-message.repository.ts

@@ -16,7 +16,7 @@ export class DrizzleOutboxMessageRepository implements OutboxMessageRepository {
     private readonly database: SharedKernelDatabase
   ) {}
 
-  async findUnprocessedMessages(): Promise<OutboxMessage[]> {
+  async findUnprocessedMessages() {
     const snapshots = await this.database
       .select()
       .from(outboxMessageSchema)

src/shared-kernel/use-cases/process-outbox-messages/use-case.spec.ts

@@ -9,7 +9,7 @@ class MockEventEmitter implements EventEmitter {
   shouldThrowError = false;
   errorMessage: string = "An error occurred";
 
-  async emitAsync(event: string, ...values: any[]): Promise<void> {
+  async emitAsync(event: string, ...values: any[]) {
     if (this.shouldThrowError) {
       throw new Error(this.errorMessage);
     }