@hed-hog/core 0.0.400 → 0.0.402

package/src/oauth/oauth-token-broker.service.ts

@@ -78,6 +78,16 @@ export class OAuthTokenBrokerService {
   /** Refresh a bit early so an in-flight request never rides an about-to-expire token. */
   private static readonly EXPIRY_SKEW_MS = 60 * 1000;
 
+  /**
+   * Quantas vezes seguir um refresh token que outro processo rotacionou.
+   *
+   * Duas bastam na prática: a corrida acontece quando várias réplicas disparam
+   * o mesmo tick de cron, e a segunda tentativa já parte do token que a
+   * vencedora gravou. O teto existe para o caso patológico de rotações
+   * encadeadas não virar laço.
+   */
+  private static readonly MAX_ROTATION_RETRIES = 2;
+
   constructor(
     private readonly http: HttpService,
     @Inject(forwardRef(() => SettingService))
@@ -169,6 +179,70 @@ export class OAuthTokenBrokerService {
     return { tokenUrl, clientId, clientSecret };
   }
 
+  /**
+   * Lê uma coluna `Bytes` que guarda texto cifrado.
+   *
+   * O Prisma 6 passou a devolver `Bytes` como `Uint8Array`, e não mais como
+   * `Buffer`. Os dois têm `.toString()`, mas com significados opostos: o do
+   * Buffer decodifica os bytes como utf8 ("salt:iv:tag:cifra"), o do
+   * Uint8Array imprime os bytes em decimal separados por vírgula
+   * ("115,97,108,116,..."). O `SecurityService.decrypt` então não achava as 4
+   * partes separadas por ":" e lançava — e como toda conta caía nesse mesmo
+   * erro, a mensagem final era "reconecte a conta", que nenhuma reconexão
+   * resolvia. `Buffer.from` normaliza os dois casos.
+   */
+  private readEncryptedColumn(value: Uint8Array | Buffer): string {
+    return Buffer.from(value).toString();
+  }
+
+  /**
+   * Resumo do erro do provedor para o log. Usa só `error` e `error_description`
+   * — campos que a Microsoft e o Google preenchem com código e explicação
+   * (AADSTS…), nunca com credencial. O corpo inteiro não vai para o log: a
+   * requisição que falhou carrega o client_secret e o refresh token.
+   */
+  private describeGrantError(error: any): string {
+    const data = error?.response?.data;
+    const code = data?.error ?? 'unknown';
+    const description = String(data?.error_description ?? '')
+      .replace(/\s+/g, ' ')
+      .trim();
+    return description ? `${code}: ${description.slice(0, 300)}` : code;
+  }
+
+  /**
+   * Relê o refresh token do banco para ver se outro processo já o rotacionou.
+   *
+   * Devolve `true` só quando o valor guardado é DIFERENTE do que acabou de
+   * falhar — é isso que distingue uma corrida entre réplicas (vale tentar de
+   * novo, agora com o token novo) de uma revogação de verdade (não adianta
+   * insistir). Comparar os valores importa: sem essa checagem, uma conta
+   * realmente desconectada entraria em laço de tentativas.
+   *
+   * Nunca lança: qualquer problema aqui vira "não rotacionou", e quem chamou
+   * segue para o erro original, que é a informação correta a dar ao usuário.
+   */
+  private async reloadRotatedRefreshToken(
+    userId: number,
+    provider: string,
+    usedRefreshToken: string,
+  ): Promise<boolean> {
+    try {
+      const account = await this.prisma.user_account.findFirst({
+        where: { user_id: userId, provider: this.toAccountProvider(provider) },
+        select: { refresh_token: true },
+      });
+      if (!account?.refresh_token) return false;
+
+      const stored = this.security.decrypt(
+        this.readEncryptedColumn(account.refresh_token),
+      );
+      return Boolean(stored) && stored !== usedRefreshToken;
+    } catch {
+      return false;
+    }
+  }
+
   private async loadUserAccount(userId: number, provider: string) {
     const account = await this.prisma.user_account.findFirst({
       where: {
@@ -232,6 +306,13 @@ export class OAuthTokenBrokerService {
   async getAccessToken(
     userId: number,
     provider: string,
+    /**
+     * Profundidade da retentativa após uma rotação concorrente. Existe para a
+     * recursão ter fim: numa corrida entre muitas réplicas, cada uma pode
+     * rotacionar de novo entre a nossa falha e a releitura, e sem teto duas
+     * réplicas azaradas ficariam se revezando indefinidamente.
+     */
+    attempt = 0,
   ): Promise<BrokeredAccessToken> {
     const key = this.cacheKey(userId, provider);
     const cached = this.cache.get(key);
@@ -249,8 +330,23 @@ export class OAuthTokenBrokerService {
 
     let decryptedRefreshToken: string;
     try {
-      decryptedRefreshToken = this.security.decrypt(account.refresh_token.toString());
+      decryptedRefreshToken = this.security.decrypt(
+        this.readEncryptedColumn(account.refresh_token),
+      );
     } catch (error) {
+      // Este caminho e o `invalid_grant` lá embaixo chegam ao usuário com a
+      // MESMA frase ("reconecte a conta"), e as causas não têm nada a ver uma
+      // com a outra: aqui o valor guardado não abre, lá é a Microsoft recusando
+      // o grant. Sem distinguir no log, não há como saber qual dos dois ocorreu.
+      // A mensagem do decrypt separa os dois motivos possíveis daqui — formato
+      // inválido (o valor lido não é o cifrado) e falha de autenticação (chave
+      // diferente da que cifrou) —, e é truncada porque ela ecoa o começo do
+      // valor que tentou decifrar.
+      this.logger.warn(
+        `Stored refresh token could not be decrypted: provider=${provider} userId=${userId} detail=${
+          error instanceof Error ? error.message.split('Value:')[0].trim() : 'unknown'
+        }`,
+      );
       throw new OAuthTokenBrokerError(
         'refresh_revoked',
         `Failed to decrypt stored refresh token for "${provider}".`,
@@ -290,8 +386,39 @@ export class OAuthTokenBrokerService {
     } catch (error: any) {
       const providerError = error?.response?.data?.error;
       if (providerError === 'invalid_grant') {
-        // Refresh token revoked/expired — the user must reconnect.
         this.cache.delete(key);
+
+        // Antes de declarar a conta desconectada, checa se outro processo
+        // rotacionou o token enquanto este fazia a troca.
+        //
+        // A Microsoft emite um refresh token novo a cada troca e invalida o
+        // anterior, então basta duas réplicas usarem o mesmo token ao mesmo
+        // tempo para a segunda levar `invalid_grant` — e este serviço roda em
+        // seis. Sem esta releitura, uma corrida entre réplicas era reportada ao
+        // usuário como "reconecte a conta", e reconectar não resolvia nada,
+        // porque a corrida se repetia no ciclo seguinte.
+        const rotated =
+          attempt < OAuthTokenBrokerService.MAX_ROTATION_RETRIES &&
+          (await this.reloadRotatedRefreshToken(
+            userId,
+            provider,
+            decryptedRefreshToken,
+          ));
+        if (rotated) {
+          this.logger.log(
+            `Refresh token was rotated by another process; retrying: provider=${provider} userId=${userId} attempt=${attempt + 1}`,
+          );
+          return this.getAccessToken(userId, provider, attempt + 1);
+        }
+
+        // Nada mudou no banco: o grant foi mesmo recusado. O `error_description`
+        // do provedor é a única coisa que diz POR QUÊ (na Microsoft, o código
+        // AADSTS: token expirado, consentimento faltando, acesso condicional).
+        // Sem ele no log, "reconecte a conta" é tudo que sobra para diagnosticar
+        // — e reconectar não resolve a maioria desses casos.
+        this.logger.warn(
+          `Refresh grant rejected: provider=${provider} userId=${userId} scopesSent="${scopeParam.join(' ')}" detail=${this.describeGrantError(error)}`,
+        );
         throw new OAuthTokenBrokerError(
           'refresh_revoked',
           `Refresh token for "${provider}" is no longer valid. Reconnect the account.`,

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

@@ -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,

package/src/pdf/document/charts/chart-bar.ts

@@ -0,0 +1,217 @@
+import { SafeSvg } from '../pdf-document.types';
+import {
+  CHART_DEFAULT_HEIGHT,
+  CHART_FONT,
+  CHART_FULL_WIDTH,
+  ChartBaseOptions,
+  ChartSeries,
+  chartColor,
+  emptyChart,
+  legendRows,
+  line,
+  svgRoot,
+  text,
+  xAxisLabels,
+  yAxis,
+} from './chart-primitives';
+import {
+  axisLabelPlan,
+  bandScale,
+  estimateTextWidth,
+  formatNumber,
+  linearScale,
+  niceScale,
+  truncateToWidth,
+} from './chart-scale';
+
+const hasData = (series: ChartSeries[]): boolean =>
+  series.some((s) => s.values.some((v) => typeof v === 'number' && Number.isFinite(v)));
+
+const maxOf = (series: ChartSeries[], stacked: boolean): number => {
+  if (!stacked) {
+    return series.reduce(
+      (max, s) => Math.max(max, ...s.values.map((v) => (typeof v === 'number' ? v : 0))),
+      0,
+    );
+  }
+
+  const length = series.reduce((max, s) => Math.max(max, s.values.length), 0);
+  let max = 0;
+  for (let i = 0; i < length; i += 1) {
+    max = Math.max(
+      max,
+      series.reduce((sum, s) => sum + (typeof s.values[i] === 'number' ? (s.values[i] as number) : 0), 0),
+    );
+  }
+  return max;
+};
+
+/** Barras verticais, uma faixa por categoria. */
+export function barChartSvg(
+  options: ChartBaseOptions & {
+    categories: string[];
+    series: ChartSeries[];
+    stacked?: boolean;
+    yMax?: number;
+    yTicks?: number;
+    showValues?: boolean;
+    legend?: boolean;
+  },
+): SafeSvg {
+  const {
+    theme,
+    categories,
+    series,
+    stacked = false,
+    width = CHART_FULL_WIDTH,
+    height = CHART_DEFAULT_HEIGHT,
+    valueFormat = (value: number) => formatNumber(value),
+  } = options;
+
+  if (categories.length === 0 || !hasData(series)) return emptyChart(options);
+
+  const showLegend = options.legend ?? series.length > 1;
+  const legendHeight = showLegend ? 16 : 0;
+  const plot = { left: 42, right: width - 8, top: 10, bottom: height - 26 - legendHeight };
+
+  const scale = niceScale(0, options.yMax ?? maxOf(series, stacked), options.yTicks ?? 4);
+  const y = linearScale([scale.min, scale.max], [plot.bottom, plot.top]);
+  const band = bandScale(categories.length, [plot.left, plot.right]);
+
+  const parts: string[] = [
+    yAxis(scale.ticks, y, plot, theme, valueFormat),
+    line(plot.left, plot.bottom, plot.right, plot.bottom, theme.mutedFg),
+  ];
+
+  const groupWidth = stacked ? band.bandwidth : band.bandwidth / series.length;
+
+  series.forEach((serie, serieIndex) => {
+    const color = chartColor(theme, serieIndex, serie.color);
+    const stackTops = new Array(categories.length).fill(plot.bottom);
+
+    categories.forEach((_, index) => {
+      const raw = serie.values[index];
+      if (typeof raw !== 'number' || !Number.isFinite(raw)) return;
+
+      const barX = stacked ? band.band(index) : band.band(index) + groupWidth * serieIndex;
+      const top = stacked ? stackTops[index] - (plot.bottom - y(raw)) : y(raw);
+      const barHeight = Math.max(plot.bottom - y(raw), raw > 0 ? 1 : 0);
+
+      if (stacked) stackTops[index] = top;
+
+      parts.push(
+        `<rect x="${barX.toFixed(1)}" y="${top.toFixed(1)}" width="${groupWidth.toFixed(1)}" ` +
+          `height="${barHeight.toFixed(1)}" fill="${color}" rx="1.5" />`,
+      );
+
+      // O valor só entra quando cabe dentro da largura da barra; senão vira
+      // sopa de números sobrepostos.
+      if (
+        options.showValues &&
+        !stacked &&
+        estimateTextWidth(valueFormat(raw), CHART_FONT.value) < groupWidth
+      ) {
+        parts.push(
+          text(valueFormat(raw), barX + groupWidth / 2, top - 3, {
+            size: CHART_FONT.value,
+            fill: theme.ink,
+            anchor: 'middle',
+            weight: 600,
+          }),
+        );
+      }
+    });
+  });
+
+  const plan = axisLabelPlan(categories, band.bandwidth, CHART_FONT.axis);
+  parts.push(xAxisLabels(categories, band.center, plot.bottom + 12, plan, band.bandwidth, theme));
+
+  if (showLegend) {
+    const legend = legendRows(
+      series.map((serie, index) => ({
+        label: serie.name,
+        color: chartColor(theme, index, serie.color),
+      })),
+      width,
+      height - 4,
+      theme,
+    );
+    parts.push(legend.markup);
+  }
+
+  return svgRoot(width, height, parts.join(''), options.ariaLabel);
+}
+
+/**
+ * Barras horizontais — a forma certa quando o rótulo é um nome (curso, aluno),
+ * que deitado vira texto girado e ilegível.
+ */
+export function horizontalBarChartSvg(
+  options: ChartBaseOptions & {
+    categories: string[];
+    series: ChartSeries[];
+    xMax?: number;
+    labelWidth?: number;
+    showValues?: boolean;
+  },
+): SafeSvg {
+  const {
+    theme,
+    categories,
+    series,
+    width = CHART_FULL_WIDTH,
+    valueFormat = (value: number) => formatNumber(value),
+    showValues = true,
+  } = options;
+
+  if (categories.length === 0 || !hasData(series)) return emptyChart(options);
+
+  const rowHeight = 22;
+  const height = options.height ?? Math.max(categories.length * rowHeight + 24, 90);
+  const labelWidth = options.labelWidth ?? Math.min(Math.round(width * 0.34), 180);
+  const plot = { left: labelWidth + 8, right: width - 38, top: 8, bottom: height - 16 };
+
+  const scale = niceScale(0, options.xMax ?? maxOf(series, false), 4);
+  const x = linearScale([scale.min, scale.max], [plot.left, plot.right]);
+  const band = bandScale(categories.length, [plot.top, plot.bottom], 0.25);
+
+  const parts: string[] = scale.ticks.map((tick) =>
+    line(x(tick), plot.top, x(tick), plot.bottom, theme.line),
+  );
+
+  categories.forEach((category, index) => {
+    parts.push(
+      text(truncateToWidth(category, CHART_FONT.axis + 1, labelWidth), labelWidth, band.center(index) + 3, {
+        size: CHART_FONT.axis + 1,
+        fill: theme.ink,
+        anchor: 'end',
+      }),
+    );
+
+    const barHeight = band.bandwidth / series.length;
+
+    series.forEach((serie, serieIndex) => {
+      const raw = serie.values[index];
+      if (typeof raw !== 'number' || !Number.isFinite(raw)) return;
+
+      const barY = band.band(index) + barHeight * serieIndex;
+      const barWidth = Math.max(x(raw) - plot.left, raw > 0 ? 1 : 0);
+
+      parts.push(
+        `<rect x="${plot.left}" y="${barY.toFixed(1)}" width="${barWidth.toFixed(1)}" ` +
+          `height="${barHeight.toFixed(1)}" fill="${chartColor(theme, serieIndex, serie.color)}" rx="1.5" />`,
+      );
+
+      if (showValues && series.length === 1) {
+        parts.push(
+          text(valueFormat(raw), plot.left + barWidth + 4, barY + barHeight / 2 + 3, {
+            size: CHART_FONT.value,
+            fill: theme.mutedFg,
+          }),
+        );
+      }
+    });
+  });
+
+  return svgRoot(width, height, parts.join(''), options.ariaLabel);
+}