@hed-hog/core 0.0.399 → 0.0.401

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.spec.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it, jest } from '@jest/globals';
+import { HttpService } from '@nestjs/axios';
+import { of } from 'rxjs';
+import { MicrosoftEntraIdProvider } from './microsoft-entra-id.provider';
+
+/**
+ * O que estes testes protegem: `user_account.scopes` tem que registrar o que a
+ * Microsoft CONCEDEU, não o que a setting pede.
+ *
+ * Gravar a setting quebrava toda a integração delegada de um jeito que não dava
+ * pista nenhuma. O `OAuthTokenBrokerService` monta o `scope` do refresh a partir
+ * dessa coluna; se ela promete um escopo que o consentimento não cobre, a
+ * Microsoft recusa o grant com `invalid_grant`, o broker traduz para "reconecte
+ * a conta" — e reconectar pelo login regrava a mesma setting, então o usuário
+ * reconecta, falha, reconecta, falha.
+ */
+
+const SCOPES_CONFIGURADOS = [
+  'openid',
+  'profile',
+  'email',
+  'User.Read',
+  'offline_access',
+  'Chat.Read',
+  'Files.Read.All',
+];
+
+const makeProvider = (tokenResponse: Record<string, unknown>) => {
+  const http = {
+    post: jest.fn(() => of({ data: tokenResponse })),
+    get: jest.fn(() => of({ data: { id: 'graph-id', mail: 'alguem@exemplo.test', displayName: 'Alguém' } })),
+  };
+
+  const setting = {
+    getSettingValues: jest.fn(async (slugs: string[]) => {
+      const values: Record<string, unknown> = {
+        'oauth-microsoft-entra-id-profile-id': 'perfil-entra',
+        'oauth-microsoft-entra-id-scopes': SCOPES_CONFIGURADOS,
+        url: 'https://app.exemplo.test',
+        'api-url': 'https://api.exemplo.test',
+      };
+      return Object.fromEntries(slugs.map((slug) => [slug, values[slug]]));
+    }),
+  };
+
+  const prisma = {
+    integration_profile: {
+      findUnique: jest.fn(async () => ({
+        slug: 'perfil-entra',
+        config: { client_id: 'CID', client_secret: 'SECRET', tenant_id: 'TENANT' },
+        integration_provider: { slug: 'microsoft-entra-id-oauth' },
+      })),
+    },
+  };
+
+  return new MicrosoftEntraIdProvider(
+    http as unknown as HttpService,
+    setting as any,
+    prisma as any,
+  );
+};
+
+const parse = (profile: any) => String(profile.oauth_scopes).split(',');
+
+describe('MicrosoftEntraIdProvider.getProfile — escopos', () => {
+  it('grava o que a Microsoft concedeu, não o que a setting pede', async () => {
+    // Consentimento antigo: nem Chat.Read nem Files.Read.All foram aprovados.
+    const provider = makeProvider({
+      access_token: 'ACCESS',
+      refresh_token: 'REFRESH',
+      expires_in: 3600,
+      scope: 'openid profile email User.Read',
+    });
+
+    const scopes = parse(await provider.getProfile('CODE', 'login'));
+
+    expect(scopes).not.toContain('Chat.Read');
+    expect(scopes).not.toContain('Files.Read.All');
+    expect(scopes).toContain('User.Read');
+  });
+
+  it('mantém offline_access quando veio refresh token, mesmo fora do scope', async () => {
+    // A Microsoft não repete `offline_access` em `token.scope`. Perdê-lo faria
+    // o broker tratar a conta como sem acesso offline.
+    const provider = makeProvider({
+      access_token: 'ACCESS',
+      refresh_token: 'REFRESH',
+      expires_in: 3600,
+      scope: 'openid profile email User.Read',
+    });
+
+    expect(parse(await provider.getProfile('CODE', 'login'))).toContain(
+      'offline_access',
+    );
+  });
+
+  it('não inventa offline_access quando não houve refresh token', async () => {
+    const provider = makeProvider({
+      access_token: 'ACCESS',
+      expires_in: 3600,
+      scope: 'openid profile email',
+    });
+
+    expect(parse(await provider.getProfile('CODE', 'login'))).not.toContain(
+      'offline_access',
+    );
+  });
+
+  it('cai para os escopos pedidos só quando a Microsoft não informa nenhum', async () => {
+    // Ausência de `scope` é omissão do provedor; lista vazia seria resposta.
+    const provider = makeProvider({
+      access_token: 'ACCESS',
+      refresh_token: 'REFRESH',
+      expires_in: 3600,
+    });
+
+    const scopes = parse(await provider.getProfile('CODE', 'login'));
+
+    expect(scopes).toEqual(expect.arrayContaining(SCOPES_CONFIGURADOS));
+  });
+
+  it('registra escopo concedido vazio como vazio, sem assumir o pedido', async () => {
+    const provider = makeProvider({
+      access_token: 'ACCESS',
+      expires_in: 3600,
+      scope: '   ',
+    });
+
+    expect(parse(await provider.getProfile('CODE', 'login'))).not.toContain(
+      'Files.Read.All',
+    );
+  });
+});

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';
@@ -77,6 +77,19 @@ export class MicrosoftEntraIdProvider extends BaseOAuthProvider {
     };
   }
 
