@hed-hog/core 0.0.401 → 0.0.402

package/hedhog/frontend/messages/pt.json

@@ -2681,6 +2681,11 @@
     "testConnectionSuccess": "Conexão validada com sucesso.",
     "testConnectionOkWithInfo": "Conexão validada: {info}",
     "testConnectionWarning": "Credenciais válidas, mas: {warning}",
+    "testConnectionWarningCodes": {
+      "google_oauth_testing": "A tela de consentimento OAuth está em Teste: os refresh tokens do Google expiram em 7 dias e os canais precisam ser reconectados toda semana. Publique o app (Em produção) para mantê-los conectados.",
+      "youtube_audit_pending": "Enquanto a auditoria da API do YouTube não for aprovada para este projeto do Google Cloud, os vídeos enviados ficam privados.",
+      "google_business_access_pending": "As APIs do Perfil da Empresa exigem acesso aprovado (Basic API Access): até o Google aprovar este projeto, a cota é 0 e as conexões falham."
+    },
     "testConnectionError": "Falha ao testar a conexão.",
     "testConnectionErrorFallback": "Não foi possível validar as credenciais.",
     "testConnectionNotPersisted": "Salve o perfil para registrar o resultado.",
@@ -2726,7 +2731,9 @@
     "fieldWabaId": "ID da Conta do WhatsApp Business (WABA)",
     "fieldVerifyToken": "Verify Token do Webhook",
     "fieldGraphApiVersion": "Versão da Graph API",
-    "fieldLinkedInApiVersion": "Versão da API do LinkedIn (AAAAMM)",
+    "fieldLinkedInApiVersion": "Versão da API do LinkedIn (AAAAMM)",
+    "fieldXClientId": "Client ID (OAuth 2.0)",
+    "fieldXClientSecret": "Client Secret (OAuth 2.0)",
     "fieldEnvironmentTest": "Teste",
     "fieldEnvironmentProduction": "Produção",
     "copiedToClipboard": "Copiado para a área de transferência",
@@ -2895,32 +2902,42 @@
     "metaSocialSectionTitle": "Conexão das redes sociais",
     "metaSocialDescription": "Este perfil é o app do HedHog na Meta. As Páginas e contas Instagram são conectadas por marca, em Social → Marcas → Canais.",
     "metaSocialRedirectUriLabel": "URI de redirecionamento do OAuth",
-    "metaSocialRedirectUriUnavailable": "Defina NEXT_PUBLIC_API_BASE_URL para exibir a URI",
+    "metaSocialRedirectUriUnavailable": "Preencha a configuração URL da API (api-url) para exibir a URI",
     "metaSocialStepsTitle": "Como configurar no painel da Meta",
     "metaSocialStep1": "Crie um app do tipo Business e adicione o Facebook Login for Business e a API do Instagram com login do Facebook.",
-    "metaSocialStep2": "Crie uma Login Configuration do tipo \"User access token\" com as permissões de publicação e cole o ID dela acima.",
+    "metaSocialStep2": "Crie uma Login Configuration do tipo \"User access token\" com as permissões pages_show_list, business_management, pages_read_engagement, pages_manage_posts, instagram_basic e instagram_content_publish, e cole o ID dela no campo Login Configuration ID.",
     "metaSocialStep3": "Cadastre a URI acima em \"Valid OAuth Redirect URIs\".",
-    "metaSocialStep4": "Até o App Review ser aprovado, use o modo Sandbox ou só contas de administradores e testadores do app.",
+    "metaSocialStep4": "Em Configurações do app > Básico, preencha a política de privacidade, os termos de uso e a URL das instruções de exclusão de dados.",
     "instagramSocialSectionTitle": "Conexão com o Instagram",
     "instagramSocialDescription": "Este perfil é o app do HedHog na API do Instagram com login do Instagram. As contas profissionais do Instagram (Empresa ou Criador de conteúdo) são conectadas por marca, em Social → Marcas → Canais, com ou sem Página do Facebook.",
     "instagramSocialRedirectUriLabel": "URI de redirecionamento do OAuth",
