1

我有一个用户实体，可以使用 GooglePeopleApi 从 Google 添加他/她的联系人。

API 按原样向前端提供一组联系人（Nextjs）。问题是如何在一个突变中插入所有这些联系人。

当然，我可以让前端循环通过数组并一一发布联系人，但这有点愚蠢。

应该可以使用 Contact 输入创建一个类型数组，然后设置一个customArgsMutation. （我从 Hasura 看到了一些例子）。

实体方面，现在看起来像这样（仅相关代码）：

用户.php

 ....
/**
 * @ORM\OneToMany(targetEntity="App\Entity\Contact", mappedBy="user")
 * @Groups({"put-contacts", "get-admin", "get-owner"})
 */
private $contacts;

联系方式.php

/**
* @ApiResource(
*      attributes={"pagination_enabled"=false},
*      graphql={
*          "item_query"={
*              "normalization_context"={"groups"={"get-admin", "get-owner"}},
*          },
*          "collection_query"={
*              "normalization_context"={"groups"={"get-admin", "get-owner"}},
*          },
*          "delete"={"security"="is_granted('IS_AUTHENTICATED_FULLY') and object.getUser() == user"},
*          "create"={
*              "security"="is_granted('IS_AUTHENTICATED_FULLY')",
*              "denormalization_context"={"groups"={"post", "put"}},
*              "normalization_context"={"groups"={"get-owner", "get-admin"}},
*          },
*      }
* )
* @ORM\Entity(repositoryClass="App\Repository\ContactRepository")
*/
class Contact
{
/**
 * @ORM\Id()
 * @ORM\GeneratedValue()
 * @ORM\Column(type="integer")
 */
private $id;

/**
 * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="contacts")
 * @Groups({"post", "get-admin", "get-owner"})
 */
private $user;

/**
 * @ORM\Column(type="string", length=180)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $email;

/**
 * @ORM\Column(type="string", length=180, nullable=true)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $familyName;

/**
 * @ORM\Column(type="string", length=180, nullable=true)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $givenName;

/**
 * @ORM\Column(type="string", length=180, nullable=true)
 * @Groups({"post", "put", "get-admin", "get-owner"})
 */
private $displayName;

从graphiql，createContact输入如下所示：

 user: String
 email: String!
 familyName: String
 givenName: String
 displayName: String
 clientMutationId: String
4

2 回答 2

0

我是这样做的：

创建自定义类型：

class CustomType extends InputObjectType implements TypeInterface
{
    public function __construct()
    {
        $config = [
            'name' => 'CustomType',
            'fields' => [
                'id_1' => Type::nonNull(Type::id()),
                'id_2' => Type::nonNull(Type::id()),
                'value' => Type::string(),
            ],
        ];
        parent::__construct($config);
    }

    public function getName(): string
    {
        return 'CustomType';
    }
}

在 src/config/services.yaml 中注册 CustomType

(...)
App\Type\Definition\CustomType:
    tags:
        - { name: api_platform.graphql.type }

将自定义突变添加到实体，使用 CustomType 参数作为数组：

/**
* @ApiResource(
* (...)
*     graphql={
*     "customMutation"={
*         "args"={
*             (...)
*             "customArgumentName"={"type"=[CustomType!]"}
*         }
*     }
*)

然后可以使用如下参数数组调用新的 customMutation：

mutation myMutation($input: customMutationEntitynameInput!) {
    customMutationEntityname(input: $input) {
        otherEntity {
            id
        }
    }
}

和 graphql 变量：

{
    "input": {
        "customArgumentName": [
            {
                "id_1": 3,
                "id_2": 4
            },{
                "id_1": 4,
                "id_2": 4
            }
        ]
    }
}
于 2021-09-30T13:50:29.547 回答
0

这里有几个选项，具体取决于您想要的并发量：

1.这些应该在串行中执行

客户端可以使用多个突变作为别名发出单个 HTTP 请求：

mutation CreateUsers {
  user1: createUser({ //userInput1 }) { ...userFields }
  user2: createUser({ //userInput2 }) { ...userFields }
  user3: createUser({ //userInput3 }) { ...userFields }
}

fragment userFields on CreateUserPayload {
  firstName
  // etc
}

响应将如下所示：

{
  "data": {
    "user1": {...},
    "user2": {...},
    "user3": {...},
  }
}

优点：

  • 如果任何单个突变失败，则只有那个突变会出错而无需特殊处理
  • 秩序得以维持。因为 API 使用者专门标记突变，所以他们知道哪个具有哪个结果。

缺点：

  • 按照设计，多个突变以串行方式运行，其中第一个突变必须在下一个突变开始之前完全完成。正因为如此，它会慢一些。
  • 客户端必须自己添加字段或为每个突变使用片段（我在上面显示的内容）

2.这些应该并行执行

创建允许您创建多个用户的“批量突变”是一种常见做法（我猜它可能很常见）。

mutation CreateUsers {
  createUsers([
    { //userInput1 },
    { //userInput2 },
    { //userInput3 }
  ]) {
    firstName
    // etc
  }
}

优点：

  • 并行运行，因此速度更快
  • 客户端不必进行字符串插值来构建查询。他们只需要传入对象数组。

缺点：

  • 您必须自己构建逻辑才能自己返回空值和错误。
  • 你必须建立逻辑来维持秩序
  • 如果客户关心订单，则必须构建逻辑以在响应数组中查找结果。
于 2021-01-08T19:46:26.437 回答