@hed-hog/core 0.0.399 → 0.0.401

package/src/whatsapp-sender/whatsapp-recipients.spec.ts

@@ -0,0 +1,89 @@
+import { parseWhatsappRecipients, toWhatsappGroupJid } from './whatsapp-recipients';
+
+/**
+ * O que este parser decide é para ONDE um aviso interno vai. Errar aqui não dá
+ * erro: entrega em outro número, ou some em silêncio — os dois modos de falha
+ * que o canal existe para evitar.
+ */
+describe('toWhatsappGroupJid', () => {
+  it('aceita a forma atual, só dígitos com sufixo', () => {
+    expect(toWhatsappGroupJid('120363430651137530@g.us')).toBe(
+      '120363430651137530@g.us',
+    );
+  });
+
+  it('aceita a forma antiga, derivada de quem criou o grupo', () => {
+    expect(toWhatsappGroupJid('5511992662104-1564082267@g.us')).toBe(
+      '5511992662104-1564082267@g.us',
+    );
+  });
+
+  it('completa o sufixo de um id colado sem ele', () => {
+    expect(toWhatsappGroupJid('120363430651137530')).toBe(
+      '120363430651137530@g.us',
+    );
+  });
+
+  it('não confunde telefone com grupo', () => {
+    expect(toWhatsappGroupJid('5511999998888')).toBeNull();
+  });
+
+  it('descarta a colagem de dois telefones grudados', () => {
+    expect(toWhatsappGroupJid('5511999998888551199999777')).toBeNull();
+  });
+});
+
+describe('parseWhatsappRecipients', () => {
+  it('devolve lista vazia para configuração ausente', () => {
+    expect(parseWhatsappRecipients(null)).toEqual([]);
+    expect(parseWhatsappRecipients('')).toEqual([]);
+  });
+
+  it('completa o DDI 55 de um número nacional com máscara', () => {
+    expect(parseWhatsappRecipients('(11) 99999-8888')).toEqual([
+      { to: '5511999998888', targetType: 'phone' },
+    ]);
+  });
+
+  it('não acrescenta DDI a quem já veio com um', () => {
+    expect(parseWhatsappRecipients('5511999998888')).toEqual([
+      { to: '5511999998888', targetType: 'phone' },
+    ]);
+  });
+
+  it('separa por vírgula, ponto-e-vírgula e quebra de linha, nunca por espaço', () => {
+    // Espaço faz parte da máscara: quebrar ali produziria `+55`, `(11)` e
+    // `3333-4444`, todos descartados, e a lista sumiria em silêncio.
+    expect(
+      parseWhatsappRecipients(
+        '+55 (11) 3333-4444, 5511999998888;\n120363430651137530@g.us',
+      ),
+    ).toEqual([
+      { to: '551133334444', targetType: 'phone' },
+      { to: '5511999998888', targetType: 'phone' },
+      { to: '120363430651137530@g.us', targetType: 'group' },
+    ]);
+  });
+
+  it('conta uma vez só o mesmo destino escrito de duas formas', () => {
+    expect(
+      parseWhatsappRecipients('(11) 99999-8888, 5511999998888'),
+    ).toHaveLength(1);
+  });
+
+  it('descarta o que não é telefone nem grupo', () => {
+    // Menos de 10 dígitos não tem DDD, e acima de 20 nem grupo é: a faixa entre
+    // 16 e 20 pertence ao id de grupo colado sem o sufixo `@g.us`.
+    expect(
+      parseWhatsappRecipients('123, abc, 123456789012345678901'),
+    ).toEqual([]);
+  });
+
+  it('16 a 20 dígitos é id de grupo, não telefone longo demais', () => {
+    // O descarte silencioso por "longo demais" é justamente o modo de falha que
+    // este canal combate: quem cola o id do painel da Evolution não recebe erro.
+    expect(parseWhatsappRecipients('1203634306511375')).toEqual([
+      { to: '1203634306511375@g.us', targetType: 'group' },
+    ]);
+  });
+});