-    "instagramSocialRedirectUriUnavailable": "Defina NEXT_PUBLIC_API_BASE_URL para exibir a URI",
+    "instagramSocialRedirectUriUnavailable": "Preencha a configuração URL da API (api-url) para exibir a URI",
     "instagramSocialStepsTitle": "Como configurar no painel da Meta",
     "instagramSocialStep1": "No app da Meta, adicione o produto Instagram e abra \"API setup with Instagram login\".",
     "instagramSocialStep2": "Copie o ID do app do Instagram e a chave secreta do app do Instagram exibidos ali e cole acima. Eles não são o ID e a chave do app da Meta.",
     "instagramSocialStep3": "Em \"Set up Instagram business login\" > Business login settings, cadastre a URI acima em \"OAuth redirect URIs\" exatamente como aparece, sem barra no final.",
     "instagramSocialStep4": "Nas mesmas configurações, preencha a Deauthorize callback URL e a Data deletion request URL com a página das suas instruções de privacidade.",
-    "instagramSocialStep5": "Até o App Review ser aprovado, adicione as contas que serão conectadas como testadoras do Instagram no app, ou use o modo Sandbox.",
-    "linkedinSocialSectionTitle": "Conexão com o LinkedIn",
-    "linkedinSocialDescription": "Este perfil é o app do HedHog na Community Management API do LinkedIn. As páginas de empresa são conectadas por marca, em Social → Marcas → Canais, por um membro que seja administrador ou administrador de conteúdo da página.",
-    "linkedinSocialRedirectUriLabel": "URL de redirecionamento autorizada",
-    "linkedinSocialRedirectUriUnavailable": "Defina NEXT_PUBLIC_API_BASE_URL para exibir a URL",
-    "linkedinSocialStepsTitle": "Como configurar no LinkedIn Developer Portal",
-    "linkedinSocialStep1": "Crie um app dedicado, sem outros produtos, vinculado à página da empresa e verificado por um superadministrador dessa Página do LinkedIn.",
-    "linkedinSocialStep2": "Na aba Products, solicite a Community Management API. O acesso começa no nível Development.",
-    "linkedinSocialStep3": "Na aba Auth, cadastre a URL acima em \"Authorized redirect URLs for your app\" exatamente como aparece e copie o Client ID e o Primary Client Secret para os campos acima.",
-    "linkedinSocialStep4": "Antes de ir para produção, solicite o nível Standard, que exige um screencast de cada caso de uso do app.",
-    "linkedinSocialStep5": "Até o nível Standard ser aprovado, use o modo Sandbox.",
+    "instagramSocialStep5": "Até o App Review ser aprovado, adicione as contas que serão conectadas como testadoras do Instagram no app e mantenha o modo Production: Sandbox é um simulador local e é recusado em produção.",
+    "linkedinSocialSectionTitle": "Conexão com o LinkedIn",
+    "linkedinSocialDescription": "Este perfil é o app do HedHog na Community Management API do LinkedIn. As páginas de empresa são conectadas por marca, em Social → Marcas → Canais, por um membro que seja administrador ou administrador de conteúdo da página.",
+    "linkedinSocialRedirectUriLabel": "URL de redirecionamento autorizada",
+    "linkedinSocialRedirectUriUnavailable": "Preencha a configuração URL da API (api-url) para exibir a URL",
+    "linkedinSocialStepsTitle": "Como configurar no LinkedIn Developer Portal",
+    "linkedinSocialStep1": "Crie um app dedicado, sem outros produtos, vinculado à página da empresa e verificado por um superadministrador dessa Página do LinkedIn.",
+    "linkedinSocialStep2": "Na aba Products, solicite a Community Management API. O acesso começa no nível Development.",
+    "linkedinSocialStep3": "Na aba Auth, cadastre a URL acima em \"Authorized redirect URLs for your app\" exatamente como aparece e copie o Client ID e o Primary Client Secret para os campos acima.",
+    "linkedinSocialStep4": "Antes de ir para produção, solicite o nível Standard, que exige um screencast de cada caso de uso do app.",
+    "linkedinSocialStep5": "Use o modo Production: ele já chama o LinkedIn no nível Development, dentro dos limites dele. Sandbox é um simulador local e é recusado em produção.",
+    "xSocialSectionTitle": "Conexão com o X",
+    "xSocialSectionDescription": "Este perfil é o app do HedHog na API do X, paga por uso. As contas do X são conectadas por marca, em Social → Marcas → Canais, por quem entra no X com a conta da marca.",
+    "xSocialRedirectUriLabel": "Callback URI",
+    "xSocialRedirectUriUnavailable": "Preencha a configuração URL da API (api-url) para exibir a URL",
+    "xSocialStepsTitle": "Como configurar no X Developer Console",
+    "xSocialStep1": "No Developer Console, crie um Project e um App. Em User authentication settings, ative o OAuth 2.0 com o tipo Web App (confidential client) e as permissões Read and write.",
+    "xSocialStep2": "Cadastre a URL acima como Callback URI, exatamente como aparece, em cada ambiente.",
+    "xSocialStep3": "Copie o Client ID e o Client Secret do OAuth 2.0 para os campos acima (não são a API Key nem a API Secret).",
+    "xSocialStep4": "Em Billing, compre créditos e defina um teto de gasto: a API é paga por uso (US$ 0,015 por post, US$ 0,20 com link).",
+    "xSocialStep5": "Use o modo Production para conectar contas reais. Sandbox é um simulador local e é recusado em produção.",
     "fieldOauthAppStatus": "Status da tela de consentimento OAuth",
     "fieldOauthAppStatusTesting": "Em teste (o token de atualização expira em 7 dias e o canal precisa ser reconectado)",
     "fieldOauthAppStatusProduction": "Em produção (o token de atualização não expira em 7 dias)",
