@hed-hog/core 0.0.399 → 0.0.400

package/src/oauth/oauth.service.ts

@@ -3,6 +3,7 @@ import { Prisma, PrismaService, user_account_provider_52222e2ecb_enum } from '@h
 import {
     BadRequestException,
     ConflictException,
+    HttpStatus,
     Inject,
     Injectable,
     Logger,
@@ -45,7 +46,6 @@ type HandleCallbackProps = {
   email?: string;
   redirectUri?: string;
   state?: string;
-  includeRefreshTokenInBody?: boolean;
   /** Origin header of the request that hit the callback (used to bind web hub flows). */
   requestOrigin?: string;
   /** Referer header, used as a fallback when the Origin header is absent. */
@@ -250,7 +250,6 @@ export class OAuthService {
     email,
     redirectUri,
     state,
-    includeRefreshTokenInBody,
     requestOrigin,
     requestReferer,
   }: HandleCallbackProps) {
@@ -339,7 +338,6 @@ export class OAuthService {
             type,
             profile,
             userId,
-            includeRefreshTokenInBody: true,
             app: webState?.app,
           });
         })) as { accessToken: string; refreshToken?: string };
@@ -367,7 +365,6 @@ export class OAuthService {
           type,
           profile,
           userId,
-          includeRefreshTokenInBody,
           app: webState?.app,
         });
 