package/src/whatsapp-sender/whatsapp-recipients.ts

@@ -0,0 +1,83 @@
+import { WhatsappTargetType } from './whatsapp-sender.service';
+
+/**
+ * Destino de um aviso interno por WhatsApp: celular ou grupo.
+ *
+ * Mora no core, e nao na library que avisa, porque ja sao duas a ler a mesma
+ * lista digitada a mao — o SAC, para o grupo do atendimento, e o commerce, para
+ * os grupos de venda. Reconhecedor de JID de grupo duplicado e como as duas
+ * divergem: uma passa a aceitar o id sem sufixo e a outra nao, e o destino some
+ * em silencio no modulo que ficou para tras.
+ */
+export type WhatsappRecipient = {
+  to: string;
+  targetType: WhatsappTargetType;
+};
+
+/**
+ * Id de grupo do WhatsApp (`...@g.us`), ou null quando o item nao e grupo.
+ *
+ * Grupo tem duas formas: a atual, so digitos (`120363...@g.us`), e a antiga,
+ * derivada de quem criou o grupo (`5511999998888-1564082267@g.us`). As duas
+ * saem do painel da Evolution ja com o sufixo.
+ *
+ * Sem sufixo tambem vale: um id colado do painel tem 18 digitos, e acima do teto
+ * do E.164 (15) nao existe telefone — a alternativa seria o descarte silencioso
+ * por "longo demais", que e o modo de falha que este canal combate. O corte em
+ * 20 digitos deixa de fora a colagem de dois telefones grudados, que nao e
+ * destino nenhum.
+ */
+export function toWhatsappGroupJid(value: string): string | null {
+  const match = /^(\d{5,}(?:-\d{5,})?)@g\.us$/i.exec(value);
+  if (match) return `${match[1]}@g.us`;
+
+  return /^\d{16,20}$/.test(value) ? `${value}@g.us` : null;
+}
+
+/**
+ * Destinos de WhatsApp de uma lista digitada a mao: celulares e grupos.
+ *
+ * Nao da para reusar um `split` de e-mail: `WhatsappSenderService.normalizeTarget`
+ * apenas remove os nao-digitos e **nao acrescenta DDI**. Um `(11) 99999-8888`
+ * digitado no admin viraria `11999998888`, um numero que o provedor aceita e
+ * entrega em outro lugar — falha silenciosa, que e exatamente o que este canal
+ * existe para evitar. Por isso o DDI 55 e completado aqui quando o que sobrou
+ * tem cara de numero nacional (DDD + 8 ou 9 digitos).
+ *
+ * A separacao e so por virgula, ponto-e-virgula e quebra de linha — nao por
+ * espaco. Espaco faz parte da mascara de um telefone (`+55 (11) 3333-4444`), e
+ * quebrar ali produziria os fragmentos `+55`, `(11)` e `3333-4444`, todos
+ * descartados: a lista inteira sumiria em silencio.
+ *
+ * Menos de 10 digitos nao e telefone com DDD, e mais de 15 nao e telefone nenhum
+ * (o teto do E.164) — normalmente sao dois numeros que alguem separou so com
+ * espaco. Descartar e melhor que enviar para um numero inventado.
+ */
+export function parseWhatsappRecipients(
+  raw: string | null | undefined,
+): WhatsappRecipient[] {
+  if (!raw) return [];
+
+  // Map, e nao Set: o mesmo destino escrito de duas formas continua contando uma
+  // vez so, e o tipo precisa vir junto do valor.
+  const seen = new Map<string, WhatsappRecipient>();
+
+  for (const item of raw.split(/[,;\n]+/)) {
+    const value = item.trim();
+    if (!value) continue;
+
+    const group = toWhatsappGroupJid(value);
+
+    if (group) {
+      seen.set(group, { to: group, targetType: 'group' });
+      continue;
+    }
+
+    const digits = value.replace(/\D+/g, '');
+    if (digits.length < 10 || digits.length > 15) continue;
+    const phone = digits.length <= 11 ? `55${digits}` : digits;
+    seen.set(phone, { to: phone, targetType: 'phone' });
+  }
+
+  return [...seen.values()];
+}