@@ -2928,10 +2945,10 @@
     "youtubeSocialDescription": "Este perfil é o projeto do HedHog no Google Cloud para o YouTube. Os canais são conectados por marca, em Social → Marcas → Canais.",
     "googleBusinessSocialDescription": "Este perfil é o projeto do HedHog no Google Cloud para o Perfil da Empresa no Google. Os locais são conectados por marca, em Social → Marcas → Canais.",
     "googleSocialRedirectUriLabel": "URI de redirecionamento autorizado do OAuth",
-    "googleSocialRedirectUriUnavailable": "Defina NEXT_PUBLIC_API_BASE_URL para exibir a URI",
+    "googleSocialRedirectUriUnavailable": "Preencha a configuração URL da API (api-url) para exibir a URI",
     "googleSocialStepsTitle": "Como configurar no Google Cloud Console",
     "youtubeSocialStep1": "Crie um projeto no Google Cloud só para o YouTube e ative a YouTube Data API v3.",
-    "youtubeSocialStep2": "Configure a tela de consentimento OAuth com os escopos youtube.upload e youtube.readonly. Por serem escopos sensíveis, o app precisa passar pela verificação do Google antes de ser publicado.",
+    "youtubeSocialStep2": "Configure a tela de consentimento OAuth com os escopos youtube.upload, youtube.readonly e youtube.force-ssl (sensíveis, exigem a verificação do Google antes de o app ser publicado) e yt-analytics.readonly (não sensível).",
     "youtubeSocialStep3": "Crie um ID do cliente OAuth do tipo \"Aplicativo da Web\", cadastre a URI acima em \"URIs de redirecionamento autorizados\" e cole o Client ID e o Client Secret acima.",
     "youtubeSocialStep4": "Solicite a auditoria de conformidade da API do YouTube: até ela ser aprovada, todo vídeo enviado pelo projeto fica privado.",
     "youtubeSocialStep5": "A cota padrão do projeto permite cerca de 100 envios de vídeo por dia. Ao esgotar, a publicação é reagendada para depois do reset (meia-noite no horário do Pacífico).",
@@ -2940,7 +2957,10 @@
     "googleBusinessSocialStep3": "Ative a My Business Account Management API, a My Business Business Information API e a Google My Business API. Até o acesso ser aprovado a cota é 0 e toda chamada falha.",
     "googleBusinessSocialStep4": "Configure a tela de consentimento OAuth com o escopo business.manage.",
     "googleBusinessSocialStep5": "Crie um ID do cliente OAuth do tipo \"Aplicativo da Web\", cadastre a URI acima em \"URIs de redirecionamento autorizados\" e cole o Client ID e o Client Secret acima.",