@@ -728,7 +725,6 @@ export class OAuthService {
         type: flow,
         profile,
         userId,
-        includeRefreshTokenInBody: false,
       });
     } catch (error) {
       throw this.mapCallbackError(locale, provider, flow, error);
@@ -744,16 +740,15 @@ export class OAuthService {
     type,
     profile,
     userId,
-    includeRefreshTokenInBody,
     app,
   }: Omit<HandleCallbackProps, 'code' | 'email' | 'redirectUri' | 'state'> & { profile: any }) {
     switch (type) {
       case 'login':
-        return this.handleLogin(res, locale, ipAddress, userAgent, provider, profile, includeRefreshTokenInBody);
+        return this.handleLogin(res, locale, ipAddress, userAgent, provider, profile);
       case 'register':
-        return this.handleRegister(res, locale, ipAddress, userAgent, provider, profile, includeRefreshTokenInBody, app);
+        return this.handleRegister(res, locale, ipAddress, userAgent, provider, profile, app);
       case 'connect':
-        return this.handleConnect(res, locale, ipAddress, userAgent, provider, profile, userId, includeRefreshTokenInBody);
+        return this.handleConnect(res, locale, ipAddress, userAgent, provider, profile, userId);
       default:
         throw new BadRequestException(
           getLocaleText('oauth.callback.invalidType', locale, 'Unsupported OAuth callback type.'),
@@ -761,16 +756,23 @@ export class OAuthService {
     }
   }
 
-  private formatAuthResponse(
-    accessToken: string,
-    refreshToken: string,
-    includeRefreshTokenInBody?: boolean,
-  ) {
-    if (includeRefreshTokenInBody) {
-      return { accessToken, refreshToken };
-    }
-
-    return { accessToken };
+  /**
+   * O corpo carrega SEMPRE o par, como `/auth/login` já faz.
+   *
+   * Antes só o app mobile recebia o refresh token aqui (`includeRefreshTokenInBody`
+   * valia `Boolean(redirectUri)`); o fluxo web ficava dependendo do cookie `rt`. Esse
+   * cookie sai com `domain` da setting `api-url` (`hub-api.hcode.com.br`), então ele
+   * só existe para quem fala DIRETO com a API — o admin. O Class fala por rewrite
+   * same-origin (`class.hcode.com.br/api`), e o browser descarta um `Set-Cookie` de
+   * domínio alheio: o aluno que entrava por OAuth ficava sem refresh token nenhum e
+   * era deslogado no minuto em que o access token vencia.
+   *
+   * Não é exposição nova: `/auth/login` devolve o refresh token no corpo desde sempre
+   * e todo app web já o guarda no localStorage. O cookie continua sendo emitido para
+   * quem o usa; ele deixa apenas de ser o único portador.
+   */
+  private formatAuthResponse(accessToken: string, refreshToken: string) {
+    return { accessToken, refreshToken };
   }
 
   private resolveProfileScopes(provider: user_account_provider_52222e2ecb_enum, profile: any) {
@@ -798,10 +800,13 @@ export class OAuthService {
 
     if (error instanceof OAuthCallbackAlreadyProcessedError) {
       return new BadRequestException(
-        getLocaleText(
-          'oauth.callback.alreadyProcessed',
-          locale,
-          'This OAuth callback has already been processed. Start the sign-in flow again.',
+        this.buildCallbackErrorBody(
+          'already_processed',
+          getLocaleText(
+            'oauth.callback.alreadyProcessed',
+            locale,
+            'This OAuth callback has already been processed. Start the sign-in flow again.',
+          ),
         ),
       );
     }
@@ -818,7 +823,12 @@ export class OAuthService {
 
     if (error instanceof OAuthProviderException) {
       if (error.reason === 'callback_consumed' || error.reason === 'invalid_callback') {
-        return new BadRequestException(getLocaleText('oauth.callback.invalid', locale, error.message));
+        return new BadRequestException(
+          this.buildCallbackErrorBody(
+            error.reason,
+            getLocaleText('oauth.callback.invalid', locale, error.message),
+          ),
+        );
       }
 
       this.logger.warn(
@@ -831,11 +841,21 @@ export class OAuthService {
           locale,
           'Unable to complete OAuth authentication right now. Please try again.',
         ),
+        // `description` vai junto porque o Nest só aplica o default dela quando o
+        // segundo argumento é ausente ou string: passar apenas `{ cause }` deixaria
+        // o campo `error` do corpo como undefined.
+        { cause: error, description: 'Service Unavailable' },
       );
     }
 
+    // Ramo de último recurso: um erro que ninguém classificou. Como a resposta ao
+    // usuário é genérica por definição, o log e a causa encadeada são o único
+    // rastro que sobra — sem eles o evento no Sentry chega sem status, sem corpo
+    // do provider e com o stack enraizado aqui, e não dá para agir.
+    const detail = error as any;
     this.logger.error(
-      `Unexpected OAuth callback failure: provider=${provider} type=${type} error=${error instanceof Error ? error.message : 'unknown'}`,
+      `Unexpected OAuth callback failure: provider=${provider} type=${type} name=${detail?.name ?? 'unknown'} code=${detail?.code ?? 'n/a'} status=${detail?.response?.status ?? 'n/a'} error=${error instanceof Error ? error.message : 'unknown'}`,
+      error instanceof Error ? error.stack : undefined,
     );
 
     return new ServiceUnavailableException(
@@ -844,10 +864,27 @@ export class OAuthService {
         locale,
         'Unable to complete OAuth authentication right now. Please try again.',
       ),
+      { cause: error, description: 'Service Unavailable' },
     );
   }
 
-  private async handleLogin(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, profile: any, includeRefreshTokenInBody?: boolean) {
+  /**
+   * Corpo dos 400 de callback. O `oauthReason` é a chave estável que o frontend
+   * usa para reconhecer "código já consumido" — antes disso os apps casavam a
+   * substring "already processed", que só existe no texto em inglês e portanto
+   * nunca disparava para quem usa o Hub em pt-BR. O `error` vai explícito para o
+   * envelope da resposta continuar idêntico ao que o Nest monta sozinho.
+   */
+  private buildCallbackErrorBody(oauthReason: string, message: string) {
+    return {
+      statusCode: HttpStatus.BAD_REQUEST,
+      message,
+      error: 'Bad Request',
+      oauthReason,
+    };
+  }
+
+  private async handleLogin(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, profile: any) {
     const userAccount = await this.prisma.user_account.findFirst({
       where: {
         provider: String(provider).toLowerCase().replace(/-/g, '_') as user_account_provider_52222e2ecb_enum,
@@ -897,11 +934,11 @@ export class OAuthService {
       );
 
       await this.token.setRefreshTokenCookie(locale, res, refreshToken, session.expires_at);
-      return this.formatAuthResponse(accessToken, refreshToken, includeRefreshTokenInBody);
+      return this.formatAuthResponse(accessToken, refreshToken);
     }
   }
 
-  private async handleRegister(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, profile: any, includeRefreshTokenInBody?: boolean, app?: string) {
+  private async handleRegister(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, profile: any, app?: string) {
     const existingUser = await this.prisma.user_identifier.findFirst({
       where: {
         type: 'email',
@@ -989,7 +1026,7 @@ export class OAuthService {
       userAgent
     );
     await this.token.setRefreshTokenCookie(locale, res, refreshToken, session.expires_at);
-    return this.formatAuthResponse(accessToken, refreshToken, includeRefreshTokenInBody);
+    return this.formatAuthResponse(accessToken, refreshToken);
   }
 
   private async handleConnect(
@@ -1000,7 +1037,6 @@ export class OAuthService {
     provider: user_account_provider_52222e2ecb_enum,
     profile: any,
     userId: number,
-    includeRefreshTokenInBody?: boolean,
   ) {
     const existingAccount = await this.prisma.user_account.findFirst({
       where: {
@@ -1057,7 +1093,7 @@ export class OAuthService {
     await this.user.registerUserActivity(userId, 'oauth-connect');
     const { accessToken, refreshToken, session } = await this.auth.getAuthenticationPayload(locale, user.id, ipAddress, userAgent);
     await this.token.setRefreshTokenCookie(locale, res, refreshToken, session.expires_at);
-    return this.formatAuthResponse(accessToken, refreshToken, includeRefreshTokenInBody);
+    return this.formatAuthResponse(accessToken, refreshToken);
   }
 
   private async handleDisconnect(res: Response, locale: string, ipAddress: string, userAgent: string, provider: user_account_provider_52222e2ecb_enum, email: string) {
@@ -1080,7 +1116,10 @@ export class OAuthService {
     await this.user.registerUserActivity(userAccount.user.id, 'oauth-disconnect');
     const { accessToken, refreshToken, session } = await this.auth.getAuthenticationPayload(locale, userAccount.user.id, ipAddress, userAgent);
     await this.token.setRefreshTokenCookie(locale, res, refreshToken, session.expires_at);
-    return { accessToken };
+    // Sessão NOVA (o `getAuthenticationPayload` acima cria uma), então o par vai
+    // inteiro no corpo, como nos demais fluxos: devolver só o access token deixava
+    // o cliente com um token de uma sessão e o refresh token de outra.
+    return this.formatAuthResponse(accessToken, refreshToken);
   }
 
   private async downloadAndSaveProfilePicture(

package/src/oauth/providers/abstract.provider.spec.ts

@@ -0,0 +1,192 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import { HttpService } from '@nestjs/axios';
+import { of, throwError } from 'rxjs';
+import { OAuthProviderException } from '../oauth.errors';
+import { BaseOAuthProvider } from './abstract.provider';
+
+/**
+ * Estes testes existem por causa do incidente API-6: os helpers da base deixavam
+ * o AxiosError cru subir, e como ele não é `OAuthProviderException` o
+ * `OAuthService.mapCallbackError` o jogava no ramo genérico — um `invalid_grant`
+ * (código reusado/expirado, o caso comum no Safari do iOS) respondia 503
+ * "tente novamente" em vez de 400 "refaça o login".
+ */
+class TestProvider extends BaseOAuthProvider {
+  getProviderType() {
+    return 'TEST';
+  }
+
+  async getAuthUrl() {
+    return 'https://example.test/authorize';
+  }
+
+  async getProfile() {
+    return {};
+  }
+
+  // Os membros abaixo apenas expõem os protegidos da base para o teste.
+  callFetchToken() {
+    return this.fetchToken({
+      code: 'CODE',
+      url: 'https://example.test/token',
+      clientId: 'id',
+      clientSecret: 'secret',
+      redirectUri: 'https://example.test/callback',
+    });
+  }
+
+  callFetchProfile() {
+    return this.fetchProfile('ACCESS_TOKEN', 'https://example.test/me');
+  }
+
+  callMapProviderError(error: unknown) {
+    return this.mapProviderError('TEST', error);
+  }
+}
+
+const makeProvider = () => {
+  const http = { post: jest.fn(), get: jest.fn() };
+  return { provider: new TestProvider(http as unknown as HttpService), http };
+};
+
+/** Erro no formato que o axios entrega quando o provider responde com status de erro. */
+const upstreamError = (status: number, data: unknown) =>
+  Object.assign(new Error(`Request failed with status code ${status}`), {
+    isAxiosError: true,
+    response: { status, data },
+  });
+
+/** Erro de transporte: não chega a existir resposta, só o código do socket. */
+const networkError = (code: string) =>
+  Object.assign(new Error(code), { isAxiosError: true, code });
+
+describe('BaseOAuthProvider.fetchToken', () => {
+  it('devolve os dados quando a troca do código dá certo', async () => {
+    const { provider, http } = makeProvider();
+    http.post.mockReturnValue(of({ data: { access_token: 'AT' } }) as never);
+
+    await expect(provider.callFetchToken()).resolves.toEqual({ access_token: 'AT' });
+  });
+
+  it('traduz invalid_grant para invalid_callback (regressão do API-6)', async () => {
+    const { provider, http } = makeProvider();
+    const original = upstreamError(400, {
+      error: 'invalid_grant',
+      error_description: 'Code was already redeemed.',
+    });
+    http.post.mockReturnValue(throwError(() => original) as never);
+
+    const error = await provider.callFetchToken().catch((e) => e);
+
+    // Sem isto o erro sai cru e vira 503 lá no OAuthService.
+    expect(error).toBeInstanceOf(OAuthProviderException);
+    expect(error.reason).toBe('callback_consumed');
+    expect(error.status).toBe(400);
+    expect(error.providerError).toBe('invalid_grant');
+    expect(error.cause).toBe(original);
+  });
+
+  it('classifica invalid_grant sem "already redeemed" como invalid_callback', async () => {
+    const { provider, http } = makeProvider();
+    http.post.mockReturnValue(
+      throwError(() => upstreamError(400, { error: 'invalid_grant' })) as never,
+    );
+
+    const error = await provider.callFetchToken().catch((e) => e);
+
+    expect(error.reason).toBe('invalid_callback');
+  });
+
+  it('trata bad_verification_code do GitHub como código inválido', async () => {
+    const { provider, http } = makeProvider();
+    http.post.mockReturnValue(
+      throwError(() => upstreamError(200, { error: 'bad_verification_code' })) as never,
+    );
+
+    const error = await provider.callFetchToken().catch((e) => e);
+
+    expect(error.reason).toBe('invalid_callback');
+  });
+
+  it('classifica falha de transporte como upstream_failure preservando o código', async () => {
+    const { provider, http } = makeProvider();
+    const original = networkError('ECONNABORTED');
+    http.post.mockReturnValue(throwError(() => original) as never);
+
+    const error = await provider.callFetchToken().catch((e) => e);
+
+    expect(error).toBeInstanceOf(OAuthProviderException);
+    expect(error.reason).toBe('upstream_failure');
+    expect(error.status).toBeUndefined();
+    expect(error.providerError).toBe('ECONNABORTED');
+    expect(error.cause).toBe(original);
+  });
+
+  it('classifica erro do servidor do provider como upstream_failure', async () => {
+    const { provider, http } = makeProvider();
+    http.post.mockReturnValue(
+      throwError(() => upstreamError(503, { error: 'server_error' })) as never,
+    );
+
+    const error = await provider.callFetchToken().catch((e) => e);
+
+    expect(error.reason).toBe('upstream_failure');
+    expect(error.status).toBe(503);
+  });
+});
+
+describe('BaseOAuthProvider.fetchProfile', () => {
+  it('devolve os dados do perfil quando dá certo', async () => {
+    const { provider, http } = makeProvider();
+    http.get.mockReturnValue(of({ data: { email: 'a@b.c' } }) as never);
+
+    await expect(provider.callFetchProfile()).resolves.toEqual({ email: 'a@b.c' });
+  });
+
+  it('também traduz a falha, não só a troca do código', async () => {
+    const { provider, http } = makeProvider();
+    http.get.mockReturnValue(
+      throwError(() => upstreamError(401, { error: 'invalid_token' })) as never,
+    );
+
+    const error = await provider.callFetchProfile().catch((e) => e);
+
+    expect(error).toBeInstanceOf(OAuthProviderException);
+    expect(error.reason).toBe('upstream_failure');
+    expect(error.status).toBe(401);
+  });
+});
+
+describe('BaseOAuthProvider.mapProviderError', () => {
+  it('é idempotente: não reembrulha um erro já traduzido', () => {
+    const { provider } = makeProvider();
+    const mapped = new OAuthProviderException('TEST', 'invalid_callback', 'msg');
+
+    // O provider do Entra ID tem o próprio try/catch por cima dos helpers, que
+    // agora já mapeiam — sem a idempotência o motivo original seria perdido.
+    expect(provider.callMapProviderError(mapped)).toBe(mapped);
+  });
+
+  it('extrai o código AADSTS da descrição quando existe', () => {
+    const { provider } = makeProvider();
+
+    const error = provider.callMapProviderError(
+      upstreamError(400, {
+        error: 'invalid_grant',
+        error_description: 'AADSTS54005: OAuth2 Authorization code was already redeemed.',
+      }),
+    );
+
+    expect(error.reason).toBe('callback_consumed');
+    expect(error.providerErrorCode).toBe('AADSTS54005');
+  });
+
+  it('usa unknown_error quando não há nada aproveitável no erro', () => {
+    const { provider } = makeProvider();
+
+    const error = provider.callMapProviderError(new Error('boom'));
+
+    expect(error.reason).toBe('upstream_failure');
+    expect(error.providerError).toBe('unknown_error');
+  });
+});

package/src/oauth/providers/abstract.provider.ts

@@ -31,25 +31,47 @@ export abstract class BaseOAuthProvider implements OAuthProvider {
       code,
     }).toString();
 
-    const response = await lastValueFrom(
-      this.http.post(url, body, {
-        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
-      }),
-    );
+    try {
+      const response = await lastValueFrom(
+        this.http.post(url, body, {
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        }),
+      );
 
-    return response.data;
+      return response.data;
+    } catch (error) {
+      throw this.mapProviderError(this.getProviderType(), error);
+    }
   }
 
   protected async fetchProfile(accessToken: string, url: string) {
-    const response = await lastValueFrom(
-      this.http.get(url, {
-        headers: { Authorization: `Bearer ${accessToken}` },
-      }),
-    );
-    return response.data;
+    try {
+      const response = await lastValueFrom(
+        this.http.get(url, {
+          headers: { Authorization: `Bearer ${accessToken}` },
+        }),
+      );
+      return response.data;
+    } catch (error) {
+      throw this.mapProviderError(this.getProviderType(), error);
+    }
   }
 
-  protected mapProviderError(provider: string, error: any) {
+  /**
+   * Traduz a falha crua do provider (quase sempre um AxiosError) para o tipo que
+   * `OAuthService.mapCallbackError` sabe classificar. Sem isso o erro atravessa
+   * todos os ramos de lá e vira um 503 genérico — inclusive um `invalid_grant`,
+   * que é código reusado/expirado e deveria ser 400 "refaça o login".
+   *
+   * É idempotente de propósito: os helpers acima já mapeiam, então um provider
+   * que também tenha o próprio try/catch (Microsoft Entra ID) recebe aqui um
+   * erro já traduzido e não pode reembrulhá-lo.
+   */
+  protected mapProviderError(provider: string, error: any): OAuthProviderException {
+    if (error instanceof OAuthProviderException) {
+      return error;
+    }
+
     const providerError = this.extractProviderError(error);
     const providerErrorCode = this.extractProviderErrorCode(error);
     const status = error?.response?.status;
@@ -62,6 +84,7 @@ export abstract class BaseOAuthProvider implements OAuthProvider {
         status,
         providerError,
         providerErrorCode,
+        error,
       );
     }
 
@@ -73,6 +96,7 @@ export abstract class BaseOAuthProvider implements OAuthProvider {
         status,
         providerError,
         providerErrorCode,
+        error,
       );
     }
 
@@ -83,6 +107,7 @@ export abstract class BaseOAuthProvider implements OAuthProvider {
       status,
       providerError,
       providerErrorCode,
+      error,
     );
   }
 
@@ -109,6 +134,13 @@ export abstract class BaseOAuthProvider implements OAuthProvider {
   }
 
   protected isInvalidAuthorizationCodeError(error: any) {
-    return this.extractProviderError(error) === 'invalid_grant';
+    const providerError = this.extractProviderError(error);
+
+    // `bad_verification_code` é o `invalid_grant` do GitHub, que responde 200 com
+    // o erro no corpo em vez de status de erro.
+    return (
+      providerError === 'invalid_grant' ||
+      providerError === 'bad_verification_code'
+    );
   }
 }

package/src/oauth/providers/github.provider.ts

@@ -76,52 +76,75 @@ export class GithubProvider extends BaseOAuthProvider {
     const redirectURI = redirectUri?.trim()
       ? redirectUri.trim()
       : new URL(fixedCallbackPath, apiUrl.replace(':3200', ':3100')).toString();
-    const tokenResponse = await this.http.axiosRef.post(
-      'https://github.com/login/oauth/access_token',
-      {
-        client_id: clientId,
-        client_secret: clientSecret,
-        code,
-        redirect_uri: redirectURI,
-      },
-      {
-        headers: {
-          Accept: 'application/json',
+    // Este provider não usa os helpers da base (fala com o axios direto), então
+    // precisa do mesmo tratamento de erro que eles aplicam — sem isso o AxiosError
+    // cru chega ao OAuthService e vira 503 genérico.
+    let tokenResponse: any;
+    try {
+      tokenResponse = await this.http.axiosRef.post(
+        'https://github.com/login/oauth/access_token',
+        {
+          client_id: clientId,
+          client_secret: clientSecret,
+          code,
+          redirect_uri: redirectURI,
+        },
+        {
+          headers: {
+            Accept: 'application/json',
+          },
         },
-      },
-    );
-
-    const { access_token, error, error_description } = tokenResponse.data;
-    if (error || !access_token) {
-      throw new Error(
-        `GitHub OAuth error: ${error_description || error || 'No access token received'}`,
       );
+    } catch (error) {
+      throw this.mapProviderError(this.getProviderType(), error);
     }
 
-    const profileResponse = await this.http.axiosRef.get(
-      'https://api.github.com/user',
-      {
-        headers: {
-          Authorization: `Bearer ${access_token}`,
+    const { access_token, error, error_description } = tokenResponse.data;
+    if (error || !access_token) {
+      // O GitHub responde 200 com o erro no corpo, então não há AxiosError para
+      // capturar: monta-se a mesma forma que o mapeador lê.
+      throw this.mapProviderError(this.getProviderType(), {
+        response: {
+          status: tokenResponse.status,
+          data: {
+            error: error || 'no_access_token',
+            error_description:
+              error_description || 'No access token received from GitHub.',
+          },
         },
-      },
-    );
+      });
+    }
 
-    const profile = profileResponse.data;
-    let email = profile.email;
-    if (!email) {
-      const emailResponse = await this.http.axiosRef.get(
-        'https://api.github.com/user/emails',
+    let profile: any;
+    let email: string | null;
+    try {
+      const profileResponse = await this.http.axiosRef.get(
+        'https://api.github.com/user',
         {
           headers: {
             Authorization: `Bearer ${access_token}`,
           },
         },
       );
-      const primaryEmail = emailResponse.data.find(
-        (e: any) => e.primary && e.verified,
-      );
-      email = primaryEmail?.email || null;
+
+      profile = profileResponse.data;
+      email = profile.email;
+      if (!email) {
+        const emailResponse = await this.http.axiosRef.get(
+          'https://api.github.com/user/emails',
+          {
+            headers: {
+              Authorization: `Bearer ${access_token}`,
+            },
+          },
+        );
+        const primaryEmail = emailResponse.data.find(
+          (e: any) => e.primary && e.verified,
+        );
+        email = primaryEmail?.email || null;
+      }
+    } catch (error) {
+      throw this.mapProviderError(this.getProviderType(), error);
     }
 
     return {

package/src/oauth/providers/microsoft-entra-id.provider.ts

@@ -1,6 +1,6 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { HttpService } from '@nestjs/axios';
-import { BadRequestException, forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { BadRequestException, forwardRef, HttpException, Inject, Injectable, Logger } from '@nestjs/common';
 import { buildOAuthConfigFromIntegration } from '../../integration-profile/integration-profile.utils';
 import { SettingService } from '../../setting/setting.service';
 import { BaseOAuthProvider } from './abstract.provider';
@@ -174,6 +174,13 @@ export class MicrosoftEntraIdProvider extends BaseOAuthProvider {
         },
       };
     } catch (error: any) {
+      // O try acima cobre também o `loadConfig`, que sinaliza perfil ausente com
+      // uma HttpException — mapeá-la transformaria um 400 de configuração em um
+      // 503 de indisponibilidade.
+      if (error instanceof HttpException) {
+        throw error;
+      }
+
       const mappedError = this.mapProviderError('Microsoft Entra ID', error);
 
       this.logger.warn(