作者选择Free Press接受捐赠，作为Write for DOnations计划的一部分。

介绍

GraphQL是一种强类型的 API 查询语言，也是一个服务器端运行时，用于使用现有数据执行这些查询。GraphQL 使客户端能够指定查询中所需的确切数据，从而允许客户端在单个请求中从服务器获取多个资源。这消除了对多个 API 调用的需要。GraphQL 独立于语言和数据库，因此可以在几乎所有编程语言中与任何数据库一起实现。

在本教程中，您将构建一个基于 GraphQL 的 Ruby on Rails API 来做笔记。完成后，您将能够使用 GraphQL 从 API 创建和查看笔记。

如果您想查看本教程的代码，请在DigitalOcean 社区 GitHub上查看本教程的配套存储库。

先决条件

要学习本教程，您需要：

• 安装在您的开发机器上的 Ruby 编程语言和 Ruby on Rails 框架。本教程在Ruby 2.6.3版本和 Rails 6.0.2.1版本上进行了测试，因此请确保在安装过程中指定这些版本。按照以下教程之一安装 Ruby 和 Rails：
  • 如何在 Ubuntu 18.04 上使用 rbenv 安装 Ruby on Rails
  • 如何在 CentOS 7 上使用 rbenv 安装 Ruby on Rails。
  • 如何在 macOS 上使用 rbenv 安装 Ruby on Rails。
• 安装了 PostgreSQL。要遵循本教程，请使用 PostgreSQL 版本 11.2。按照以下教程之一的步骤 1 和 2 安装 PostgreSQL：
  • 如何在 Ubuntu 18.04 上将 PostgreSQL 与 Ruby on Rails 应用程序一起使用
  • 如何在 macOS 上将 PostgreSQL 与 Ruby on Rails 应用程序一起使用。
  • 要在不同的 Linux 发行版或其他操作系统上开发此应用程序，请访问官方 PostgreSQL 下载页面。有关如何使用 PostgreSQL 的更多信息，请访问如何安装和使用 PostgreSQL。

步骤 1 — 设置新的 Rails API 应用程序

在这一步中，您将设置一个新的 Rails API 应用程序并将其连接到 PostgreSQL 数据库。这将作为笔记 API 的基础。

Rails 提供的命令可以让开发人员更快地构建现代 Web 应用程序。这些命令可以执行从创建新的 Rails 应用程序到生成应用程序开发所需的文件的操作。有关这些命令及其作用的完整列表，请在终端窗口中运行以下命令：

rails -h

此命令会生成可用于设置应用程序参数的广泛选项列表。列出的命令之一是newcommand，它接受一个APP_PATH并在指定路径创建一个新的 Rails 应用程序。

使用new生成器创建一个新的 Rails 应用程序。在终端窗口中运行以下命令：

rails new rails_graphql -d=postgresql -T --api

这将在名为的目录中创建一个新的 Rails 应用程序rails_graphql并安装所需的依赖项。让我们回顾一下与new命令相关的标志：

• 该-d标志使用指定的数据库预先配置应用程序。
• 该-T标志指示 Rails 不生成测​​试文件，因为在本教程中您不会编写测试。如果您计划使用不同于 Rails 提供的测试框架，您也可以使用此标志。
• 该--api标志仅使用使用 Rails 构建 API 所需的文件来配置 Rails 应用程序。它跳过配置浏览器应用程序所需的设置。

命令运行完成后，切换到新创建的rails_graphql目录，即应用程序的根目录：

cd rails_graphql

现在您已经成功设置了一个新的 Rails API 应用程序，您必须先将它连接到数据库，然后才能运行该应用程序。Rails 在 中提供了一个database.yml文件config/database.yml，其中包含用于将您的应用程序连接到不同开发环境的不同数据库的配置。Rails 通过将下划线 ( _) 后跟环境名称附加到您的应用程序名称来为不同的开发环境指定数据库名称。您始终可以将任何环境数据库名称更改为您选择的任何名称。

