Express.js 中等待多个 Promise 完成再响应的策略

// app.post 路由处理器 (可能存在问题)
app.post('/', async (req: Request, res: Response) => {
   const tasksRequest = req.body as TasksRequest;
   let tasks: Promise<any>[] = [];

   // 这里的 await Promise.all(tasks) 看起来正确，但如果 processTask 有问题，可能仍无法等待
   tasks = tasksRequest.tasks.map((t) => processTask(t, tasksRequest.configs));
   await Promise.all(tasks); // 问题可能出在 processTask 的实现或后续没有发送响应
   // ... 缺少 res.send() 或 res.json()
});

// processTask 函数 (使用回调风格的 fs.writeFile，且错误处理不完善)
function processTask(task: Task, configs: Configs) {
  return new Promise<void>((resolve, reject) => {
    try {
      const fileName = './output/' + task.tag + 's.json';

      fetch(configs.Host + configs.APIsBasePrefix + task.parentResource + task.mostRelatedPath, {
        method: 'GET'
      }).then(result => {
        result.json().then(jsonResult => {
          // fs.writeFile 是回调风格，需要检查 err 并 reject
          fs.writeFile(fileName, JSON.stringify(jsonResult), function () {
            console.log('finished writing :' + fileName);
            resolve();
          });
        }).catch(err => reject(err));
      }).catch(err => reject(err));
    } catch (err) {
      console.log(err); // 这里的 catch 只能捕获同步错误
    }
  });
}

// app.post 路由处理器 (缺少 await Promise.all)
app.post('/', async (req: Request, res: Response) => { // 声明为 async 是正确的
  const tasksRequest = req.body as TasksRequest;
  let tasks = [];

  tasks = tasksRequest.tasks.map( (t) =>  processTask(t, tasksRequest.configs));

  // 这里的 Promise.all(tasks).then(...) 没有被 await
  // 导致路由处理器会立即继续执行，可能在任务完成前就结束
  Promise.all(tasks).then(results => {
    console.log('After awaiting');
    // ... 应该在这里发送响应，但如果这里没有 res.send()，外部也无法收到响应
  });
  // 如果这里没有 res.send()，且上面的 Promise 没被 await，API 将挂起或超时
});

import * as fs from 'fs/promises'; // 导入 fs.promises
import fetch from 'node-fetch'; // 如果在 Node.js 环境，可能需要安装 node-fetch

// 定义类型 (假设已定义)
interface Task {
  tag: string;
  parentResource: string;
  mostRelatedPath: string;
}

interface Configs {
  Host: string;
  APIsBasePrefix: string;
}

async function processTask(task: Task, configs: Configs): Promise<void> {
  try {
    const fileName = `./output/${task.tag}s.json`;

    // 使用 await 等待 fetch 请求完成
    const result = await fetch(configs.Host + configs.APIsBasePrefix + task.parentResource + task.mostRelatedPath, {
      method: 'GET'
    });

    // 使用 await 等待 JSON 解析完成
    const jsonResult = await result.json();

    // 使用 fs.promises.writeFile，它返回一个 Promise，可以直接 await
    await fs.writeFile(fileName, JSON.stringify(jsonResult));
    console.log(`finished writing: ${fileName}`);
  } catch (err) {
    console.error(`Error processing task ${task.tag}:`, err);
    // 捕获并重新抛出错误，以便 Promise.all 能够感知到
    throw err;
  }
}

import express, { Request, Response } from 'express';
// ... 其他导入，如 processTask 函数

const app = express();
app.use(express.json()); // 用于解析请求体

// 定义类型 (假设已定义)
interface TasksRequest {
  tasks: Task[];
  configs: Configs;
}

app.post('/', async (req: Request, res: Response) => {
  try {
    const tasksRequest = req.body as TasksRequest;

    // 映射任务为 Promise 数组
    const tasks: Promise<void>[] = tasksRequest.tasks.map((t) =>
      processTask(t, tasksRequest.configs)
    );

    console.log('Starting to process tasks...');

    // 使用 await 等待所有 Promise 完成
    // Promise.all 会等待所有任务成功，如果任何一个失败，它会立即拒绝
    await Promise.all(tasks);

    console.log('All tasks finished successfully.');
    // 所有任务完成后，发送成功响应
    res.status(200).json({ message: 'All tasks processed successfully.' });

  } catch (error) {
    console.error('An error occurred during task processing:', error);
    // 捕获任何一个任务失败的错误，并发送错误响应
    res.status(500).json({ message: 'Failed to process some tasks.', error: (error as Error).message });
  }
});

// 启动服务器 (示例)
const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});