如何使用 Node.js 和 TypeScript 构建自定义的 PDF 文本提取工具

创建解析逻辑

解析逻辑是用于解析PDF文件的核心功能。它是一个异步函数，能够从PDF缓冲区中提取文本内容和元数据。

async function parsePDF(file: Uint8Array) {
  const parser = new PDFParse(file);
  const data = await parser.getText();
  const info = await parser.getInfo({ parsePageInfo: true });
  return { text: data?.text || "", info, numpages: info?.pages || 0 };
}

让我们来看看代码中具体发生了什么：

• 该函数接受一个包含原始PDF文件数据的Uint8Array缓冲区作为参数。

• 使用这个PDF缓冲区创建了一个新的PDFParse对象。

• 调用getText()方法来提取PDF文件中的所有文本内容。

• 同时调用getInfo()方法，并设置parsePageInfo: true，以获取文档的元信息，包括页数。

• 最终返回一个对象，其中包含以下内容：

  • text：提取出的文本内容（如果没有找到文本，则返回空字符串）

  • info：文档的元数据，如作者、标题、创建日期等

  • numpages：PDF文件的总页数

为什么解析逻辑是异步的？

无论是getText()还是getInfo()，都属于异步操作。它们都需要一定的时间来解析PDF文件的内容，因此使用await可以确保这些操作完成后再返回结果。这样就能避免在处理大型PDF文件时导致服务器堵塞。

创建PDF上传与处理端点

现在你已经拥有了核心的parsePDF()函数，接下来需要创建一个端点，该端点能够接收文件上传，并使用这个函数来处理这些文件。

app.post("/upload", async (req: Request, res: Response) => {  
  try {    
    if (!req.files || !("file" in req.files)) {      
      return res.status(400).json({        
        error: "没有分享PDF文件。",        
        body: `请求体内容为：${JSON.stringify(req.body)}`,        
      });    
    }    

    const pdfFile = req.files.file as UploadedFile;    
    const unit8ArrayData = new Uint8Array(pdfFile?.data);    
    const result = await parsePDF(unit8ArrayData);    
    console.log("PDF文件解析成功，结果为：", result);    
    res.json({ result, success: true });  
  } catch (error) {    
    console.error("处理PDF文件时出现错误：", error);    
    if (error instanceof Error) {      
      return res.status(500).json({        
        error: error.message,        
        success: false,        
      });    
    }    
    res.status(500).json({        
      error: "由于未知原因，无法处理PDF文件。",        
      success: false,        
    });  
  }  
});

让我们来详细分析这段代码中发生的作用：

• 你在 `/upload` 路由上定义了一个处理 PDF 文件上传的函数。该函数使用 `req.files` 来获取上传的文件，并检查请求中是否包含 “file” 字段。

• 该函数会提取上传的 PDF 文件，并将其转换为 `Uint8Array` 类型，因为 `parsePDF()` 函数需要这种格式才能进行 PDF 解析操作。

• 你使用了 try-catch 块来实现全面的错误处理机制：

  • 会将错误信息记录到控制台，以便于调试。

  • 当错误属于 `Error` 类时，会返回具体的错误信息。

  • 对于其他意外故障，也会返回相应的错误响应，并确保客户端收到的响应中始终包含 `success: false` 这一字段，以保证一致性。

这个路由处理器创建了一个用于处理 PDF 文件的接口：它能够验证输入数据、高效地处理文件上传操作，并提供清晰的错误反馈信息。

启动你的服务器

最后一步就是启动 Express 服务器，确认它是否正常运行。

const PORT = process.env.PORT || 8080;

app.listen(PORT, () => {
  console.log(`🚀 服务器正在 http://localhost:${PORT} 上运行`);
});

• app.listen()：将 Express 服务器绑定到指定的端口上，然后开始监听传入的请求。

• 端口号配置：如果设置了 `PORT` 环境变量，服务器就会使用该值；否则默认使用 `8080` 端口。