package/src/whatsapp-sender/whatsapp-sender.service.spec.ts

@@ -0,0 +1,185 @@
+import {
+  WhatsappSendError,
+  WhatsappSenderService,
+} from './whatsapp-sender.service';
+
+describe('WhatsappSenderService', () => {
+  const buildService = (providerSlug: string) => {
+    const prisma = {
+      integration_profile: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: 7,
+          slug: 'whatsapp-api-hcode',
+          config: { access_token: 'token', phone_number_id: '109371452' },
+          integration_provider: { slug: providerSlug },
+          integration_type: { slug: 'whatsapp' },
+        }),
+        findFirst: jest.fn(),
+      },
+    };
+
+    return { prisma, service: new WhatsappSenderService(prisma as any) };
+  };
+
+  describe('normalizeTarget', () => {
+    it('preserva o sufixo do grupo, que um strip de digitos destruiria', () => {
+      const { service } = buildService('evolution-api');
+
+      expect(
+        service.normalizeTarget('120363430651137530@g.us', 'group'),
+      ).toBe('120363430651137530@g.us');
+    });
+
+    it('reduz o telefone a digitos', () => {
+      const { service } = buildService('evolution-api');
+
+      expect(service.normalizeTarget('+55 (11) 3333-4444')).toBe(
+        '551133334444',
+      );
+    });
+  });
+
+  // A Cloud API nao tem endpoint de grupo. Sem a guarda, o destino seria
+  // reduzido a digitos e a Graph API receberia o id do grupo como telefone.
+  describe('grupo no provider oficial', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+      fetchSpy = jest
+        .spyOn(global, 'fetch' as any)
+        .mockResolvedValue({ ok: true, json: async () => ({}) } as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('recusa o envio sem chamar a Graph API', async () => {
+      const { service } = buildService('whatsapp-official');
+
+      await expect(
+        service.send({
+          profileSlug: 'whatsapp-api-hcode',
+          to: '120363430651137530@g.us',
+          targetType: 'group',
+          text: 'Novo chamado',
+        }),
+      ).rejects.toThrow(/não envia mensagem para grupo/);
+
+      expect(fetchSpy).not.toHaveBeenCalled();
+    });
+
+    it('marca a recusa como permanente, para o job nao insistir', async () => {
+      const { service } = buildService('whatsapp-official');
+
+      const error = await service
+        .send({
+          profileSlug: 'whatsapp-api-hcode',
+          to: '120363430651137530@g.us',
+          targetType: 'group',
+          text: 'Novo chamado',
+        })
+        .catch((thrown) => thrown);
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect((error as WhatsappSendError).retryable).toBe(false);
+    });
+
+    it('a Evolution continua entregando no grupo', async () => {
+      const { prisma, service } = buildService('evolution-api');
+      prisma.integration_profile.findUnique.mockResolvedValue({
+        id: 2,
+        slug: 'hcode',
+        config: {
+          host: 'https://evolution.hcode.com.br',
+          token: 'apikey',
+          instance_name: 'hcode',
+        },
+        integration_provider: { slug: 'evolution-api' },
+        integration_type: { slug: 'whatsapp' },
+      });
+
+      await service.send({
+        profileSlug: 'hcode',
+        to: '120363430651137530@g.us',
+        targetType: 'group',
+        text: 'Novo chamado',
+      });
+
+      const [url, init] = fetchSpy.mock.calls[0];
+      expect(url).toBe('https://evolution.hcode.com.br/message/sendText/hcode');
+      expect(JSON.parse(init.body).number).toBe('120363430651137530@g.us');
+    });
+  });
+
+  // O worker so insiste quando a recusa pode mudar; numero sem WhatsApp e dado
+  // de cadastro e reprocessaria o job tres vezes a toa.
+  describe('recusa da Evolution', () => {
+    let fetchSpy: jest.SpyInstance;
+
+    const buildEvolution = () => {
+      const built = buildService('evolution-api');
+      built.prisma.integration_profile.findUnique.mockResolvedValue({
+        id: 2,
+        slug: 'hcode',
+        config: {
+          host: 'https://evolution.hcode.com.br',
+          token: 'apikey',
+          instance_name: 'hcode',
+        },
+        integration_provider: { slug: 'evolution-api' },
+        integration_type: { slug: 'whatsapp' },
+      });
+      return built.service;
+    };
+
+    const respond = (status: number, body: unknown) =>
+      fetchSpy.mockResolvedValue({
+        ok: false,
+        status,
+        text: async () => JSON.stringify(body),
+      } as any);
+
+    const sendAndCatch = () =>
+      buildEvolution()
+        .send({ profileSlug: 'hcode', to: '5515991103304', text: 'Oi' })
+        .catch((thrown) => thrown);
+
+    beforeEach(() => {
+      fetchSpy = jest.spyOn(global, 'fetch' as any);
+    });
+
+    afterEach(() => fetchSpy.mockRestore());
+
+    it('numero sem WhatsApp e recusa permanente com mensagem legivel', async () => {
+      respond(400, {
+        status: 400,
+        error: 'Bad Request',
+        response: {
+          message: [{ jid: '5515991103304@s.whatsapp.net', exists: false, number: '5515991103304' }],
+        },
+      });
+
+      const error = await sendAndCatch();
+
+      expect(error).toBeInstanceOf(WhatsappSendError);
+      expect(error.retryable).toBe(false);
+      expect(error.message).toMatch(/5515991103304 não tem WhatsApp/);
+    });
+
+    it('outro 4xx tambem e permanente', async () => {
+      respond(400, { response: { message: ['text is required'] } });
+
+      const error = await sendAndCatch();
+
+      expect(error.retryable).toBe(false);
+      expect(error.message).toMatch(/HTTP 400/);
+    });
+
+    it('5xx e 429 podem ser tentados de novo', async () => {
+      respond(502, {});
+      expect((await sendAndCatch()).retryable).toBe(true);
+
+      respond(429, {});
+      expect((await sendAndCatch()).retryable).toBe(true);
+    });
+  });
+});

