Question

我目前正在尝试通过为自己开发一个膳食计划应用来学习React。来自传统的商业编程世界，我决定使用MySQL作为后端，Sequelize / GraphQL作为我的数据接口。

我的数据模型如下：
- 用户有餐 - 餐具有日间，类型（早餐，午餐等）和＆＃34; MealItems＆＃34;的特性 -MealItems可以是FoodItem或Recipe -Recipes基本上是FoodItems的集合

我用这个数据模式实现了这个想法（在Access中完成了很快的模型）：Meal Planner Model

我设法编写了一个Sequelize模型，它可以完全按照我的要求创建表和约束。我使用官方Sequelize文档中的n：m关联示例来创建MealItems查找表，该表应允许模型根据范围动态返回FoodItem或Recipe（＆＃34; ItemType＆＃34;）。（但我不知道我是否正确地完成了这一部分，因为我无法通过原始SQL查询以外的其他任何方式提取数据。）

我的项目的完整源代码可以在这里找到:(相关数据组件位于＆＃39; ./ src / data＆＃39;） https://github.com/philspins/NourishMe

Sequelize模型：

//
// Model definitions
// -----------------------------------------------------------------------------    
import DataType from "sequelize";
import Model from "../sequelize";

const FoodItem = Model.define("FoodItem",
{

    Name: { type: DataType.STRING(100) },
    Quantity: { type: DataType.STRING(32) },
    Weight: { type: DataType.INTEGER },
    Calories: { type: DataType.INTEGER },
    Protein: { type: DataType.DOUBLE },
    Carbs: { type: DataType.DOUBLE },
    Fat: { type: DataType.DOUBLE },
    Fibre: { type: DataType.DOUBLE },
    ImageURL: { type: DataType.TEXT }
});

const Recipe = Model.define("Recipe",
{
    Name: { type: DataType.STRING(100) },
    Instructions: { type: DataType.TEXT },
    ImageURL: { type: DataType.TEXT }
});

const Ingredient = Model.define("Ingredient");

const Meal = Model.define("Meal",
{
    Day: { type: DataType.DATE }
});

const MealType = Model.define("MealType",
{
    Name: { type: DataType.STRING(100) }
});

const MealItem = Model.define("MealItem",
{
    id: {type: DataType.INTEGER, primaryKey: true, autoIncrement: true},
    ItemType: { type: DataType.STRING(100) },
    ItemID: { type: DataType.STRING(100) },
    Quantity: { type: DataType.DOUBLE }
},
{
    instanceMethods: {
        getItem: function() {
            return this["get" + this.get("ItemType").substr(0,1).toUpperCase() + this.get("ItemType").substr(1)]();
        }
    }
});

//
// Recipe and FoodItem relations
// -----------------------------------------------------------------------------
Recipe.FoodItems = Recipe.belongsToMany(FoodItem, {
    through: Ingredient,
    as: "FoodItems"
});
FoodItem.Recipes = FoodItem.belongsToMany(Recipe, {
    through: Ingredient,
    as: "Recipes"
});


//
// Meals relationships with Recipe and FoodItem
// -----------------------------------------------------------------------------
Meal.belongsToMany(Recipe, {
    through: MealItem,
    foreignKey: "ItemID",
    constraints: false,
    scope: {
        ItemType: "Recipe"
    }
});
Recipe.belongsToMany(Meal, {
    through: MealItem,
    foreignKey: "ItemID",
    constraints: false,
    as: "Recipe"
});
Meal.belongsToMany(FoodItem, {
    through: MealItem,
    foreignKey: "ItemID",
    constraints: false,
    scope: {
        ItemType: "FoodItem"
    }
});
FoodItem.belongsToMany(Meal, {
    through: MealItem,
    foreignKey: "ItemID",
    constraints: false,
    as: "FoodItem"
});


//
// Other Meal relationships
// -----------------------------------------------------------------------------
Meal.MealItems = Meal.hasMany(MealItem, {foreignKey: {allowNull: false}, onDelete: "CASCADE"});
Meal.User = User.hasMany(Meal, {foreignKey: {allowNull: false}, onDelete: "CASCADE"});
Meal.MealType = MealType.hasMany(Meal, {foreignKey: {allowNull: false}, onDelete: "CASCADE"});

我有GraphQL类型和查询设置，以返回除Meal之外的所有数据。除了实际在MealItem表中的值之外，我无法返回任何内容。我能够将FoodItem与Recipe链接没问题，并检索一个嵌入Recipes中的FoodItems的JSON包，但无法弄清楚如何使用MealItems做同样的事情。这是我现在正在使用的模型：[可视化GraphQL模型] [3] 但我希望Meals能够在输出中嵌入FoodItems或Recipes而不是MealItems。

这是我的GraphQL代码，因为我有它的工作：

import {GraphQLObjectType,
    GraphQLList,
    GraphQLNonNull,
    GraphQLID,
    GraphQLString} from "graphql";
import {resolver, attributeFields} from "graphql-sequelize";
import {Meal, 
    Recipe, 
    FoodItem as 
    FoodModel, 
    MealItem as MealItemModel} from "../models";

const FoodType = new GraphQLObjectType({
    name: "FoodItem",
    fields: attributeFields(FoodModel),
    resolve: resolver(FoodModel)
});

const RecipeType = new GraphQLObjectType({
    name: "Recipe",
    fields: {
        id: { type: new GraphQLNonNull(GraphQLID) },
        Name: { type: GraphQLString },
        Instructions: { type: GraphQLString },
        ImageURL: { type: GraphQLString },
        Ingredients: {
            type: new GraphQLList(FoodType),
            resolve: resolver(Recipe.FoodItems) }
    }
});

const MealTypeType = new GraphQLObjectType({
    name: "MealType",
    fields: attributeFields(MealType)
});

const MealItemType = new GraphQLObjectType({
    name: "MealItem",
    fields: attributeFields(MealItemModel),
    resolve: resolver(MealItemModel)
});

const MealType = new GraphQLObjectType({
    name: "Meal",
    fields: {
        id: { type: new GraphQLNonNull(GraphQLID) },
        Day: { type: DateType },
        UserId: { type: GraphQLID },
        MealTypeId: { type: GraphQLID },
        MealItems: {
            type: new GraphQLList(MealItemType),
            resolve: resolver(Meal.MealItems)
        }
    }
});

const Meals = {
    type: new GraphQLList(MealType),
    resolve: resolver(Meal)
};

const schema = new Schema({
    query: new ObjectType({
        name: "Root",
        fields: {
            Meals
        }
    })
});

为了让MealType动态返回FoodType或RecipeType而不是MealItemType，我需要做的是认为，这就是我的想法。但这是我无法开展工作的原因，也是这个极其冗长问题的原因。

function resolveMealItemType(value){
    if(value.ItemType == "Recipe"){return RecipeType;}else{return FoodType;}
}

const MealItemType = new GraphQLUnionType({
    name: "MealItem",
    types: [RecipeType, FoodType],
    resolveType: resolveMealItemType
});

const MealType = new GraphQLObjectType({
    name: "Meal",
    fields: {
        id: { type: new GraphQLNonNull(GraphQLID) },
        Day: { type: DateType },
        UserId: { type: GraphQLID },
        MealTypeId: { type: GraphQLID },
        MealItems: {
            type: new GraphQLList(MealItemType),
            resolve: resolver(Meal.MealItems)
        }
    }
});

当前查询和输出：

{
  Meal {
    Day
    MealTypeId
    UserId
    MealItems {
      ItemType
      ItemID
    }
  }
}

{
  "data": {
    "Meal": {
      "Day": "2017-02-07T16:18:47.000Z",
      "MealTypeId": "1",
      "UserId": "1",
      "MealItems": [
        {
          "ItemType": "Recipe",
          "ItemID": 1
        },
        {
          "ItemType": "FoodItem",
          "ItemID": 25
        }
      ]
    }
  }
}

所需查询和输出：

{
  Meal {
    Day
    MealTypeId
    UserId
    MealItems {
      ... on FoodItem {
        Name
        Quantity
        Weight
        Calories
        Carbs
        Protein
        Fat
        Fibre
      }
      ... on Recipe {
        Name
        Instructions
        Ingredients {
          Name
          Quantity
          Weight
          Calories
          Carbs
          Protein
          Fat
          Fibre
        }
      }
    }
  }
}


{
  "data": {
    "Meal": {
      "Day": "2017-02-07T15:30:10.000Z",
      "MealTypeId": "1",
      "UserId": "1",
      "MealItems": [
        {
          "Name": "Fish, Halibut, Pacific",
          "Quantity": "4 oz uncooked",
          "Weight": 113,
          "Calories": 124,
          "Carbs": 0,
          "Protein": 24,
          "Fat": 3,
          "Fibre": 0
        },
        {
          "Name": "Test Recipe 1",
          "Instructions": "Recipe instructions go here...",
          "Ingredients": [
            {
              "Name": "Fish, Halibut, Pacific",
              "Quantity": "4 oz uncooked",
              "Weight": 113,
              "Calories": 124,
              "Carbs": 0,
              "Protein": 24,
              "Fat": 3,
              "Fibre": 0
            },
            {
              "Name": "Sardines (herring), canned in olive oil",
              "Quantity": "1 can (3.2 oz)",
              "Weight": 91,
              "Calories": 191,
              "Carbs": 0,
              "Protein": 23,
              "Fat": 11,
              "Fibre": 0
            }
        }
      ]
    }
  }
}

Answer 1

请勿直接在resolver：

中设置密钥GraphQLObjectType

...
const FoodType = new GraphQLObjectType({
    name: "FoodItem",
    fields: attributeFields(FoodModel),
    resolve: resolver(FoodModel), // <--- this is wrong, it won't be used
    // Only set resolvers inside fields, not on the root of the object
});
...

然后你使用GraphQLUnionType是正确的。
但是在MealType的resolve函数中，您应该返回一个合并的FoodItems和Recipes数组，而不是MealItems表的条目。你在联盟中说“我正在返回FoodItem或Recipe的列表”，所以这就是你应该做的。

所以，

const MealType = new GraphQLObjectType({
    ...
    fields: {
        ...
        MealItems: {
            type: new GraphQLList(MealItemType),
            resolve: (meal, args, context) => {
                return Promise.all([
                    Meal.getFoodItems(), // pseudo-code
                    Meal.getRecipes(), // pseudo-code
                ])
                .then(([ foodItems, recipes ]) => foodItems.concat(recipes));
            },
        },
        ...
    },
});

如何使用Sequelize和GraphQL正确设置多态模型

1 个答案: