如何用Node.js传递带AND/OR逻辑的MongoDB嵌套查询参数？

一、优先用POST请求体传递复杂查询结构 #

URL查询参数天生不适合承载嵌套层级深的JSON结构，编码和解码容易出问题，直接用POST请求的请求体传递是最优解，能完整保留逻辑嵌套关系。

前端（Angular）实现步骤 #

1. 构建查询结构对象：直接对应MongoDB $expr 里的逻辑结构，或者定义简化的业务逻辑结构（后者更安全，避免暴露数据库操作符）。比如对应你给出的示例：

// 直接映射MongoDB逻辑的结构
const filterQuery = {
  $or: [
    {
      $and: [
        { $eq: ["$$phaseId", "123409876"] },
        { $eq: ["$$taskId", "987654387"] }
      ]
    },
    { $eq: ["$$projectId", "123456789"] }
  ]
};

2. 用HttpClient发送POST请求：把构建好的对象放进请求体：

import { HttpClient } from '@angular/common/http';

// 在组件/service中注入HttpClient
constructor(private http: HttpClient) {}

submitFilter() {
  const filterQuery = { /* 上面的结构 */ };
  this.http.post('/api/report/filter', { filter: filterQuery })
    .subscribe(response => {
      // 处理返回的报表数据
    });
}

后端（Node.js/Express）实现步骤 #

1. 接收请求体并验证：先确保Express配置了解析JSON的中间件，然后提取请求体里的过滤条件，做安全校验（比如只允许指定的操作符和业务字段）：

const express = require('express');
const app = express();
app.use(express.json()); // 解析JSON请求体

// 安全校验函数：白名单允许的操作符和字段
const validateFilter = (filter) => {
  const allowedOperators = new Set(['$eq', '$and', '$or']);
  const allowedFields = new Set(['$$phaseId', '$$taskId', '$$projectId']);
  
  const checkNode = (node) => {
    if (Array.isArray(node)) {
      // 处理$eq这类数组形式的条件
      if (node[0] === '$eq' && node.length === 3) {
        if (!allowedFields.has(node[1])) {
          throw new Error(`不允许的字段：${node[1]}`);
        }
      }
      return;
    }
    if (typeof node === 'object' && node !== null) {
      for (const key of Object.keys(node)) {
        if (!allowedOperators.has(key)) {
          throw new Error(`不允许的操作符：${key}`);
        }
        checkNode(node[key]);
      }
    }
  };
  
  checkNode(filter);
};

app.post('/api/report/filter', async (req, res) => {
  try {
    const { filter } = req.body;
    validateFilter(filter); // 先做安全校验
    
    // 构建MongoDB的$match阶段
    const matchStage = {
      $expr: filter
    };
    
    // 执行MongoDB查询（假设用mongoose）
    const reportData = await YourModel.aggregate([
      matchStage,
      // 其他聚合阶段（比如$group、$project等）
    ]);
    
    res.json(reportData);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

二、如果必须用GET请求（比如支持书签） #

如果业务需求必须用GET请求，可以把JSON结构转成Base64编码后放在查询参数里：

前端处理 #

submitFilterWithGet() {
  const filterQuery = { /* 你的逻辑结构 */ };
  const encodedFilter = encodeURIComponent(btoa(JSON.stringify(filterQuery)));
  this.http.get(`/api/report/filter?filter=${encodedFilter}`)
    .subscribe(response => { /* 处理数据 */ });
}

后端处理 #

app.get('/api/report/filter', async (req, res) => {
  try {
    const encodedFilter = req.query.filter;
    const filter = JSON.parse(atob(decodeURIComponent(encodedFilter)));
    validateFilter(filter); // 同样要做安全校验
    
    // 后续逻辑和POST一致
    const matchStage = { $expr: filter };
    const reportData = await YourModel.aggregate([matchStage]);
    res.json(reportData);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

三、更安全的简化逻辑方案（推荐） #

如果不想直接暴露MongoDB的操作符给前端，可以定义一套业务友好的逻辑语法，比如：

// 前端定义的简化结构：用type区分逻辑节点和条件节点
const simplifiedFilter = {
  type: 'or',
  conditions: [
    {
      type: 'and',
      conditions: [
        { field: 'phaseId', operator: 'eq', value: '123409876' },
        { field: 'taskId', operator: 'eq', value: '987654387' }
      ]
    },
    { field: 'projectId', operator: 'eq', value: '123456789' }
  ]
};

然后后端写转换函数，把简化结构转成MongoDB的$expr逻辑：

const convertToMongoExpr = (simplifiedFilter) => {
  if (simplifiedFilter.type === 'and' || simplifiedFilter.type === 'or') {
    const operator = `$${simplifiedFilter.type}`;
    return {
      [operator]: simplifiedFilter.conditions.map(convertToMongoExpr)
    };
  } else {
    // 处理条件节点
    const { field, operator, value } = simplifiedFilter;
    const mongoOperator = `$${operator}`;
    return {
      [mongoOperator]: [`$$${field}`, value]
    };
  }
};

// 使用示例
const mongoExpr = convertToMongoExpr(simplifiedFilter);
// 转换后得到的就是你示例里的$or/$and结构

这种方式更安全，前端不用关心MongoDB语法，后端也能完全控制允许的操作和字段。

内容的提问来源于stack exchange，提问作者afish