@hed-hog/core 0.0.390 → 0.0.393

package/src/mail-sent/dto/query-mail-sent-list.dto.ts

@@ -13,6 +13,21 @@ export class QueryMailSentListDTO extends PaginationDTO {
   @IsString()
   hasError?: string;
 
+  /**
+   * Desfecho reportado pelo provedor. `pending` e a ausencia de desfecho: ele
+   * aceitou a mensagem e nao disse mais nada.
+   */
+  @IsOptional()
+  @Transform(({ value }) => String(value ?? '').trim().toLowerCase())
+  @IsIn(['all', 'pending', 'delivered', 'bounced', 'complained', 'rejected'])
+  deliveryStatus?:
+    | 'all'
+    | 'pending'
+    | 'delivered'
+    | 'bounced'
+    | 'complained'
+    | 'rejected';
+
   @IsOptional()
   @Transform(({ value }) => String(value ?? '').trim())
   @IsString()

package/src/mail-sent/mail-sent.service.ts

@@ -42,7 +42,18 @@ export class MailSentService {
   ) { }
 
   async list(paginationParams: QueryMailSentListDTO) {
-    const fields = ['subject', 'from', 'to', 'cc', 'bcc', 'body'];
+    // `provider_message_id` entra na busca porque e o unico identificador que o
+    // evento do provedor traz: sem ele, ler um bounce no console da AWS e achar
+    // o envio correspondente aqui exigia adivinhacao.
+    const fields = [
+      'subject',
+      'from',
+      'to',
+      'cc',
+      'bcc',
+      'body',
+      'provider_message_id',
+    ];
     const OR: any[] = this.prismaService.createInsensitiveSearch(
       fields,
       paginationParams,
@@ -99,6 +110,17 @@ export class MailSentService {
       });
     }
 
+    const deliveryStatus = paginationParams.deliveryStatus?.trim();
+    if (deliveryStatus && deliveryStatus !== 'all') {
+      // `pending` e a ausencia de desfecho: o provedor aceitou e nao disse mais
+      // nada. E o estado em que ficam os envios que ninguem sabe se chegaram.
+      AND.push(
+        deliveryStatus === 'pending'
+          ? { delivery_status: null }
+          : { delivery_status: deliveryStatus },
+      );
+    }
+
     const createdAt: { gte?: Date; lte?: Date } = {};
     const createdAtFrom = paginationParams.createdAtFrom?.trim();
     const createdAtTo = paginationParams.createdAtTo?.trim();
@@ -146,6 +168,22 @@ export class MailSentService {
               updated_at: true,
             },
           },
+          // O que o provedor disse depois de aceitar. `mail_sent_user` so cobre
+          // destinatario que e usuario da plataforma; um solicitante externo nao
+          // deixava rastro nenhum de entrega.
+          mail_delivery_event: {
+            select: {
+              id: true,
+              recipient_email: true,
+              event_type: true,
+              bounce_type: true,
+              bounce_subtype: true,
+              diagnostic_code: true,
+              reporting_mta: true,
+              occurred_at: true,
+            },
+            orderBy: { occurred_at: 'desc' },
+          },
         },
       },
     );
@@ -198,9 +236,15 @@ export class MailSentService {
     };
   }
 