• 回调函数：当服务器启动后，这个回调函数会向控制台输出服务器的地址。

使用以下命令来启动你的服务器：

npm run dev

如果服务器成功启动，你会在控制台中看到如下信息：

🚀 服务器正在 http://localhost:8080 上运行

现在，你的 PDF 解析器 API 已经可以接收文件上传并处理 PDF 文件了。

你可以通过 Postman 或其他喜欢的 API 客户端，访问该接口来验证它的功能是否正常。

恭喜！你成功开发出了一个自定义的 PDF 解析器。

这个解析器对于简单的 PDF 处理任务来说已经足够使用了，但你也可以进一步扩展它的功能，使其更加强大。

在接下来的章节中，你会添加一些额外的功能，比如处理损坏的文件。

添加针对特定页面的提取功能

在处理较大的PDF文件时，提取整个文件的内容往往既效率低下又没有必要。这一功能允许用户指定特定的页面范围，从而仅从这些页面中提取文本。这样一来，解析器在面对实际应用场景时就会变得更加灵活、高效。

例如，用户可能只想从一份100页的报告中提取第5页到第10页的内容。通过在你的接口中添加可选的查询参数startPage和endPage，用户就可以精确地控制自己想要解析PDF文档中的哪些部分。

在本节中，你将创建一个专门用于提取特定页面内容的函数，以及一个用于处理请求参数的接口。

创建用于提取特定页面内容的函数

这个专门用于提取特定页面内容的函数是整个系统的核心部分，它的作用就是解析用户指定的那些页面。

// 用于从指定页面范围中提取文本的函数
async function parsePageRangeFromPDF(
  file: Uint8Array,
  startPage: number,
  endPage: number,
) {
  const parser = new PDFParse(file);
  const info = await parser.getInfo({ parsePageInfo: true });
  const totalPages = Array.isArray(info?.pages)
    ? info.pages.length
    : (info?.pages as number) || 0;

  if (startPage < 1 || endPage > totalPages || startPage > endPage) {
    throw new Error(
      `无效的页面范围。该PDF文件共有${totalPages}页。请提供有效的页面范围，确保开始页数大于或等于1，结束页数小于或等于总页数，并且开始页数小于结束页数。`
    );
  }

  const data = await parser.getText();
  const lines = data?.text?.split("\n") || [];

  // 注意：pdf-parse库并不提供直接的页面筛选功能，因此getText()方法会返回文档中的所有文本。
  // 如果你需要准确提取指定范围内的页面内容，可以考虑使用其他PDF处理库。
  return { text: data?.text || "", startPage, endPage, totalPages };
}

让我们来详细分析一下这段代码的功能：

1. 你定义了一个async函数parsePageRangeFromPDF，它的作用是从PDF文档中提取指定页面范围内的文本。这个函数接受一个Uint8Array类型的PDF文件对象，以及两个表示起始页码和结束页码的数值参数。

2. 该函数使用了PDFParse库来分析PDF文件的结构，首先通过parser.getInfo()方法获取文档的元数据信息，包括总页数。然后它会检查用户请求的页面范围是否在文档的有效范围内。

3. 验证通过后，函数会使用parser.getText()方法提取所有文本内容，并将这些文本按行分割开来。最后，它返回一个对象，其中包含了提取到的文本、以及关于请求的页面范围和总页数的元数据信息。

这个函数为从PDF文件中提取特定页面内容提供了便捷且可靠的解决方案，同时还包含了完善的验证机制和错误处理功能。

创建用于提取特定页面内容的接口

现在你已经创建了用于解析PDF文档中指定页面内容的函数，接下来就需要创建一个接口，用来接收用户上传的PDF文件并执行相应的解析操作。

