✨ feat(api/auth): multi-provider new template

apps/api/.env.example

@@ -0,0 +1,19 @@
+# Database Configuration
+# Set to 'true' to use in-memory database (no Postgres needed)
+# Set to 'false' or remove to use Postgres
+USE_IN_MEMORY_DB=true
+
+# Postgres Configuration (when USE_IN_MEMORY_DB=false)
+# DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+
+# JWT Configuration
+# JWT_SECRET=your-secret-key-here
+# JWT_EXPIRES_IN=1d
+
+# Auth Configuration
+# Available providers: credentials
+AUTH_PROVIDER=credentials
+
+# Server Configuration
+# PORT=3000
+# NODE_ENV=development

apps/api/src/modules/auth/application/ports/in/SignInWithProviderPort.ts

@@ -0,0 +1,12 @@
+import { UseCase } from '@shared/application/UseCase';
+import type { AuthResult } from '../../../domain/types/AuthResult';
+
+export interface SignInWithProviderDto {
+	email: string;
+	password: string;
+}
+
+export abstract class SignInWithProviderPort extends UseCase<
+	SignInWithProviderDto,
+	AuthResult
+> {}

apps/api/src/modules/auth/application/ports/in/SignUpWithProviderPort.ts

@@ -0,0 +1,14 @@
+import { UseCase } from '@shared/application/UseCase';
+import type { AuthResult } from '../../../domain/types/AuthResult';
+
+export interface SignUpWithProviderDto {
+	email: string;
+	password: string;
+	firstName: string;
+	lastName: string;
+}
+
+export abstract class SignUpWithProviderPort extends UseCase<
+	SignUpWithProviderDto,
+	AuthResult
+> {}

apps/api/src/modules/auth/application/ports/out/AuthConfigPort.ts

@@ -0,0 +1,5 @@
+import type { ProviderType } from '../../../domain/types/ProviderType';
+
+export abstract class AuthConfigPort {
+  abstract getProvider(): ProviderType;
+}

apps/api/src/modules/auth/application/ports/out/AuthProviderFactoryPort.ts

@@ -0,0 +1,6 @@
+import type { ProviderType } from '../../../domain/types/ProviderType';
+import type { AuthProviderPort } from './AuthProviderPort';
+
+export abstract class AuthProviderFactoryPort {
+  abstract getProvider(providerType: ProviderType): AuthProviderPort;
+}

apps/api/src/modules/auth/application/ports/out/AuthProviderPort.ts

@@ -0,0 +1,20 @@
+import type { AuthResult } from '../../../domain/types/AuthResult';
+import type { ProviderType } from '../../../domain/types/ProviderType';
+
+export interface SignInData {
+  email: string;
+  password: string;
+}
+
+export interface SignUpData {
+  email: string;
+  password: string;
+  firstName: string;
+  lastName: string;
+}
+
+export abstract class AuthProviderPort {
+  abstract getProviderType(): ProviderType;
+  abstract signIn(data: SignInData): Promise<AuthResult>;
+  abstract signUp(data: SignUpData): Promise<AuthResult>;
+}

apps/api/src/modules/auth/application/use-case/SignInWithProviderUseCase.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import {
+  SignInWithProviderPort,
+  type SignInWithProviderDto,
+} from '../ports/in/SignInWithProviderPort';
+import type { AuthResult } from '../../domain/types/AuthResult';
+import { AuthProviderFactoryPort } from '../ports/out/AuthProviderFactoryPort';
+import { AuthConfigPort } from '../ports/out/AuthConfigPort';
+
+@Injectable()
+export class SignInWithProviderUseCase implements SignInWithProviderPort {
+  constructor(
+    private readonly providerFactory: AuthProviderFactoryPort,
+    private readonly authConfig: AuthConfigPort
+  ) {}
+
+  async execute(dto: SignInWithProviderDto): Promise<AuthResult> {
+    const providerType = this.authConfig.getProvider();
+    const provider = this.providerFactory.getProvider(providerType);
+    return provider.signIn({
+      email: dto.email,
+      password: dto.password,
+    });
+  }
+}