注意：您可以更改config/database.yml以选择希望 Rails 用来创建数据库的 PostgreSQL 角色。如果您创建了一个受密码保护的角色，请按照如何在 Ubuntu 18.04 上将 PostgreSQL 与您的 Ruby on Rails 应用程序一起使用或如何在 macOS 上将 PostgreSQL 与您的 Ruby on Rails 应用程序一起使用的步骤 4中的说明配置您的角色。

Rails 包括用于创建和使用数据库的命令。准备好数据库凭据后，在终端窗口中运行以下命令以创建数据库：

rails db:create

该db:create命令创建development和test基础上，所提供的信息数据库config/database.yml文件。运行该命令会产生以下输出：

Output
Created database 'rails_graphql_development'
Created database 'rails_graphql_test'

现在您的应用程序已成功连接到数据库，您可以测试应用程序以确保其正常工作。如果您在本地工作，请使用以下命令启动您的服务器：

bundle exec rails server

如果您在开发服务器上工作，您可以通过指定服务器应该绑定到的 IP 地址来启动您的应用程序：

bundle exec rails server --binding=your_server_ip

注意：服务器侦听端口3000。如果您在开发服务器上工作，请确保您已3000在防火墙中打开端口以允许连接。

该rails server命令会启动Puma，这是一个随 Rails 分发的 Ruby 网络服务器。该命令将服务器绑定到您提供的任何 IP。--binding=your_server_ip

运行此命令后，您的命令提示符将替换为以下输出：

Output
=> Booting Puma
=> Rails 6.0.2.1 application starting in development
=> Run `rails server --help` for more startup options
Puma starting in single mode...
* Version 4.3.1 (ruby 2.6.3-p62), codename: Mysterious Traveller
* Min threads: 5, max threads: 5
* Environment: development
* Listening on tcp://127.0.0.1:3000
* Listening on tcp://[::1]:3000
Use Ctrl-C to stop

要运行您的应用程序，请导航到localhost:3000或在您的浏览器中。你会看到 Rails 默认的欢迎页面：http://your_server_ip:3000

欢迎页面意味着您已经正确设置了 Rails 应用程序。

要停止服务器，请CTRL+C在运行服务器的终端窗口中按。

您已成功为笔记 API 设置了 Rails API 应用程序。在下一步中，您将设置 Rails API 应用程序以接收和执行 GraphQL 查询。

第 2 步 – 为 Rails 设置 GraphQL

在此步骤中，您将配置 Rails API 应用程序以使用 GraphQL。您将在 Rails 中安装和设置 GraphQL 开发所需的必要 gem。

如前所述，GraphQL 与语言无关，并以多种编程语言实现。该graphql-红宝石的宝石是Ruby实现的GraphQL。GraphQL 还提供了一个称为GraphiQL的交互式浏览器内 IDE，用于运行 GraphQL 查询。该graphiql-rails宝石帮助您添加GraphiQL到你的开发环境。

要安装这些依赖项，请Gemfile使用 nano 或您喜欢的文本编辑器打开项目进行编辑：

nano Gemfile

将graphql和graphiql-rails宝石添加到您的 Gemfile 中。你可以在graphiql任何地方添加gem，但是graphiql-railsgem 应该添加在开发依赖项下：

...
group :development do
  gem 'listen', '>= 3.0.5', '< 3.2'
  # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
  gem 'spring'
  gem 'spring-watcher-listen', '~> 2.0.0'
  gem 'graphiql-rails'
end

gem 'graphql', '1.9.18'
...

添加完宝石后，保存并关闭文件。

在终端窗口中，使用以下命令安装 gem：

bundle install

输出显示 gems 已安装。

该graphql宝石提供了发电机，以创建各种文件。要查看可用的生成器，请在终端窗口中运行以下命令：

rails generate

前缀graphql:为 的生成器是与graphqlgem关联的生成器。

您将使用该graphql:install命令将graphql-ruby样板代码添加到应用程序并在您的开发环境中安装 GraphiQL。样板代码将包含graphql-rubygem 与 Rails 一起工作所需的所有文件和目录。