// 用于提取指定页面范围内的PDF文本的端点
app.post("/upload-page-range", async (req: Request, res: Response) => {
  try {
    if (!req.files || !("file" in req.files)) {
      return res.status(400).json({
        error: "没有分享PDF文件。",
      });
    }

    // 从查询参数或请求体中获取页面范围
    const startPage = parseInt(
      (req.query.startPage as string) || (req.body?.startPage as string) || "1"
    );
    const endPage = parseInt(
      (req.query.endPage as string) || (req.body?.endPage as string) || "1"
    );

    if (isNaN(startPage) || isNaN(endPage)) {
      return res.status(400).json({
        error: "页面范围无效。请提供有效的整数作为startPage和endPage。",
      });
    }

    const pdfFile = req.files.file as UploadedFile;
    const unit8ArrayData = new Uint8Array(pdfFile?.data);
    const result = await parsePageRangeFromPDF(
      unit8ArrayData,
      startPage,
      endPage
    );
    console.log(
      `成功提取了从${startPage}到${endPage}的页面内容：`, 
      result
    );
    res.json({ result, success: true });
  } catch (error) {
    console.error("处理PDF文件时出现错误：", error);
    if (error instanceof Error) {
      return res.status(400).json({ error: error.message, success: false });
    }
    res.status(500).json({
      error: "由于未知原因，无法处理PDF文件。",
      success: false,
    });
  }
});

让我们来分析一下这段代码中发生的操作：

1. 你在 `/upload-page-range` 路由上定义了一个处理程序，该程序可以从上传的 PDF 文件中提取特定页码范围内的文本。首先，这个处理程序会通过 `req.files` 来检查请求中是否包含 PDF 文件；如果没有文件，就会返回 400 错误。

2. 该函数会从查询参数或请求体中获取 `startPage` 和 `endPage` 的值，如果这两个参数都没有被指定，它会使用默认值 “1”。然后，它会通过 `isNaN()` 函数来验证这些值是否为有效的整数，这样就能确保对页码范围请求的处理更加可靠。

3. 一旦 PDF 文件被转换成缓冲区，它就会被传递给 `parsePageRangeFromPDF()` 函数，以便提取用户所要求的页面内容。API 会返回提取到的文本以及相关的页码范围信息；如果出现错误，也会明确指出错误类型：验证失败会导致 400 错误，服务器问题则会导致 500 错误。

这个接口为客户端提供了一种专门用于处理 PDF 文件的机制，使用户能够只提取特定页码范围内的文本，而无需处理整个文档。

现在，你可以使用查询参数来指定要提取的页面了：

curl -F "file=@yourfile.pdf" "http://localhost:8080/upload-page-range?startPage=5&endPage=7"

或者也可以通过请求体来传递这些参数：

curl -X POST -F "file=@yourfile.pdf" \
  -F "startPage=5" \
  -F "endPage=7" \
  http://localhost:8080/upload-page-range

在下一节中，你将添加一个专门用于获取上传文件元数据的接口。

添加仅提供元数据的轻量级接口

创建这样一个仅提供元数据的轻量级接口，可以让用户快速验证和查看 PDF 文件的内容，而无需对整个文档进行处理。

这在处理文件之前预览文件信息时非常有用。

创建元数据提取函数

添加一个仅用于获取文档信息的新函数：

async function getPDFMetadata(file: Uint8Array) {
  const parser = new PDFParse(file);
  const info = await parser.getInfo({ parsePageInfo: true });
  return {
    title: info?.info?.Title || "N/A",
    author: info?.info?.Author || "N/A",
    subject: info?.info?.Subject || "N/A",
    creator: info?.info?.Creator || "N/A",
    producer: info?.info?.Producer || "N/A",
    creationDate: convertPDFDateToReadable(info?.info?.CreationDate || "N/A"),
    modificationDate: convertPDFDateToReadable(info?.info?.ModDate || "N/A"),
    pages: info?.total || 0,
  };
}

让我们来分析一下这段代码中发生的操作：