apps/api/src/modules/auth/application/use-case/SignUpWithProviderUseCase.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@nestjs/common';
+import {
+  SignUpWithProviderPort,
+  type SignUpWithProviderDto,
+} from '../ports/in/SignUpWithProviderPort';
+import type { AuthResult } from '../../domain/types/AuthResult';
+import { AuthProviderFactoryPort } from '../ports/out/AuthProviderFactoryPort';
+import { AuthConfigPort } from '../ports/out/AuthConfigPort';
+
+@Injectable()
+export class SignUpWithProviderUseCase implements SignUpWithProviderPort {
+  constructor(
+    private readonly providerFactory: AuthProviderFactoryPort,
+    private readonly authConfig: AuthConfigPort
+  ) {}
+
+  async execute(dto: SignUpWithProviderDto): Promise<AuthResult> {
+    const providerType = this.authConfig.getProvider();
+    const provider = this.providerFactory.getProvider(providerType);
+    return provider.signUp({
+      email: dto.email,
+      password: dto.password,
+      firstName: dto.firstName,
+      lastName: dto.lastName,
+    });
+  }
+}

apps/api/src/modules/auth/domain/types/AuthResult.ts

@@ -0,0 +1,14 @@
+export interface AuthResult {
+	user: {
+		id: string;
+		email: string;
+		firstName: string | null;
+		lastName: string | null;
+		timezone?: string;
+		status: 'active' | 'inactive';
+		createdAt: string | null | undefined;
+		updatedAt: string | null | undefined;
+	};
+	accessToken: string;
+	refreshToken: string;
+}

apps/api/src/modules/auth/domain/types/ProviderType.ts

@@ -0,0 +1,5 @@
+export enum ProviderType {
+	CREDENTIALS = 'credentials',
+	GOOGLE = 'google',
+	GITHUB = 'github',
+}

apps/api/src/modules/auth/infrastructure/config/AuthConfig.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ProviderType } from '../../domain/types/ProviderType';
+import { AuthConfigPort } from '../../application/ports/out/AuthConfigPort';
+
+@Injectable()
+export class AuthConfig implements AuthConfigPort {
+  private readonly provider: ProviderType;
+
+  constructor() {
+    const configuredProvider = process.env.AUTH_PROVIDER || 'credentials';
+
+    if (!configuredProvider) {
+      throw new Error('AUTH_PROVIDER environment variable is required');
+    }
+
+    if (
+      !Object.values(ProviderType).includes(configuredProvider as ProviderType)
+    ) {
+      throw new Error(
+        `Invalid AUTH_PROVIDER: ${configuredProvider}. Must be one of: ${Object.values(ProviderType).join(', ')}`
+      );
+    }
+
+    this.provider = configuredProvider as ProviderType;
+  }
+
+  getProvider(): ProviderType {
+    return this.provider;
+  }
+}

apps/api/src/modules/auth/infrastructure/providers/AuthProviderFactoryImpl.ts

@@ -0,0 +1,26 @@
+import { Injectable, BadRequestException } from '@nestjs/common';
+import { ProviderType } from '../../domain/types/ProviderType';
+import { AuthProviderPort } from '../../application/ports/out/AuthProviderPort';
+import { AuthProviderFactoryPort } from '../../application/ports/out/AuthProviderFactoryPort';
+import { CredentialsAuthProvider } from './CredentialsAuthProvider';
+
+@Injectable()
+export class AuthProviderFactoryImpl extends AuthProviderFactoryPort {
+  constructor(private readonly credentialsProvider: CredentialsAuthProvider) {
+    super();
+  }
+
+  getProvider(providerType: ProviderType): AuthProviderPort {
+    switch (providerType) {
+      case ProviderType.CREDENTIALS:
+        return this.credentialsProvider;
+      case ProviderType.GOOGLE:
+      case ProviderType.GITHUB:
+        throw new BadRequestException(
+          `Provider ${providerType} is not yet implemented`
+        );
+      default:
+        throw new BadRequestException(`Unknown provider: ${providerType}`);
+    }
+  }
+}