处理递归数据结构

Question

我正在做一个绿地项目。 它基本上有两个模式， Item和Inventory 。 Item由自己的属性和具有规则的子项目组成。 最基本的（为了简化演示）模式字段如下所示：

物品：

{
  id: string,
  minChildItems?: number,
  maxChildItems?: number,
  childItems: [
    {
      itemId: string,
      min?: number,
      max?: number,
      default?: number,
    }
  ]
}

存货：

{
  id: string,
  amount: number,
  itemId: string,
}

一个简单的例子是一个可定制的书架：

{
  id: 'bookshelf',
  childItems: [
    {
      itemId: 'shelf',
      min: 2,
      max: 6,
      default: 4,
    }
  ]
}
{
  id: 'shelf',
  childItems: [
    {
      itemId: 'chipboard-m',
      min: 1,
      max: 1,
      default: 1,
    },
    {
      itemId: 'chipboard-s',
      min: 2,
      max: 2,
      default: 2,
    },
    {
      itemId: 'color',
      min: 1,
      max: 1,
      default: 1,
    }
  ]
}
{
  id: 'color',
  minChildItems: 1,
  maxChilditems: 1,
  childItems: [
    {
      itemId: 'white',
      min: 0,
      max: 1,
      default: 0,
    },
    {
      itemId: 'black',
      min: 0,
      max: 1,
      default: 0,
    },
    {
      itemId: 'wood',
      min: 0,
      max: 1,
      default: 0,
    }
  ]
}

（为了使它更短，没有显示像chipboard-s这样的项目，这是因为它们没有子项目）

因此，父子项之间存在一对多的关系。 将其想象为产品的线框，以及用户定制的限制。 一个书架可以有2-6个书架，一个书架需要选好颜色。 孩子和父母级别的最小最大金额的目的是：

• 验证用户是否在树上选择了正确的值一直到最低级别（它将在订单模式上，不会详细说明 go，这个问题已经足够长了）
• 检查产品是否可用

如果产品直接或间接有库存（ Inventory模式），则该产品可用（其childItems以可以验证的方式有库存）。

因此，要确定bookshelf是否可用，我们必须在树下找到 go。

Is `bookshelf` directly in inventory? No. Then:
  Is `shelf` directly in inventory? No. Then:
    Is `chipboard-m` directly in inventory? Yes, 5.
    Is `chipboard-s` directly in inventory? Yes, 30.
    Is `color` directly in inventory? No, then:
      Is `white` in inventory? Yes, 10.
      Is `black` in inventory? No.
      Is `wood` in inventory? Yes, 20.
    Available `color` is 10 (worst case).
  Available `shelf` is 5 (worst case).
Available `bookshelf` is 1 (worst case). 

这个写的比较长，但是很简单，足够服务器计算了。 但是想象一下要复杂得多，嵌套的Item有多个级别，而且很多。 要每次都进行这些计算，可能需要大量资源。 尽管这是我迄今为止最好的主意，但感觉不对。 我正在考虑使用 mongoose 来完成任务，因为聚合、虚拟字段和填充递归文档可能很方便。

我还没有遇到过相互依赖的数据，其中关系可以 go 下降到 n 级，所以不太清楚如何处理它。 我的方法在以下方面是否正确：

• 建立关系
• 正确计算/验证
• 选择正确的数据库/技术

?