在终端窗口中，运行以下命令：

rails g graphql:install

此命令生成多个文件，包括graphql_controller.rb位于的文件app/controllers/graphql_controller.rb和包含在 Rails 中开始使用 GraphQL 所需的文件的graphql目录app/graphql。它还在位于的路由文件中添加了一个/graphqlHTTPPOST路由config/routes.rb。此路由映射到app/controllers/graphql_controller.rb#execute处理对 GraphQL 服务器的所有查询的方法。

在您可以测试 GraphQL 端点之前，您需要将 GraphiQL 引擎挂载到路由文件，以便您可以访问 GraphiQL 浏览器 IDE。为此，请打开位于以下位置的路由文件config/routes.rb：

nano ~/rails_graphql/config/routes.rb

在文件中添加以下代码，在开发环境中挂载GraphiQL引擎：

Rails.application.routes.draw do
  if Rails.env.development?
    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "graphql#execute"
  end
  post "/graphql", to: "graphql#execute"
  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
end

这会将 GraphiQL 引擎安装到/graphiql路径并将所有查询定向到graphql#execute方法。

由于这是一个使用该--api标志创建的 API 应用程序，它不希望在浏览器中呈现任何页面。要使 GraphiQL 编辑器显示在浏览器中，您需要对应用程序的配置进行一些小的更改。

首先，打开application.rb位于以下位置的文件config/application.rb：

nano ~/rails_graphql/config/application.rb

接下来，取消注释该require "sprockets/railtie"行：

require_relative 'boot'

require "rails"
# Pick the frameworks you want:
require "active_model/railtie"
require "active_job/railtie"
require "active_record/railtie"
require "active_storage/engine"
require "action_controller/railtie"
require "action_mailer/railtie"
require "action_mailbox/engine"
require "action_text/engine"
require "action_view/railtie"
require "action_cable/engine"
require "sprockets/railtie"
# require "rails/test_unit/railtie"

...

取消注释该行后保存并关闭文件。

现在config在app/assets以下位置创建一个目录：

mkdir -p app/assets/config

接下来，manifest.js在新创建的config目录中创建一个文件。该manifest.js文件指定了要编译并可供浏览器使用的其他资产：

nano app/assets/config/manifest.js

将以下代码添加到文件中，它告诉 Rails 预编译graphiql/rails/application.css和graphiql/rails/application.js文件，以便 Rails 可以将它们提供给您的浏览器：

//= link graphiql/rails/application.css
//= link graphiql/rails/application.js

保存并关闭文件。

完成后，您可以测试您的 GraphQL 端点。重新启动开发服务器，然后在浏览器中导航到localhost:3000/graphiql或。GraphiQL 查询编辑器显示在您的浏览器中：http://your_server_ip:3000/graphiql

GraphiQL IDE 的左侧接受 GraphQL 查询，右侧显示运行查询的结果。GraphiQL 查询编辑器还有一个语法高亮器和一个由 GraphQL Schema 提供支持的预输入提示。总之，这些可以帮助您进行有效的查询。

要尝试一个Hello World示例，请清除编辑器左窗格中的默认文本并键入以下查询：

query {
    testField
}

单击标题中的播放图标按钮，您将在屏幕上收到成功的响应，如下图所示：

您已成功设置 Rails API 应用程序以使用 GraphQL 并测试了您的 GraphQL 端点以确认其工作正常。在下一步中，您将为您的应用程序创建 GraphQL 类型。

第 3 步 – 为应用程序创建类型

GraphQL 依赖其类型和架构来验证和响应查询。在此步骤中，您将创建笔记模型和笔记 API 所需的 GraphQL 类型。

GraphQL 类型由 GraphQL 类型组成，fields而arguments这些类型又定义了可以出现在对该类型进行操作的任何 GraphQL 查询中的字段和参数。这些类型构成了一个 GraphQL Schema。GraphQL 定义了以下类型：