-    "googleSocialTestingStep": "Enquanto a tela de consentimento estiver em \"Teste\", escolha \"Em teste\" no status acima e use o modo Sandbox para desenvolver sem depender das aprovações do Google."
+    "googleSocialTestingStep": "Enquanto a tela de consentimento estiver em \"Teste\", escolha \"Em teste\" no status acima e adicione como usuários de teste as contas Google que serão conectadas.",
+    "metaSocialStep5": "Conclua a Verificação da empresa e peça a App Review das permissões. Até a aprovação, só administradores, desenvolvedores e testadores do app conseguem conectar.",
+    "socialRedirectUriMismatch": "A configuração URL da API ({setting}) é diferente da API que este painel usa ({env}). A URI acima segue a configuração, que é o que o backend envia à rede.",
+    "socialGuideLink": "Ver o guia completo de configuração"
   },
   "SystemPagesPage": {
     "title": "Páginas",
@@ -3356,7 +3376,13 @@
     "redeemInvalidDescription": "O link funciona uma única vez e expira em um minuto. Peça ao operador para iniciar uma nova simulação.",
     "redeemMissingCode": "Nenhum código de simulação foi encontrado no link.",
     "noAdminAccessTitle": "Este usuário não tem acesso ao painel",
-    "noAdminAccessDescription": "{name} não tem papel administrativo, então não há o que mostrar aqui. Simule esse acesso na aplicação que a pessoa realmente usa."
+    "noAdminAccessDescription": "{name} não tem papel administrativo, então não há o que mostrar aqui. Simule esse acesso na aplicação que a pessoa realmente usa.",
+    "apps": {
+      "admin": "Hub (administração)",
+      "class": "Hcode Class",
+      "partners": "Portal de Parceiros",
+      "training": "Hcode Training"
+    }
   },
   "MessageTemplatesPage": {
     "title": "Modelos de mensagem",

package/hedhog/table/file.yaml

@@ -15,8 +15,10 @@ columns:
       table: file_mimetype
       column: id
       onDelete: CASCADE
+  # Em bytes. bigint: int parava em 2.147.483.647 (~2 GB) e video maior nao
+  # entrava. O PrismaService devolve o valor como number (extension de result).
   - name: size
-    type: int
+    type: bigint
     unsigned: true
     default: 0
   # Tira o arquivo das duas rotas que servem por id sem autenticacao

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/core",
-  "version": "0.0.401",
+  "version": "0.0.402",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,12 +48,12 @@
     "ua-parser-js": "^2.0.10",
     "uuid": "^11.1.0",
     "@hed-hog/api-prisma": "0.0.7",
+    "@hed-hog/vault-crypto": "0.0.1",
     "@hed-hog/api-mail": "0.0.11",
     "@hed-hog/api-locale": "0.0.15",
-    "@hed-hog/vault-crypto": "0.0.1",
     "@hed-hog/api-types": "0.0.2",
-    "@hed-hog/api-pagination": "0.0.8",
-    "@hed-hog/api": "0.0.9"
+    "@hed-hog/api": "0.0.9",
+    "@hed-hog/api-pagination": "0.0.8"
   },
   "exports": {
     ".": {

package/src/access-log/access-log.interceptor.spec.ts

@@ -0,0 +1,50 @@
+import 'reflect-metadata';
+import { SetMetadata } from '@nestjs/common';
+import { lastValueFrom, of } from 'rxjs';
+import { AccessLogInterceptor, SKIP_ACCESS_LOG_KEY } from './access-log.interceptor';
+
+class PlainController {
+  handler() {}
+}
+
+@SetMetadata(SKIP_ACCESS_LOG_KEY, true)
+class AnonymousController {
+  handler() {}
+}
+
+function contextFor(controller: any) {
+  const request = {
+    url: '/x',
+    ip: '203.0.113.7',
+    method: 'POST',
+    headers: { 'user-agent': 'UA' },
+  };
+  return {
+    getType: () => 'http',
+    switchToHttp: () => ({ getRequest: () => request }),
+    getHandler: () => controller.prototype.handler,
+    getClass: () => controller,
+  } as any;
+}
+
+describe('AccessLogInterceptor', () => {
+  it('records ordinary requests', async () => {
+    const recordHttp = jest.fn();
+    const interceptor = new AccessLogInterceptor({ recordHttp } as any);
+    await lastValueFrom(
+      interceptor.intercept(contextFor(PlainController), { handle: () => of(1) }),
+    );
+    expect(recordHttp).toHaveBeenCalledWith(
+      expect.objectContaining({ ip: '203.0.113.7', userAgent: 'UA' }),
+    );
+  });
+
+  it('skips routes marked with skipAccessLog (anonymous whistleblower channel)', async () => {
+    const recordHttp = jest.fn();
+    const interceptor = new AccessLogInterceptor({ recordHttp } as any);
+    await lastValueFrom(
+      interceptor.intercept(contextFor(AnonymousController), { handle: () => of(1) }),
+    );
+    expect(recordHttp).not.toHaveBeenCalled();
+  });
+});

package/src/access-log/access-log.interceptor.ts

@@ -7,6 +7,17 @@ import {
 import { Observable, tap } from 'rxjs';
 import { AccessLogService } from './access-log.service';
 
+/**
+ * Metadado (handler ou classe) que tira a rota do access log.
+ *
+ * Existe para superficies cujo valor depende de NAO saber quem chamou — o canal
+ * de denuncias da library integrity: uma linha com IP, user agent e horario de
+ * `POST /integrity/public/reports` identificaria o denunciante. Quem usa aplica
+ * `SetMetadata('skipAccessLog', true)` direto, sem importar daqui, para uma
+ * library nao exigir esta versao do core (um core antigo apenas continua logando).
+ */
+export const SKIP_ACCESS_LOG_KEY = 'skipAccessLog';
+
 @Injectable()
 export class AccessLogInterceptor implements NestInterceptor {
   constructor(private readonly accessLogService: AccessLogService) {}
@@ -23,6 +34,13 @@ export class AccessLogInterceptor implements NestInterceptor {
       return next.handle();
     }
 
+    if (
+      Reflect.getMetadata(SKIP_ACCESS_LOG_KEY, context.getHandler()) === true ||
+      Reflect.getMetadata(SKIP_ACCESS_LOG_KEY, context.getClass()) === true
+    ) {
+      return next.handle();
+    }
+
     return next.handle().pipe(
       tap(() => {
         const userId: number | undefined = request.auth?.sub;

package/src/file/file-direct-upload.spec.ts

@@ -0,0 +1,344 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { BadRequestException, ConflictException } from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { FileService } from './file.service';
+
+/**
+ * Upload direto em partes assinadas: o cliente manda os bytes ao storage e a API so
+ * abre, assina e fecha. O que estes testes protegem:
+ *
+ * - a chave segue o `location`/`path` que o `uploadFromPath` grava;
+ * - a regra de parte do Studio (>= 16 MiB, <= 9000 partes);
+ * - no complete, nada vira linha `file` sem conferir tamanho, teto, allowlist e os
+ *   primeiros bytes — e o que for recusado sai do bucket;
+ * - o token só é aceito com a assinatura e o tipo certos.
+ */
+const MIB = 1024 * 1024;
+
+describe('FileService — upload direto', () => {
+  let deps: any;
+  let service: FileService;
+  let provider: any;
+  let settingValues: Record<string, unknown>;
+
+  beforeEach(() => {
+    process.env.JWT_SECRET = 'spec-secret';
+    settingValues = {
+      'storage-max-size': String(1024 * MIB),
+      'storage-accept-mimetype': ['video/mp4', 'image/jpeg'],
+    };
+
+    deps = {
+      prisma: {
+        file: {
+          create: jest.fn().mockImplementation((args: any) => Promise.resolve({ id: 42, ...args.data })),
+        },
+      },
+      pagination: {},
+      setting: {
+        getSettingValues: jest.fn().mockImplementation(async (slugs: any) =>
+          Object.fromEntries((slugs as string[]).map((slug) => [slug, settingValues[slug]])),
+        ),
+      },
+      jwt: new JwtService(),
+      imageOptimization: {},
+    };
+
+    service = new FileService(
+      deps.prisma,
+      deps.pagination,
+      deps.setting,
+      deps.jwt,
+      deps.imageOptimization,
+    );
+
+    provider = {
+      getFilename: jest.fn().mockReturnValue('uuid-1.mp4'),
+      createMultipartUpload: jest.fn().mockResolvedValue('upload-1' as never),
+      signUploadParts: jest.fn().mockImplementation(async (_k: any, _u: any, numbers: any) =>
+        (numbers as number[]).map((partNumber) => ({ partNumber, url: `https://put/${partNumber}` })),
+      ),
+      completeMultipartUpload: jest.fn().mockResolvedValue(undefined as never),
+      abortMultipartUpload: jest.fn().mockResolvedValue(undefined as never),
+      readHead: jest.fn().mockResolvedValue(Buffer.from('head') as never),
+      metaData: jest.fn().mockResolvedValue({ ContentLength: 100 * MIB } as never),
+      delete: jest.fn().mockResolvedValue(true as never),
+    };
+
+    jest.spyOn(service, 'getProvider').mockImplementation(async () => {
+      (service as any).providerId = 3;
+      return provider;
+    });
+    jest.spyOn(service, 'getMimeType').mockResolvedValue(7 as never);
+  });
+
+  afterEach(() => jest.restoreAllMocks());
+
+  const complete = (overrides: Record<string, unknown> = {}) =>
+    service.completeDirectUpload({
+      key: 'social/brands/1/uuid-1.mp4',
+      uploadId: 'upload-1',
+      destination: 'social/brands/1',
+      parts: [{ partNumber: 1, etag: '"a"' }],
+      size: 100 * MIB,
+      mimetype: 'video/mp4',
+      originalname: 'demo.mp4',
+      isPrivate: true,
+      createdByUserId: 9,
+      ...overrides,
+    } as any);
+
+  describe('supportsDirectUpload', () => {
+    it('provider com os cinco métodos suporta', async () => {
+      await expect(service.supportsDirectUpload()).resolves.toBe(true);
+    });
+
+    it('provider sem multipart (local, gcs, azure) não suporta', async () => {
+      delete provider.readHead;
+      await expect(service.supportsDirectUpload()).resolves.toBe(false);
+    });
+
+    it('sem storage configurado é false, não erro', async () => {
+      (service.getProvider as any).mockRejectedValueOnce(new Error('no profile'));
+      await expect(service.supportsDirectUpload()).resolves.toBe(false);
+    });
+  });
+
+  describe('startDirectUpload', () => {
+    it('abre o multipart com a chave destination/uuid.ext e a regra de partes', async () => {
+      const result = await service.startDirectUpload('social/brands/1', {
+        originalname: 'demo.mp4',
+        mimetype: 'video/mp4',
+        size: 216_000_000,
+      });
+
+      expect(provider.getFilename).toHaveBeenCalledWith('demo.mp4');
+      expect(provider.createMultipartUpload).toHaveBeenCalledWith(
+        'social/brands/1/uuid-1.mp4',
+        'video/mp4',
+      );
+      expect(result).toEqual({
+        key: 'social/brands/1/uuid-1.mp4',
+        uploadId: 'upload-1',
+        partSize: 16 * MIB,
+        partCount: 13,
+      });
+    });
+
+    it('arquivo enorme: a parte cresce para caber em 9000 partes', async () => {
+      settingValues['storage-max-size'] = String(2_147_483_647);
+      const size = 2_000_000_000;
+      const { partSize, partCount } = await service.startDirectUpload('x', {
+        originalname: 'a.mp4',
+        mimetype: 'video/mp4',
+        size,
+      });
+      // 2 GB / 16 MiB = 120 partes: ainda vale o mínimo.
+      expect(partSize).toBe(16 * MIB);
+      expect(partCount).toBe(Math.ceil(size / (16 * MIB)));
+    });
+
+    it('acima da storage-max-size é recusado antes de abrir nada', async () => {
+      settingValues['storage-max-size'] = String(10 * MIB);
+      await expect(
+        service.startDirectUpload('x', { originalname: 'a.mp4', mimetype: 'video/mp4', size: 11 * MIB }),
+      ).rejects.toThrow('File too large');
+      expect(provider.createMultipartUpload).not.toHaveBeenCalled();
+    });
+
+    it('skipSizeValidation pula a storage-max-size, mas não o teto de file.size', async () => {
+      settingValues['storage-max-size'] = String(10 * MIB);
+      const info = { originalname: 'a.mp4', mimetype: 'video/mp4', skipSizeValidation: true };
+
+      await expect(service.startDirectUpload('x', { ...info, size: 11 * MIB })).resolves.toMatchObject({
+        uploadId: 'upload-1',
+      });
+      await expect(
+        service.startDirectUpload('x', { ...info, size: Number.MAX_SAFE_INTEGER + 1 }),
+      ).rejects.toThrow('File too large');
+    });
+
+    it('fora da allowlist é recusado, a não ser com skipMimeValidation', async () => {
+      await expect(
+        service.startDirectUpload('x', { originalname: 'a.mov', mimetype: 'video/quicktime', size: MIB }),
+      ).rejects.toThrow('Invalid file type');
+
+      await expect(
+        service.startDirectUpload('x', {
+          originalname: 'a.mov',
+          mimetype: 'video/quicktime',
+          size: MIB,
+          skipMimeValidation: true,
+        }),
+      ).resolves.toMatchObject({ uploadId: 'upload-1' });
+    });
+
+    it('acima de 2 GB passa (file.size é BIGINT); acima do number exato é recusado', async () => {
+      settingValues['storage-max-size'] = String(10 * 1024 * MIB);
+      const info = { originalname: 'a.mp4', mimetype: 'video/mp4' };
+
+      await expect(service.startDirectUpload('x', { ...info, size: 3 * 1024 * MIB })).resolves.toMatchObject({
+        uploadId: 'upload-1',
+      });
+      await expect(
+        service.startDirectUpload('x', { ...info, size: Number.MAX_SAFE_INTEGER + 1, skipSizeValidation: true }),
+      ).rejects.toThrow('File too large');
+    });
+
+    it('storage sem upload direto é 409', async () => {
+      delete provider.createMultipartUpload;
+      await expect(
+        service.startDirectUpload('x', { originalname: 'a.mp4', mimetype: 'video/mp4', size: MIB }),
+      ).rejects.toBeInstanceOf(ConflictException);
+    });
+  });
+
+  describe('signDirectUploadParts / abortDirectUpload', () => {
+    it('assina as partes pedidas, sem repetir', async () => {
+      const parts = await service.signDirectUploadParts('k', 'u', [1, 2, 2], 3600);
+      expect(provider.signUploadParts).toHaveBeenCalledWith('k', 'u', [1, 2], 3600);
+      expect(parts).toHaveLength(2);
+    });
+
+    it('número de parte inválido é 400', async () => {
+      await expect(service.signDirectUploadParts('k', 'u', [0])).rejects.toBeInstanceOf(
+        BadRequestException,
+      );
+      await expect(service.signDirectUploadParts('k', 'u', [9001])).rejects.toBeInstanceOf(
+        BadRequestException,
+      );
+    });
+
+    it('abort de upload que já não existe não é erro', async () => {
+      provider.abortMultipartUpload.mockRejectedValueOnce(
+        Object.assign(new Error('gone'), { name: 'NoSuchUpload' }),
+      );
+      await expect(service.abortDirectUpload('k', 'u')).resolves.toBeUndefined();
+    });
+  });
+
+  describe('completeDirectUpload', () => {
+    it('fecha, confere e grava a linha file como o uploadFromPath', async () => {
+      const file: any = await complete();
+
+      expect(provider.completeMultipartUpload).toHaveBeenCalledWith(
+        'social/brands/1/uuid-1.mp4',
+        'upload-1',
+        [{ partNumber: 1, etag: '"a"' }],
+      );
+      expect(deps.prisma.file.create).toHaveBeenCalledWith({
+        data: {
+          filename: 'demo.mp4',
+          path: 'uuid-1.mp4',
+          provider_id: 3,
+          location: 'social/brands/1',
+          mimetype_id: 7,
+          size: 100 * MIB,
+          is_private: true,
+          created_by_user_id: 9,
+        },
+      });
+      expect(file.id).toBe(42);
+      expect(provider.delete).not.toHaveBeenCalled();
+    });
+
+    it('tamanho gravado diferente do declarado: 400 e objeto apagado', async () => {
+      provider.metaData.mockResolvedValueOnce({ ContentLength: 5 });
+      await expect(complete()).rejects.toThrow('differs from the declared size');
+      expect(provider.delete).toHaveBeenCalledWith('social/brands/1/uuid-1.mp4');
+      expect(deps.prisma.file.create).not.toHaveBeenCalled();
+    });
+
+    it('acima da storage-max-size: 400 e objeto apagado', async () => {
+      settingValues['storage-max-size'] = String(10 * MIB);
+      await expect(complete()).rejects.toThrow('File too large');
+      expect(provider.delete).toHaveBeenCalled();
+      expect(deps.prisma.file.create).not.toHaveBeenCalled();
+    });
+
+    it('acima da storage-max-size com skipSizeValidation: grava a linha', async () => {
+      settingValues['storage-max-size'] = String(10 * MIB);
+      await complete({ skipSizeValidation: true });
+      expect(provider.delete).not.toHaveBeenCalled();
+      expect(deps.prisma.file.create).toHaveBeenCalled();
+    });
+
+    it('fora da allowlist: 400 e objeto apagado', async () => {
+      await expect(complete({ mimetype: 'application/zip' })).rejects.toThrow('Invalid file type');
+      expect(provider.delete).toHaveBeenCalled();
+    });
+
+    it('verifyHead recusa: objeto apagado e o erro sobe como veio', async () => {
+      const check = jest.fn(() => {
+        throw new BadRequestException('not a video');
+      });
+      await expect(complete({ verifyHead: { bytes: 32, check } })).rejects.toThrow('not a video');
+      expect(provider.readHead).toHaveBeenCalledWith('social/brands/1/uuid-1.mp4', 32);
+      expect(provider.delete).toHaveBeenCalled();
+      expect(deps.prisma.file.create).not.toHaveBeenCalled();
+    });
+
+    it('verifyHead que devolve o tipo real: é ele que vai para a linha', async () => {
+      const getMimeType = service.getMimeType as any;
+      await complete({
+        mimetype: 'video/mp4',
+        skipMimeValidation: true,
+        verifyHead: { bytes: 32, check: () => 'video/quicktime' },
+      });
+      expect(getMimeType).toHaveBeenCalledWith('video/quicktime');
+    });
+
+    it('partes que o storage não monta (4xx): aborta e responde 400', async () => {
+      provider.completeMultipartUpload.mockRejectedValueOnce(
+        Object.assign(new Error('InvalidPart'), { $metadata: { httpStatusCode: 400 } }),
+      );
+      await expect(complete()).rejects.toThrow('could not be assembled');
+      expect(provider.abortMultipartUpload).toHaveBeenCalledWith(
+        'social/brands/1/uuid-1.mp4',
+        'upload-1',
+      );
+    });
+
+    it('chave fora do destination é 400, sem tocar no storage', async () => {
+      await expect(complete({ key: 'outra/pasta/uuid-1.mp4' })).rejects.toThrow(
+        'Invalid direct upload key',
+      );
+      await expect(complete({ key: 'social/brands/1/sub/uuid-1.mp4' })).rejects.toThrow(
+        'Invalid direct upload key',
+      );
+      expect(provider.completeMultipartUpload).not.toHaveBeenCalled();
+    });
+
+    it('sem partes é 400', async () => {
+      await expect(complete({ parts: [] })).rejects.toThrow('Invalid upload parts');
+    });
+  });
+
+  describe('token', () => {
+    it('ida e volta com as claims', () => {
+      const token = service.signDirectUploadToken({ key: 'k', brandId: 1 }, 60);
+      expect(service.readDirectUploadToken(token)).toMatchObject({ key: 'k', brandId: 1 });
+    });
+
+    it('claims adulteradas (sem reassinar) são 400', () => {
+      const token = service.signDirectUploadToken({ key: 'k', size: 10 }, 60);
+      const [header, payload, signature] = token.split('.');
+      const claims = JSON.parse(Buffer.from(payload, 'base64url').toString());
+      const forged = Buffer.from(JSON.stringify({ ...claims, size: 1 })).toString('base64url');
+
+      expect(() => service.readDirectUploadToken(`${header}.${forged}.${signature}`)).toThrow(
+        'Invalid or expired upload token',
+      );
+    });
+
+    it('assinado com outro segredo é 400', () => {
+      const token = new JwtService().sign({ t: 'file-direct-upload' }, { secret: 'other' });
+      expect(() => service.readDirectUploadToken(token)).toThrow('Invalid or expired upload token');
+    });
+
+    it('JWT válido de outro tipo (ex.: download) é 400', () => {
+      const token = service.createDownloadToken('a/b.mp4', 60);
+      expect(() => service.readDirectUploadToken(token)).toThrow('not a direct upload token');
+    });
+  });
+});