@hed-hog/core 0.0.398 → 0.0.400

package/src/file/mcp-file-source.service.spec.ts

@@ -0,0 +1,473 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+jest.mock('@hed-hog/api-prisma', () => ({
+  __esModule: true,
+  PrismaService: class {},
+  Prisma: {},
+}));
+
+jest.mock('./remote-fetch.util', () => ({
+  __esModule: true,
+  fetchRemoteFile: jest.fn(),
+  assertFetchableUrl: jest.fn(),
+  describeBlockedAddress: jest.fn(),
+}));
+
+import { McpFileSourceService } from './mcp-file-source.service';
+import { fetchRemoteFile } from './remote-fetch.util';
+
+const PDF_BYTES = Buffer.concat([Buffer.from('%PDF-1.7'), Buffer.alloc(64)]);
+const PNG_BYTES = Buffer.concat([
+  Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+  Buffer.alloc(64),
+]);
+const PDF_BASE64 = PDF_BYTES.toString('base64');
+const MAX_BYTES = 10485760;
+
+const CALLER = 7;
+const OTHER_USER = 99;
+
+type Overrides = {
+  acceptMimetypes?: boolean;
+  maxBytes?: number;
+  allowedHosts?: string;
+};
+
+const makeService = (overrides: Overrides = {}) => {
+  const audit: any[] = [];
+
+  const prisma: any = {
+    audit_log: {
+      create: jest.fn(async ({ data }: any) => {
+        audit.push(data);
+        return data;
+      }),
+    },
+  };
+
+  const files: Record<number, any> = {
+    // Do próprio chamador.
+    10: {
+      id: 10,
+      filename: 'nota.pdf',
+      size: 120,
+      mimetype_id: 1,
+      created_by_user_id: CALLER,
+    },
+    // De outro usuário.
+    20: {
+      id: 20,
+      filename: 'alheio.pdf',
+      size: 120,
+      mimetype_id: 1,
+      created_by_user_id: OTHER_USER,
+    },
+    // Anterior à coluna de dono.
+    30: { id: 30, filename: 'legado.pdf', size: 120, mimetype_id: 1, created_by_user_id: null },
+  };
+
+  const fileService: any = {
+    acceptMimetypes: jest.fn(async () => overrides.acceptMimetypes ?? true),
+    mimetypeNameById: jest.fn(async () => 'application/pdf'),
+    bufferById: jest.fn(async () => PDF_BYTES),
+    upload: jest.fn(async (destination: string, file: any, _r: any, opts: any) => ({
+      id: 555,
+      filename: file.originalname,
+      size: file.size,
+      mimetype_id: 1,
+      location: destination,
+      created_by_user_id: opts?.createdByUserId ?? null,
+      is_private: opts?.isPrivate ?? false,
+    })),
+    // Espelha a regra real: dono ou admin; aqui ninguém é admin.
+    assertFileUsable: jest.fn(async (fileId: number, userId: number) => {
+      const file = files[fileId];
+      if (!file) {
+        throw Object.assign(new Error(`File not found: ${fileId}`), { status: 404 });
+      }
+      if (file.created_by_user_id !== userId) {
+        throw Object.assign(new Error(`File ${fileId} belongs to another user`), {
+          status: 403,
+        });
+      }
+      return file;
+    }),
+  };
+
+  const uploadTickets: any = {
+    complete: jest.fn(async () => ({
+      id: 777,
+      filename: 'do-ticket.pdf',
+      size: 200,
+      mimetype_id: 1,
+    })),
+  };
+
+  const settingService: any = {
+    getSettingValues: jest.fn(async (keys: string[]) => {
+      const values: Record<string, any> = {
+        'storage-max-size': overrides.maxBytes ?? MAX_BYTES,
+        'mcp-file-url-allowed-hosts': overrides.allowedHosts ?? '',
+      };
+      return Object.fromEntries(keys.map((key) => [key, values[key]]));
+    }),
+  };
+
+  const service = new McpFileSourceService(
+    prisma,
+    fileService,
+    uploadTickets,
+    settingService,
+  );
+
+  return { service, prisma, fileService, uploadTickets, audit };
+};
+
+const ctx = { userId: CALLER, toolName: 'finance.titles.attachments.add' };
+const opts = { destination: 'finance/titles/1' };
+
+beforeEach(() => {
+  (fetchRemoteFile as any).mockReset();
+});
+
+describe('detectModality: exatamente uma origem', () => {
+  it('recusa quando não vem nenhuma', async () => {
+    const { service } = makeService();
+    await expect(service.resolveFileId({}, ctx, opts)).rejects.toThrow(
+      /file source is required/,
+    );
+  });
+
+  it('recusa quando vêm duas, nomeando quais', async () => {
+    const { service } = makeService();
+    // Aceitar as duas e eleger uma "melhor" faria o resultado depender de uma
+    // precedência que ninguém leu.
+    await expect(
+      service.resolveFileId({ fileId: 10, fileBase64: PDF_BASE64 }, ctx, opts),
+    ).rejects.toThrow(/exactly one file source, got 2: fileId, fileBase64/);
+  });
+
+  it('deixa passar sem origem quando a tool marca required: false', async () => {
+    const { service } = makeService();
+    await expect(
+      service.resolveFileId({}, ctx, { ...opts, required: false }),
+    ).resolves.toBeNull();
+  });
+
+  it('ignora string vazia, que não é uma origem', async () => {
+    const { service } = makeService();
+    await expect(
+      service.resolveFileId({ fileId: 10, fileUrl: '' }, ctx, opts),
+    ).resolves.toMatchObject({ modality: 'fileId' });
+  });
+});
+
+describe('modalidade fileId', () => {
+  it('usa o arquivo do próprio usuário sem regravar nada', async () => {
+    const { service, fileService } = makeService();
+
+    const result = await service.resolveFileId({ fileId: 10 }, ctx, opts);
+
+    expect(result).toMatchObject({ fileId: 10, modality: 'fileId' });
+    // O ponto da modalidade: o arquivo já está lá, não há segundo upload.
+    expect(fileService.upload).not.toHaveBeenCalled();
+  });
+
+  it('recusa o arquivo de outro usuário', async () => {
+    const { service } = makeService();
+    await expect(service.resolveFileId({ fileId: 20 }, ctx, opts)).rejects.toThrow(
+      /belongs to another user/,
+    );
+  });
+
+  it('recusa arquivo inexistente', async () => {
+    const { service } = makeService();
+    await expect(service.resolveFileId({ fileId: 404 }, ctx, opts)).rejects.toThrow(
+      /File not found/,
+    );
+  });
+
+  it('recusa arquivo legado, sem dono registrado', async () => {
+    const { service } = makeService();
+    await expect(service.resolveFileId({ fileId: 30 }, ctx, opts)).rejects.toThrow();
+  });
+});
+
+describe('modalidade uploadId', () => {
+  it('finaliza o ticket e devolve o arquivo dele', async () => {
+    const { service, uploadTickets, fileService } = makeService();
+
+    const result = await service.resolveFileId({ uploadId: 42 }, ctx, opts);
+
+    expect(uploadTickets.complete).toHaveBeenCalledWith(42, CALLER);
+    expect(result).toMatchObject({ fileId: 777, modality: 'uploadId' });
+    expect(fileService.upload).not.toHaveBeenCalled();
+  });
+});
+
+describe('modalidade fileBase64', () => {
+  it('grava o arquivo com o dono registrado', async () => {
+    const { service, fileService } = makeService();
+
+    const result = await service.resolveFileId(
+      { fileBase64: PDF_BASE64, fileName: 'nota.pdf', mimeType: 'application/pdf' },
+      ctx,
+      opts,
+    );
+
+    expect(result).toMatchObject({ fileId: 555, modality: 'fileBase64' });
+    expect(fileService.upload).toHaveBeenCalledWith(
+      'finance/titles/1',
+      expect.objectContaining({ originalname: 'nota.pdf' }),
+      undefined,
+      expect.objectContaining({ createdByUserId: CALLER }),
+    );
+  });
+
+  it('exige fileName e mimeType', async () => {
+    const { service } = makeService();
+    await expect(
+      service.resolveFileId({ fileBase64: PDF_BASE64 }, ctx, opts),
+    ).rejects.toThrow(/requires fileName and mimeType/);
+  });
+
+  it('recusa base64 inválido em vez de gravar bytes truncados', async () => {
+    const { service } = makeService();
+    // `Buffer.from(x, 'base64')` nunca reclama: lixo vira bytes em silêncio.
+    await expect(
+      service.resolveFileId(
+        { fileBase64: 'nao###base64###', fileName: 'x.pdf', mimeType: 'application/pdf' },
+        ctx,
+        opts,
+      ),
+    ).rejects.toThrow(/not valid base64/);
+  });
+
+  it('recusa conteúdo que contradiz o mimeType declarado', async () => {
+    const { service } = makeService();
+    await expect(
+      service.resolveFileId(
+        {
+          fileBase64: PNG_BYTES.toString('base64'),
+          fileName: 'nota.pdf',
+          mimeType: 'application/pdf',
+        },
+        ctx,
+        opts,
+      ),
+    ).rejects.toThrow(/but the content is image\/png/);
+  });
+});
+
+describe('modalidade fileUrl', () => {
+  const mockDownload = (buffer: Buffer, contentType = 'application/pdf') =>
+    (fetchRemoteFile as any).mockResolvedValue({
+      buffer,
+      contentType,
+      finalHost: 'exemplo.com',
+      finalUrl: 'https://exemplo.com/nota.pdf',
+    });
+
+  it('baixa, grava e registra o host de origem', async () => {
+    const { service, audit } = makeService();
+    mockDownload(PDF_BYTES);
+
+    const result = await service.resolveFileId(
+      { fileUrl: 'https://exemplo.com/nota.pdf' },
+      ctx,
+      opts,
+    );
+
+    expect(result).toMatchObject({ fileId: 555, modality: 'fileUrl' });
+    expect(JSON.parse(audit[0].after_data)).toMatchObject({
+      modality: 'fileUrl',
+      source_host: 'exemplo.com',
+    });
+  });
+
+  it('deriva o nome do arquivo da URL quando não vem declarado', async () => {
+    const { service, fileService } = makeService();
+    mockDownload(PDF_BYTES);
+
+    await service.resolveFileId({ fileUrl: 'https://exemplo.com/nota.pdf' }, ctx, opts);
+
+    expect(fileService.upload).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ originalname: 'nota.pdf' }),
+      undefined,
+      expect.anything(),
+    );
+  });
+
+  it('repassa a allowlist configurada para a guarda de SSRF', async () => {
+    const { service } = makeService({ allowedHosts: 'sharepoint.com, drive.google.com' });
+    mockDownload(PDF_BYTES);
+
+    await service.resolveFileId({ fileUrl: 'https://exemplo.com/a.pdf' }, ctx, opts);
+
+    expect(fetchRemoteFile).toHaveBeenCalledWith(
+      'https://exemplo.com/a.pdf',
+      expect.objectContaining({
+        allowedHosts: ['sharepoint.com', 'drive.google.com'],
+        maxBytes: MAX_BYTES,
+      }),
+    );
+  });
+
+  it('recusa conteúdo que contradiz o Content-Type recebido', async () => {
+    const { service } = makeService();
+    mockDownload(PNG_BYTES, 'application/pdf');
+
+    await expect(
+      service.resolveFileId({ fileUrl: 'https://exemplo.com/nota.pdf' }, ctx, opts),
+    ).rejects.toThrow(/but the content is image\/png/);
+  });
+});
+
+describe('validações que valem para toda modalidade', () => {
+  const sources = [
+    [
+      'fileBase64',
+      { fileBase64: PDF_BASE64, fileName: 'nota.pdf', mimeType: 'application/pdf' },
+    ],
+    ['fileUrl', { fileUrl: 'https://exemplo.com/nota.pdf' }],
+  ] as const;
+
+  it.each(sources)(
+    'aplica storage-accept-mimetype em %s',
+    async (_label, args) => {
+      // O teste que garante que nenhum caminho novo escapou da allowlist.
+      const { service } = makeService({ acceptMimetypes: false });
+      (fetchRemoteFile as any).mockResolvedValue({
+        buffer: PDF_BYTES,
+        contentType: 'application/pdf',
+        finalHost: 'exemplo.com',
+        finalUrl: 'https://exemplo.com/nota.pdf',
+      });
+
+      await expect(service.resolveFileId(args as any, ctx, opts)).rejects.toThrow(
+        /Invalid file type/,
+      );
+    },
+  );
+
+  it.each(sources)('aplica storage-max-size em %s', async (_label, args) => {
+    const { service } = makeService({ maxBytes: 10 });
+    (fetchRemoteFile as any).mockResolvedValue({
+      buffer: PDF_BYTES,
+      contentType: 'application/pdf',
+      finalHost: 'exemplo.com',
+      finalUrl: 'https://exemplo.com/nota.pdf',
+    });
+
+    await expect(service.resolveFileId(args as any, ctx, opts)).rejects.toThrow(
+      /File too large/,
+    );
+  });
+
+  it('confere o sha256 quando informado, e aceita quando bate', async () => {
+    const { service } = makeService();
+    const correct = require('crypto')
+      .createHash('sha256')
+      .update(PDF_BYTES)
+      .digest('hex');
+
+    await expect(
+      service.resolveFileId(
+        {
+          fileBase64: PDF_BASE64,
+          fileName: 'nota.pdf',
+          mimeType: 'application/pdf',
+          sha256: correct,
+        },
+        ctx,
+        opts,
+      ),
+    ).resolves.toMatchObject({ fileId: 555 });
+
+    await expect(
+      service.resolveFileId(
+        {
+          fileBase64: PDF_BASE64,
+          fileName: 'nota.pdf',
+          mimeType: 'application/pdf',
+          sha256: 'f'.repeat(64),
+        },
+        ctx,
+        opts,
+      ),
+    ).rejects.toThrow(/sha256 mismatch/);
+  });
+});
+
+describe('auditoria', () => {
+  it.each([
+    ['fileId', { fileId: 10 }, 'fileId'],
+    ['uploadId', { uploadId: 42 }, 'uploadId'],
+    [
+      'fileBase64',
+      { fileBase64: PDF_BASE64, fileName: 'n.pdf', mimeType: 'application/pdf' },
+      'fileBase64',
+    ],
+  ])('registra MCP_FILE_INGEST com a modalidade %s', async (_label, args, expected) => {
+    const { service, audit } = makeService();
+
+    await service.resolveFileId(args as any, ctx, opts);
+
+    expect(audit).toHaveLength(1);
+    expect(audit[0]).toMatchObject({
+      action: 'MCP_FILE_INGEST',
+      entity_table: 'file',
+      actor_user_id: CALLER,
+    });
+    expect(JSON.parse(audit[0].after_data)).toMatchObject({
+      modality: expected,
+      tool: 'finance.titles.attachments.add',
+    });
+  });
+
+  it('não derruba o anexo quando a auditoria falha', async () => {
+    // Trocar um problema de observabilidade por um de funcionamento seria pior.
+    const { service, prisma } = makeService();
+    prisma.audit_log.create.mockRejectedValue(new Error('banco fora'));
+
+    await expect(service.resolveFileId({ fileId: 10 }, ctx, opts)).resolves.toMatchObject(
+      { fileId: 10 },
+    );
+  });
+});
+
+describe('resolveMulterFile', () => {
+  it('materializa os bytes de um fileId sem gravar nada de novo', async () => {
+    const { service, fileService } = makeService();
+
+    const result = await service.resolveMulterFile({ fileId: 10 }, ctx, {});
+
+    expect(result.file.buffer).toEqual(PDF_BYTES);
+    expect(result).toMatchObject({ modality: 'fileId', fileId: 10 });
+    expect(fileService.bufferById).toHaveBeenCalledWith(10, MAX_BYTES);
+    expect(fileService.upload).not.toHaveBeenCalled();
+  });
+
+  it('não persiste o arquivo quando ele veio inline', async () => {
+    // O extrato é lido e descartado: gravar cada importação encheria o acervo.
+    const { service, fileService } = makeService();
+
+    const result = await service.resolveMulterFile(
+      { fileBase64: PDF_BASE64, fileName: 'extrato.pdf', mimeType: 'application/pdf' },
+      ctx,
+      {},
+    );
+
+    expect(result.file.originalname).toBe('extrato.pdf');
+    expect(result.fileId).toBeUndefined();
+    expect(fileService.upload).not.toHaveBeenCalled();
+  });
+
+  it('continua recusando arquivo de outro usuário', async () => {
+    const { service } = makeService();
+    await expect(service.resolveMulterFile({ fileId: 20 }, ctx, {})).rejects.toThrow(
+      /belongs to another user/,
+    );
+  });
+});