1. 你定义了一个名为`getPDFMetadata`的`async`函数，该函数用于从PDF文档中提取并处理元数据。这个函数接受一个`Uint8Array`类型的PDF文件缓冲区，并使用`PDFParse`库来获取文档信息。

2. 该函数会提取PDF文档中的关键元数据字段，包括标题、作者、主题、创建者和制作者等；当这些字段缺失时，会返回“N/A”作为默认值。这样一来，即使某些PDF文件缺少部分信息，该函数也能始终返回一个完整的元数据对象。

3. 你还实现了一个名为`convertPDFDateToReadable`的辅助函数，用于将PDF文档中特殊的日期格式转换成人类可读的形式。这个函数会返回一个结构化对象，其中包含所有提取到的元数据以及总页数。

这个实用函数为提取和规范处理PDF元数据提供了便捷的方式，使人们能够以标准化的格式轻松获取文档的作者信息、创建日期和页数等数据。

以下是`convertPDFDateToReadable`函数的实现代码：

function convertPDFDateToReadable(pdfDateString: string): string {
  try {
    // 如果日期字符串以“D:”开头，则去除这个前缀
    let dateStr = pdfDateString.startsWith("D:")
      ? pdfDateString.slice(2)
      : pdfDateString;

    // 提取日期和时间成分（格式为YYYYMMDDHHmmss）
    const year = dateStr.substring(0, 4);
    const month = dateStr.substring(4, 6);
    const day = dateStr.substring(6, 8);
    const hour = dateStr.substring(8, 10);
    const minute = dateStr.substring(10, 12);
    const second = dateStr.substring(12, 14);

    // 验证日期成分的有效性
    const monthNum = parseInt(month);
    const dayNum = parseInt(day);

    if (monthNum < 1 || monthNum > 12 || dayNum < 1 || dayNum > 31) {
      throw new Error("无效的日期值");
    }

    // 返回格式为dd/mm/yyyy的日期字符串
    return `${day}/${month}/${year}`;
  } catch (error) {
    console.error("在转换PDF日期时发生错误:", error);
    return "无效的日期";
  }
}

创建元数据端点

创建一个POST端点，该端点接受文件上传，并仅返回元数据信息：

app.post("/metadata", async (req: Request, res: Response) => {
  try {
    if (!req.files || !("file" in req.files)) {
      return res.status(400).json({
        error: "没有上传PDF文件。",
      });
    }

    const pdfFile = req.files.file as UploadedFile;
    const unit8ArrayData = new Uint8Array(pdfFile?.data);
    const metadata = await getPDFMetadata(unit8ArrayData);

    console.log("成功提取了PDF元数据：", metadata);
    res.json({ metadata, success: true });
  } catch (error) {
    console.error("在提取元数据时发生错误:", error);
    if (error instanceof Error) {
      return res.status(500).json({ error: error.message, success: false });
    }
    res.status(500).json({
      error: "由于未知原因，无法提取元数据。",
      success: false,
    });
  }
});

让我们来详细分析这段代码中发生的操作：

1. 你在 `/metadata` 路由上定义了一个处理程序，该程序会从上传的 PDF 文件中提取元数据并将其返回。首先，该程序会使用 `req.files` 来验证请求中是否确实存在 PDF 文件；如果没有文件被提供，就会返回一个带有明确错误信息的 400 错误码。

2. 随后，这个函数会将上传的 PDF 文件转换为 `Uint8Array` 格式，因为你之前创建的 `getPDFMetadata()` 工具函数需要这种格式的数据。这种转换能确保 PDF 数据具备被 PDF 解析库处理的正确格式。

3. 在成功提取元数据后，该处理程序会将结果记录下来，并以结构化的 JSON 格式返回给客户端。完善的错误处理机制能够捕获处理过程中出现的任何问题，在遇到问题时就会返回相应的 500 错误码及描述性信息，同时确保响应格式的一致性。