• Query 和 Mutation 类型：这些是定义每个 GraphQL 查询入口点的特殊类型。每个 GraphQL 服务都有一个query类型，可能有也可能没有mutation类型。
• 对象类型：这些是 GraphQL 模式的基本组件。这些代表您可以从 GraphQL 服务中获取的对象以及每个对象拥有的字段。
• 标量类型：这些是 GraphQL 开箱即用的默认类型。它们包括Int，Float，String，Boolean，和ID。
• 枚举类型：这些类型定义了一组特定的允许值。
• 输入类型：它们类似于对象类型，唯一的区别是它们定义了可以作为参数传递给查询的对象。

还有其他类型，包括Union，List，Non-Null，和Interface。您可以在官方GraphQL 文档 中找到可用 GraphQL 类型的列表。

对于此应用程序，您将创建一个Note模型、一个Note对象和输入类型。该Note模型将表示将存储您的笔记的数据库表，而Note对象和输入类型将定义Note对象上存在的字段和参数。

首先，Note使用generate modelRails 提供的子命令创建模型，并指定模型的名称及其列和数据类型。在终端窗口中运行以下命令：

rails generate model note title:string:index body:text

此命令创建一个Note包含两个字段的模型：title，类型为string，和body，类型为text。该命令还在列index上添加了一个数据库title。它生成这两个文件：

• note.rb位于的文件app/models/note.rb。该文件将保存所有与模型相关的逻辑。
• 一个20200617173228_create_notes.rb文件（在文件开头的号码将有所不同，这取决于您运行日期的命令）位于。这是一个迁移文件，其中包含在数据库中创建相应表的指令。db/migrate/20200617173228_create_notes.rbnotes

要执行迁移文件中的指令，您将使用db:migrate执行迁移文件中指令的子命令。在终端窗口中运行以下命令：

rails db:migrate

命令成功运行后，您将看到类似于以下内容的输出：

Output
== 20200617173228 CreateNotes: migrating ======================================
-- create_table(:notes)
   -> 0.0134s
-- add_index(:notes, :title)
   -> 0.0073s
== 20200617173228 CreateNotes: migrated (0.0208s) =============================

有了笔记模型，接下来您将创建一个NoteType. 一个有效的笔记对象应该有一个id、一个title和text。在终端窗口中运行以下命令以创建NoteType：

rails generate graphql:object Note id:ID! title:String! body:String!

该命令指示 Rails 创建一个Note带有三个字段的 GraphQL 对象类型：id一个类型为的字段ID，以及title和body字段，每个字段都有一个String类型。!附加到字段类型的感叹号 ( ) 表示该字段应该是不可为空的，这意味着该字段不应返回空值。不可为空的字段很重要，因为它们作为一种验证形式，保证在查询 GraphQL 对象时必须存在哪些字段。

运行前面的命令会创建一个note_type.rb位于的文件，该文件app/graphql/types/note_type.rb包含一个Types::NoteType具有三个不可为空字段的类。

最后，您将创建一个NoteInput类型来定义创建注释所需的参数。首先input在app/graphql/types. 输入目录将容纳输入类型：

mkdir ~/rails_graphql/app/graphql/types/input

注意：不需要在输入目录中创建输入类型；这只是一个共同的约定。您可以决定将所有类型保留在 types 目录下，并Input在访问模块时排除在模块下嵌套类。

在~/rails_graphql/app/graphql/types/input目录中，创建一个note_input_type.rb文件：

nano ~/rails_graphql/app/graphql/types/input/note_input_type.rb

将以下代码添加到文件中以定义Input类型的字段：

module Types
  module Input
    class NoteInputType < Types::BaseInputObject
      argument :title, String, required: true
      argument :body, String, required: true
    end
  end
end

在该note_input_type.rb文件中，您添加了一个Types::Input::NoteInputType继承自Types::BaseInputObject该类并接受两个必需参数的类；title和body，都是字符串类型。

您已经为笔记应用创建了一个模型和两个 GraphQL 类型。在下一步中，您将创建查询以获取现有笔记。

