pdf: add new feature

Signed-off-by: Rodrigo Bertoldo de Sousa Martins <rodrigo.sousa.577@gmail.com>

.env.pdf.example

@@ -0,0 +1,26 @@
+# Configurações de Manipulação de PDF
+
+# Tamanho máximo de arquivo em MB
+PDF_MAX_FILE_SIZE=100
+
+# Número máximo de arquivos por operação
+PDF_MAX_FILES_COMPRESS=10
+PDF_MAX_FILES_MERGE=50
+PDF_MAX_FILES_IMAGES_TO_PDF=100
+
+# Tempo de retenção de arquivos processados em horas
+PDF_FILES_RETENTION_HOURS=24
+
+# Qualidade padrão para compressão (50-100)
+PDF_DEFAULT_QUALITY=95
+
+# DPI padrão para conversão de imagens (150-600)
+PDF_DEFAULT_DPI=300
+
+# Idioma padrão para OCR (por, eng, spa)
+PDF_DEFAULT_OCR_LANGUAGE=por
+
+# Diretórios de armazenamento (relativos ao root do projeto)
+PDF_TEMP_DIR=storage/temp/pdf-ops
+PDF_OUTPUT_DIR=storage/pdf-output
+PDF_UPLOAD_DIR=storage/temp/uploads

backend/app.ts

@@ -5,6 +5,7 @@ import usuariosRoutes from "./routes/usuarios";
 import clientesRoutes from "./routes/clientes";
 import processosRoutes from "./routes/processos";
 import audienciasRoutes from "./routes/audiencias";
+import pdfRoutes from "./routes/pdf";
 
 const app = express();
 const prisma = new PrismaClient();
@@ -16,6 +17,7 @@ app.use("/api/usuarios", usuariosRoutes);
 app.use("/api/clientes", clientesRoutes);
 app.use("/api/processos", processosRoutes);
 app.use("/api/audiencias", audienciasRoutes);
+app.use("/api/pdf", pdfRoutes);
 
 app.get("/", (req, res) => {
   res.json({ message: "API is running" });

backend/controllers/pdfController.ts

@@ -0,0 +1,798 @@
+import { Request, Response } from 'express';
+import { PrismaClient } from '@prisma/client';
+import { PDFService } from '../services/pdfService';
+import multer from 'multer';
+import path from 'path';
+import fs from 'fs/promises';
+import { v4 as uuidv4 } from 'uuid';
+
+const prisma = new PrismaClient();
+
+// Configuração do multer para upload de arquivos
+const storage = multer.diskStorage({
+  destination: async (req, file, cb) => {
+    const uploadDir = path.join(process.cwd(), 'storage', 'temp', 'uploads');
+    await fs.mkdir(uploadDir, { recursive: true });
+    cb(null, uploadDir);
+  },
+  filename: (req, file, cb) => {
+    const uniqueName = `${uuidv4()}${path.extname(file.originalname)}`;
+    cb(null, uniqueName);
+  },
+});
+
+const upload = multer({
+  storage,
+  limits: {
+    fileSize: 100 * 1024 * 1024, // 100MB
+  },
+  fileFilter: (req, file, cb) => {
+    const allowedMimes = [
+      'application/pdf',
+      'image/png',
+      'image/jpeg',
+      'image/jpg',
+      'image/webp',
+    ];
+
+    if (allowedMimes.includes(file.mimetype)) {
+      cb(null, true);
+    } else {
+      cb(new Error('Tipo de arquivo não permitido. Use PDF ou imagens (PNG, JPG, WEBP).'));
+    }
+  },
+});
+
+export const uploadMiddleware = upload;
+
+/**
+ * Controller para operações de PDF
+ */
+export class PDFController {
+  /**
+   * Comprime um ou mais PDFs
+   */
+  static async compress(req: Request, res: Response): Promise<void> {
+    const startTime = Date.now();
+    let operacaoId: string | null = null;
+
+    try {
+      const files = req.files as Express.Multer.File[];
+      const userId = (req as any).user?.id;
+
+      if (!files || files.length === 0) {
+        res.status(400).json({ error: 'Nenhum arquivo enviado' });
+        return;
+      }
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const quality = req.body.quality ? parseInt(req.body.quality) : 95;
+      const maxSizeMB = req.body.maxSizeMB ? parseInt(req.body.maxSizeMB) : undefined;
+
+      const arquivosOriginais: string[] = [];
+      const arquivosResultado: string[] = [];
+      let tamanhoOriginal = BigInt(0);
+      let tamanhoResultado = BigInt(0);
+
+      // Cria registro da operação no banco
+      const operacao = await prisma.operacaoPDF.create({
+        data: {
+          tipoOperacao: 'COMPRIMIR',
+          status: 'PROCESSANDO',
+          usuarioId: userId,
+          arquivosOriginais: [],
+          arquivosResultado: [],
+          tamanhoOriginal: BigInt(0),
+          parametros: { quality, maxSizeMB },
+        },
+      });
+
+      operacaoId = operacao.id;
+
+      // Processa cada arquivo
+      const results = [];
+      for (const file of files) {
+        arquivosOriginais.push(file.path);
+        tamanhoOriginal += BigInt(file.size);
+
+        const result = await PDFService.compressPDF(file.path, undefined, {
+          quality,
+          maxSizeMB,
+        });
+
+        arquivosResultado.push(result.outputPath);
+        tamanhoResultado += BigInt(result.compressedSize);
+
+        results.push({
+          originalName: file.originalname,
+          originalSize: result.originalSize,
+          compressedSize: result.compressedSize,
+          reduction: result.reduction,
+          outputPath: result.outputPath,
+        });
+
+        // Remove o arquivo original
+        await fs.unlink(file.path).catch(() => {});
+      }
+
+      const tempoProcessamento = Date.now() - startTime;
+
+      // Atualiza a operação no banco
+      await prisma.operacaoPDF.update({
+        where: { id: operacaoId },
+        data: {
+          status: 'CONCLUIDO',
+          arquivosOriginais,
+          arquivosResultado,
+          tamanhoOriginal,
+          tamanhoResultado,
+          tempoProcessamento,
+        },
+      });
+
+      res.json({
+        success: true,
+        operacaoId,
+        results,
+        totalOriginalSize: Number(tamanhoOriginal),
+        totalCompressedSize: Number(tamanhoResultado),
+        totalReduction: ((Number(tamanhoOriginal) - Number(tamanhoResultado)) / Number(tamanhoOriginal)) * 100,
+        processingTime: tempoProcessamento,
+      });
+    } catch (error) {
+      console.error('Erro ao comprimir PDF:', error);
+
+      if (operacaoId) {
+        await prisma.operacaoPDF.update({
+          where: { id: operacaoId },
+          data: {
+            status: 'ERRO',
+            mensagemErro: error instanceof Error ? error.message : 'Erro desconhecido',
+            tempoProcessamento: Date.now() - startTime,
+          },
+        });
+      }
+
+      res.status(500).json({
+        error: 'Falha ao comprimir PDF',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Divide um PDF
+   */
+  static async split(req: Request, res: Response): Promise<void> {
+    const startTime = Date.now();
+    let operacaoId: string | null = null;
+
+    try {
+      const file = (req.files as Express.Multer.File[])?.[0];
+      const userId = (req as any).user?.id;
+
+      if (!file) {
+        res.status(400).json({ error: 'Nenhum arquivo enviado' });
+        return;
+      }
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const { splitType, pages, ranges, chunkSize } = req.body;
+
+      if (!splitType) {
+        res.status(400).json({ error: 'Tipo de divisão não especificado' });
+        return;
+      }
+
+      const options: any = { splitType };
+
+      if (splitType === 'pages' && pages) {
+        options.pages = JSON.parse(pages);
+      } else if (splitType === 'range' && ranges) {
+        options.ranges = JSON.parse(ranges);
+      } else if (splitType === 'chunks' && chunkSize) {
+        options.chunkSize = parseInt(chunkSize);
+      }
+
+      // Cria registro da operação
+      const operacao = await prisma.operacaoPDF.create({
+        data: {
+          tipoOperacao: 'DIVIDIR',
+          status: 'PROCESSANDO',
+          usuarioId: userId,
+          arquivosOriginais: [file.path],
+          arquivosResultado: [],
+          tamanhoOriginal: BigInt(file.size),
+          parametros: options,
+        },
+      });
+
+      operacaoId = operacao.id;
+
+      // Divide o PDF
+      const outputPaths = await PDFService.splitPDF(file.path, options);
+
+      // Calcula tamanho total dos arquivos resultantes
+      let tamanhoResultado = BigInt(0);
+      for (const outputPath of outputPaths) {
+        const stats = await fs.stat(outputPath);
+        tamanhoResultado += BigInt(stats.size);
+      }
+
+      const tempoProcessamento = Date.now() - startTime;
+
+      // Atualiza a operação
+      await prisma.operacaoPDF.update({
+        where: { id: operacaoId },
+        data: {
+          status: 'CONCLUIDO',
+          arquivosResultado: outputPaths,
+          tamanhoResultado,
+          tempoProcessamento,
+        },
+      });
+
+      // Remove o arquivo original
+      await fs.unlink(file.path).catch(() => {});
+
+      res.json({
+        success: true,
+        operacaoId,
+        filesCreated: outputPaths.length,
+        outputPaths,
+        processingTime: tempoProcessamento,
+      });
+    } catch (error) {
+      console.error('Erro ao dividir PDF:', error);
+
+      if (operacaoId) {
+        await prisma.operacaoPDF.update({
+          where: { id: operacaoId },
+          data: {
+            status: 'ERRO',
+            mensagemErro: error instanceof Error ? error.message : 'Erro desconhecido',
+            tempoProcessamento: Date.now() - startTime,
+          },
+        });
+      }
+
+      res.status(500).json({
+        error: 'Falha ao dividir PDF',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Mescla múltiplos PDFs
+   */
+  static async merge(req: Request, res: Response): Promise<void> {
+    const startTime = Date.now();
+    let operacaoId: string | null = null;
+
+    try {
+      const files = req.files as Express.Multer.File[];
+      const userId = (req as any).user?.id;
+
+      if (!files || files.length < 2) {
+        res.status(400).json({ error: 'São necessários pelo menos 2 arquivos para mesclar' });
+        return;
+      }
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const filePaths = files.map((f) => f.path);
+      let tamanhoOriginal = BigInt(0);
+
+      for (const file of files) {
+        tamanhoOriginal += BigInt(file.size);
+      }
+
+      // Cria registro da operação
+      const operacao = await prisma.operacaoPDF.create({
+        data: {
+          tipoOperacao: 'MESCLAR',
+          status: 'PROCESSANDO',
+          usuarioId: userId,
+          arquivosOriginais: filePaths,
+          arquivosResultado: [],
+          tamanhoOriginal,
+          parametros: { filesCount: files.length },
+        },
+      });
+
+      operacaoId = operacao.id;
+
+      // Mescla os PDFs
+      const outputPath = await PDFService.mergePDFs({
+        filePaths,
+        outputPath: path.join(process.cwd(), 'storage', 'pdf-output', `merged-${uuidv4()}.pdf`),
+      });
+
+      // Calcula tamanho do arquivo resultante
+      const stats = await fs.stat(outputPath);
+      const tamanhoResultado = BigInt(stats.size);
+
+      const tempoProcessamento = Date.now() - startTime;
+
+      // Atualiza a operação
+      await prisma.operacaoPDF.update({
+        where: { id: operacaoId },
+        data: {
+          status: 'CONCLUIDO',
+          arquivosResultado: [outputPath],
+          tamanhoResultado,
+          tempoProcessamento,
+        },
+      });
+
+      // Remove os arquivos originais
+      for (const filePath of filePaths) {
+        await fs.unlink(filePath).catch(() => {});
+      }
+
+      res.json({
+        success: true,
+        operacaoId,
+        outputPath,
+        originalSize: Number(tamanhoOriginal),
+        mergedSize: Number(tamanhoResultado),
+        processingTime: tempoProcessamento,
+      });
+    } catch (error) {
+      console.error('Erro ao mesclar PDFs:', error);
+
+      if (operacaoId) {
+        await prisma.operacaoPDF.update({
+          where: { id: operacaoId },
+          data: {
+            status: 'ERRO',
+            mensagemErro: error instanceof Error ? error.message : 'Erro desconhecido',
+            tempoProcessamento: Date.now() - startTime,
+          },
+        });
+      }
+
+      res.status(500).json({
+        error: 'Falha ao mesclar PDFs',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Converte PDF em imagens
+   */
+  static async pdfToImages(req: Request, res: Response): Promise<void> {
+    const startTime = Date.now();
+    let operacaoId: string | null = null;
+
+    try {
+      const file = (req.files as Express.Multer.File[])?.[0];
+      const userId = (req as any).user?.id;
+
+      if (!file) {
+        res.status(400).json({ error: 'Nenhum arquivo enviado' });
+        return;
+      }
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const format = req.body.format || 'png';
+      const quality = req.body.quality ? parseInt(req.body.quality) : 95;
+      const density = req.body.density ? parseInt(req.body.density) : 300;
+      const pages = req.body.pages ? JSON.parse(req.body.pages) : 'all';
+
+      // Cria registro da operação
+      const operacao = await prisma.operacaoPDF.create({
+        data: {
+          tipoOperacao: 'PDF_PARA_IMAGEM',
+          status: 'PROCESSANDO',
+          usuarioId: userId,
+          arquivosOriginais: [file.path],
+          arquivosResultado: [],
+          tamanhoOriginal: BigInt(file.size),
+          parametros: { format, quality, density, pages },
+        },
+      });
+
+      operacaoId = operacao.id;
+
+      // Converte para imagens
+      const outputPaths = await PDFService.pdfToImages(file.path, {
+        format,
+        quality,
+        density,
+        pages,
+      });
+
+      // Calcula tamanho total
+      let tamanhoResultado = BigInt(0);
+      for (const outputPath of outputPaths) {
+        const stats = await fs.stat(outputPath);
+        tamanhoResultado += BigInt(stats.size);
+      }
+
+      const tempoProcessamento = Date.now() - startTime;
+
+      // Atualiza a operação
+      await prisma.operacaoPDF.update({
+        where: { id: operacaoId },
+        data: {
+          status: 'CONCLUIDO',
+          arquivosResultado: outputPaths,
+          tamanhoResultado,
+          tempoProcessamento,
+        },
+      });
+
+      // Remove o arquivo original
+      await fs.unlink(file.path).catch(() => {});
+
+      res.json({
+        success: true,
+        operacaoId,
+        imagesCreated: outputPaths.length,
+        outputPaths,
+        processingTime: tempoProcessamento,
+      });
+    } catch (error) {
+      console.error('Erro ao converter PDF para imagens:', error);
+
+      if (operacaoId) {
+        await prisma.operacaoPDF.update({
+          where: { id: operacaoId },
+          data: {
+            status: 'ERRO',
+            mensagemErro: error instanceof Error ? error.message : 'Erro desconhecido',
+            tempoProcessamento: Date.now() - startTime,
+          },
+        });
+      }
+
+      res.status(500).json({
+        error: 'Falha ao converter PDF para imagens',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Converte imagens em PDF
+   */
+  static async imagesToPDF(req: Request, res: Response): Promise<void> {
+    const startTime = Date.now();
+    let operacaoId: string | null = null;
+
+    try {
+      const files = req.files as Express.Multer.File[];
+      const userId = (req as any).user?.id;
+
+      if (!files || files.length === 0) {
+        res.status(400).json({ error: 'Nenhuma imagem enviada' });
+        return;
+      }
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const imagePaths = files.map((f) => f.path);
+      let tamanhoOriginal = BigInt(0);
+
+      for (const file of files) {
+        tamanhoOriginal += BigInt(file.size);
+      }
+
+      const fitToPage = req.body.fitToPage === 'true';
+      const pageSize = req.body.pageSize ? JSON.parse(req.body.pageSize) : undefined;
+
+      // Cria registro da operação
+      const operacao = await prisma.operacaoPDF.create({
+        data: {
+          tipoOperacao: 'IMAGEM_PARA_PDF',
+          status: 'PROCESSANDO',
+          usuarioId: userId,
+          arquivosOriginais: imagePaths,
+          arquivosResultado: [],
+          tamanhoOriginal,
+          parametros: { fitToPage, pageSize, imagesCount: files.length },
+        },
+      });
+
+      operacaoId = operacao.id;
+
+      // Converte para PDF
+      const outputPath = await PDFService.imagesToPDF({
+        imagePaths,
+        outputPath: path.join(process.cwd(), 'storage', 'pdf-output', `images-to-pdf-${uuidv4()}.pdf`),
+        fitToPage,
+        pageSize,
+      });
+
+      // Calcula tamanho do arquivo resultante
+      const stats = await fs.stat(outputPath);
+      const tamanhoResultado = BigInt(stats.size);
+
+      const tempoProcessamento = Date.now() - startTime;
+
+      // Atualiza a operação
+      await prisma.operacaoPDF.update({
+        where: { id: operacaoId },
+        data: {
+          status: 'CONCLUIDO',
+          arquivosResultado: [outputPath],
+          tamanhoResultado,
+          tempoProcessamento,
+        },
+      });
+
+      // Remove os arquivos originais
+      for (const imagePath of imagePaths) {
+        await fs.unlink(imagePath).catch(() => {});
+      }
+
+      res.json({
+        success: true,
+        operacaoId,
+        outputPath,
+        imagesProcessed: files.length,
+        pdfSize: Number(tamanhoResultado),
+        processingTime: tempoProcessamento,
+      });
+    } catch (error) {
+      console.error('Erro ao converter imagens para PDF:', error);
+
+      if (operacaoId) {
+        await prisma.operacaoPDF.update({
+          where: { id: operacaoId },
+          data: {
+            status: 'ERRO',
+            mensagemErro: error instanceof Error ? error.message : 'Erro desconhecido',
+            tempoProcessamento: Date.now() - startTime,
+          },
+        });
+      }
+
+      res.status(500).json({
+        error: 'Falha ao converter imagens para PDF',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Realiza OCR em PDF
+   */
+  static async performOCR(req: Request, res: Response): Promise<void> {
+    const startTime = Date.now();
+    let operacaoId: string | null = null;
+
+    try {
+      const file = (req.files as Express.Multer.File[])?.[0];
+      const userId = (req as any).user?.id;
+
+      if (!file) {
+        res.status(400).json({ error: 'Nenhum arquivo enviado' });
+        return;
+      }
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const language = req.body.language || 'por';
+      const pages = req.body.pages ? JSON.parse(req.body.pages) : 'all';
+
+      // Cria registro da operação
+      const operacao = await prisma.operacaoPDF.create({
+        data: {
+          tipoOperacao: 'OCR',
+          status: 'PROCESSANDO',
+          usuarioId: userId,
+          arquivosOriginais: [file.path],
+          arquivosResultado: [],
+          tamanhoOriginal: BigInt(file.size),
+          parametros: { language, pages },
+        },
+      });
+
+      operacaoId = operacao.id;
+
+      // Realiza OCR
+      const ocrResult = await PDFService.performOCR(file.path, {
+        language,
+        pages,
+      });
+
+      const tempoProcessamento = Date.now() - startTime;
+
+      // Atualiza a operação
+      await prisma.operacaoPDF.update({
+        where: { id: operacaoId },
+        data: {
+          status: 'CONCLUIDO',
+          detalhesOCR: ocrResult as any,
+          tempoProcessamento,
+        },
+      });
+
+      // Remove o arquivo original
+      await fs.unlink(file.path).catch(() => {});
+
+      res.json({
+        success: true,
+        operacaoId,
+        result: ocrResult,
+        processingTime: tempoProcessamento,
+      });
+    } catch (error) {
+      console.error('Erro ao realizar OCR:', error);
+
+      if (operacaoId) {
+        await prisma.operacaoPDF.update({
+          where: { id: operacaoId },
+          data: {
+            status: 'ERRO',
+            mensagemErro: error instanceof Error ? error.message : 'Erro desconhecido',
+            tempoProcessamento: Date.now() - startTime,
+          },
+        });
+      }
+
+      res.status(500).json({
+        error: 'Falha ao realizar OCR',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Obtém informações sobre um PDF
+   */
+  static async getInfo(req: Request, res: Response): Promise<void> {
+    try {
+      const file = (req.files as Express.Multer.File[])?.[0];
+
+      if (!file) {
+        res.status(400).json({ error: 'Nenhum arquivo enviado' });
+        return;
+      }
+
+      const info = await PDFService.getPDFInfo(file.path);
+
+      // Remove o arquivo
+      await fs.unlink(file.path).catch(() => {});
+
+      res.json({
+        success: true,
+        info,
+      });
+    } catch (error) {
+      console.error('Erro ao obter informações do PDF:', error);
+      res.status(500).json({
+        error: 'Falha ao obter informações do PDF',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Obtém histórico de operações do usuário
+   */
+  static async getHistory(req: Request, res: Response): Promise<void> {
+    try {
+      const userId = (req as any).user?.id;
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const page = parseInt(req.query.page as string) || 1;
+      const limit = parseInt(req.query.limit as string) || 20;
+      const skip = (page - 1) * limit;
+
+      const [operacoes, total] = await Promise.all([
+        prisma.operacaoPDF.findMany({
+          where: { usuarioId: userId },
+          orderBy: { criadoEm: 'desc' },
+          skip,
+          take: limit,
+          select: {
+            id: true,
+            tipoOperacao: true,
+            status: true,
+            tamanhoOriginal: true,
+            tamanhoResultado: true,
+            tempoProcessamento: true,
+            mensagemErro: true,
+            criadoEm: true,
+            parametros: true,
+          },
+        }),
+        prisma.operacaoPDF.count({
+          where: { usuarioId: userId },
+        }),
+      ]);
+
+      res.json({
+        success: true,
+        operacoes,
+        pagination: {
+          page,
+          limit,
+          total,
+          pages: Math.ceil(total / limit),
+        },
+      });
+    } catch (error) {
+      console.error('Erro ao obter histórico:', error);
+      res.status(500).json({
+        error: 'Falha ao obter histórico',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+
+  /**
+   * Download de arquivo processado
+   */
+  static async downloadFile(req: Request, res: Response): Promise<void> {
+    try {
+      const { operacaoId, fileIndex } = req.params;
+      const userId = (req as any).user?.id;
+
+      if (!userId) {
+        res.status(401).json({ error: 'Usuário não autenticado' });
+        return;
+      }
+
+      const operacao = await prisma.operacaoPDF.findUnique({
+        where: { id: operacaoId },
+      });
+
+      if (!operacao) {
+        res.status(404).json({ error: 'Operação não encontrada' });
+        return;
+      }
+
+      if (operacao.usuarioId !== userId) {
+        res.status(403).json({ error: 'Acesso negado' });
+        return;
+      }
+
+      const index = parseInt(fileIndex);
+      const filePath = operacao.arquivosResultado[index];
+
+      if (!filePath) {
+        res.status(404).json({ error: 'Arquivo não encontrado' });
+        return;
+      }
+
+      res.download(filePath, path.basename(filePath));
+    } catch (error) {
+      console.error('Erro ao fazer download:', error);
+      res.status(500).json({
+        error: 'Falha ao fazer download',
+        message: error instanceof Error ? error.message : 'Erro desconhecido',
+      });
+    }
+  }
+}

backend/middleware/auth.ts

@@ -0,0 +1,105 @@
+import { Request, Response, NextFunction } from 'express';
+import jwt from 'jsonwebtoken';
+import { PrismaClient } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+// Adicionar interface para tipo de usuário no Request
+declare global {
+  namespace Express {
+    interface Request {
+      user?: {
+        id: string;
+        nome: string;
+        email: string;
+        perfil: string;
+      };
+    }
+  }
+}
+
+export const authenticateToken = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+): Promise<void> => {
+  try {
+    // Verificar se há token
+    const authHeader = req.headers.authorization;
+    if (!authHeader) {
+      res.status(401).json({ error: 'Token não fornecido' });
+      return;
+    }
+
+    // Extrair o token do header (remover o Bearer)
+    const token = authHeader.replace('Bearer ', '');
+
+    // Verificar o token
+    const secret = process.env.JWT_SECRET || 'default-secret';
+    const decoded = jwt.verify(token, secret) as any;
+
+    // Buscar o usuário no banco
+    const user = await prisma.usuario.findUnique({
+      where: { id: decoded.id },
+      select: {
+        id: true,
+        nome: true,
+        email: true,
+        perfil: true,
+        ativo: true,
+      },
+    });
+
+    if (!user || !user.ativo) {
+      res.status(401).json({ error: 'Usuário inválido ou inativo' });
+      return;
+    }
+
+    // Adicionar o usuário no request
+    req.user = {
+      id: user.id,
+      nome: user.nome,
+      email: user.email,
+      perfil: user.perfil,
+    };
+
+    next();
+  } catch (error) {
+    console.error('Erro na autenticação:', error);
+    
+    if (error instanceof jwt.TokenExpiredError) {
+      res.status(401).json({ error: 'Token expirado' });
+      return;
+    }
+    
+    if (error instanceof jwt.JsonWebTokenError) {
+      res.status(401).json({ error: 'Token inválido' });
+      return;
+    }
+    
+    res.status(500).json({ error: 'Erro ao autenticar' });
+  }
+};
+
+export const requireAdmin = async (
+  req: Request,
+  res: Response,
+  next: NextFunction
+): Promise<void> => {
+  try {
+    if (!req.user) {
+      res.status(401).json({ error: 'Usuário não autenticado' });
+      return;
+    }
+
+    if (req.user.perfil !== 'ADVOGADO_ADMIN') {
+      res.status(403).json({ error: 'Acesso negado. Apenas administradores.' });
+      return;
+    }
+
+    next();
+  } catch (error) {
+    console.error('Erro na verificação de permissão:', error);
+    res.status(500).json({ error: 'Erro ao verificar permissões' });
+  }
+};

backend/routes/pdf.ts

@@ -0,0 +1,82 @@
+import express from 'express';
+import { PDFController, uploadMiddleware } from '../controllers/pdfController';
+import { authenticateToken } from '../middleware/auth';
+
+const router = express.Router();
+
+/**
+ * Rotas para manipulação de PDF
+ * Todas as rotas requerem autenticação
+ */
+
+// Comprime PDFs
+router.post(
+  '/compress',
+  authenticateToken,
+  uploadMiddleware.array('files', 10),
+  PDFController.compress
+);
+
+// Divide PDF
+router.post(
+  '/split',
+  authenticateToken,
+  uploadMiddleware.array('files', 1),
+  PDFController.split
+);
+
+// Mescla PDFs
+router.post(
+  '/merge',
+  authenticateToken,
+  uploadMiddleware.array('files', 50),
+  PDFController.merge
+);
+
+// Converte PDF para imagens
+router.post(
+  '/pdf-to-images',
+  authenticateToken,
+  uploadMiddleware.array('files', 1),
+  PDFController.pdfToImages
+);
+
+// Converte imagens para PDF
+router.post(
+  '/images-to-pdf',
+  authenticateToken,
+  uploadMiddleware.array('files', 100),
+  PDFController.imagesToPDF
+);
+
+// Realiza OCR em PDF
+router.post(
+  '/ocr',
+  authenticateToken,
+  uploadMiddleware.array('files', 1),
+  PDFController.performOCR
+);
+
+// Obtém informações de um PDF
+router.post(
+  '/info',
+  authenticateToken,
+  uploadMiddleware.array('files', 1),
+  PDFController.getInfo
+);
+
+// Obtém histórico de operações
+router.get(
+  '/history',
+  authenticateToken,
+  PDFController.getHistory
+);
+
+// Download de arquivo processado
+router.get(
+  '/download/:operacaoId/:fileIndex',
+  authenticateToken,
+  PDFController.downloadFile
+);
+
+export default router;

docs/PDF_MANIPULATION.md

@@ -0,0 +1,421 @@
+# Funcionalidade de Manipulação de PDFs
+
+## Visão Geral
+
+Sistema completo de manipulação de arquivos PDF com as seguintes funcionalidades:
+
+### Recursos Implementados
+
+1. **Compressão de PDF sem perda de qualidade**
+   - Compressão inteligente mantendo qualidade entre 50-100%
+   - Remoção de metadados desnecessários
+   - Otimização de streams de objetos
+   - Suporte para múltiplos arquivos simultâneos
+
+2. **Divisão de PDF**
+   - Por páginas específicas (ex: 1,3,5,7)
+   - Por intervalos (ex: 1-5, 6-10)
+   - Por chunks de tamanho fixo
+
+3. **Mesclagem de PDFs**
+   - Combine até 50 PDFs em um único arquivo
+   - Preserva qualidade original
+   - Ordem personalizável
+
+4. **PDF para Imagens**
+   - Formatos: PNG, JPG, WEBP
+   - DPI ajustável (150-600)
+   - Qualidade configurável (50-100%)
+   - Conversão de páginas específicas ou todas
+
+5. **Imagens para PDF**
+   - Suporta múltiplas imagens (até 100)
+   - Ajuste automático ao tamanho da página
+   - Suporta PNG, JPG, JPEG, WEBP
+
+6. **OCR (Reconhecimento Ótico de Caracteres)**
+   - Extração de texto de PDFs escaneados
+   - Suporte para Português, Inglês e Espanhol
+   - Retorna confiança da extração
+   - Processamento por página
+
+7. **Informações do PDF**
+   - Número de páginas
+   - Tamanho do arquivo
+   - Metadados (título, autor, criador, etc.)
+   - Datas de criação e modificação
+
+## Instalação
+
+### 1. Instalar Dependências
+
+```bash
+npm install pdf-lib pdf-parse pdf2pic tesseract.js
+npm install --save-dev @types/pdf-parse
+```
+
+Ou execute o script de instalação:
+
+```bash
+npm run install-pdf-deps
+```
+
+### 2. Executar Migration do Banco de Dados
+
+```bash
+npm run prisma:migrate
+```
+
+Ou manualmente:
+
+```bash
+npx prisma migrate dev --name add_operacoes_pdf
+```
+
+### 3. Gerar Cliente Prisma
+
+```bash
+npm run prisma:generate
+```
+
+### 4. Criar Diretórios Necessários
+
+Os diretórios serão criados automaticamente na primeira execução, mas você pode criá-los manualmente:
+
+```bash
+mkdir -p storage/temp/pdf-ops
+mkdir -p storage/pdf-output
+mkdir -p storage/temp/uploads
+```
+
+## Uso
+
+### Frontend
+
+Acesse a página de manipulação de PDFs através da rota:
+
+```
+/pdf
+```
+
+### API Endpoints
+
+Todas as rotas requerem autenticação via Bearer token.
+
+#### 1. Comprimir PDF
+
+```http
+POST /api/pdf/compress
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File[] (array de PDFs)
+- quality: number (50-100, padrão 95)
+- maxSizeMB: number (opcional)
+```
+
+#### 2. Dividir PDF
+
+```http
+POST /api/pdf/split
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+- splitType: 'pages' | 'range' | 'chunks'
+- pages: string (ex: "1,2,3") - para splitType='pages'
+- ranges: string (ex: "1-5,6-10") - para splitType='range'
+- chunkSize: number - para splitType='chunks'
+```
+
+#### 3. Mesclar PDFs
+
+```http
+POST /api/pdf/merge
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File[] (mínimo 2 PDFs)
+```
+
+#### 4. PDF para Imagens
+
+```http
+POST /api/pdf/pdf-to-images
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+- format: 'png' | 'jpg' | 'webp' (padrão: png)
+- quality: number (50-100, padrão: 95)
+- density: number (DPI, 150-600, padrão: 300)
+- pages: string (opcional, ex: "[1,2,3]" ou "all")
+```
+
+#### 5. Imagens para PDF
+
+```http
+POST /api/pdf/images-to-pdf
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File[] (array de imagens)
+- fitToPage: boolean (padrão: true)
+- pageSize: string (opcional, JSON: {"width":595,"height":842})
+```
+
+#### 6. OCR
+
+```http
+POST /api/pdf/ocr
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+- language: string ('por' | 'eng' | 'spa', padrão: 'por')
+- pages: string (opcional, ex: "[1,2]" ou "all")
+```
+
+#### 7. Informações do PDF
+
+```http
+POST /api/pdf/info
+Content-Type: multipart/form-data
+Authorization: Bearer {token}
+
+Body:
+- files: File (único PDF)
+```
+
+#### 8. Histórico de Operações
+
+```http
+GET /api/pdf/history?page=1&limit=20
+Authorization: Bearer {token}
+```
+
+#### 9. Download de Arquivo Processado
+
+```http
+GET /api/pdf/download/:operacaoId/:fileIndex
+Authorization: Bearer {token}
+```
+
+## Estrutura de Resposta
+
+### Sucesso (Compressão)
+
+```json
+{
+  "success": true,
+  "operacaoId": "uuid",
+  "results": [
+    {
+      "originalName": "documento.pdf",
+      "originalSize": 1048576,
+      "compressedSize": 524288,
+      "reduction": 50.0,
+      "outputPath": "/path/to/compressed.pdf"
+    }
+  ],
+  "totalOriginalSize": 1048576,
+  "totalCompressedSize": 524288,
+  "totalReduction": 50.0,
+  "processingTime": 1234
+}
+```
+
+### Sucesso (OCR)
+
+```json
+{
+  "success": true,
+  "operacaoId": "uuid",
+  "result": {
+    "text": "Texto extraído completo...",
+    "confidence": 95.5,
+    "pages": [
+      {
+        "pageNumber": 1,
+        "text": "Texto da página 1...",
+        "confidence": 96.2
+      }
+    ]
+  },
+  "processingTime": 5678
+}
+```
+
+### Erro
+
+```json
+{
+  "error": "Falha ao processar arquivo",
+  "message": "Detalhes específicos do erro"
+}
+```
+
+## Modelo de Dados
+
+### OperacaoPDF
+
+```typescript
+interface OperacaoPDF {
+  id: string;
+  tipoOperacao: 'COMPRIMIR' | 'DIVIDIR' | 'MESCLAR' | 'PDF_PARA_IMAGEM' | 'IMAGEM_PARA_PDF' | 'OCR';
+  status: 'PROCESSANDO' | 'CONCLUIDO' | 'ERRO';
+  usuarioId: string;
+  arquivosOriginais: string[];
+  arquivosResultado: string[];
+  tamanhoOriginal: bigint;
+  tamanhoResultado: bigint | null;
+  parametros: any;
+  mensagemErro: string | null;
+  detalhesOCR: any | null;
+  tempoProcessamento: number | null;
+  criadoEm: Date;
+  atualizadoEm: Date;
+}
+```
+
+## Segurança
+
+- ✅ Autenticação obrigatória em todas as rotas
+- ✅ Validação de tipos de arquivo (apenas PDF e imagens)
+- ✅ Limite de tamanho de arquivo (100MB por arquivo)
+- ✅ Limite de quantidade de arquivos por operação
+- ✅ Sanitização de nomes de arquivo
+- ✅ Isolamento de arquivos por operação
+- ✅ Limpeza automática de arquivos temporários
+
+## Performance
+
+- ✅ Processamento assíncrono
+- ✅ Otimização de memória com streams
+- ✅ Compressão sem perda de qualidade perceptível
+- ✅ Cache de workers de OCR
+- ✅ Índices no banco de dados para consultas rápidas
+- ✅ Limpeza automática de arquivos antigos
+
+## Tratamento de Erros
+
+Todos os erros são:
+- Logados no console do servidor
+- Registrados no banco de dados (tabela operacoes_pdf)
+- Retornados ao cliente com mensagens descritivas
+- Capturados por try-catch em todas as operações
+
+## Limitações
+
+- Tamanho máximo por arquivo: 100MB
+- Máximo de arquivos para compressão: 10
+- Máximo de arquivos para mesclagem: 50
+- Máximo de imagens para conversão em PDF: 100
+- Arquivos processados são mantidos por 24 horas
+
+## Manutenção
+
+### Limpeza de Arquivos Antigos
+
+Execute periodicamente (recomendado: diariamente via cron):
+
+```typescript
+import { PDFService } from './src/services/pdfService';
+
+// Remove arquivos com mais de 24 horas
+await PDFService.cleanupOldFiles(24);
+```
+
+### Monitoramento
+
+Consulte a tabela `operacoes_pdf` para:
+- Estatísticas de uso
+- Taxa de erro
+- Tempo médio de processamento
+- Operações mais utilizadas
+
+```sql
+-- Operações por tipo
+SELECT "tipoOperacao", COUNT(*) as total
+FROM operacoes_pdf
+GROUP BY "tipoOperacao"
+ORDER BY total DESC;
+
+-- Taxa de sucesso
+SELECT 
+  status,
+  COUNT(*) as total,
+  ROUND(COUNT(*) * 100.0 / SUM(COUNT(*)) OVER(), 2) as percentual
+FROM operacoes_pdf
+GROUP BY status;
+
+-- Tempo médio por operação
+SELECT 
+  "tipoOperacao",
+  AVG("tempoProcessamento") as tempo_medio_ms,
+  MIN("tempoProcessamento") as tempo_min_ms,
+  MAX("tempoProcessamento") as tempo_max_ms
+FROM operacoes_pdf
+WHERE status = 'CONCLUIDO'
+GROUP BY "tipoOperacao";
+```
+
+## Troubleshooting
+
+### Erro: "Tesseract worker failed"
+
+Solução: Certifique-se de que o Tesseract está instalado corretamente:
+
+```bash
+npm install tesseract.js --force
+```
+
+### Erro: "Cannot find module 'sharp'"
+
+Solução: Reinstale o Sharp com rebuild:
+
+```bash
+npm uninstall sharp
+npm install sharp
+npm rebuild sharp
+```
+
+### Erro: "ENOSPC: no space left on device"
+
+Solução: Aumente o espaço em disco ou execute a limpeza:
+
+```bash
+npm run cleanup-pdf-files
+```
+
+### Performance lenta no OCR
+
+Solução: Reduza o DPI ou processe menos páginas por vez.
+
+## Suporte
+
+Para questões ou problemas:
+1. Verifique os logs do servidor
+2. Consulte a tabela `operacoes_pdf` para detalhes do erro
+3. Verifique se os diretórios de storage têm permissões corretas
+4. Certifique-se de que todas as dependências estão instaladas
+
+## Changelog
+
+### v1.0.0 (2026-02-27)
+- ✅ Implementação inicial
+- ✅ Compressão sem perda de qualidade
+- ✅ Divisão de PDFs
+- ✅ Mesclagem de PDFs
+- ✅ Conversão PDF para imagens
+- ✅ Conversão de imagens para PDF
+- ✅ OCR com Tesseract
+- ✅ Histórico de operações
+- ✅ Interface React completa
+- ✅ Validação e segurança

package.json

@@ -19,7 +19,9 @@
     "lint:fix": "eslint . --ext .ts,.tsx --fix",
     "create-admin": "ts-node scripts/create_admin_user.ts",
     "worker": "ts-node src/workers/startWorker.ts",
-    "install-deps": "npm install ua-parser-js uuid axios xlsx"
+    "install-deps": "npm install ua-parser-js uuid axios xlsx",
+    "install-pdf-deps": "npm install pdf-parse pdf2pic tesseract.js && npm install --save-dev @types/pdf-parse",
+    "cleanup-pdf-files": "ts-node scripts/cleanup_pdf_files.ts"
   },
   "dependencies": {
     "@emotion/react": "^11.11.3",
@@ -49,9 +51,12 @@
     "multer": "^1.4.5-lts.1",
     "opentimestamps-javascript": "^1.0.1",
     "pdf-lib": "^1.17.1",
+    "pdf-parse": "^1.1.1",
+    "pdf2pic": "^3.1.3",
     "pdfkit": "^0.13.0",
     "puppeteer": "^24.5.0",
     "qrcode": "^1.5.3",
+    "tesseract.js": "^5.0.4",
     "react": "^18.2.0",
     "react-beautiful-dnd": "^13.1.1",
     "react-dom": "^18.2.0",
@@ -77,6 +82,7 @@
     "@types/jsonwebtoken": "^9.0.9",
     "@types/multer": "^1.4.12",
     "@types/node": "^22.13.14",
+    "@types/pdf-parse": "^1.1.4",
     "@types/react": "^19.0.12",
     "@types/react-beautiful-dnd": "^13.1.8",
     "@types/react-dom": "^19.0.4",

prisma/migrations/20260227000000_add_operacoes_pdf.sql

@@ -0,0 +1,35 @@
+-- Migration para adicionar tabela de operações de PDF
+-- Created: 2026-02-27
+
+-- Criar ENUM para tipo de operação
+CREATE TYPE "TipoOperacaoPDF" AS ENUM ('COMPRIMIR', 'DIVIDIR', 'MESCLAR', 'PDF_PARA_IMAGEM', 'IMAGEM_PARA_PDF', 'OCR');
+
+-- Criar ENUM para status da operação
+CREATE TYPE "StatusOperacaoPDF" AS ENUM ('PROCESSANDO', 'CONCLUIDO', 'ERRO');
+
+-- Criar tabela de operações de PDF
+CREATE TABLE "operacoes_pdf" (
+    "id" UUID NOT NULL DEFAULT gen_random_uuid(),
+    "tipoOperacao" "TipoOperacaoPDF" NOT NULL,
+    "status" "StatusOperacaoPDF" NOT NULL DEFAULT 'PROCESSANDO',
+    "usuarioId" UUID NOT NULL,
+    "arquivosOriginais" TEXT[] NOT NULL,
+    "arquivosResultado" TEXT[] NOT NULL,
+    "tamanhoOriginal" BIGINT NOT NULL,
+    "tamanhoResultado" BIGINT,
+    "parametros" JSONB,
+    "mensagemErro" TEXT,
+    "detalhesOCR" JSONB,
+    "tempoProcessamento" INTEGER,
+    "criadoEm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "atualizadoEm" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "operacoes_pdf_pkey" PRIMARY KEY ("id")
+);
+
+-- Adicionar foreign key para usuariosALTER TABLE "operacoes_pdf" ADD CONSTRAINT "operacoes_pdf_usuarioId_fkey" FOREIGN KEY ("usuarioId") REFERENCES "usuarios"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- Criar índice para melhor performance nas consultas
+CREATE INDEX "operacoes_pdf_usuarioId_idx" ON "operacoes_pdf"("usuarioId");
+CREATE INDEX "operacoes_pdf_criadoEm_idx" ON "operacoes_pdf"("criadoEm" DESC);
+CREATE INDEX "operacoes_pdf_status_idx" ON "operacoes_pdf"("status");

prisma/schema.prisma

@@ -51,6 +51,9 @@ model Usuario {
   // Adicionar relação para cálculos de pensão alimentícia
   calculosPensaoAlimenticia CalculoPensaoAlimenticia[]
 
+  // Adicionar relação para operações de PDF
+  operacoesPDF OperacaoPDF[]
+
   @@map("usuarios")
 }
 
@@ -1067,3 +1070,47 @@ model CalculoPensaoAlimenticia {
 
   @@map("calculos_pensao_alimenticia")
 }
+
+// Modelo para histórico de operações de PDF
+enum TipoOperacaoPDF {
+  COMPRIMIR
+  DIVIDIR
+  MESCLAR
+  PDF_PARA_IMAGEM
+  IMAGEM_PARA_PDF
+  OCR
+}
+
+enum StatusOperacaoPDF {
+  PROCESSANDO
+  CONCLUIDO
+  ERRO
+}
+
+model OperacaoPDF {
+  id                String            @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  tipoOperacao      TipoOperacaoPDF
+  status            StatusOperacaoPDF @default(PROCESSANDO)
+  usuarioId         String            @db.Uuid
+  usuario           Usuario           @relation(fields: [usuarioId], references: [id])
+  
+  // Informações dos arquivos
+  arquivosOriginais String[]          // Array de paths dos arquivos originais
+  arquivosResultado String[]          // Array de paths dos arquivos resultantes
+  tamanhoOriginal   BigInt            // Tamanho total dos arquivos originais em bytes
+  tamanhoResultado  BigInt?           // Tamanho total dos arquivos resultantes em bytes
+  
+  // Parâmetros da operação
+  parametros        Json?             // Parâmetros específicos da operação (ex: páginas para dividir)
+  
+  // Resultado da operação
+  mensagemErro      String?           
+  detalhesOCR       Json?             // Quando for OCR, armazena o texto extraído
+  
+  tempoProcessamento Int?             // Tempo de processamento em milissegundos
+  
+  criadoEm          DateTime          @default(now())
+  atualizadoEm      DateTime          @updatedAt
+  
+  @@map("operacoes_pdf")
+}

scripts/cleanup_pdf_files.ts

@@ -0,0 +1,41 @@
+import { PDFService } from '../src/services/pdfService';
+
+/**
+ * Script para limpeza de arquivos PDF antigos
+ * Remove arquivos com mais de 24 horas por padrão
+ * 
+ * Uso:
+ * npm run cleanup-pdf-files
+ * 
+ * Ou via ts-node:
+ * ts-node scripts/cleanup_pdf_files.ts [horas]
+ */
+
+async function main() {
+  console.log('Iniciando limpeza de arquivos PDF antigos...');
+  
+  const horasArg = process.argv[2];
+  const horas = horasArg ? parseInt(horasArg) : 24;
+  
+  if (isNaN(horas) || horas < 0) {
+    console.error('Erro: O argumento deve ser um número positivo de horas');
+    process.exit(1);
+  }
+  
+  console.log(`Removendo arquivos com mais de ${horas} horas...`);
+  
+  try {
+    await PDFService.cleanupOldFiles(horas);
+    console.log('✅ Limpeza concluída com sucesso!');
+  } catch (error) {
+    console.error('❌ Erro durante a limpeza:', error);
+    process.exit(1);
+  }
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error('Erro fatal:', error);
+    process.exit(1);
+  });

scripts/test_pdf_operations.ts

@@ -0,0 +1,271 @@
+import { PDFService } from '../src/services/pdfService';
+import path from 'path';
+import fs from 'fs/promises';
+
+/**
+ * Script de teste para funcionalidades de PDF
+ * 
+ * ATENÇÃO: Este é um script de teste. Certifique-se de ter arquivos de teste
+ * disponíveis antes de executar.
+ * 
+ * Uso:
+ * ts-node scripts/test_pdf_operations.ts
+ */
+
+async function testPDFInfo() {
+  console.log('\n=== Testando: Informações do PDF ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    // Verifica se o arquivo existe
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const info = await PDFService.getPDFInfo(testPdfPath);
+    console.log('✅ Informações obtidas com sucesso:');
+    console.log('   Páginas:', info.pages);
+    console.log('   Tamanho:', (info.size / 1024).toFixed(2), 'KB');
+    console.log('   Título:', info.title || 'N/A');
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testCompression() {
+  console.log('\n=== Testando: Compressão de PDF ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const result = await PDFService.compressPDF(testPdfPath, undefined, {
+      quality: 95,
+    });
+    
+    console.log('✅ Compressão concluída:');
+    console.log('   Tamanho original:', (result.originalSize / 1024).toFixed(2), 'KB');
+    console.log('   Tamanho comprimido:', (result.compressedSize / 1024).toFixed(2), 'KB');
+    console.log('   Redução:', result.reduction.toFixed(2), '%');
+    console.log('   Arquivo salvo em:', result.outputPath);
+    
+    // Limpa o arquivo de teste
+    await fs.unlink(result.outputPath);
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testSplit() {
+  console.log('\n=== Testando: Divisão de PDF ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    // Primeiro, verifica quantas páginas o PDF tem
+    const info = await PDFService.getPDFInfo(testPdfPath);
+    
+    if (info.pages < 2) {
+      console.log('⚠️  PDF tem menos de 2 páginas. Pulando teste de divisão.');
+      return;
+    }
+    
+    const outputPaths = await PDFService.splitPDF(testPdfPath, {
+      splitType: 'chunks',
+      chunkSize: 1,
+    });
+    
+    console.log('✅ Divisão concluída:');
+    console.log('   Arquivos criados:', outputPaths.length);
+    
+    // Limpa os arquivos de teste
+    for (const outputPath of outputPaths) {
+      await fs.unlink(outputPath);
+    }
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testMerge() {
+  console.log('\n=== Testando: Mesclagem de PDFs ===');
+  try {
+    const testPdf1 = path.join(process.cwd(), 'test', 'sample1.pdf');
+    const testPdf2 = path.join(process.cwd(), 'test', 'sample2.pdf');
+    
+    try {
+      await fs.access(testPdf1);
+      await fs.access(testPdf2);
+    } catch {
+      console.log('⚠️  Arquivos de teste não encontrados. Pulando teste.');
+      return;
+    }
+    
+    const outputPath = await PDFService.mergePDFs({
+      filePaths: [testPdf1, testPdf2],
+      outputPath: path.join(process.cwd(), 'storage', 'pdf-output', 'test-merged.pdf'),
+    });
+    
+    console.log('✅ Mesclagem concluída:');
+    console.log('   Arquivo salvo em:', outputPath);
+    
+    // Limpa o arquivo de teste
+    await fs.unlink(outputPath);
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testImagesToPDF() {
+  console.log('\n=== Testando: Imagens para PDF ===');
+  try {
+    const testImage1 = path.join(process.cwd(), 'test', 'image1.png');
+    const testImage2 = path.join(process.cwd(), 'test', 'image2.png');
+    
+    try {
+      await fs.access(testImage1);
+    } catch {
+      console.log('⚠️  Imagens de teste não encontradas. Pulando teste.');
+      return;
+    }
+    
+    const imagePaths = [testImage1];
+    
+    try {
+      await fs.access(testImage2);
+      imagePaths.push(testImage2);
+    } catch {
+      // Ignora se a segunda imagem não existe
+    }
+    
+    const outputPath = await PDFService.imagesToPDF({
+      imagePaths,
+      outputPath: path.join(process.cwd(), 'storage', 'pdf-output', 'test-images.pdf'),
+      fitToPage: true,
+    });
+    
+    console.log('✅ Conversão concluída:');
+    console.log('   Imagens processadas:', imagePaths.length);
+    console.log('   Arquivo salvo em:', outputPath);
+    
+    // Limpa o arquivo de teste
+    await fs.unlink(outputPath);
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testPDFToImages() {
+  console.log('\n=== Testando: PDF para Imagens ===');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const outputPaths = await PDFService.pdfToImages(testPdfPath, {
+      format: 'png',
+      quality: 95,
+      density: 150, // Menor DPI para teste mais rápido
+      pages: [1], // Apenas primeira página
+    });
+    
+    console.log('✅ Conversão concluída:');
+    console.log('   Imagens criadas:', outputPaths.length);
+    
+    // Limpa os arquivos de teste
+    for (const outputPath of outputPaths) {
+      await fs.unlink(outputPath);
+    }
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function testOCR() {
+  console.log('\n=== Testando: OCR ===');
+  console.log('⚠️  OCR pode levar vários segundos. Aguarde...');
+  try {
+    const testPdfPath = path.join(process.cwd(), 'test', 'sample-text.pdf');
+    
+    try {
+      await fs.access(testPdfPath);
+    } catch {
+      console.log('⚠️  Arquivo de teste não encontrado. Pulando teste.');
+      return;
+    }
+    
+    const result = await PDFService.performOCR(testPdfPath, {
+      language: 'por',
+      pages: [1], // Apenas primeira página
+    });
+    
+    console.log('✅ OCR concluído:');
+    console.log('   Confiança:', result.confidence.toFixed(2), '%');
+    console.log('   Páginas processadas:', result.pages.length);
+    console.log('   Texto extraído (primeiros 100 caracteres):');
+    console.log('   ', result.text.substring(0, 100).replace(/\n/g, ' '));
+  } catch (error) {
+    console.error('❌ Erro:', error);
+  }
+}
+
+async function main() {
+  console.log('╔════════════════════════════════════════════╗');
+  console.log('║  Teste de Operações de PDF                ║');
+  console.log('╚════════════════════════════════════════════╝');
+  
+  console.log('\nPré-requisitos:');
+  console.log('- Coloque arquivos de teste na pasta "test/"');
+  console.log('- sample.pdf: PDF com múltiplas páginas');
+  console.log('- sample1.pdf e sample2.pdf: PDFs para mesclagem');
+  console.log('- image1.png e image2.png: Imagens para conversão');
+  console.log('- sample-text.pdf: PDF com texto para OCR');
+  
+  // Criar diretório de teste se não existir
+  const testDir = path.join(process.cwd(), 'test');
+  try {
+    await fs.mkdir(testDir, { recursive: true });
+  } catch {
+    // Ignora se já existe
+  }
+  
+  await PDFService.initialize();
+  
+  await testPDFInfo();
+  await testCompression();
+  await testSplit();
+  await testMerge();
+  await testImagesToPDF();
+  await testPDFToImages();
+  await testOCR();
+  
+  console.log('\n╔════════════════════════════════════════════╗');
+  console.log('║  Testes concluídos!                       ║');
+  console.log('╚════════════════════════════════════════════╝\n');
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((error) => {
+    console.error('\n❌ Erro fatal durante os testes:', error);
+    process.exit(1);
+  });

src/App.tsx

@@ -50,6 +50,9 @@ import { DetalhesCalculo } from './components/calculos/DetalhesCalculo';
 import { NovoPensaoAlimenticia } from './components/calculos/NovoPensaoAlimenticia';
 import { DetalhePensaoAlimenticia } from './components/calculos/DetalhePensaoAlimenticia';
 
+// Importar componente de manipulação de PDF
+import { PDFManipulationPage } from './components/pdf/PDFManipulationPage';
+
 const queryClient = new QueryClient();
 
 const router = createBrowserRouter(
@@ -126,6 +129,13 @@ const router = createBrowserRouter(
               <DetalhePensaoAlimenticia />
             </ProtectedRoute>
           } />
+          
+          {/* Rota para Manipulação de PDF */}
+          <Route path="/pdf" element={
+            <ProtectedRoute>
+              <PDFManipulationPage />
+            </ProtectedRoute>
+          } />
         </Route>
       </Route>
       <Route path="*" element={<Navigate to="/login" />} />

src/components/pdf/PDFManipulationPage.tsx

@@ -0,0 +1,658 @@
+import React, { useState, useCallback } from 'react';
+import { useDropzone } from 'react-dropzone';
+import axios from 'axios';
+import { toast } from 'react-toastify';
+import {
+  DocumentIcon,
+  CloudArrowUpIcon,
+  ArrowsPointingInIcon,
+  ScissorsIcon,
+  ArrowsUpDownIcon,
+  PhotoIcon,
+  DocumentTextIcon,
+  InformationCircleIcon,
+  ArrowDownTrayIcon,
+  ClockIcon,
+} from '@heroicons/react/24/outline';
+
+interface OperationResult {
+  operacaoId: string;
+  outputPaths?: string[];
+  outputPath?: string;
+  processingTime?: number;
+  reduction?: number;
+  filesCreated?: number;
+  text?: string;
+  confidence?: number;
+}
+
+type OperationType =
+  | 'compress'
+  | 'split'
+  | 'merge'
+  | 'pdfToImages'
+  | 'imagesToPDF'
+  | 'ocr'
+  | 'info';
+
+export const PDFManipulationPage: React.FC = () => {
+  const [selectedOperation, setSelectedOperation] = useState<OperationType>('compress');
+  const [files, setFiles] = useState<File[]>([]);
+  const [processing, setProcessing] = useState(false);
+  const [result, setResult] = useState<OperationResult | null>(null);
+  const [history, setHistory] = useState<any[]>([]);
+
+  // Configurações para cada operação
+  const [compressQuality, setCompressQuality] = useState(95);
+  const [splitType, setSplitType] = useState<'pages' | 'range' | 'chunks'>('pages');
+  const [splitPages, setSplitPages] = useState<string>('1,2,3');
+  const [splitRanges, setSplitRanges] = useState<string>('1-5,6-10');
+  const [chunkSize, setChunkSize] = useState(5);
+  const [imageFormat, setImageFormat] = useState<'png' | 'jpg' | 'webp'>('png');
+  const [imageQuality, setImageQuality] = useState(95);
+  const [imageDensity, setImageDensity] = useState(300);
+  const [ocrLanguage, setOcrLanguage] = useState('por');
+
+  const onDrop = useCallback((acceptedFiles: File[]) => {
+    setFiles((prev) => [...prev, ...acceptedFiles]);
+  }, []);
+
+  const { getRootProps, getInputProps, isDragActive } = useDropzone({
+    onDrop,
+    accept: {
+      'application/pdf': ['.pdf'],
+      'image/*': ['.png', '.jpg', '.jpeg', '.webp'],
+    },
+  });
+
+  const removeFile = (index: number) => {
+    setFiles((prev) => prev.filter((_, i) => i !== index));
+  };
+
+  const clearFiles = () => {
+    setFiles([]);
+    setResult(null);
+  };
+
+  const getToken = () => {
+    return localStorage.getItem('token');
+  };
+
+  const processFiles = async () => {
+    if (files.length === 0) {
+      toast.error('Selecione pelo menos um arquivo');
+      return;
+    }
+
+    setProcessing(true);
+    setResult(null);
+
+    try {
+      const formData = new FormData();
+      files.forEach((file) => {
+        formData.append('files', file);
+      });
+
+      const token = getToken();
+      const config = {
+        headers: {
+          'Content-Type': 'multipart/form-data',
+          Authorization: `Bearer ${token}`,
+        },
+      };
+
+      let response;
+
+      switch (selectedOperation) {
+        case 'compress':
+          formData.append('quality', compressQuality.toString());
+          response = await axios.post('/api/pdf/compress', formData, config);
+          toast.success('PDFs comprimidos com sucesso!');
+          break;
+
+        case 'split':
+          formData.append('splitType', splitType);
+          if (splitType === 'pages') {
+            const pages = splitPages.split(',').map((p) => parseInt(p.trim()));
+            formData.append('pages', JSON.stringify(pages));
+          } else if (splitType === 'range') {
+            const ranges = splitRanges.split(',').map((r) => {
+              const [start, end] = r.trim().split('-').map(Number);
+              return { start, end };
+            });
+            formData.append('ranges', JSON.stringify(ranges));
+          } else {
+            formData.append('chunkSize', chunkSize.toString());
+          }
+          response = await axios.post('/api/pdf/split', formData, config);
+          toast.success('PDF dividido com sucesso!');
+          break;
+
+        case 'merge':
+          response = await axios.post('/api/pdf/merge', formData, config);
+          toast.success('PDFs mesclados com sucesso!');
+          break;
+
+        case 'pdfToImages':
+          formData.append('format', imageFormat);
+          formData.append('quality', imageQuality.toString());
+          formData.append('density', imageDensity.toString());
+          response = await axios.post('/api/pdf/pdf-to-images', formData, config);
+          toast.success('PDF convertido em imagens!');
+          break;
+
+        case 'imagesToPDF':
+          formData.append('fitToPage', 'true');
+          response = await axios.post('/api/pdf/images-to-pdf', formData, config);
+          toast.success('Imagens convertidas em PDF!');
+          break;
+
+        case 'ocr':
+          formData.append('language', ocrLanguage);
+          response = await axios.post('/api/pdf/ocr', formData, config);
+          toast.success('OCR realizado com sucesso!');
+          break;
+
+        case 'info':
+          response = await axios.post('/api/pdf/info', formData, config);
+          break;
+      }
+
+      setResult(response.data);
+      loadHistory();
+    } catch (error: any) {
+      console.error('Erro ao processar arquivos:', error);
+      toast.error(error.response?.data?.message || 'Erro ao processar arquivos');
+    } finally {
+      setProcessing(false);
+    }
+  };
+
+  const loadHistory = async () => {
+    try {
+      const token = getToken();
+      const response = await axios.get('/api/pdf/history', {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      setHistory(response.data.operacoes || []);
+    } catch (error) {
+      console.error('Erro ao carregar histórico:', error);
+    }
+  };
+
+  const downloadFile = async (operacaoId: string, fileIndex: number) => {
+    try {
+      const token = getToken();
+      const response = await axios.get(`/api/pdf/download/${operacaoId}/${fileIndex}`, {
+        headers: { Authorization: `Bearer ${token}` },
+        responseType: 'blob',
+      });
+
+      const url = window.URL.createObjectURL(new Blob([response.data]));
+      const link = document.createElement('a');
+      link.href = url;
+      link.setAttribute('download', `arquivo-${fileIndex}.pdf`);
+      document.body.appendChild(link);
+      link.click();
+      link.remove();
+
+      toast.success('Download iniciado!');
+    } catch (error) {
+      console.error('Erro ao fazer download:', error);
+      toast.error('Erro ao fazer download');
+    }
+  };
+
+  React.useEffect(() => {
+    loadHistory();
+  }, []);
+
+  const operations = [
+    {
+      id: 'compress' as OperationType,
+      name: 'Comprimir PDF',
+      icon: ArrowsPointingInIcon,
+      description: 'Reduza o tamanho mantendo a qualidade',
+    },
+    {
+      id: 'split' as OperationType,
+      name: 'Dividir PDF',
+      icon: ScissorsIcon,
+      description: 'Separe páginas específicas',
+    },
+    {
+      id: 'merge' as OperationType,
+      name: 'Mesclar PDFs',
+      icon: ArrowsUpDownIcon,
+      description: 'Combine múltiplos PDFs',
+    },
+    {
+      id: 'pdfToImages' as OperationType,
+      name: 'PDF para Imagens',
+      icon: PhotoIcon,
+      description: 'Converta páginas em imagens',
+    },
+    {
+      id: 'imagesToPDF' as OperationType,
+      name: 'Imagens para PDF',
+      icon: DocumentIcon,
+      description: 'Crie PDF a partir de imagens',
+    },
+    {
+      id: 'ocr' as OperationType,
+      name: 'OCR',
+      icon: DocumentTextIcon,
+      description: 'Extraia texto de PDFs',
+    },
+    {
+      id: 'info' as OperationType,
+      name: 'Informações',
+      icon: InformationCircleIcon,
+      description: 'Obtenha detalhes do PDF',
+    },
+  ];
+
+  const formatBytes = (bytes: number) => {
+    if (bytes === 0) return '0 Bytes';
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return Math.round((bytes / Math.pow(k, i)) * 100) / 100 + ' ' + sizes[i];
+  };
+
+  return (
+    <div className="min-h-screen bg-gray-50 py-8">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+        <div className="mb-8">
+          <h1 className="text-3xl font-bold text-gray-900">Manipulação de PDFs</h1>
+          <p className="mt-2 text-gray-600">
+            Ferramentas completas para trabalhar com arquivos PDF
+          </p>
+        </div>
+
+        {/* Seleção de operação */}
+        <div className="grid grid-cols-2 md:grid-cols-4 lg:grid-cols-7 gap-4 mb-8">
+          {operations.map((op) => (
+            <button
+              key={op.id}
+              onClick={() => {
+                setSelectedOperation(op.id);
+                clearFiles();
+              }}
+              className={`p-4 rounded-lg border-2 transition-all ${
+                selectedOperation === op.id
+                  ? 'border-blue-500 bg-blue-50 text-blue-700'
+                  : 'border-gray-200 bg-white hover:border-gray-300'
+              }`}
+            >
+              <op.icon className="h-8 w-8 mx-auto mb-2" />
+              <div className="text-sm font-medium">{op.name}</div>
+            </button>
+          ))}
+        </div>
+
+        <div className="grid grid-cols-1 lg:grid-cols-3 gap-8">
+          {/* Área principal */}
+          <div className="lg:col-span-2 space-y-6">
+            {/* Upload de arquivos */}
+            <div className="bg-white rounded-lg shadow p-6">
+              <h2 className="text-xl font-semibold mb-4">Arquivos</h2>
+
+              <div
+                {...getRootProps()}
+                className={`border-2 border-dashed rounded-lg p-12 text-center cursor-pointer transition-colors ${
+                  isDragActive
+                    ? 'border-blue-500 bg-blue-50'
+                    : 'border-gray-300 hover:border-gray-400'
+                }`}
+              >
+                <input {...getInputProps()} />
+                <CloudArrowUpIcon className="h-12 w-12 mx-auto text-gray-400 mb-4" />
+                {isDragActive ? (
+                  <p className="text-blue-600">Solte os arquivos aqui...</p>
+                ) : (
+                  <div>
+                    <p className="text-gray-600 mb-2">
+                      Arraste e solte arquivos aqui, ou clique para selecionar
+                    </p>
+                    <p className="text-sm text-gray-500">
+                      PDFs e imagens (PNG, JPG, WEBP)
+                    </p>
+                  </div>
+                )}
+              </div>
+
+              {/* Lista de arquivos */}
+              {files.length > 0 && (
+                <div className="mt-4">
+                  <div className="flex justify-between items-center mb-2">
+                    <h3 className="font-medium">
+                      Arquivos selecionados ({files.length})
+                    </h3>
+                    <button
+                      onClick={clearFiles}
+                      className="text-sm text-red-600 hover:text-red-700"
+                    >
+                      Limpar todos
+                    </button>
+                  </div>
+                  <div className="space-y-2">
+                    {files.map((file, index) => (
+                      <div
+                        key={index}
+                        className="flex items-center justify-between p-3 bg-gray-50 rounded"
+                      >
+                        <div className="flex items-center space-x-3">
+                          <DocumentIcon className="h-5 w-5 text-gray-400" />
+                          <div>
+                            <p className="text-sm font-medium">{file.name}</p>
+                            <p className="text-xs text-gray-500">
+                              {formatBytes(file.size)}
+                            </p>
+                          </div>
+                        </div>
+                        <button
+                          onClick={() => removeFile(index)}
+                          className="text-red-600 hover:text-red-700"
+                        >
+                          Remover
+                        </button>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              )}
+            </div>
+
+            {/* Configurações específicas */}
+            <div className="bg-white rounded-lg shadow p-6">
+              <h2 className="text-xl font-semibold mb-4">Configurações</h2>
+
+              {selectedOperation === 'compress' && (
+                <div>
+                  <label className="block text-sm font-medium mb-2">
+                    Qualidade ({compressQuality}%)
+                  </label>
+                  <input
+                    type="range"
+                    min="50"
+                    max="100"
+                    value={compressQuality}
+                    onChange={(e) => setCompressQuality(parseInt(e.target.value))}
+                    className="w-full"
+                  />
+                  <p className="text-xs text-gray-500 mt-1">
+                    95% recomendado para qualidade sem perda perceptível
+                  </p>
+                </div>
+              )}
+
+              {selectedOperation === 'split' && (
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      Tipo de divisão
+                    </label>
+                    <select
+                      value={splitType}
+                      onChange={(e) => setSplitType(e.target.value as any)}
+                      className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                    >
+                      <option value="pages">Páginas específicas</option>
+                      <option value="range">Intervalos</option>
+                      <option value="chunks">Chunks (partes iguais)</option>
+                    </select>
+                  </div>
+
+                  {splitType === 'pages' && (
+                    <div>
+                      <label className="block text-sm font-medium mb-2">
+                        Páginas (separadas por vírgula)
+                      </label>
+                      <input
+                        type="text"
+                        value={splitPages}
+                        onChange={(e) => setSplitPages(e.target.value)}
+                        placeholder="1,2,3,5,8"
+                        className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                      />
+                    </div>
+                  )}
+
+                  {splitType === 'range' && (
+                    <div>
+                      <label className="block text-sm font-medium mb-2">
+                        Intervalos (ex: 1-5,6-10)
+                      </label>
+                      <input
+                        type="text"
+                        value={splitRanges}
+                        onChange={(e) => setSplitRanges(e.target.value)}
+                        placeholder="1-5,6-10,11-15"
+                        className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                      />
+                    </div>
+                  )}
+
+                  {splitType === 'chunks' && (
+                    <div>
+                      <label className="block text-sm font-medium mb-2">
+                        Páginas por chunk
+                      </label>
+                      <input
+                        type="number"
+                        value={chunkSize}
+                        onChange={(e) => setChunkSize(parseInt(e.target.value))}
+                        min="1"
+                        className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                      />
+                    </div>
+                  )}
+                </div>
+              )}
+
+              {selectedOperation === 'pdfToImages' && (
+                <div className="space-y-4">
+                  <div>
+                    <label className="block text-sm font-medium mb-2">Formato</label>
+                    <select
+                      value={imageFormat}
+                      onChange={(e) => setImageFormat(e.target.value as any)}
+                      className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                    >
+                      <option value="png">PNG</option>
+                      <option value="jpg">JPG</option>
+                      <option value="webp">WEBP</option>
+                    </select>
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      Qualidade ({imageQuality}%)
+                    </label>
+                    <input
+                      type="range"
+                      min="50"
+                      max="100"
+                      value={imageQuality}
+                      onChange={(e) => setImageQuality(parseInt(e.target.value))}
+                      className="w-full"
+                    />
+                  </div>
+
+                  <div>
+                    <label className="block text-sm font-medium mb-2">
+                      DPI ({imageDensity})
+                    </label>
+                    <input
+                      type="range"
+                      min="150"
+                      max="600"
+                      step="50"
+                      value={imageDensity}
+                      onChange={(e) => setImageDensity(parseInt(e.target.value))}
+                      className="w-full"
+                    />
+                  </div>
+                </div>
+              )}
+
+              {selectedOperation === 'ocr' && (
+                <div>
+                  <label className="block text-sm font-medium mb-2">Idioma</label>
+                  <select
+                    value={ocrLanguage}
+                    onChange={(e) => setOcrLanguage(e.target.value)}
+                    className="w-full border border-gray-300 rounded-lg px-3 py-2"
+                  >
+                    <option value="por">Português</option>
+                    <option value="eng">Inglês</option>
+                    <option value="spa">Espanhol</option>
+                  </select>
+                </div>
+              )}
+
+              <button
+                onClick={processFiles}
+                disabled={processing || files.length === 0}
+                className={`mt-6 w-full py-3 rounded-lg font-medium transition-colors ${
+                  processing || files.length === 0
+                    ? 'bg-gray-300 text-gray-500 cursor-not-allowed'
+                    : 'bg-blue-600 text-white hover:bg-blue-700'
+                }`}
+              >
+                {processing ? (
+                  <span className="flex items-center justify-center">
+                    <svg
+                      className="animate-spin h-5 w-5 mr-2"
+                      xmlns="http://www.w3.org/2000/svg"
+                      fill="none"
+                      viewBox="0 0 24 24"
+                    >
+                      <circle
+                        className="opacity-25"
+                        cx="12"
+                        cy="12"
+                        r="10"
+                        stroke="currentColor"
+                        strokeWidth="4"
+                      ></circle>
+                      <path
+                        className="opacity-75"
+                        fill="currentColor"
+                        d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+                      ></path>
+                    </svg>
+                    Processando...
+                  </span>
+                ) : (
+                  'Processar'
+                )}
+              </button>
+            </div>
+
+            {/* Resultado */}
+            {result && (
+              <div className="bg-white rounded-lg shadow p-6">
+                <h2 className="text-xl font-semibold mb-4">Resultado</h2>
+
+                {selectedOperation === 'compress' && result.reduction !== undefined && (
+                  <div className="space-y-2">
+                    <p className="text-green-600 font-medium">
+                      Redução de {result.reduction.toFixed(2)}%
+                    </p>
+                    <p className="text-sm text-gray-600">
+                      Tempo de processamento: {result.processingTime}ms
+                    </p>
+                  </div>
+                )}
+
+                {(result.outputPaths || result.outputPath) && (
+                  <div className="mt-4">
+                    <p className="font-medium mb-2">Arquivos gerados:</p>
+                    {result.outputPaths?.map((path, index) => (
+                      <button
+                        key={index}
+                        onClick={() => downloadFile(result.operacaoId, index)}
+                        className="flex items-center space-x-2 w-full p-2 hover:bg-gray-50 rounded"
+                      >
+                        <ArrowDownTrayIcon className="h-5 w-5 text-blue-600" />
+                        <span className="text-sm">Arquivo {index + 1}</span>
+                      </button>
+                    ))}
+                    {result.outputPath && (
+                      <button
+                        onClick={() => downloadFile(result.operacaoId, 0)}
+                        className="flex items-center space-x-2 w-full p-2 hover:bg-gray-50 rounded"
+                      >
+                        <ArrowDownTrayIcon className="h-5 w-5 text-blue-600" />
+                        <span className="text-sm">Download</span>
+                      </button>
+                    )}
+                  </div>
+                )}
+
+                {selectedOperation === 'ocr' && result.text && (
+                  <div className="mt-4">
+                    <p className="font-medium mb-2">Texto extraído:</p>
+                    <div className="bg-gray-50 p-4 rounded max-h-64 overflow-y-auto">
+                      <pre className="text-sm whitespace-pre-wrap">{result.text}</pre>
+                    </div>
+                    {result.confidence && (
+                      <p className="text-sm text-gray-600 mt-2">
+                        Confiança: {result.confidence.toFixed(2)}%
+                      </p>
+                    )}
+                  </div>
+                )}
+              </div>
+            )}
+          </div>
+
+          {/* Histórico */}
+          <div className="lg:col-span-1">
+            <div className="bg-white rounded-lg shadow p-6 sticky top-8">
+              <h2 className="text-xl font-semibold mb-4">Histórico</h2>
+
+              {history.length === 0 ? (
+                <p className="text-gray-500 text-sm">Nenhuma operação ainda</p>
+              ) : (
+                <div className="space-y-3 max-h-96 overflow-y-auto">
+                  {history.map((op) => (
+                    <div key={op.id} className="border-b pb-3">
+                      <div className="flex items-center justify-between">
+                        <span className="text-sm font-medium">
+                          {op.tipoOperacao.replace('_', ' ')}
+                        </span>
+                        <span
+                          className={`text-xs px-2 py-1 rounded ${
+                            op.status === 'CONCLUIDO'
+                              ? 'bg-green-100 text-green-800'
+                              : op.status === 'ERRO'
+                              ? 'bg-red-100 text-red-800'
+                              : 'bg-yellow-100 text-yellow-800'
+                          }`}
+                        >
+                          {op.status}
+                        </span>
+                      </div>
+                      <div className="flex items-center text-xs text-gray-500 mt-1">
+                        <ClockIcon className="h-3 w-3 mr-1" />
+                        {new Date(op.criadoEm).toLocaleString('pt-BR')}
+                      </div>
+                      {op.tempoProcessamento && (
+                        <p className="text-xs text-gray-500 mt-1">
+                          {op.tempoProcessamento}ms
+                        </p>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

src/services/pdfService.ts

@@ -0,0 +1,588 @@
+import { PDFDocument } from 'pdf-lib';
+import sharp from 'sharp';
+import { createWorker } from 'tesseract.js';
+import { fromPath } from 'pdf2pic';
+import fs from 'fs/promises';
+import path from 'path';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Serviço completo de manipulação de PDFs
+ * Implementa compressão sem perda, divisão, mesclagem, conversão e OCR
+ */
+
+interface CompressOptions {
+  quality?: number; // 0-100, padrão 95 para qualidade alta
+  maxSizeMB?: number;
+}
+
+interface SplitOptions {
+  splitType: 'pages' | 'range' | 'chunks';
+  pages?: number[]; // Páginas específicas para extrair
+  ranges?: Array<{ start: number; end: number }>; // Intervalos de páginas
+  chunkSize?: number; // Tamanho de cada chunk em páginas
+}
+
+interface MergeOptions {
+  filePaths: string[];
+  outputPath: string;
+}
+
+interface PDFToImageOptions {
+  format?: 'png' | 'jpg' | 'webp';
+  quality?: number;
+  density?: number; // DPI, padrão 300
+  pages?: number[] | 'all'; // Páginas específicas ou todas
+}
+
+interface ImageToPDFOptions {
+  imagePaths: string[];
+  outputPath: string;
+  pageSize?: { width: number; height: number };
+  fitToPage?: boolean;
+}
+
+interface OCROptions {
+  language?: string; // padrão 'por' (português)
+  pages?: number[] | 'all';
+}
+
+interface OCRResult {
+  text: string;
+  confidence: number;
+  pages: Array<{
+    pageNumber: number;
+    text: string;
+    confidence: number;
+  }>;
+}
+
+export class PDFService {
+  private static readonly TEMP_DIR = path.join(process.cwd(), 'storage', 'temp', 'pdf-ops');
+  private static readonly OUTPUT_DIR = path.join(process.cwd(), 'storage', 'pdf-output');
+
+  /**
+   * Inicializa os diretórios necessários
+   */
+  static async initialize(): Promise<void> {
+    try {
+      await fs.mkdir(this.TEMP_DIR, { recursive: true });
+      await fs.mkdir(this.OUTPUT_DIR, { recursive: true });
+    } catch (error) {
+      console.error('Erro ao criar diretórios:', error);
+      throw new Error('Falha ao inicializar diretórios para operações de PDF');
+    }
+  }
+
+  /**
+   * Comprime um PDF mantendo a qualidade máxima possível
+   * Usa otimização de streams e remoção de metadados desnecessários
+   */
+  static async compressPDF(
+    inputPath: string,
+    outputPath?: string,
+    options: CompressOptions = {}
+  ): Promise<{ outputPath: string; originalSize: number; compressedSize: number; reduction: number }> {
+    try {
+      await this.initialize();
+
+      const { quality = 95 } = options;
+
+      // Lê o PDF original
+      const pdfBytes = await fs.readFile(inputPath);
+      const originalSize = pdfBytes.length;
+
+      // Carrega o PDF
+      const pdfDoc = await PDFDocument.load(pdfBytes, {
+        updateMetadata: false,
+      });
+
+      // Remove metadados desnecessários mas mantém metadados essenciais
+      pdfDoc.setTitle('');
+      pdfDoc.setAuthor('');
+      pdfDoc.setSubject('');
+      pdfDoc.setKeywords([]);
+      pdfDoc.setProducer('');
+      pdfDoc.setCreator('');
+
+      // Salva com compressão
+      const compressedBytes = await pdfDoc.save({
+        useObjectStreams: true, // Comprime streams de objetos
+        addDefaultPage: false,
+        objectsPerTick: 50,
+      });
+
+      // Se a compressão não foi suficiente, otimiza as imagens
+      let finalBytes = compressedBytes;
+      
+      if (options.maxSizeMB && compressedBytes.length > options.maxSizeMB * 1024 * 1024) {
+        // Recarrega para otimizar imagens
+        const reloadedDoc = await PDFDocument.load(compressedBytes);
+        const pages = reloadedDoc.getPages();
+
+        // Processa cada página para otimizar imagens
+        for (const page of pages) {
+          // A otimização de imagens seria feita aqui
+          // Por limitações da pdf-lib, mantemos a qualidade original
+        }
+
+        finalBytes = await reloadedDoc.save({
+          useObjectStreams: true,
+          addDefaultPage: false,
+        });
+      }
+
+      // Define o caminho de saída
+      const finalOutputPath = outputPath || path.join(
+        this.OUTPUT_DIR,
+        `compressed-${uuidv4()}.pdf`
+      );
+
+      // Salva o arquivo comprimido
+      await fs.writeFile(finalOutputPath, finalBytes);
+
+      const compressedSize = finalBytes.length;
+      const reduction = ((originalSize - compressedSize) / originalSize) * 100;
+
+      return {
+        outputPath: finalOutputPath,
+        originalSize,
+        compressedSize,
+        reduction: Math.max(0, reduction),
+      };
+    } catch (error) {
+      console.error('Erro ao comprimir PDF:', error);
+      throw new Error(`Falha ao comprimir PDF: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+
+  /**
+   * Divide um PDF em múltiplos arquivos
+   */
+  static async splitPDF(
+    inputPath: string,
+    options: SplitOptions
+  ): Promise<string[]> {
+    try {
+      await this.initialize();
+
+      const pdfBytes = await fs.readFile(inputPath);
+      const pdfDoc = await PDFDocument.load(pdfBytes);
+      const totalPages = pdfDoc.getPageCount();
+      const outputPaths: string[] = [];
+
+      if (options.splitType === 'pages' && options.pages) {
+        // Divide em páginas específicas
+        for (const pageNum of options.pages) {
+          if (pageNum < 1 || pageNum > totalPages) {
+            throw new Error(`Página ${pageNum} inválida. O PDF tem ${totalPages} páginas.`);
+          }
+
+          const newDoc = await PDFDocument.create();
+          const [copiedPage] = await newDoc.copyPages(pdfDoc, [pageNum - 1]);
+          newDoc.addPage(copiedPage);
+
+          const outputPath = path.join(this.OUTPUT_DIR, `split-page-${pageNum}-${uuidv4()}.pdf`);
+          const newPdfBytes = await newDoc.save();
+          await fs.writeFile(outputPath, newPdfBytes);
+          outputPaths.push(outputPath);
+        }
+      } else if (options.splitType === 'range' && options.ranges) {
+        // Divide em intervalos de páginas
+        for (let i = 0; i < options.ranges.length; i++) {
+          const { start, end } = options.ranges[i];
+
+          if (start < 1 || end > totalPages || start > end) {
+            throw new Error(`Intervalo inválido: ${start}-${end}. O PDF tem ${totalPages} páginas.`);
+          }
+
+          const newDoc = await PDFDocument.create();
+          const pageIndices = Array.from({ length: end - start + 1 }, (_, idx) => start - 1 + idx);
+          const copiedPages = await newDoc.copyPages(pdfDoc, pageIndices);
+          copiedPages.forEach((page) => newDoc.addPage(page));
+
+          const outputPath = path.join(this.OUTPUT_DIR, `split-range-${start}-${end}-${uuidv4()}.pdf`);
+          const newPdfBytes = await newDoc.save();
+          await fs.writeFile(outputPath, newPdfBytes);
+          outputPaths.push(outputPath);
+        }
+      } else if (options.splitType === 'chunks' && options.chunkSize) {
+        // Divide em chunks de tamanho fixo
+        const chunkSize = options.chunkSize;
+        const numChunks = Math.ceil(totalPages / chunkSize);
+
+        for (let i = 0; i < numChunks; i++) {
+          const startPage = i * chunkSize;
+          const endPage = Math.min((i + 1) * chunkSize, totalPages);
+
+          const newDoc = await PDFDocument.create();
+          const pageIndices = Array.from({ length: endPage - startPage }, (_, idx) => startPage + idx);
+          const copiedPages = await newDoc.copyPages(pdfDoc, pageIndices);
+          copiedPages.forEach((page) => newDoc.addPage(page));
+
+          const outputPath = path.join(this.OUTPUT_DIR, `split-chunk-${i + 1}-${uuidv4()}.pdf`);
+          const newPdfBytes = await newDoc.save();
+          await fs.writeFile(outputPath, newPdfBytes);
+          outputPaths.push(outputPath);
+        }
+      } else {
+        throw new Error('Opções de divisão inválidas');
+      }
+
+      return outputPaths;
+    } catch (error) {
+      console.error('Erro ao dividir PDF:', error);
+      throw new Error(`Falha ao dividir PDF: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+
+  /**
+   * Mescla múltiplos PDFs em um único arquivo
+   */
+  static async mergePDFs(options: MergeOptions): Promise<string> {
+    try {
+      await this.initialize();
+
+      if (!options.filePaths || options.filePaths.length === 0) {
+        throw new Error('Nenhum arquivo fornecido para mesclagem');
+      }
+
+      const mergedDoc = await PDFDocument.create();
+
+      // Mescla cada PDF
+      for (const filePath of options.filePaths) {
+        try {
+          const pdfBytes = await fs.readFile(filePath);
+          const pdfDoc = await PDFDocument.load(pdfBytes);
+          const copiedPages = await mergedDoc.copyPages(pdfDoc, pdfDoc.getPageIndices());
+          copiedPages.forEach((page) => mergedDoc.addPage(page));
+        } catch (error) {
+          console.error(`Erro ao processar arquivo ${filePath}:`, error);
+          throw new Error(`Falha ao processar arquivo ${path.basename(filePath)}`);
+        }
+      }
+
+      const outputPath = options.outputPath || path.join(
+        this.OUTPUT_DIR,
+        `merged-${uuidv4()}.pdf`
+      );
+
+      const mergedBytes = await mergedDoc.save();
+      await fs.writeFile(outputPath, mergedBytes);
+
+      return outputPath;
+    } catch (error) {
+      console.error('Erro ao mesclar PDFs:', error);
+      throw new Error(`Falha ao mesclar PDFs: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+
+  /**
+   * Converte páginas de PDF em imagens
+   */
+  static async pdfToImages(
+    inputPath: string,
+    options: PDFToImageOptions = {}
+  ): Promise<string[]> {
+    try {
+      await this.initialize();
+
+      const {
+        format = 'png',
+        quality = 95,
+        density = 300,
+        pages = 'all',
+      } = options;
+
+      const pdfBytes = await fs.readFile(inputPath);
+      const pdfDoc = await PDFDocument.load(pdfBytes);
+      const totalPages = pdfDoc.getPageCount();
+
+      // Determina quais páginas converter
+      const pagesToConvert = pages === 'all'
+        ? Array.from({ length: totalPages }, (_, i) => i + 1)
+        : pages;
+
+      const outputPaths: string[] = [];
+
+      // Configura o conversor
+      const converter = fromPath(inputPath, {
+        density,
+        saveFilename: uuidv4(),
+        savePath: this.OUTPUT_DIR,
+        format,
+        width: 2480, // A4 em 300 DPI
+        height: 3508,
+      });
+
+      // Converte cada página
+      for (const pageNum of pagesToConvert) {
+        if (pageNum < 1 || pageNum > totalPages) {
+          console.warn(`Página ${pageNum} ignorada - fora do intervalo`);
+          continue;
+        }
+
+        try {
+          const result = await converter(pageNum, { responseType: 'image' });
+          
+          if (result && typeof result === 'object' && 'path' in result) {
+            const imagePath = result.path as string;
+            
+            // Otimiza a imagem com sharp
+            const optimizedPath = path.join(
+              this.OUTPUT_DIR,
+              `page-${pageNum}-${uuidv4()}.${format}`
+            );
+
+            if (format === 'jpg') {
+              await sharp(imagePath)
+                .jpeg({ quality, progressive: true })
+                .toFile(optimizedPath);
+            } else if (format === 'png') {
+              await sharp(imagePath)
+                .png({ quality, progressive: true, compressionLevel: 9 })
+                .toFile(optimizedPath);
+            } else if (format === 'webp') {
+              await sharp(imagePath)
+                .webp({ quality })
+                .toFile(optimizedPath);
+            }
+
+            // Remove o arquivo temporário
+            await fs.unlink(imagePath).catch(() => {});
+
+            outputPaths.push(optimizedPath);
+          }
+        } catch (error) {
+          console.error(`Erro ao converter página ${pageNum}:`, error);
+        }
+      }
+
+      return outputPaths;
+    } catch (error) {
+      console.error('Erro ao converter PDF para imagens:', error);
+      throw new Error(`Falha ao converter PDF para imagens: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+
+  /**
+   * Converte imagens em PDF
+   */
+  static async imagesToPDF(options: ImageToPDFOptions): Promise<string> {
+    try {
+      await this.initialize();
+
+      if (!options.imagePaths || options.imagePaths.length === 0) {
+        throw new Error('Nenhuma imagem fornecida para conversão');
+      }
+
+      const pdfDoc = await PDFDocument.create();
+
+      for (const imagePath of options.imagePaths) {
+        try {
+          const imageBytes = await fs.readFile(imagePath);
+          const ext = path.extname(imagePath).toLowerCase();
+
+          let image;
+          if (ext === '.png') {
+            image = await pdfDoc.embedPng(imageBytes);
+          } else if (ext === '.jpg' || ext === '.jpeg') {
+            image = await pdfDoc.embedJpg(imageBytes);
+          } else {
+            // Converte outros formatos para PNG primeiro
+            const pngBuffer = await sharp(imageBytes).png().toBuffer();
+            image = await pdfDoc.embedPng(pngBuffer);
+          }
+
+          const { width, height } = image;
+
+          // Define o tamanho da página
+          let pageWidth = width;
+          let pageHeight = height;
+
+          if (options.pageSize) {
+            pageWidth = options.pageSize.width;
+            pageHeight = options.pageSize.height;
+          }
+
+          const page = pdfDoc.addPage([pageWidth, pageHeight]);
+
+          // Calcula dimensões para ajustar à página se necessário
+          if (options.fitToPage) {
+            const scale = Math.min(pageWidth / width, pageHeight / height);
+            const scaledWidth = width * scale;
+            const scaledHeight = height * scale;
+            const x = (pageWidth - scaledWidth) / 2;
+            const y = (pageHeight - scaledHeight) / 2;
+
+            page.drawImage(image, {
+              x,
+              y,
+              width: scaledWidth,
+              height: scaledHeight,
+            });
+          } else {
+            page.drawImage(image, {
+              x: 0,
+              y: 0,
+              width: pageWidth,
+              height: pageHeight,
+            });
+          }
+        } catch (error) {
+          console.error(`Erro ao processar imagem ${imagePath}:`, error);
+          throw new Error(`Falha ao processar imagem ${path.basename(imagePath)}`);
+        }
+      }
+
+      const outputPath = options.outputPath || path.join(
+        this.OUTPUT_DIR,
+        `images-to-pdf-${uuidv4()}.pdf`
+      );
+
+      const pdfBytes = await pdfDoc.save();
+      await fs.writeFile(outputPath, pdfBytes);
+
+      return outputPath;
+    } catch (error) {
+      console.error('Erro ao converter imagens para PDF:', error);
+      throw new Error(`Falha ao converter imagens para PDF: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+
+  /**
+   * Realiza OCR em um PDF e extrai o texto
+   */
+  static async performOCR(
+    inputPath: string,
+    options: OCROptions = {}
+  ): Promise<OCRResult> {
+    try {
+      await this.initialize();
+
+      const { language = 'por', pages = 'all' } = options;
+
+      // Primeiro converte o PDF em imagens
+      const imageOptions: PDFToImageOptions = {
+        format: 'png',
+        density: 300,
+        pages,
+      };
+
+      const imagePaths = await this.pdfToImages(inputPath, imageOptions);
+
+      // Cria um worker do Tesseract
+      const worker = await createWorker(language);
+
+      const pageResults: Array<{
+        pageNumber: number;
+        text: string;
+        confidence: number;
+      }> = [];
+
+      let allText = '';
+      let totalConfidence = 0;
+
+      // Processa cada imagem
+      for (let i = 0; i < imagePaths.length; i++) {
+        try {
+          const imagePath = imagePaths[i];
+          const { data } = await worker.recognize(imagePath);
+
+          pageResults.push({
+            pageNumber: i + 1,
+            text: data.text,
+            confidence: data.confidence,
+          });
+
+          allText += data.text + '\n\n';
+          totalConfidence += data.confidence;
+
+          // Remove a imagem temporária
+          await fs.unlink(imagePath).catch(() => {});
+        } catch (error) {
+          console.error(`Erro ao processar OCR na página ${i + 1}:`, error);
+        }
+      }
+
+      await worker.terminate();
+
+      const averageConfidence = pageResults.length > 0
+        ? totalConfidence / pageResults.length
+        : 0;
+
+      return {
+        text: allText.trim(),
+        confidence: averageConfidence,
+        pages: pageResults,
+      };
+    } catch (error) {
+      console.error('Erro ao realizar OCR:', error);
+      throw new Error(`Falha ao realizar OCR: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+
+  /**
+   * Limpa arquivos temporários antigos
+   */
+  static async cleanupOldFiles(olderThanHours: number = 24): Promise<void> {
+    try {
+      const dirs = [this.TEMP_DIR, this.OUTPUT_DIR];
+      const now = Date.now();
+      const maxAge = olderThanHours * 60 * 60 * 1000;
+
+      for (const dir of dirs) {
+        try {
+          const files = await fs.readdir(dir);
+
+          for (const file of files) {
+            const filePath = path.join(dir, file);
+            const stats = await fs.stat(filePath);
+
+            if (now - stats.mtimeMs > maxAge) {
+              await fs.unlink(filePath);
+              console.log(`Arquivo removido: ${filePath}`);
+            }
+          }
+        } catch (error) {
+          console.error(`Erro ao limpar diretório ${dir}:`, error);
+        }
+      }
+    } catch (error) {
+      console.error('Erro ao limpar arquivos antigos:', error);
+    }
+  }
+
+  /**
+   * Obtém informações sobre um PDF
+   */
+  static async getPDFInfo(filePath: string): Promise<{
+    pages: number;
+    size: number;
+    title?: string;
+    author?: string;
+    creator?: string;
+    producer?: string;
+    creationDate?: Date;
+    modificationDate?: Date;
+  }> {
+    try {
+      const pdfBytes = await fs.readFile(filePath);
+      const pdfDoc = await PDFDocument.load(pdfBytes);
+
+      return {
+        pages: pdfDoc.getPageCount(),
+        size: pdfBytes.length,
+        title: pdfDoc.getTitle(),
+        author: pdfDoc.getAuthor(),
+        creator: pdfDoc.getCreator(),
+        producer: pdfDoc.getProducer(),
+        creationDate: pdfDoc.getCreationDate(),
+        modificationDate: pdfDoc.getModificationDate(),
+      };
+    } catch (error) {
+      console.error('Erro ao obter informações do PDF:', error);
+      throw new Error(`Falha ao obter informações do PDF: ${error instanceof Error ? error.message : 'Erro desconhecido'}`);
+    }
+  }
+}