@hed-hog/core 0.0.400 → 0.0.402

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');
+    });
+  });
+});

package/src/file/file.service.spec.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
-import { NotFoundException } from '@nestjs/common';
+import { NotFoundException, ServiceUnavailableException } from '@nestjs/common';
 import { FileService } from './file.service';
 import { ProviderFactory } from './provider/provider.factory';
 
@@ -274,6 +274,80 @@ describe('FileService — arquivo privado nas rotas por id', () => {
   });
 });
 
+/**
+ * Um 503 do Spaces com corpo que não é XML estourava no parse do SDK
+ * (`char 'u' is not expected`) e virava 500 na rota de segmento HLS. O SDK ainda
+ * carimba o status em `$metadata`, e é por ele que a falha vira 503 passageiro.
+ */
+describe('FileService — falha do storage na leitura', () => {
+  const buildService = (readError: unknown, size: number | null = 1024) => {
+    const prisma = {
+      file: {
+        findUnique: jest.fn().mockResolvedValue({
+          id: 9,
+          filename: 'seg037.ts',
+          location: 'lms/lessons/hls/2274/stream_0',
+          path: 'lms/lessons/hls/2274/stream_0/abc.ts',
+          size,
+          file_mimetype: { name: 'video/MP2T' },
+        } as never),
+      },
+    };
+    const service = new FileService(prisma as any, {} as any, {} as any, {} as any, {} as any);
+    const provider = {
+      metaData: jest.fn().mockResolvedValue({ ContentLength: 1024 } as never),
+      readStream: jest.fn().mockRejectedValue(readError as never),
+    };
+    jest.spyOn(service, 'getProvider').mockResolvedValue(provider as never);
+    return { service, provider };
+  };
+
+  afterEach(() => jest.restoreAllMocks());
+
+  it('503 do storage com corpo ilegível vira ServiceUnavailable com code STORAGE_UNAVAILABLE', async () => {
+    const sdkError = Object.assign(new Error("char 'u' is not expected.:1:1"), {
+      $metadata: { httpStatusCode: 503 },
+    });
+    const { service } = buildService(sdkError);
+
+    const erro: any = await service.openReadStreamById(9).catch((e) => e);
+
+    expect(erro).toBeInstanceOf(ServiceUnavailableException);
+    expect(erro.getResponse()).toMatchObject({ code: 'STORAGE_UNAVAILABLE' });
+    expect(erro.cause).toBe(sdkError);
+  });
+
+  it('throttle (SlowDown) também é indisponibilidade, inclusive na leitura por faixa', async () => {
+    const { service } = buildService(Object.assign(new Error('Slow down'), { name: 'SlowDown' }));
+
+    await expect(service.openReadStreamWithRange(9, 0, 99)).rejects.toBeInstanceOf(
+      ServiceUnavailableException,
+    );
+  });
+
+  it('NoSuchKey continua 404', async () => {
+    const { service } = buildService(Object.assign(new Error('missing'), { name: 'NoSuchKey' }));
+
+    await expect(service.openReadStreamById(9)).rejects.toBeInstanceOf(NotFoundException);
+  });
+
+  it('erro sem status de storage é repassado como veio', async () => {
+    const original = new Error('boom');
+    const { service } = buildService(original);
+
+    await expect(service.openReadStreamById(9)).rejects.toBe(original);
+  });
+
+  it('não faz HEAD no storage quando o tamanho já está na tabela', async () => {
+    const { service, provider } = buildService(null);
+    provider.readStream.mockResolvedValue({} as never);
+
+    await service.openReadStreamById(9);
+
+    expect(provider.metaData).not.toHaveBeenCalled();
+  });
+});
+
 /**
  * A varredura de reotimização do acervo passa em todo arquivo, e recomprimir WebP sobre
  * WebP sempre devolve alguns bytes a menos. Sem um ganho mínimo, cada passada trocaria o
@@ -367,3 +441,96 @@ describe('FileService.reoptimizeFile — ganho mínimo', () => {
     expect(result.mimetypeChanged).toBe(true);
   });
 });
+
+/**
+ * O Instagram recusa WebP, e toda image/* que passa pela otimizacao vira WebP. Quem
+ * entrega o arquivo a um consumidor externo pede os bytes intactos.
+ */
+describe('FileService — skipImageOptimization', () => {
+  const makeService = () => {
+    const deps: any = {
+      prisma: { file: { create: jest.fn().mockImplementation((args: any) => Promise.resolve(args.data)) } },
+      pagination: {},
+      setting: {},
+      jwt: {},
+      imageOptimization: {
+        optimizeBuffer: jest.fn().mockResolvedValue({
+          buffer: Buffer.from('webp'),
+          mimetype: 'image/webp',
+          originalname: 'foto.webp',
+        } as never),
+      },
+    };
+    const service = new FileService(
+      deps.prisma,
+      deps.pagination,
+      deps.setting,
+      deps.jwt,
+      deps.imageOptimization,
+    );
+    const provider = {
+      upload: jest.fn().mockResolvedValue('social/foto.jpg' as never),
+      uploadFromPath: jest.fn().mockResolvedValue('social/foto.jpg' as never),
+    };
+    jest.spyOn(service as any, 'getProvider').mockResolvedValue(provider as never);
+    jest.spyOn(service as any, 'getMimeType').mockResolvedValue(7 as never);
+    return { service, deps, provider };
+  };
+
+  it('upload grava a imagem sem otimizar quando o chamador pede', async () => {
+    const { service, deps, provider } = makeService();
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]);
+
+    const file: any = await service.upload(
+      'social/brands/1',
+      { buffer: jpeg, mimetype: 'image/jpeg', originalname: 'foto.jpg', size: jpeg.length } as any,
+      undefined,
+      { skipMimeValidation: true, skipSizeValidation: true, skipImageOptimization: true },
+    );
+
+    expect(deps.imageOptimization.optimizeBuffer).not.toHaveBeenCalled();
+    const sent = (provider.upload.mock.calls[0] as any[])[1];
+    expect(sent.mimetype).toBe('image/jpeg');
+    expect(Buffer.compare(sent.buffer, jpeg)).toBe(0);
+    expect(file.size).toBe(jpeg.length);
+  });
+
+  it('upload sem a opcao continua otimizando', async () => {
+    const { service, deps } = makeService();
+    const jpeg = Buffer.from([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]);
+
+    await service.upload(
+      'social/brands/1',
+      { buffer: jpeg, mimetype: 'image/jpeg', originalname: 'foto.jpg', size: jpeg.length } as any,
+      undefined,
+      { skipMimeValidation: true, skipSizeValidation: true },
+    );
+
+    expect(deps.imageOptimization.optimizeBuffer).toHaveBeenCalledTimes(1);
+  });
+
+  it('uploadFromPath manda a imagem pelo caminho de streaming, intacta', async () => {
+    const { service, deps, provider } = makeService();
+    const os = await import('node:os');
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const tmp = path.join(os.tmpdir(), `skip-opt-${process.pid}.jpg`);
+    await fs.writeFile(tmp, Buffer.from([0xff, 0xd8, 0xff, 0xe0, 1, 2, 3]));
+
+    try {
+      await service.uploadFromPath('social/brands/1', tmp, {
+        mimetype: 'image/jpeg',
+        originalname: 'foto.jpg',
+        skipMimeValidation: true,
+        skipSizeValidation: true,
+        skipImageOptimization: true,
+      });
+    } finally {
+      await fs.rm(tmp, { force: true });
+    }
+
+    expect(deps.imageOptimization.optimizeBuffer).not.toHaveBeenCalled();
+    expect(provider.uploadFromPath).toHaveBeenCalledTimes(1);
+    expect(provider.upload).not.toHaveBeenCalled();
+  });
+});