package/src/whatsapp-sender/whatsapp-sender.service.ts

@@ -35,11 +35,27 @@ export type WhatsappSendInput = {
 };
 
 type ResolvedProfile = {
+  id: number;
   slug: string;
   providerSlug: string;
   config: Record<string, unknown>;
 };
 
+/**
+ * Erro de envio classificado: `retryable` diz se tentar de novo pode dar
+ * resultado diferente. Um HTTP 4xx da Graph API (id inexistente, sem
+ * permissão, token ruim) não muda em cinco minutos; um 5xx ou falha de rede
+ * pode ser uma instabilidade passageira do provedor.
+ */
+export class WhatsappSendError extends BadRequestException {
+  constructor(
+    message: string,
+    public readonly retryable: boolean,
+  ) {
+    super(message);
+  }
+}
+
 /**
  * Envio de WhatsApp usando um perfil de integração escolhido pelo usuário.
  *
@@ -92,6 +108,22 @@ export class WhatsappSenderService {
     }
   }
 
+  /**
+   * Identidade do perfil que o `send` usaria, sem o `config`.
+   *
+   * Quem envia pelo provider oficial precisa dizer por qual número a mensagem
+   * sai, e cada módulo guarda esse id no próprio cadastro. Para achar o cadastro
+   * certo é preciso saber qual perfil foi resolvido — inclusive quando o slug
+   * veio vazio e a escolha coube a este serviço. O `config` fica de fora de
+   * propósito: é onde moram `access_token` e `app_secret`.
+   */
+  async describeProfile(
+    profileSlug?: string,
+  ): Promise<{ id: number; slug: string; providerSlug: string }> {
+    const { id, slug, providerSlug } = await this.resolveProfile(profileSlug);
+    return { id, slug, providerSlug };
+  }
+
   /**
    * Normaliza o destino: número vira só dígitos, id de grupo passa intacto
    * (grupos do WhatsApp têm sufixo `@g.us`, que seria destruído por um strip).
@@ -153,6 +185,7 @@ export class WhatsappSenderService {
     }
 
     return {
+      id: profile.id,
       slug: profile.slug,
       providerSlug: String((profile as any).integration_provider?.slug ?? ''),
       config: ((profile.config ?? {}) as Record<string, unknown>),
@@ -209,13 +242,27 @@ export class WhatsappSenderService {
       const detail = await response.text().catch(() => '');
 
       if (response.status === 401) {
-        throw new BadRequestException(
+        throw new WhatsappSendError(
           `Credenciais do WhatsApp inválidas (401). Verifique o token do perfil "${profile.slug}".`,
+          false,
         );
       }
 
-      throw new BadRequestException(
+      // Número sem conta no WhatsApp: a Evolution responde 400 com
+      // `exists: false`. É dado do cadastro, não instabilidade — reenviar não
+      // muda nada, e o chamador precisa saber disso para não insistir.
+      if (isEvolutionNumberMissing(detail)) {
+        throw new WhatsappSendError(
+          `O número ${target} não tem WhatsApp (Evolution: exists=false).`,
+          false,
+        );
+      }
+
+      // Mesmo critério do provider oficial: 4xx é recusa estrutural, 5xx e
+      // 429 podem passar numa próxima tentativa.
+      throw new WhatsappSendError(
         `Evolution API recusou o envio (HTTP ${response.status}): ${detail.slice(0, 300)}`,
+        response.status >= 500 || response.status === 429,
       );
     }
   }
@@ -226,6 +273,19 @@ export class WhatsappSenderService {
   ): Promise<void> {
     const cfg = buildWhatsappOfficialConfigFromIntegration(profile.config);
 
+    // A Cloud API da Meta não envia para grupo — não há endpoint para isso. Sem
+    // esta guarda o `normalizeTarget(..., 'phone')` logo abaixo arrancaria o
+    // sufixo `@g.us` e a Graph API receberia o id do grupo como se fosse um
+    // telefone: ou erro genérico de número inválido, ou (pior) entrega a um
+    // número que por acaso exista. `retryable: false` porque trocar de provider
+    // é decisão de configuração, não instabilidade.
+    if (input.targetType === 'group') {
+      throw new WhatsappSendError(
+        `Perfil de integração "${profile.slug}" usa a Cloud API oficial da Meta, que não envia mensagem para grupo. Use um perfil evolution-api para esse destino.`,
+        false,
+      );
+    }
+
     if (!cfg.accessToken) {
       throw new BadRequestException(
         `Perfil de WhatsApp "${profile.slug}" está sem access_token.`,
@@ -290,22 +350,45 @@ export class WhatsappSenderService {
 
     if (!response.ok) {
       const payload = (await response.json().catch(() => ({}))) as {
-        error?: { message?: string };
+        error?: { message?: string; code?: number };
       };
 
-      throw new BadRequestException(
+      // Código documentado pela Meta para "business-initiated message fora da
+      // janela de 24h sem template" (re-engagement). Outros 4xx (id inválido,
+      // sem permissão, token ruim) não têm nada a ver com template e não
+      // devem exibir essa dica.
+      const isReengagementWindowError = payload?.error?.code === 131047;
+
+      throw new WhatsappSendError(
         `WhatsApp recusou o envio (HTTP ${response.status}): ${
           payload?.error?.message ?? 'sem detalhe'
         }${
-          input.template?.name
-            ? ''
-            : ' — sem template configurado, a entrega só funciona na janela de 24h'
+          !input.template?.name && isReengagementWindowError
+            ? ' — sem template configurado, a entrega só funciona na janela de 24h'
+            : ''
         }`,
+        response.status >= 500,
       );
     }
   }
 }
 
+/**
+ * Reconhece o 400 da Evolution para destino inexistente:
+ * `{"response":{"message":[{"exists":false,"number":"55..."}]}}`.
+ */
+function isEvolutionNumberMissing(detail: string): boolean {
+  try {
+    const messages = JSON.parse(detail)?.response?.message;
+    return (
+      Array.isArray(messages) &&
+      messages.some((item) => item && typeof item === 'object' && item.exists === false)
+    );
+  } catch {
+    return false;
+  }
+}
+
 /** Evolution espera base64 puro; um data URL vindo do chamador quebraria o envio. */
 function stripDataUrlPrefix(image: string): string {
   const match = /^data:[^;]+;base64,(.*)$/i.exec(image);

package/hedhog/query/device_pairing_request.sql

@@ -1,46 +0,0 @@
--- Pareamento de dispositivo (QR entre celular e navegador).
---
--- Tabela de infra de auth: vive so aqui, sem YAML em hedhog/table (ver
--- oauth_mobile_state_token.sql).
---
--- Usada por libraries/core/src/pairing/pairing.service.ts. A FK para "user"
--- resolve porque os arquivos de hedhog/query sao anexados DEPOIS de todos os
--- CREATE TABLE (ver docs/YAML-SPEC.md secao 7).
-CREATE TABLE IF NOT EXISTS device_pairing_request (
-  id                BIGSERIAL    PRIMARY KEY,
-  direction         VARCHAR(20)  NOT NULL,
-  -- Só o hash do token de resgate/poll: um dump do banco não permite reivindicar
-  -- nem consumir pareamento nenhum.
-  auth_hash         VARCHAR(255) NOT NULL UNIQUE,
-  -- NULL em 'device-to-browser' até a aprovação: o navegador que pede ainda não
-  -- é ninguém. Preenchido pelo aparelho que aprova.
-  user_id           INTEGER      NULL REFERENCES "user"(id) ON DELETE CASCADE,
-  client_id         VARCHAR(100) NOT NULL,
-  purpose           VARCHAR(50)  NOT NULL DEFAULT 'vaults',
-  -- 'device-to-browser': ponto EC não comprimido (65 bytes) em base64. É a chave
-  -- para a qual o celular cifra; a privada correspondente nunca sai da aba.
-  eph_public_key    TEXT         NULL,
-  -- 'device-to-browser': o navegador também precisa de sessão (computador novo,
-  -- ninguém logado) ou só das chaves do cofre (sessão já existe, cofre travado).
-  want_session      BOOLEAN      NOT NULL DEFAULT TRUE,
-  -- OPACO para o servidor: AES-256-GCM feito no cliente com uma chave que nunca
-  -- chega aqui (fragmento do QR ou par efêmero da aba). Fica NULL até a
-  -- aprovação, então um pareamento não aprovado nunca guarda material de chave.
-  payload_enc       TEXT         NULL,
-  issued_ip         VARCHAR(64)  NULL,
-  issued_user_agent TEXT         NULL,
-  claimed_at        TIMESTAMPTZ  NULL,
-  claim_ip          VARCHAR(64)  NULL,
-  claim_user_agent  TEXT         NULL,
-  confirmed_at      TIMESTAMPTZ  NULL,
-  cancelled_at      TIMESTAMPTZ  NULL,
-  consumed_at       TIMESTAMPTZ  NULL,
-  expires_at        TIMESTAMPTZ  NOT NULL,
-  created_at        TIMESTAMPTZ  NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_device_pairing_request_expires_at
-  ON device_pairing_request (expires_at);
-
-CREATE INDEX IF NOT EXISTS idx_device_pairing_request_user
-  ON device_pairing_request (user_id, created_at DESC);

package/hedhog/query/impersonation_grant.sql

@@ -1,71 +0,0 @@
--- Simulacao de acesso ("simular login"): um operador abre uma sessao curta,
--- auditada e nao renovavel como outro usuario.
---
--- Tabela de infra de auth: vive so aqui, sem YAML em hedhog/table (ver
--- oauth_mobile_state_token.sql).
---
--- Usada por libraries/core/src/impersonation/impersonation.service.ts.
---
--- POR QUE impersonator_user_id E target_user_id SAO INTEGER SEM FOREIGN KEY:
--- as tabelas marcadas mais abaixo ja tem uma FK para "user". Uma segunda FK faz
--- o `prisma db pull` desambiguar os nomes das relacoes NOS DOIS LADOS, o que
--- renomearia `user.user_session`, `user.access_log` e `user.user_activity` e
--- quebraria UserService, packages/api-types e a tela de sessoes do admin. O nome
--- do operador e resolvido por uma segunda consulta.
-CREATE TABLE IF NOT EXISTS impersonation_grant (
-  id                   SERIAL       PRIMARY KEY,
-  code_hash            VARCHAR(255) NOT NULL UNIQUE,
-  -- Sem FK de proposito — ver a nota no topo do arquivo.
-  impersonator_user_id INTEGER      NOT NULL,
-  target_user_id       INTEGER      NOT NULL,
-  -- Chave do app de destino ('admin', 'class', 'partners'), resolvida contra a
-  -- setting app-urls.
-  app                  VARCHAR(50)  NOT NULL,
-  reason               VARCHAR(255) NULL,
-  -- Preenchido no resgate: aponta para a user_session simulada que nasceu daqui.
-  session_id           INTEGER      NULL,
-  issued_ip            VARCHAR(64)  NULL,
-  issued_user_agent    TEXT         NULL,
-  redeemed_ip          VARCHAR(64)  NULL,
-  redeemed_user_agent  TEXT         NULL,
-  consumed_at          TIMESTAMPTZ  NULL,
-  ended_at             TIMESTAMPTZ  NULL,
-  expires_at           TIMESTAMPTZ  NOT NULL,
-  created_at           TIMESTAMPTZ  NOT NULL DEFAULT NOW()
-);
-
-CREATE INDEX IF NOT EXISTS idx_impersonation_grant_impersonator
-  ON impersonation_grant (impersonator_user_id, created_at DESC);
-
-CREATE INDEX IF NOT EXISTS idx_impersonation_grant_target
-  ON impersonation_grant (target_user_id, created_at DESC);
-
-CREATE INDEX IF NOT EXISTS idx_impersonation_grant_expires
-  ON impersonation_grant (expires_at);
-
-CREATE INDEX IF NOT EXISTS idx_impersonation_grant_session
-  ON impersonation_grant (session_id)
-  WHERE session_id IS NOT NULL;
-
--- ---------------------------------------------------------------------------
--- Indices das colunas de simulacao nas tabelas que TEM YAML.
---
--- As colunas em si vem de hedhog/table/{user_session,access_log,user_activity}.yaml
--- e o CLI as cria; os indices NAO — o gerador nao emite indice para elas, e a
--- semantica parcial (WHERE ... IS NOT NULL) nao e exprimivel em YAML.
---
--- Parciais de proposito: a esmagadora maioria das linhas nao tem simulacao
--- nenhuma, entao um indice cheio numa coluna quase toda NULL seria bem maior sem
--- servir a nenhuma consulta.
--- ---------------------------------------------------------------------------
-CREATE INDEX IF NOT EXISTS "user_session_impersonator_user_id_idx"
-  ON "user_session" ("impersonator_user_id")
-  WHERE "impersonator_user_id" IS NOT NULL;
-
-CREATE INDEX IF NOT EXISTS "access_log_impersonator_user_id_idx"
-  ON "access_log" ("impersonator_user_id")
-  WHERE "impersonator_user_id" IS NOT NULL;
-
-CREATE INDEX IF NOT EXISTS "user_activity_actor_user_id_idx"
-  ON "user_activity" ("actor_user_id")
-  WHERE "actor_user_id" IS NOT NULL;