第 4 步 – 为应用程序创建查询

您的 GraphQL 驱动的 API 正在逐渐融合在一起。在这一步中，您将创建两个查询；一个用于获取单个音符id，另一个用于获取所有音符。GraphQLquery类型处理数据的获取，可以比作 REST 中的 GET 请求。

首先，您将创建一个查询以获取所有笔记。首先，创建一个queries目录来存放所有查询：

mkdir ~/rails_graphql/app/graphql/queries

在该app/graphql/queries目录中，创建一个base_query.rb文件，所有其他查询类都将从该文件继承：

nano ~/rails_graphql/app/graphql/queries/base_query.rb

将以下代码添加到base_query.rb文件中以创建BaseQuery其他查询类将从其继承的类：

module Queries
  class BaseQuery < GraphQL::Schema::Resolver
  end
end

在该base_query.rb文件中，您添加了一个Queries::BaseQuery继承自GraphQL::Schema::Resolver该类的类。的GraphQL::Schema::Resolver类是可容纳逻辑属于一个容器field。它可以附加到field带有resolver:关键字的a上。

该Queries::BaseQuery班还可以包含你打算在多个查询类重用任何代码。

接下来，fetch_notes.rb在queries目录中创建一个文件。该文件将保存获取所有现有笔记的逻辑，并将附加到field查询类型文件中的 a ：

nano ~/rails_graphql/app/graphql/queries/fetch_notes.rb

将以下代码添加到文件中以定义返回对象类型并解析请求的注释：

module Queries
  class FetchNotes < Queries::BaseQuery

    type [Types::NoteType], null: false

    def resolve
      Note.all.order(created_at: :desc)
    end
  end
end

在该fetch_notes.rb文件中，您创建了一个Queries::FetchNotes继承Queries::BaseQuery先前创建的类。该类有一个返回type声明，声明此查询返回的数据应该是已创建的数组NoteType。

该Queries::FetchNotes还包含resolve返回排序按降序排列其创建日期，所有现有的音符组成的数组方法。

该FetchNotes查询已准备好接收和票据返回的请求，但GraphQL仍然不知道它的存在，来解决这个问题，打开位于GraphQL查询类型的文件app/graphql/types/query_type.rb：

nano ~/rails_graphql/app/graphql/types/query_type.rb

该query_type.rb文件是所有 GraphQLquery类型的入口点。它包含查询字段及其各自的解析器方法。将文件中的示例代码替换为以下内容：

module Types
  class QueryType < Types::BaseObject
    # Add root-level fields here.
    # They will be entry points for queries on your schema.

    field :fetch_notes, resolver: Queries::FetchNotes
  end
end

在该query_type.rb文件中，您添加了一个fetch_notes字段并Queries::FetchNotes使用resolver:. 这样，无论何时fetch_notes调用查询，它都会执行类的resolve方法中的逻辑Queries::FetchNotes。

为了测试您的查询，您需要获取一些数据，但您的数据库中目前没有任何注释。您可以通过向数据库添加一些种子数据来解决这个问题。打开seeds.rb位于以下位置的文件db/seeds.rb：

nano ~/rails_graphql/db/seeds.rb

将以下代码添加到文件中以创建五个注释：

5.times do |i|
  Note.create(title: "Note #{i + 1}", body: 'Lorem ipsum saves lives')
end

添加代码后保存并关闭文件。

在另一个终端窗口中打开项目的根目录并运行以下命令以运行seed.rb文件中的代码：

rails db:seed

这将在数​​据库中创建 5 个笔记。

使用数据库中的数据和运行的开发服务器，导航到localhost:3000/graphiql或在浏览器中打开您的 GraphiQL IDE。在编辑器的左侧，输入以下查询：http://your_server_ip:3000/graphiql

query {
  fetchNotes {
    id
    title
    body
  }
}

这个 GraphQL 查询声明了一个query操作，表明您要发出查询请求。在查询操作中，您调用了一个fetchNotes与fetch_notesAPI 中声明的查询字段匹配的字段，并将这些字段包含在您希望在响应中返回的注释中。