-  async get(locale:string, id: number) {
+  async get(locale: string, id: number) {
     const mailSent = await this.prismaService.mail_sent.findUnique({
       where: { id: id },
+      // Sem os relacionamentos, abrir um envio direto pelo id devolvia um
+      // registro sem nenhuma informacao de entrega - so a listagem trazia.
+      include: {
+        mail_sent_user: true,
+        mail_delivery_event: { orderBy: { occurred_at: 'desc' } },
+      },
     });
 
     if (!mailSent) {

package/src/mailbox/mailbox-fetcher.registry.ts

@@ -0,0 +1,132 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+/**
+ * Uma mensagem recebida, ainda crua.
+ *
+ * O fetcher devolve o MIME e nada mais. Interpretar (parsear cabeçalhos, cortar
+ * citação, decidir se é autoresposta) é do consumidor — assim os dois provedores
+ * compartilham exatamente o mesmo caminho de leitura, e o core não precisa
+ * conhecer mailparser nem as regras de atendimento.
+ */
+export interface RawInboundMessage {
+  /**
+   * Identidade da mensagem no provedor (Message-Id, id do Graph).
+   * É a chave de idempotência de quem consome.
+   */
+  externalId: string;
+  /** Mensagem RFC 822 completa. */
+  source: Buffer;
+  receivedAt: Date;
+}
+
+export interface MailboxFetchTarget {
+  /** Perfil de integração com as credenciais. */
+  integrationProfileId: number;
+  /** Endereço monitorado. No Graph, é também o alvo do acesso app-only. */
+  address: string;
+  folder: string;
+  /**
+   * Cursor OPACO, como o fetcher o gravou da última vez.
+   *
+   * Cada provedor escolhe o formato — UID + UIDVALIDITY no IMAP, deltaLink no
+   * Graph. Manter isso opaco é o que permite um campo só no banco servir aos
+   * dois sem o consumidor entender nenhum dos dois.
+   */
+  cursor: string | null;
+  markAsRead: boolean;
+  /** Teto por ciclo, para uma caixa esquecida não virar um poll infinito. */
+  maxMessages: number;
+}
+
+export interface MailboxFetchResult {
+  messages: RawInboundMessage[];
+  /** Cursor a gravar DEPOIS que as mensagens forem persistidas. */
+  cursor: string | null;
+  /**
+   * O provedor invalidou o cursor anterior (UIDVALIDITY novo, delta expirado).
+   * Serve para o consumidor registrar o fato — a releitura em si já vem
+   * resolvida no resultado.
+   */
+  cursorReset: boolean;
+}
+
+/** Resultado de um teste de leitura, no mesmo formato do `MailVerifyResult`. */
+export interface MailboxVerifyResult {
+  ok: boolean;
+  /** Evidência legível do sucesso. Nunca contém credencial. */
+  info?: string;
+  /** Motivo legível da falha. Nunca contém credencial. */
+  error?: string;
+}
+
+/**
+ * Lê uma caixa de correio.
+ *
+ * Implementações vivem nas libraries donas do protocolo (IMAP no `sac`,
+ * Microsoft Graph no `microsoft`) e se registram aqui no boot.
+ */
+export interface IMailboxFetcher {
+  /** Falso quando o provedor está desligado ou mal configurado nesta instalação. */
+  isAvailable(): Promise<boolean>;
+  fetch(target: MailboxFetchTarget): Promise<MailboxFetchResult>;
+  /**
+   * Confere se ESTA caixa pode ser lida agora, exercitando o caminho real.
+   *
+   * Existe porque testar o perfil de integração não é a mesma coisa que testar a
+   * caixa: para o Entra, o teste do perfil só pede um token e passa mesmo sem
+   * permissão de e-mail, sem acesso àquele endereço e sem a pasta existir — ou
+   * seja, aprovaria uma caixa que nunca vai receber nada.
+   *
+   * Opcional: sem ela, o chamador cai no testador do perfil (o que basta para o
+   * IMAP, onde autenticar já prova o acesso).
+   */
+  verify?(target: MailboxFetchTarget): Promise<MailboxVerifyResult>;
+}
+
+/**
+ * Registro dos leitores de caixa, no mesmo padrão do MeetingProviderRegistry.
+ *
+ * Existe pelo mesmo motivo daquele: permitir que um módulo de negócio leia uma
+ * caixa do Microsoft 365 sem depender de `@hed-hog-pro/microsoft` — o que
+ * arrastaria as tabelas, as rotas e os crons daquela library para toda
+ * instalação, só para obter um token.
+ *
+ * A chave é o SLUG DO PROVIDER DE INTEGRAÇÃO (`imap`,
+ * `microsoft-entra-id-oauth`), então o caminho perfil → fetcher se resolve sem
+ * nenhuma tabela de-para.
+ */
+@Injectable()
+export class MailboxFetcherRegistry {
+  private readonly logger = new Logger(MailboxFetcherRegistry.name);
+  private readonly fetchers = new Map<string, IMailboxFetcher>();
+
+  register(providerSlug: string, implementation: IMailboxFetcher): void {
+    const key = normalizeProvider(providerSlug);
+    if (!key) throw new Error('Mailbox fetcher provider key is required.');
+
+    if (this.fetchers.has(key)) {
+      this.logger.warn(`Mailbox fetcher "${key}" was overwritten.`);
+    }
+
+    this.fetchers.set(key, implementation);
+    this.logger.log(`Registered mailbox fetcher "${key}"`);
+  }
+
+  get(providerSlug: string | null | undefined): IMailboxFetcher | null {
+    const key = normalizeProvider(providerSlug);
+    return key ? (this.fetchers.get(key) ?? null) : null;
+  }
+
+  has(providerSlug: string | null | undefined): boolean {
+    return this.get(providerSlug) !== null;
+  }
+
+  /** Providers que sabem ler caixa nesta instalação (a UI filtra por isto). */
+  list(): string[] {
+    return [...this.fetchers.keys()].sort();
+  }
+}
+
+function normalizeProvider(providerSlug: string | null | undefined): string {
+  return String(providerSlug ?? '').trim().toLowerCase();
+}

package/src/mailbox/mailbox.module.ts

@@ -0,0 +1,14 @@
+import { Global, Module } from '@nestjs/common';
+import { MailboxFetcherRegistry } from './mailbox-fetcher.registry';
+
+/**
+ * Porta genérica de leitura de caixa de correio. Só carrega o registro — as
+ * implementações vêm de quem se registrar no boot (a library `sac` com a chave
+ * `imap`, a library `microsoft` com `microsoft-entra-id-oauth`).
+ */
+@Global()
+@Module({
+  providers: [MailboxFetcherRegistry],
+  exports: [MailboxFetcherRegistry],
+})
+export class MailboxModule {}

package/src/meeting/meeting-provider.registry.ts

@@ -0,0 +1,193 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+/**
+ * Pedido de criação de uma reunião online para uma entidade de negócio qualquer.
+ *
+ * A tripla `sourceModule`/`sourceEntity`/`sourceEntityId` é o que amarra a reunião
+ * à origem sem que o provedor precise conhecer o domínio: o LMS envia
+ * `('lms', 'course_class_session', '42')` e recebe de volta, no evento de gravação,
+ * exatamente a mesma tripla.
+ */
+export interface CreateMeetingInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  subject: string;
+  startAt: Date;
+  endAt: Date;
+  /** Liga a gravação automática, quando o provedor suportar. */
+  autoRecord?: boolean;
+  /** Usuário que pediu a criação (usado no modo delegado). */
+  requestedByUserId?: number;
+  /**
+   * Usuários que devem poder controlar a reunião (iniciar/parar gravação, admitir
+   * participantes). Sem isso, num organizador de serviço, o professor entra como
+   * participante comum.
+   */
+  coOrganizerUserIds?: number[];
+  /** Convidados do evento de calendário. */
+  attendeeEmails?: string[];
+  /** Local do evento (aula presencial/híbrida com reunião gerenciada). */
+  location?: string | null;
+  /** Texto da origem que acompanha o link no corpo do evento. */
+  description?: string | null;
+}
+
+export interface CreatedMeeting {
+  /** Link que o aluno abre. É o que vai para `meeting_url` da aula. */
+  joinUrl: string;
+  /** Id da reunião no provedor — necessário para buscar a gravação depois. */
+  providerMeetingId: string;
+  /** Id do evento de calendário, quando o provedor cria um. */
+  providerEventId?: string | null;
+}
+
+export interface MeetingSourceRef {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityIds: string[];
+}
+
+export type CreateMeetingResult =
+  | ({ ok: true } & CreatedMeeting)
+  | { ok: false; sourceEntityId: string; error: string };
+
+/** Pedido de troca de convidados de uma reunião já existente. */
+export interface UpdateMeetingAttendeesInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  attendeeEmails: string[];
+}
+
+/**
+ * Pedido de atualização de assunto/horário/local de uma reunião já existente.
+ *
+ * Separado de `createMeeting` pelo mesmo motivo de `updateAttendees`: recriar
+ * geraria link novo e derrubaria quem já tem o evento antigo na agenda.
+ */
+export interface UpdateMeetingDetailsInput {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  subject: string;
+  startAt: Date;
+  endAt: Date;
+  location?: string | null;
+  description?: string | null;
+}
+
+/**
+ * Estado de uma reunião, na forma em que o módulo de origem precisa ver.
+ *
+ * Existe para que o dono da origem consulte o provedor em vez de ler a tabela
+ * dele: o LMS não deve saber que existe uma `microsoft_meeting`.
+ */
+export interface MeetingSummary {
+  sourceEntityId: string;
+  joinUrl: string | null;
+  status: 'scheduled' | 'cancelled' | 'failed';
+  autoRecord: boolean;
+  /**
+   * Assunto e janela gravados no provedor, para a origem comparar com o que é
+   * desejado antes de mandar `updateDetails` — evita um PATCH a cada sync
+   * quando nada mudou. `null` em reuniões criadas antes deste campo existir.
+   */
+  subject: string | null;
+  startAt: Date | null;
+  endAt: Date | null;
+  location: string | null;
+  description: string | null;
+  /**
+   * Convidados atualmente no evento de calendário.
+   *
+   * Existe para o módulo de origem comparar antes de mandar atualizar: alterar
+   * a lista faz o provedor reenviar convite/atualização para todos, então um
+   * PATCH incondicional a cada sincronização viraria spam na caixa de quem
+   * acompanha a turma.
+   */
+  attendeeEmails: string[];
+  /** Estado da importação da gravação, quando `autoRecord` está ligado. */
+  recordingStatus:
+    | 'not_requested'
+    | 'pending'
+    | 'imported'
+    | 'unavailable'
+    | 'failed';
+  recordingFileId: number | null;
+  lastError: string | null;
+}
+
+/**
+ * Provedor de reuniões online (Teams hoje; Meet/Zoom cabem no mesmo contrato).
+ *
+ * Existe para que os módulos de negócio não dependam do pacote de um provedor
+ * específico: eles pedem ao registro e, se ninguém tiver se registrado, a
+ * funcionalidade simplesmente não aparece.
+ */
+export interface IMeetingProvider {
+  /** Se a integração está configurada a ponto de aceitar chamadas. */
+  isAvailable(): Promise<boolean>;
+  createMeeting(input: CreateMeetingInput): Promise<CreatedMeeting>;
+  /** Criação em lote; nunca rejeita — devolve o erro por item. */
+  createMeetings(inputs: CreateMeetingInput[]): Promise<CreateMeetingResult[]>;
+  /** Cancela no provedor as reuniões das origens informadas. Tolerante a ausências. */
+  cancelBySource(ref: MeetingSourceRef): Promise<void>;
+  /**
+   * Troca a lista de convidados do evento de uma reunião já criada.
+   *
+   * Separado de `createMeeting` porque o custo é diferente: recriar a reunião
+   * geraria um link novo e derrubaria quem já tinha o antigo na agenda, enquanto
+   * ajustar convidados preserva a reunião. Tolerante a reunião inexistente.
+   */
+  updateAttendees(input: UpdateMeetingAttendeesInput): Promise<void>;
+  /**
+   * Atualiza assunto, horário e local do evento/reunião já criados, sem gerar
+   * link novo. Tolerante a reunião inexistente (mesmo padrão de updateAttendees).
+   */
+  updateDetails(input: UpdateMeetingDetailsInput): Promise<void>;
+  /** Estado das reuniões das origens informadas, para a UI do módulo de origem. */
+  findBySource(ref: MeetingSourceRef): Promise<MeetingSummary[]>;
+}
+
+/**
+ * Registro dos provedores de reunião, no mesmo padrão do WebhookProtocolRegistry:
+ * o módulo dono do provedor se registra no boot.
+ */
+@Injectable()
+export class MeetingProviderRegistry {
+  private readonly logger = new Logger(MeetingProviderRegistry.name);
+  private readonly providers = new Map<string, IMeetingProvider>();
+
+  register(provider: string, implementation: IMeetingProvider): void {
+    const key = normalizeProvider(provider);
+    if (!key) throw new Error('Meeting provider key is required.');
+
+    if (this.providers.has(key)) {
+      this.logger.warn(`Meeting provider "${key}" was overwritten.`);
+    }
+
+    this.providers.set(key, implementation);
+    this.logger.log(`Registered meeting provider "${key}"`);
+  }
+
+  get(provider: string | null | undefined): IMeetingProvider | null {
+    const key = normalizeProvider(provider);
+    return key ? (this.providers.get(key) ?? null) : null;
+  }
+
+  has(provider: string | null | undefined): boolean {
+    return this.get(provider) !== null;
+  }
+
+  /** Provedores registrados (para a UI listar o que existe). */
+  list(): string[] {
+    return [...this.providers.keys()].sort();
+  }
+}
+
+function normalizeProvider(provider: string | null | undefined): string {
+  return String(provider ?? '')
+    .trim()
+    .toLowerCase();
+}

package/src/meeting/meeting.constants.ts

@@ -0,0 +1,53 @@
+/** Chave do provedor Microsoft Teams no {@link MeetingProviderRegistry}. */
+export const TEAMS_MEETING_PROVIDER = 'teams';
+
+/**
+ * Evento de domínio publicado quando a gravação de uma reunião foi baixada e já
+ * existe como registro em `file`. Fica no core porque é o contrato entre quem
+ * publica (provedor da reunião) e quem consome (módulo dono da origem) — assim
+ * nenhum dos dois precisa importar o pacote do outro.
+ */
+export const MEETING_RECORDING_AVAILABLE_EVENT =
+  'microsoft.meeting.recording.available';
+
+export interface MeetingRecordingAvailablePayload {
+  /** `file.id` do vídeo já enviado ao storage. */
+  fileId: number;
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  providerMeetingId?: string | null;
+  providerRecordingId?: string | null;
+  durationSeconds?: number | null;
+  joinUrl?: string | null;
+}
+
+/**
+ * Evento publicado quando o relatório de presença de uma reunião foi importado.
+ *
+ * Mesma razão de existir do evento de gravação: o provedor sabe quem entrou na
+ * reunião, mas não sabe o que é um aluno; o módulo de origem sabe quem está
+ * matriculado, mas não conhece o Graph. O encontro é aqui.
+ */
+export const MEETING_ATTENDANCE_AVAILABLE_EVENT =
+  'microsoft.meeting.attendance.available';
+
+/** Um participante do relatório, na forma em que a origem precisa ver. */
+export interface MeetingAttendanceRecord {
+  /**
+   * Nulo quando o provedor não identificou quem entrou (link aberto por
+   * convidado externo ou anônimo). A origem trata esse caso como "participante
+   * não identificado" em vez de descartar.
+   */
+  email: string | null;
+  displayName: string;
+  totalAttendanceSeconds: number;
+}
+
+export interface MeetingAttendanceAvailablePayload {
+  sourceModule: string;
+  sourceEntity: string;
+  sourceEntityId: string;
+  providerMeetingId?: string | null;
+  records: MeetingAttendanceRecord[];
+}

package/src/meeting/meeting.module.ts

@@ -0,0 +1,13 @@
+import { Global, Module } from '@nestjs/common';
+import { MeetingProviderRegistry } from './meeting-provider.registry';
+
+/**
+ * Porta genérica de reuniões online. Só carrega o registro — a implementação vem
+ * de quem se registrar no boot (hoje a library `microsoft`, com a chave `teams`).
+ */
+@Global()
+@Module({
+  providers: [MeetingProviderRegistry],
+  exports: [MeetingProviderRegistry],
+})
+export class MeetingModule {}

package/src/middlewares/locale-injection.middleware.ts

@@ -1,15 +1,34 @@
+import { localeStorage } from '@hed-hog/api-locale';
 import { Injectable, NestMiddleware } from '@nestjs/common';
 import { NextFunction, Request, Response } from 'express';
-import { localeStorage } from '../utils/locale-context';
 
+/**
+ * Rede de seguranca do contexto de locale.
+ *
+ * Quem resolve o idioma e o `LocaleMiddleware` do `api-locale`, que ja abre o
+ * `AsyncLocalStorage` para o resto da cadeia. Este middleware so entra em acao
+ * quando aquele nao rodou (app que nao registrou o `LocaleModule`, ou uma
+ * ordem de middleware que o coloque depois), para que
+ * `getLocaleFromContext()` nunca leia um store vazio.
+ *
+ * Nao reinterpreta o header: sem a tabela `locale` a mao, validar aqui de novo
+ * era justamente como as duas camadas divergiam.
+ */
 @Injectable()
 export class LocaleInjectionMiddleware implements NestMiddleware {
   use(req: Request, res: Response, next: NextFunction) {
-    const acceptLanguage = req.headers['accept-language'] || 'en';
-    const locale = acceptLanguage.split(',')[0].split('-')[0];
+    if (localeStorage.getStore()) {
+      return next();
+    }
 
-    localeStorage.run({ locale }, () => {
-      next();
-    });
+    localeStorage.run(
+      {
+        locale: req['locale'] || 'en',
+        detected: Boolean(req['localeDetected']),
+      },
+      () => {
+        next();
+      },
+    );
   }
 }

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

@@ -1,12 +1,23 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { HttpService } from '@nestjs/axios';
-import { BadRequestException, forwardRef, Inject, Injectable } from '@nestjs/common';
+import { BadRequestException, forwardRef, 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';
 
 @Injectable()
 export class GoogleProvider extends BaseOAuthProvider {
+  private readonly logger = new Logger(GoogleProvider.name);
+
+  /**
+   * personFields da People API e o escopo sensível que cada um exige. Escopo sensível
+   * só entra na conta se estiver marcado em `oauth-google-scopes` e aprovado na
+   * verificação do Google; sem ele a People API responde 403.
+   */
+  private static readonly PEOPLE_FIELD_SCOPES: Record<string, string> = {
+    genders: 'https://www.googleapis.com/auth/user.gender.read',
+    birthdays: 'https://www.googleapis.com/auth/user.birthday.read',
+  };
 
   constructor(
     http: HttpService,
@@ -82,6 +93,7 @@ export class GoogleProvider extends BaseOAuthProvider {
 
     const peopleProfile = await this.getGoogleProfileFromAccessToken(
       token.access_token,
+      String(token.scope ?? ''),
     );
 
     return {
@@ -97,22 +109,44 @@ export class GoogleProvider extends BaseOAuthProvider {
     };
   }
 
-  private async getGoogleProfileFromAccessToken(accessToken: string) {
-    const url =
-      'https://people.googleapis.com/v1/people/me?personFields=genders,birthdays';
-
-    const res = await fetch(url, {
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-      },
-    });
-
-    if (!res.ok) {
-      throw new Error(`Google People API error: ${res.statusText}`);
+  private async getGoogleProfileFromAccessToken(
+    accessToken: string,
+    grantedScopes: string,
+  ) {
+    const empty = { gender: null, birthday: null, raw: null };
+    const granted = new Set(grantedScopes.split(/\s+/).filter(Boolean));
+    const personFields = Object.entries(GoogleProvider.PEOPLE_FIELD_SCOPES)
+      .filter(([, scope]) => granted.has(scope))
+      .map(([field]) => field);
+
+    // Login com os escopos básicos (openid/email/profile) não passa pela People API:
+    // ela responderia 403 e derrubaria a autenticação inteira por um dado opcional.
+    if (!personFields.length) return empty;
+
+    const url = `https://people.googleapis.com/v1/people/me?personFields=${personFields.join(',')}`;
+
+    let data: any;
+    try {
+      const res = await fetch(url, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+        },
+      });
+
+      if (!res.ok) {
+        throw new Error(`Google People API error: ${res.statusText}`);
+      }
+
+      data = await res.json();
+    } catch (error) {
+      // People API desabilitada no projeto ou consentimento revogado não podem
+      // impedir o usuário de entrar.
+      this.logger.warn(
+        `Google People API indisponível, seguindo sem gênero/aniversário: ${(error as Error).message}`,
+      );
+      return empty;
     }
 
-    const data: any = await res.json();
-
     const gender =
       data.genders?.find((g: any) => g.metadata?.primary)?.value ??
       data.genders?.[0]?.value ??