+  /**
+   * Escopos que a Microsoft devolveu no token, ou `null` quando ela não
+   * informou — só nesse caso vale cair de volta para os escopos pedidos.
+   * Uma lista vazia é resposta legítima e não pode virar "assume o pedido".
+   */
+  private parseGrantedScopes(scope: unknown): string[] | null {
+    if (typeof scope !== 'string') return null;
+    return scope
+      .split(/[\s,]+/)
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+
   /** Absolute redirect URI the web flow registers/exchanges against (the API). */
   private buildApiRedirectUri(apiUrl: string) {
     if (!String(apiUrl).trim()) {
@@ -155,8 +168,22 @@ export class MicrosoftEntraIdProvider extends BaseOAuthProvider {
         'https://graph.microsoft.com/v1.0/me',
       );
 
+      // `token.scope` é o que a Microsoft de fato consentiu, que pode ser MENOS
+      // do que a setting pede — consentimento antigo do usuário, ou escopo novo
+      // ainda sem aprovação do admin. Gravar a setting como se fosse o concedido
+      // faz o refresh seguinte pedir escopo que o grant não cobre, e aí a
+      // resposta é `invalid_grant`: a UI diz "reconecte a conta", e reconectar
+      // pelo login regrava a mesma setting, então nunca sai do lugar.
+      const grantedScopes = this.parseGrantedScopes(token.scope) ?? scopes;
+      // A Microsoft não repete `offline_access` em `token.scope`, mas ter
+      // devolvido um refresh token é prova de que foi concedido.
+      if (token.refresh_token && !grantedScopes.includes('offline_access')) {
+        grantedScopes.push('offline_access');
+      }
+      const missing = scopes.filter((scope) => !grantedScopes.includes(scope));
+
       this.logger.log(
-        `OAuth profile fetched: provider=MICROSOFT-ENTRA-ID type=${type} profileIdPresent=${profile?.id ? 'yes' : 'no'} emailPresent=${profile?.mail || profile?.userPrincipalName ? 'yes' : 'no'}`,
+        `OAuth profile fetched: provider=MICROSOFT-ENTRA-ID type=${type} profileIdPresent=${profile?.id ? 'yes' : 'no'} emailPresent=${profile?.mail || profile?.userPrincipalName ? 'yes' : 'no'} scopesGranted=${grantedScopes.length}/${scopes.length}${missing.length ? ` missing=${missing.join(' ')}` : ''}`,
       );
 
       const pictureUrl = 'https://graph.microsoft.com/v1.0/me/photo/$value';
@@ -165,7 +192,7 @@ export class MicrosoftEntraIdProvider extends BaseOAuthProvider {
         email: profile.mail || profile.userPrincipalName,
         name: profile.displayName,
         picture: pictureUrl,
-        oauth_scopes: scopes.join(','),
+        oauth_scopes: grantedScopes.join(','),
         oauth_tokens: {
           access_token: token.access_token,
           refresh_token: token.refresh_token,
@@ -174,6 +201,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(

package/src/observability/monitored-cron.spec.ts

@@ -1,7 +1,8 @@
-import { describe, it, expect, jest, beforeEach } from '@jest/globals';
+import { describe, it, expect, jest, beforeEach, afterEach } from '@jest/globals';
 
 const withMonitor = jest.fn((_slug: string, callback: () => any) => callback());
 const startSpan = jest.fn((_opts: any, callback: () => any) => callback());
+const startNewTrace = jest.fn((callback: () => any) => callback());
 const captureException = jest.fn();
 const withScope = jest.fn((cb: (scope: any) => void) => {
   const scope = { setTag: jest.fn() };
@@ -9,41 +10,83 @@ const withScope = jest.fn((cb: (scope: any) => void) => {
   return scope;
 });
 
-jest.mock('@sentry/nestjs', () => ({ withMonitor, startSpan, captureException, withScope }));
+jest.mock('@sentry/nestjs', () => ({
+  withMonitor,
+  startSpan,
+  startNewTrace,
+  captureException,
+  withScope,
+}));
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { runMonitoredCron } = require('./monitored-cron');
 
-function fakePrisma(locked: boolean, overrides: { transactionThrows?: boolean } = {}) {
-  const queryRaw = jest.fn().mockResolvedValue([{ locked }]);
-  const transaction = jest.fn(async (fn: any) => {
-    if (overrides.transactionThrows) throw new Error('transaction aborted');
-    return fn({ $queryRaw: queryRaw });
+type FakeOptions = {
+  /** `false` simula outro pod segurando a lease (nenhuma linha devolvida). */
+  won?: boolean;
+  claimThrows?: boolean;
+  releaseThrows?: boolean;
+};
+
+/**
+ * O Prisma chama a tagged template como `$queryRaw(strings, ...values)`, então os
+ * parâmetros do SQL chegam aqui na ordem em que aparecem na query: o claim manda
+ * [slug, holder, leaseSeconds] e o release manda [slug, holder].
+ */
+function fakePrisma(options: FakeOptions = {}) {
+  const claims: any[][] = [];
+  const releases: any[][] = [];
+
+  const $queryRaw = jest.fn(async (_strings: any, ...values: any[]) => {
+    claims.push(values);
+    if (options.claimThrows) throw new Error('Unable to start a transaction in the given time.');
+    return options.won === false ? [] : [{ won: 1 }];
   });
-  return { $transaction: transaction, $queryRaw: queryRaw };
+
+  const $executeRaw = jest.fn(async (_strings: any, ...values: any[]) => {
+    releases.push(values);
+    if (options.releaseThrows) throw new Error('release falhou');
+    return 1;
+  });
+
+  return { $queryRaw, $executeRaw, claims, releases };
 }
 
+const BASE = { slug: 'meu-cron', schedule: '* * * * *' };
+
 describe('runMonitoredCron', () => {
+  const originalSlugs = process.env.SENTRY_CRON_MONITOR_SLUGS;
+
   beforeEach(() => {
     jest.clearAllMocks();
+    // O default de produção libera check-in só para um slug; os casos abaixo
+    // descrevem o comportamento com o monitor ligado, então valem para todos.
+    process.env.SENTRY_CRON_MONITOR_SLUGS = '*';
+  });
+
+  afterEach(() => {
+    if (originalSlugs === undefined) delete process.env.SENTRY_CRON_MONITOR_SLUGS;
+    else process.env.SENTRY_CRON_MONITOR_SLUGS = originalSlugs;
   });
 
   it('retorna undefined sem executar work() quando outro pod já ganhou o tick', async () => {
-    const prisma = fakePrisma(false);
+    const prisma = fakePrisma({ won: false });
     const work = jest.fn();
 
-    const result = await runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work);
+    const result = await runMonitoredCron(prisma, BASE, work);
 
     expect(result).toBeUndefined();
     expect(work).not.toHaveBeenCalled();
     expect(withMonitor).not.toHaveBeenCalled();
+    // Perder o tick não pode mexer na lease de quem venceu.
+    expect(prisma.$executeRaw).not.toHaveBeenCalled();
   });
 
   it('executa work() e devolve o resultado quando ganha o tick', async () => {
-    const prisma = fakePrisma(true);
+    const prisma = fakePrisma();
     const work = jest.fn().mockResolvedValue({ ok: true });
 
-    const result = await runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work);
+    const result = await runMonitoredCron(prisma, BASE, work);
 
     expect(work).toHaveBeenCalledTimes(1);
     expect(withMonitor).toHaveBeenCalledWith(
@@ -54,44 +97,61 @@ describe('runMonitoredCron', () => {
     expect(result).toEqual({ ok: true });
   });
 
-  it('NUNCA relança quando work() falha — captura no Sentry e retorna undefined', async () => {
-    const prisma = fakePrisma(true);
+  it('libera a lease com o MESMO holder que a tomou', async () => {
+    const prisma = fakePrisma();
+
+    await runMonitoredCron(prisma, BASE, jest.fn().mockResolvedValue(undefined));
+
+    const [claimSlug, claimHolder] = prisma.claims[0];
+    const [releaseSlug, releaseHolder] = prisma.releases[0];
+
+    expect(claimSlug).toBe('meu-cron');
+    expect(releaseSlug).toBe('meu-cron');
+    expect(releaseHolder).toBe(claimHolder);
+  });
+
+  it('usa um holder diferente a cada execução, para um release atrasado não apagar a lease do tick seguinte', async () => {
+    const prisma = fakePrisma();
+    const work = jest.fn().mockResolvedValue(undefined);
+
+    await runMonitoredCron(prisma, BASE, work);
+    await runMonitoredCron(prisma, BASE, work);
+
+    expect(prisma.claims[0][1]).not.toBe(prisma.claims[1][1]);
+  });
+
+  it('NUNCA relança quando work() falha — captura no Sentry, libera a lease e retorna undefined', async () => {
+    const prisma = fakePrisma();
     const boom = new Error('cron falhou');
     const work = jest.fn().mockRejectedValue(boom);
 
-    await expect(
-      runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work),
-    ).resolves.toBeUndefined();
+    await expect(runMonitoredCron(prisma, BASE, work)).resolves.toBeUndefined();
 
     expect(captureException).toHaveBeenCalledWith(
       boom,
       expect.objectContaining({ mechanism: { handled: true, type: 'hedhog.cron' } }),
     );
+    // A lease não pode ficar presa até vencer só porque o trabalho deu erro.
+    expect(prisma.$executeRaw).toHaveBeenCalledTimes(1);
   });
 
-  it('dimensiona o timeout/maxWait da transação a partir de maxRuntimeMinutes', async () => {
-    const prisma = fakePrisma(true);
-    const work = jest.fn().mockResolvedValue(undefined);
+  it('dimensiona a validade da lease a partir de maxRuntimeMinutes', async () => {
+    const prisma = fakePrisma();
 
     await runMonitoredCron(
       prisma,
-      { slug: 'meu-cron', schedule: '* * * * *', maxRuntimeMinutes: 2 },
-      work,
+      { ...BASE, maxRuntimeMinutes: 2 },
+      jest.fn().mockResolvedValue(undefined),
     );
 
-    expect(prisma.$transaction).toHaveBeenCalledWith(
-      expect.any(Function),
-      { timeout: 2 * 60_000 + 30_000, maxWait: 20_000 },
-    );
+    expect(prisma.claims[0][2]).toBe(2 * 60 + 30);
   });
 
-  it('NUNCA relança quando a transação falha (ex.: pool esgotado) — captura no Sentry e retorna undefined', async () => {
-    const prisma = fakePrisma(true, { transactionThrows: true });
+  it('NUNCA relança quando a eleição falha (ex.: banco indisponível) — captura no Sentry', async () => {
+    const prisma = fakePrisma({ claimThrows: true });
     const work = jest.fn();
 
-    await expect(
-      runMonitoredCron(prisma, { slug: 'meu-cron', schedule: '* * * * *' }, work),
-    ).resolves.toBeUndefined();
+    await expect(runMonitoredCron(prisma, BASE, work)).resolves.toBeUndefined();
 
     expect(work).not.toHaveBeenCalled();
     expect(captureException).toHaveBeenCalledWith(
@@ -99,4 +159,77 @@ describe('runMonitoredCron', () => {
       expect.objectContaining({ mechanism: { handled: true, type: 'hedhog.cron' } }),
     );
   });
+
+  it('falha ao liberar a lease não derruba o cron nem mascara o resultado de work()', async () => {
+    const prisma = fakePrisma({ releaseThrows: true });
+    const work = jest.fn().mockResolvedValue({ ok: true });
+
+    await expect(runMonitoredCron(prisma, BASE, work)).resolves.toEqual({ ok: true });
+
+    expect(captureException).not.toHaveBeenCalled();
+  });
+
+  /**
+   * O plano do Sentry cobre UM monitor de cron e o projeto tem cinco. Check-in de
+   * slug sem cota é descartado na entrada, então o que se protege aqui é que a
+   * ausência dele não leve junto o trabalho, o span nem o relato de erro.
+   */
+  describe('allowlist de check-in (SENTRY_CRON_MONITOR_SLUGS)', () => {
+    it('emite check-in para slug listado', async () => {
+      process.env.SENTRY_CRON_MONITOR_SLUGS = 'outro-cron,meu-cron';
+      const prisma = fakePrisma();
+
+      await runMonitoredCron(prisma, BASE, jest.fn().mockResolvedValue({ ok: true }));
+
+      expect(withMonitor).toHaveBeenCalledTimes(1);
+      expect(startNewTrace).not.toHaveBeenCalled();
+    });
+
+    it('slug fora da lista roda work() e o span, sem check-in', async () => {
+      process.env.SENTRY_CRON_MONITOR_SLUGS = 'outro-cron';
+      const prisma = fakePrisma();
+      const work = jest.fn().mockResolvedValue({ ok: true });
+
+      const result = await runMonitoredCron(prisma, BASE, work);
+
+      expect(result).toEqual({ ok: true });
+      expect(work).toHaveBeenCalledTimes(1);
+      expect(withMonitor).not.toHaveBeenCalled();
+      // O trace continua isolado por execução, papel que o `isolateTrace` do
+      // withMonitor cumpre no outro ramo.
+      expect(startNewTrace).toHaveBeenCalledTimes(1);
+      expect(startSpan).toHaveBeenCalledWith(
+        expect.objectContaining({ name: 'meu-cron', op: 'cron.hedhog' }),
+        expect.any(Function),
+      );
+    });
+
+    it('slug fora da lista continua liberando a lease e reportando erro', async () => {
+      process.env.SENTRY_CRON_MONITOR_SLUGS = 'outro-cron';
+      const prisma = fakePrisma();
+      const boom = new Error('cron falhou');
+
+      await expect(
+        runMonitoredCron(prisma, BASE, jest.fn().mockRejectedValue(boom)),
+      ).resolves.toBeUndefined();
+
+      expect(captureException).toHaveBeenCalledWith(
+        boom,
+        expect.objectContaining({ mechanism: { handled: true, type: 'hedhog.cron' } }),
+      );
+      expect(prisma.$executeRaw).toHaveBeenCalledTimes(1);
+    });
+
+    it('sem a env, o default deixa passar só o sac-mailbox-poller', async () => {
+      delete process.env.SENTRY_CRON_MONITOR_SLUGS;
+      const work = jest.fn().mockResolvedValue(undefined);
+
+      await runMonitoredCron(fakePrisma(), { ...BASE, slug: 'sac-mailbox-poller' }, work);
+      expect(withMonitor).toHaveBeenCalledTimes(1);
+
+      await runMonitoredCron(fakePrisma(), BASE, work);
+      expect(withMonitor).toHaveBeenCalledTimes(1);
+      expect(work).toHaveBeenCalledTimes(2);
+    });
+  });
 });