单击标题中的播放图标按钮。您将在输出窗格中看到类似于以下内容的响应：

{
  "data": {
    "fetchNotes": [
      {
        "id": "5",
        "title": "Note 5",
        "body": "Lorem ipsum saves lives"
      },
      {
        "id": "4",
        "title": "Note 4",
        "body": "Lorem ipsum saves lives"
      },
      {
        "id": "3",
        "title": "Note 3",
        "body": "Lorem ipsum saves lives"
      },
      {
        "id": "2",
        "title": "Note 2",
        "body": "Lorem ipsum saves lives"
      },
      {
        "id": "1",
        "title": "Note 1",
        "body": "Lorem ipsum saves lives"
      }
    ]
  }
}

响应包含与左侧查询中声明的字段匹配的 5 个注释的数组。如果您删除编辑器左侧查询中的某些字段并重新运行查询，您将收到仅包含您请求的字段的响应。这就是 GraphQL 的强大之处。

接下来，您将创建另一个查询以通过 获取笔记id。此查询将类似于fetch_notes查询，只是它会接受一个id参数。继续fetch_note.rb在查询目录中创建一个文件：

nano ~/rails_graphql/app/graphql/queries/fetch_note.rb

将以下代码添加到文件中以查找并返回带有提供的注释id：

module Queries
  class FetchNote < Queries::BaseQuery
    type Types::NoteType, null: false
    argument :id, ID, required: true

    def resolve(id:)
      Note.find(id)
    rescue ActiveRecord::RecordNotFound => _e
      GraphQL::ExecutionError.new('Note does not exist.')
    rescue ActiveRecord::RecordInvalid => e
      GraphQL::ExecutionError.new("Invalid attributes for #{e.record.class}:"\
        " #{e.record.errors.full_messages.join(', ')}")
    end
  end
end

这定义了一个Queries::FetchNote从Queries::BaseQuery类继承的类。这个类不仅返回一个必须是 a 的项目NoteType，它还接受id一个ID类型的参数。该resolve方法接收提供的id参数，然后查找并返回带有提供的注释id。如果不存在注释或发生错误，则将其拯救并作为GraphQL::ExecutionError.

接下来，您将Queries::FetchNote类附加到查询类型文件中的查询字段。query_type.rb在编辑器中打开文件：

nano ~/rails_graphql/app/graphql/types/query_type.rb

将以下代码添加到定义解析器的文件中fetch_notes：

module Types
  class QueryType < Types::BaseObject
    # Add root-level fields here.
    # They will be entry points for queries on your schema.

    field :fetch_notes, resolver: Queries::FetchNotes
    field :fetch_note, resolver: Queries::FetchNote
  end
end

要测试您的新查询，请确保您的服务器正在运行并导航到localhost:3000/graphiql或在您的浏览器中打开您的 GraphiQL IDE。在编辑器的左侧，输入以下查询：http://your_server_ip:3000/graphiql

query {
  fetchNote(id: 1) {
    id
    title
    body
  }
}

此查询操作请求一个fetchNote字段，该字段对应于fetch_note查询字段，并传递一个id参数。它指定我们希望在响应中返回三个字段。

通过单击标题中的播放图标按钮运行查询。您将在输出窗格中收到如下响应：

{
  "data": {
    "fetchNote": {
      "id": "1",
      "title": "Note 1",
      "body": "Lorem ipsum saves lives"
    }
  }
}

响应包含一个注释，该注释将请求id的字段与请求中的字段相匹配。

在此步骤中，您创建了 GraphQL 查询以从您的 API 获取笔记。接下来，您将编写更改以创建笔记。

第 5 步 — 创建 GraphQL 突变以修改注释

除了查询之外，GraphQL 还mutation为修改服务器端数据的操作定义了一种类型。正如REST提供POST，PUT，PATCH，以及DELETE用于创建，更新和删除资源的请求，GraphQL的mutation类型定义操作的约定，导致在服务器端写入。在这一步中，您将创建一个用于添加新音符的变更。