这个接口为提取 PDF 文件的元数据提供了专门的支持，比如文件标题、作者、创建日期和页数等信息。这样一来，用户就可以轻松分析 PDF 文档的属性，而无需逐个解析文件的全部内容。

现在，你可以仅提取上传文件的元数据了：

curl -X POST -F "file=@document.pdf" http://localhost:8080/metadata

你收到的响应应该如下所示：

{
    "metadata": {
        "title": "MSA",
        "author": "N/A",
        "subject": "N/A",
        "creator": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/144.0.0.0 Safari/537.36",
        "producer": "Skia/PDF m144",
        "creationDate": "22/01/2026",
        "modificationDate": "22/01/2026",
        "pages": 26
    },
    "success": true
}

添加搜索/查找功能

在处理较大的 PDF 文件时，手动查找特定信息会非常耗时。搜索功能允许用户在 PDF 文件中查找关键词，并立即得到结果显示哪些页面包含了该关键词以及该关键词出现了多少次。

这一功能对于研究、合规性检查或文档分析等工作来说尤为有用。

例如，用户可能希望在一份长达50页的财务报告中找到所有包含“发票”这个词的内容，或者在一份法律文件中查找“第3.2条”这一条款。通过提供一个专门用于搜索的接口，该接口能够接受PDF文件和关键词作为输入，你就能帮助客户快速浏览大量文档，而无需逐一阅读每一页的内容。

在本节中，你将创建一个搜索函数，该函数能够在PDF文本中查找关键词，并且还会创建一个接收文件上传以及搜索查询的接口。

创建搜索/查找功能

搜索函数是核心工具，它能够在PDF文档中找到关键词，并返回关于这些关键词位置的详细信息。

