fix: auth throws

Author: soorq

src/auth/application/controllers/oauth/controller.ts

@@ -56,7 +56,7 @@ export class OAuthController {
     @SkipContract()
     async oauthCallback(
         @Query() query: { code?: string; state?: string },
-        @Param('provider') provider: 'google' | 'yandex' | 'github' | 'vkontakte',
+        @Param('provider') provider: 'google' | 'yandex' | 'github',
         @Res({ passthrough: true }) res: FastifyReply,
         @Req() req: FastifyRequest,
     ) {
@@ -79,7 +79,7 @@ export class OAuthController {
 
             const result = await this.facade.authenticateOAuth(dto, meta, state);
 
-            if (result.isSign) {
+            if (!result.isConnect) {
                 res.redirect(`${baseUrl}/oauth?${result.query.toString()}`, 302);
             } else {
                 res.redirect(`${baseUrl}/user/profile?${result.query.toString()}`, 302);

src/auth/application/dtos/oauth.dto.ts

@@ -9,7 +9,7 @@ const OAuthResponseSchema = z.object({
     avatar_url: z.string().nullish(),
     bio: z.string().nullish(),
     sex: z.enum(['male', 'female']).or(z.string()),
-    provider: z.enum(['google', 'yandex', 'github', 'vkontakte']),
+    provider: z.enum(['google', 'yandex', 'github']),
 });
 
 export class OAuthResponse extends createZodDto(OAuthResponseSchema) {}
@@ -71,13 +71,9 @@ export const ExchangeSchema = z.object({
 
 export class ExchangeDto extends createZodDto(ExchangeSchema) {}
 
-export interface IOAuthExchangeData {
-    userId: string;
-    isNewUser: boolean;
-    email: string;
-    provider: 'google' | 'yandex' | 'github' | 'vkontakte';
-    ip: string;
-}
+export type IOAuthExchangeData = z.infer<typeof OAuthResponseSchema> & {
+    ip: string | null;
+};
 
 export const ExchangeResponseSchema = z.object({
     success: z.boolean().describe('Успешность операции'),
@@ -91,7 +87,6 @@ export const ExchangeResponseSchema = z.object({
         .min(10, 'access токен слишком короткий')
         .max(500, 'access токен слишком длинный')
         .describe('JWT access токен'),
-    isNewUser: z.boolean().describe('Новый пользователь?'),
     provider: z
         .enum(['google', 'yandex', 'github', 'vkontakte'], {
             message: 'provider должен быть: google, yandex, github или vkontakte',

src/auth/application/use-cases/auth/sign-up.use-case.ts

@@ -40,7 +40,10 @@ export class SignUpUseCase {
         }
 
         try {
-            await this.findUserQ.execute({ email: dto.email }, { throwIfExists: true });
+            await this.findUserQ.execute(
+                { email: dto.email },
+                { throwIfExists: true, throwIfNotFound: false },
+            );
 
             const hashPass = await argon.hash(dto.password);
 

src/auth/application/use-cases/index.ts

@@ -11,7 +11,6 @@ import { DisconnectProviderUseCase } from './oauth/disconnect-provider.use-case'
 import { ExchangeUseCase } from './oauth/exchange.use-case';
 import { GetConnectedProvidersQuery } from './oauth/get-connected-providers.query';
 import { GetEnabledProvidersQuery } from './oauth/get-enabled-providers.query';
-import { OAuthOrchestratorUseCase } from './oauth/oauth-orchestrator.use-case';
 import { ProcessOAuthLoginUseCase } from './oauth/process-oauth-login.use-case';
 import { ProcessOAuthRegistrationUseCase } from './oauth/process-oauth-registration.use-case';
 import { ConfirmResetPasswordUseCase } from './password/confirm-reset-password.use-case';
@@ -24,7 +23,6 @@ export const AuthUseCases = [
     GetConnectedProvidersQuery,
     DisconnectProviderUseCase,
     GetEnabledProvidersQuery,
-    OAuthOrchestratorUseCase,
     ProcessOAuthLoginUseCase,
     ProcessOAuthRegistrationUseCase,
     ConnectOAuthProviderUseCase,
@@ -53,7 +51,6 @@ export * from './auth/sign-up-verify.use-case';
 export * from './oauth/get-enabled-providers.query';
 export * from './oauth/exchange.use-case';
 
-export * from './oauth/oauth-orchestrator.use-case';
 export * from './oauth/process-oauth-login.use-case';
 export * from './oauth/process-oauth-registration.use-case';
 export * from './oauth/connect-oauth-provider.use-case';

src/auth/application/use-cases/oauth/authenticate-oauth.use-case.ts

@@ -1,61 +1,46 @@
-import crypto from 'node:crypto';
+import { Injectable } from '@nestjs/common';
+import { isBaseExceptionWithCode } from '@shared/error';
 
-import { Inject, Injectable } from '@nestjs/common';
-import { CACHE_SERVICE } from '@shared/adapters/cache/constants';
-import { ICacheService } from '@shared/adapters/cache/ports';
+import { OAuthErrorCodes } from '../../../domain/errors';
 
-import { EXCHANGE_TOKEN_NAME, EXCHANGE_TOKEN_TTL } from '../../../infrastructure/constants';
-
-import { OAuthOrchestratorUseCase } from './oauth-orchestrator.use-case';
+import { ConnectOAuthProviderUseCase } from './connect-oauth-provider.use-case';
+import { ProcessOAuthLoginUseCase } from './process-oauth-login.use-case';
+import { ProcessOAuthRegistrationUseCase } from './process-oauth-registration.use-case';
 
 import type { OAuthResponse } from '../../dtos';
 import type { DeviceMetadata } from '@core/auth/infrastructure/utils';
 
 @Injectable()
 export class AuthenticateOAuthUseCase {
     constructor(
-        @Inject(CACHE_SERVICE)
-        private readonly cacheService: ICacheService,
-        private readonly orchestrator: OAuthOrchestratorUseCase,
+        private readonly processLogin: ProcessOAuthLoginUseCase,
+        private readonly connectProvider: ConnectOAuthProviderUseCase,
+        private readonly processRegistration: ProcessOAuthRegistrationUseCase,
     ) {}
 
     async execute(dto: OAuthResponse, meta: DeviceMetadata, state?: string) {
-        const { user, isNewUser, isConnect } = await this.orchestrator.execute(dto, state);
-
-        if (isConnect) {
-            const query = new URLSearchParams({
-                success: 'true',
-                message: `Провайдер ${dto.provider} успешно привязан`,
-            });
-
-            return {
-                query,
-                isSign: false,
-                refresh: null,
-                expiresAt: null,
-            };
+        if (state) {
+            try {
+                return this.connectProvider.execute(dto, state);
+            } catch (error) {
+                if (!isBaseExceptionWithCode(error, 'INVALID_ACTION')) {
+                    throw error;
+                }
+            }
         }
-        const token = crypto.randomBytes(32).toString('hex');
-
-        const data = {
-            userId: user.id,
-            isNewUser,
-            email: user.email,
-            provider: dto.provider,
-            ip: meta.ip,
-        };
-
-        await this.cacheService.setOne(
-            EXCHANGE_TOKEN_NAME(token),
-            JSON.stringify(data),
-            EXCHANGE_TOKEN_TTL,
-        );
-
-        const query = new URLSearchParams({
-            token,
-            success: 'true',
+
+        const login = await this.processLogin.execute(dto).catch((err) => {
+            if (isBaseExceptionWithCode(err, OAuthErrorCodes.OAUTH_LOGIN_NOT_FOUND)) {
+                return null;
+            }
+
+            throw err;
         });
 
-        return { query, isSign: true };
+        if (login) {
+            return login;
+        }
+
+        return this.processRegistration.execute(dto, meta);
     }
 }

src/auth/application/use-cases/oauth/connect-oauth-provider.use-case.ts

@@ -30,7 +30,7 @@ export class ConnectOAuthProviderUseCase {
         await this.identityRepo.create({
             userId: user.id,
             avatarUrl: dto.avatar_url,
-            provider: dto.provider as any,
+            provider: dto.provider,
             providerUserId: dto.id,
             email: dto.email,
         });
@@ -40,7 +40,11 @@ export class ConnectOAuthProviderUseCase {
             `oauth:state:${state}`,
         ]);
 
-        return { user, isConnect: true, isNewUser: false };
+        const query = new URLSearchParams({
+            success: 'true',
+        });
+
+        return { isConnect: true, query };
     }
 
     private async getStateData(state: string) {

src/auth/application/use-cases/oauth/exchange.use-case.ts

@@ -1,11 +1,16 @@
+import { RegisterUserUseCase } from '@core/user';
+import { InjectQueue } from '@nestjs/bullmq';
 import { HttpStatus, Inject, Injectable } from '@nestjs/common';
 import { createId } from '@paralleldrive/cuid2';
 import { CACHE_SERVICE } from '@shared/adapters/cache/constants';
 import { ICacheService } from '@shared/adapters/cache/ports';
 import { BaseException } from '@shared/error';
+import { Queue } from 'bullmq';
 
+import { AuthQueues, AuthUserJobs } from '../../../domain/enums';
 import { OAuthErrorCodes, OAuthErrorMessages } from '../../../domain/errors';
-import { ISessionRepository } from '../../../domain/repository';
+import { CreateUserWorkspaceEvent } from '../../../domain/events';
+import { IIdentityRepository, ISessionRepository } from '../../../domain/repository';
 import { EXCHANGE_TOKEN_NAME } from '../../../infrastructure/constants';
 import { TokenService } from '../../../infrastructure/security';
 import { ExchangeDto, type IOAuthExchangeData } from '../../dtos';
@@ -19,7 +24,12 @@ export class ExchangeUseCase {
         private readonly sessionRepo: ISessionRepository,
         @Inject(CACHE_SERVICE)
         private readonly cacheService: ICacheService,
+        @InjectQueue(AuthQueues.AUTH_USER)
+        private readonly queue: Queue,
+        @Inject('IIdentityRepository')
+        private readonly identityRepo: IIdentityRepository,
         private readonly tokenService: TokenService,
+        private readonly registerUserUC: RegisterUserUseCase,
     ) {}
 
     async execute(dto: ExchangeDto, meta: DeviceMetadata) {
@@ -40,7 +50,7 @@ export class ExchangeUseCase {
         const data: IOAuthExchangeData = JSON.parse(rawData);
         await this.cacheService.removeOne(key);
 
-        if (!data.userId || !data.email || data.provider !== dto.provider) {
+        if (!data.email || data.provider) {
             await this.cacheService.removeOne(key);
             throw new BaseException(
                 {
@@ -51,18 +61,47 @@ export class ExchangeUseCase {
             );
         }
 
+        if (data.provider !== dto.provider) {
+            throw new BaseException(
+                {
+                    code: OAuthErrorCodes.EXCHANGE_TOKEN_INVALID,
+                    message: OAuthErrorMessages[OAuthErrorCodes.EXCHANGE_TOKEN_INVALID],
+                },
+                HttpStatus.BAD_REQUEST,
+            );
+        }
+
         try {
+            const user = await this.registerUserUC.execute({
+                email: data.email,
+                firstName: data.first_name || 'User',
+                lastName: data.last_name ?? '',
+                password: null,
+                bio: data.bio,
+                gender: data.sex === 'male' ? 'male' : data.sex === 'female' ? 'female' : 'none',
+                avatarUrl: data.avatar_url,
+            });
+
+            await this.identityRepo.create({
+                userId: user.id,
+                avatarUrl: data.avatar_url,
+                provider: data.provider,
+                providerUserId: data.id,
+                email: data.email,
+            });
+
             const sessionId = createId();
+
             const { access, expiresAt, refresh } = await this.tokenService.generateTokens(
-                { id: data.userId, email: data.email },
+                { id: user.id, email: user.email },
                 sessionId,
             );
 
             const result = await this.sessionRepo.create({
                 id: sessionId,
                 ...meta,
                 expiresAt: expiresAt.toISOString(),
-                userId: data.userId,
+                userId: user.id,
             });
 
             if (!result?.id) {
@@ -75,11 +114,13 @@ export class ExchangeUseCase {
                 );
             }
 
+            const event = new CreateUserWorkspaceEvent(user.id, user.firstName);
+            await this.queue.add(AuthUserJobs.CREATE_WORKSPACE, event);
+
             return {
                 success: true,
                 message: 'Вход выполнен успешно',
                 access,
-                isNewUser: data.isNewUser,
                 provider: data.provider,
                 refresh,
                 expiresAt,