graphQL-ruby包括两个用于编写突变的类。他们是：

• GraphQL::Schema::Mutation：这是用于编写突变的通用基类。如果你不想input在你的突变中需要一个参数，你应该使用这个类。
• GraphQL::Schema::RelayClassicMutation：这是一个有一些约定的基类；clientMutationId总是插入到响应中的称为 的参数，以及接受称为 的参数的突变input。当您使用install generator向项目添加样板 GraphQL 文件时，默认使用此类。

add_note.rb在mutations位于以下位置的目录中创建一个文件app/graphql/mutations：

nano ~/rails_graphql/app/graphql/mutations/add_note.rb

将以下代码添加到文件中以定义添加新注释的突变：

module Mutations
  class AddNote < Mutations::BaseMutation
    argument :params, Types::Input::NoteInputType, required: true

    field :note, Types::NoteType, null: false

    def resolve(params:)
      note_params = Hash params

      begin
        note = Note.create!(note_params)

        { note: note }
      rescue ActiveRecord::RecordInvalid => e
        GraphQL::ExecutionError.new("Invalid attributes for #{e.record.class}:"\
          " #{e.record.errors.full_messages.join(', ')}")
      end
    end
  end
end

这定义了一个Mutations::AddNote继承自Mutations::BaseMutation该类的类，该类是您install generator在安装 GraphQL-Ruby gem时运行时创建的类之一。该Mutations::AddNote级接收argument的名称params和类型的NoteInputType，你在步骤3中创建它也返回一个field叫note那必须是一个非空NoteType类型。

resolve该类的方法接收params并将其转换为一个散列，用于创建和返回一个包含新笔记的新散列。如果在创建笔记时出现错误，则会挽救该错误并将其作为GraphQL::ExecutionError.

注意：resolve mutation 中的方法必须返回一个哈希，其符号与field名称匹配。

与查询一样，Mutations::AddNote必须使用mutation:关键字将变异附加到变异字段。

打开位于app/graphql/types/mutation_type.rb编辑器中的突变类型文件：

nano ~/rails_graphql/app/graphql/types/mutation_type.rb

将文件中的代码替换为以下代码，该代码为其添加了一个字段add_note及其对应的变异类：

module Types
  class MutationType < Types::BaseObject
    field :add_note, mutation: Mutations::AddNote
  end
end

在此代码中，您向add_note变异类型文件添加了一个字段，并Mutations::AddNote使用mutation:关键字将其附加到类。当add_note突变被调用时，它运行类的resolve方法中的代码Mutations::AddNote。

要测试您的新变更，请导航到localhost:3000/graphiql或在您的浏览器中打开您的 GraphiQL IDE。在编辑器的左侧，输入以下查询：http://your_server_ip:3000/graphiql

mutation {
  addNote(input: { params: { title: "GraphQL notes", body: "A long body of text about GraphQL"  }}) {
    note {
      id
      title
      body
    }
  }
}

这声明了一个带有addNote接受单个input参数的字段的变异操作，该字段又接受一个param键与NoteInputType. 变异操作还包括一个note与类note返回的字段相匹配的字段Mutations::AddNote。

在 GraphiQL 中运行突变，您将在输出窗格中看到以下结果：

{
  "data": {
    "addNote": {
      "note": {
        "id": "6",
        "title": "GraphQL notes",
        "body": "A long body of text about GraphQL"
      }
    }
  }
}

返回的响应是新创建的笔记，其中包含更改请求中请求的字段。

随着您的add_note变更现在工作，您的 API 可以使用 GraphQL 查询和变更获取和创建笔记。

结论

在本教程中，您使用 Ruby on Rails 创建了一个笔记记录 API 应用程序，使用 PostgreSQL 作为数据库，使用 GraphQL 作为 API 查询语言。您可以在其官方网站上了解有关 GraphQL 的更多信息。该GraphQL-红宝石创业板网站还包含了一些指南，以帮助您GraphQL在Rails的工作。