async function searchPDFText(
  file: Uint8Array,
  searchQuery: string,
  caseSensitive: boolean = false
) const parser = new PDFParse(file);
  const info = await parser.getInfo({ parsePageInfo: true });
  const totalPages = Array.isArray(info?.pages)
    ? info.pages.length
    : (info?.pages as number) || 0;

  const results = {
    query: searchQuery,
    caseSensitive,
    matchCount: 0,
    matches: [] as Array<{
      page: number;
      text: string;
      position: number;
    }>,
  };

  // 从所有页面中提取文本
  for (let page = 1; page <= totalPages; page++) {
    const data = await parser.getText();
    const pageText = data?.text || "";

    // 根据大小写敏感设置来确定搜索文本
    const searchText = caseSensitive ? searchQuery : searchQuery.toLowerCase();
    const compareText = caseSensitive ? pageText : pageText.toLowerCase();

    let searchIndex = 0;
    while ((searchIndex = compareText.indexOf(searchText, searchIndex)) !== -1) {
      // 提取上下文内容（搜索文本前后各100个字符）
      const startContext = Math.max(0, searchIndex - 50const endContext = Math.min(pageText.length, searchIndex + searchQuery.length + 50;
      const contextText = pageText.substring(startContext, endContext);

      results.matches.push({
        page,
        text: contextText.trim(),
        position: searchIndex,
      });

      results.matchCount++;
      searchIndex += searchText.length;
    }
  }

  return results;
}

让我们来分析一下这段代码中发生了什么：

1. 你定义了一个名为`searchPDFText`的`async`函数，该函数能够在PDF文档中执行文本搜索，并且可以选择是否区分大小写。这个函数接受一个PDF文件缓冲区、一个搜索查询字符串，以及一个`caseSensitive`参数，默认值为`false`，这样就可以实现更加灵活的搜索功能。

2. 该函数使用了`PDFParse`库来首先从PDF元数据中提取总页数。然后它会创建一个结果对象，用于记录搜索查询信息、大小写设置、匹配项的总数以及每个匹配项的具体位置、上下文文本等信息。

3. 对于PDF中的每一页，该函数都会提取文本，并根据`caseSensitive`参数的设置来执行区分大小写或不区分大小写的搜索。当找到匹配项时，它会截取每个匹配项前后各100个字符作为上下文内容，并将页面编号、位置以及上下文文本记录在结果对象中。

这个函数构建了一个功能强大的PDF搜索工具，它能够在文档中定位特定的文本内容，同时为每一个匹配项提供相应的上下文信息。因此，它在文档分析和内容检索应用中非常有用。

创建搜索/查找端点

现在你已经创建了这个搜索函数，接下来需要创建一个端点，该端点能够接收文件上传以及搜索查询字符串，并且也支持区分大小写的搜索功能。

app.post("/search", async (req: Request, res: Response) => {
  try {
    if (!req.files || !("file" in req.files)) {
      return res.status(400).json({
        error: "没有上传PDF文件。,
      });
    }

    // 获取搜索查询字符串和选项
    const query = (req.query.query as string) || (req.body?.query as string;
    const caseSensitive =
      (req.query.caseSensitive as string) === "true" ||
      req.body?.caseSensitive === true;

    if (!query || query.trim() === "") {
      return res.status(400).json({
        error: "需要提供搜索查询字符串。,
      });
    }

    const pdfFile = req.files.file as UploadedFile;
    const unit8ArrayData = new Uint8Array(pdfFile?.data);
    const results = await searchPDFText(unit8ArrayData, query, caseSensitive);

    if (results.matchCount === 0) {
      return res.json({
        result: results,
        success: true,
        message: "没有找到匹配项。,
      });
    }

    console.log(`找到了;
    res.json({ result: results, success: true });
  } catch (error) {
    console.error("搜索PDF时出现错误：, error);
    if (error instanceof Error) {
      return res.status(400).json({ error: error.message, success: false });
    }
    res.status(500).json({
      error: "由于未知错误，搜索PDF失败。,
      success: false,
    });
  }
});

让我们来详细分析这段代码中发生的操作：

1. 你在 `/search` 路由上定义了一个处理程序，该程序能够对上传的 PDF 文档进行全文搜索。在开始处理之前，系统会先进行验证，确保用户提供了 PDF 文件和搜索查询参数；如果缺少其中任何一项或这些参数为空，系统就会返回包含详细错误信息的 400 错误响应。

2. 该程序会从查询参数或请求体中提取搜索查询内容以及 `caseSensitive` 选项，并会对布尔值参数进行类型转换。随后，它会将上传的 PDF 文件转换为 `Uint8Array` 类型的缓冲区，并将这些数据连同搜索参数一起传递给 `searchPDFText()` 函数进行处理。

3. 根据搜索结果，该处理程序会返回相应的响应：如果没有找到匹配项，就会返回包含 “未找到匹配结果” 信息的成功响应；如果找到了匹配项，就会返回全部搜索结果。在错误处理方面，系统会区分客户端错误（例如输入无效导致的 400 错误）和服务器端错误（例如处理失败导致的 500 错误）。

这个接口为开发者提供了一个功能强大的 PDF 搜索 API，允许客户端根据可配置的区分大小写设置，在文档中查找特定文本，从而为文档分析应用提供精确的结果。

现在，你可以通过查询参数在 PDF 文件中搜索关键词了。

搜索 “example”（不区分大小写）：

curl -F "file=@document.pdf" "http://localhost:8080/search?query=example"

搜索 “Example”（区分大小写）：

curl -F "file=@document.pdf" "http://localhost:8080/search?query=Example&caseSensitive=true"

你也可以使用请求体来进行搜索：

curl -X POST -F "file=@document.pdf" \
  -F "query=PDF" \
  -F "caseSensitive=true" \
  http://localhost:8080/search

你收到的响应应该如下所示：

{
  "result": {
    "query": "PDF",
    "caseSensitive": false,
    "matchCount": 3,
    "matches": [
      {
        "page": 1,
        "text": "...这是一份 PDF 文档。PDF 格式是...",
        "position": 10
      },
      {
        "page": 2,
        "text": "...了解更多关于 PDF 标准的信息...",
        "position": 25
      }
    ]
  },
  "success": true
}

您现在已经为自己的PDF解析器添加了三个重要的功能。

在下一节中，我们将探讨如何处理一些特殊情况。

处理特殊情况与最佳实践

在构建自定义PDF解析器时，如果您希望打造一个更加稳定、可靠的解析工具，那么有一些特殊情况是需要特别注意的。

以下是一些需要留意的特殊情况：

损坏或格式错误的PDF文件

有些用户可能会上传损坏的PDF文件，也就是那些结构无效或头部信息被破坏的PDF文件。这类文件在处理过程中很可能会导致错误。

您可以将解析操作放在try-catch块中，以便优雅地处理这些错误。同时，您还需要提供清晰的错误提示，以便用户能够区分文件损坏与其他类型的错误。

受密码保护的PDF文件

PDF文件可以被设置用户密码或所有者密码进行加密。不过，pdf-parse工具对这类文件的支持比较有限，因此这会带来一些问题。

function validatePDFFile(pdfFile: UploadedFile): { valid: boolean; error?: string } {
  // 检查MIME类型
  if (pdfFile.mimetype !== "application/pdf") {
    return { valid: false, error: "无效的MIME类型。预期格式应为application/pdf" };
  }

  // 检查文件大小
  const maxSize = 50 * 1024 * 1024; // 50MB
  if (pdfFile.size > maxSize) {
    return { valid: false, error: "文件大小超过了50MB的限制" };
  }

  // 检查文件是否为空
  if (pdfFile.size === 0) {
    return { valid: false, error: "文件内容为空" };
  }

  // 检查文件的签名
  const data = new Uint8Array(pdfFile.data as ArrayBuffer);
  const header = String.fromCharCode(...data.slice(0, 4));
  if (header !== "%PDF") {
    return { valid: false, error: "文件格式不正确" };
  }

  return { valid: true };
}

describe("POST /upload-page-range", () => {
  it("在没有提供文件时应返回错误", async () => {
    const response = await request(app)
      .post("/upload-page-range")
      .query({ startPage: 1, endPage: 2 });
    expect(response.status).toBe(400);
    expect(response.body.error).toBe("没有分享PDF文件。");
  });

  it("对于无效的页面范围，也应返回错误", async () => {
    const mockPdfBuffer = Buffer.from("%PDF-1.4 mock pdf");
    const response = await request(app)
      .post("/upload-page-range")
      .query({ startPage: "invalid", endPage: 2 })
      .attach("file", mockPdfBuffer, "test.pdf");

    expect(response.status).toBe(400);
    expect(response.body.error).toContain("页面范围必须是有效的整数。");
  });

  it("应该能够从指定的页面范围中提取文本", async () => {
    const mockPdfBuffer = Buffer.from("%PDF-1.4 mock pdf");
    const response = await request(app)
      .post("/upload-page-range")
      .query({ startPage: 1, endPage: 2 })
      .attach("file", mockPdfBuffer, "test.pdf");

    expect(response.status).toBe(200);
    expect(response.body.success).toBe(true);
    expect(response.body.result.startPage).toBe(1);
    expect(response.body.result.endPage).toBe(2);
  });
});

# 一次性运行所有测试
npm test

# 在开发模式下以实时监控模式运行测试
npm run test:watch

# 生成代码覆盖率报告
npm test -- --coverage

npm run dev

# 测试健康检查功能
curl http://localhost:8080/

# 上传并解析PDF文件
curl -F "file=@sample.pdf" http://localhost:8080/upload

# 提取特定页面内容
curl -F "file=@sample.pdf" "http://localhost:8080/upload-page-range?startPage=1&endPage=5"

# 搜索文本
curl -F "file=@sample.pdf" "http://localhost:8080/search?query=invoice"

# 仅获取元数据
curl -F "file=@sample.pdf" http://localhost:8080/metadata

npm run build

npm start