如何设置 Ruby on Rails GraphQL API

作者选择了免费打印以获得捐赠作为写给捐赠计划的一部分。

介绍

GraphQL是一種為API和伺服器端執行這些查詢的強調查詢語言,用您的現有資料執行這些查詢。GraphQL允許客戶在單一請求中從伺服器上收集多種資源,讓客戶能夠指定查詢中所需的準確數據。

在本教程中,您将构建一个由 GraphQL 驱动的 Ruby on Rails API 用于笔记. 完成后,您将能够使用 GraphQL 创建和查看 API 的笔记。

GraphiQL IDE

如果您想查看本教程的代码,请查看 DigitalOcean 社区 GitHub上的本教程的伴侣库(https://github.com/do-community/rails_graphql)。

前提条件

要遵循这个教程,你需要:

Ruby编程语言和Ruby on Rails框架安装在您的开发机器上。此教程在Ruby的2.6.3版本和Rails的6.0.2.1版本上进行了测试,因此在安装过程中确保指定这些版本. 遵循其中之一的教程安装Ruby和Rails: -[如何在铁路上安装Ruby,在Ubuntu 18.04上安装rbenv (https://andsky.com/tech/tutorials/how-to-install-ruby-on-rails-with-rbenv-on-ubuntu-18-04) -[如何在铁路上安装Ruby,在CentOS 7上安装rbenv (https://andsky.com/tech/tutorials/how-to-install-ruby-on-rails-with-rbenv-on-centos-7).

[如何在铁路上安装Ruby,在macOS上安装rbenv] (https://andsky.com/tech/tutorials/how-to-install-ruby-on-rails-with-rbenv-on-macos).

PostgreSQL 已安装. 要跟踪此教程, 请使用 PostgreSQL 版本 11. 2 。通过下列一个教程中的步骤1和步骤2安装 PostgreSQL: -[在Ubuntu 18.04的铁路应用上如何使用PostgreSQL(https://andsky.com/tech/tutorials/how-to-use-postgresql-with-your-ruby-on-rails-application-on-ubuntu-18-04) -在macOS的铁路应用上如何使用PostgreSQL.

为在 Linux 的另一种发售方式或其他操作系统中开发此应用程序, 请访问 [官方 PostgreSQL 下载页] (https://www.postgresql.org/download/). 关于如何使用PostgreSQL的更多信息,请访问如何安装和使用PostgreSQL. (英语)

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

在此步骤中,您将设置一个新的 Rails API 应用程序,并将其连接到 PostgreSQL 数据库。

Rails 提供了使开发人员更快地构建现代Web应用程序的命令. 这些命令可以执行从创建新的 Rails 应用程序到生成应用程序开发所需的文件的操作。

1rails -h

此命令产生了广泛的选项列表,您可以用来设置应用程序的参数。列出的命令之一是新命令,该命令接受APP_PATH,并在指定的路径上创建一个新的 Rails 应用程序。

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

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

这在名为rails_graphql的目录中创建了一个新的 Rails 应用程序,并安装所需的依赖性。

-d 旗预配置应用程序与指定的数据库。
-T 旗指示 Rails 不要生成测试文件,因为您不会在本教程中写测试。如果您打算使用与 Rails 提供的测试框架不同的测试框架,您也可以使用这个旗帜。

一旦命令完成运行,切换到新创建的 rails_graphql 目录,即应用程序的 root 目录:

1cd rails_graphql

现在您已经成功设置了新的 Rails API 应用程序,您必须将其连接到数据库才能运行该应用程序 Rails 提供了在 config/database.yml 中找到的 database.yml 文件,其中包含将您的应用程序连接到不同的开发环境的不同数据库的配置。

<$>[注] 注: 您可以更改 config/database.yml 以选择您希望 Rails 使用的 PostgreSQL 角色来创建您的数据库。如果您创建了由密码保护的角色,请遵循如何在 Ubuntu 18.04 上使用 PostgreSQL 与您的 Ruby on Rails 应用程序或如何在 macOS 上使用 PostgreSQL 与您的 Ruby on Rails 应用程序中的 步骤 4中的说明来配置您的角色。

Rails 包含用于创建和使用数据库的命令. 有了数据库凭证,在终端窗口中运行以下命令来创建数据库:

1rails db:create

db:create命令创建一个基于config/database.yml文件提供的信息的开发和测试数据库。

1[secondary_label Output]
2Created database 'rails_graphql_development'
3Created database 'rails_graphql_test'

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

1bundle exec rails server

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

1bundle exec rails server --binding=your_server_ip

<$>[注] 注:服务器在端口3000上倾听。如果您在开发服务器上工作,请确保您在防火墙中打开端口3000,以允许连接。

rails server 命令启动了 Ruby 的 Web 服务器 Puma,该 Web 服务器与 Rails 一起分发。

运行此命令后,您的命令提示将被以下输出所取代:

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

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

Rails welcome page

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

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

您已成功设置 Rails API 应用程序为备注 API. 在下一步,您将设置 Rails API 应用程序来接收和执行 GraphQL 查询。

步骤 2:为 Rails 设置 GraphQL

在此步骤中,您将配置您的 Rails API 应用程序以与 GraphQL 一起工作,您将安装和设置在 Rails 中开发 GraphQL 所需的必要宝石。

如前所述,GraphQL是语言无知的,并在许多编程语言中实现。 graphql-ruby宝石是GraphQL的Ruby实现。GraphQL还提供了名为 GraphiQL的互动式浏览器IDE,用于运行GraphQL查询。

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

1nano Gemfile

将graphql和graphiql-rails宝石添加到您的 Gemfile. 您可以将graphiql宝石添加到任何地方,但graphiql-rails宝石应在开发依赖中添加:

 1[label ~/rails_graphql/Gemfile]
 2...
 3group :development do
 4  gem 'listen', '>= 3.0.5', '< 3.2'
 5  # Spring speeds up development by keeping your application running in the background. Read more: https://github.com/rails/spring
 6  gem 'spring'
 7  gem 'spring-watcher-listen', '~> 2.0.0'
 8  gem 'graphiql-rails'
 9end
10
11gem 'graphql', '1.9.18'
12...

保存并关闭文件,当你完成添加宝石。

在您的终端窗口中,使用以下命令来安装宝石:

1bundle install

输出表明宝石已安装。

graphql宝石提供发电机来创建各种文件. 要查看可用的发电机,请在终端窗口中运行以下命令:

1rails generate

以graphql:为前缀的发电机是与graphql宝石相关的。

您将使用graphql:install命令将graphql-ruby锅炉代码添加到应用程序中,并在您的开发环境中安装 GraphiQL。

在您的终端窗口中,运行以下命令:

1rails g graphql:install

此命令生成了一些文件,包括位于 app/controllers/graphql_controller.rb 位置的 graphql_controller.rb 文件和在 app/graphql 位置的 graphql 目录,其中包含需要在 Rails 中使用 GraphQL 启动的文件。

在您可以测试 GraphQL 终端之前,您需要将 GraphiQL 引擎安装在路由文件中,以便您可以访问浏览器中的 GraphiQL IDE。

1nano ~/rails_graphql/config/routes.rb

将下列代码添加到文件中,以在开发环境中安装 GraphiQL 引擎:

1[label ~/rails_graphql/config/routes.rb]
2Rails.application.routes.draw do
3  if Rails.env.development?
4    mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "graphql#execute"
5  end
6  post "/graphql", to: "graphql#execute"
7  # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
8end

这将 GraphiQL 引擎安装在 /graphiql 路径上,并将所有查询导向 graphql# execute' 方法。

由于这是一个用--api旗创建的API应用程序,它不希望在浏览器中渲染任何页面. 为了使 GraphiQL 编辑器出现在浏览器中,您需要对应用程序的配置做出几个小更改。

首先,打开位于config/application.rb的application.rb文件:

1nano ~/rails_graphql/config/application.rb

接下来,不要评论要求sprockets/railtie``的行:

 1[label ~/rails_graphql/config/application.rb]
 2require_relative 'boot'
 3
 4require "rails"
 5# Pick the frameworks you want:
 6require "active_model/railtie"
 7require "active_job/railtie"
 8require "active_record/railtie"
 9require "active_storage/engine"
10require "action_controller/railtie"
11require "action_mailer/railtie"
12require "action_mailbox/engine"
13require "action_text/engine"
14require "action_view/railtie"
15require "action_cable/engine"
16require "sprockets/railtie"
17# require "rails/test_unit/railtie"
18
19...

保存并关闭文档后不评论行。

现在在app/assets中创建一个config目录:

1mkdir -p app/assets/config

接下来,在新创建的config目录中创建一个manifest.js文件。

1nano app/assets/config/manifest.js

将以下代码添加到该文件中,该文件要求 Rails 预编译 graphiql/rails/application.css 和 graphiql/rails/application.js 文件,以便 Rails 可以将其服务于您的浏览器:

1[label ~/rails_graphql/app/assets/config/manifest.js]
2//= link graphiql/rails/application.css
3//= link graphiql/rails/application.js

保存并关闭文件。

您可以重新启动您的开发服务器,并在浏览器中导航到 localhost:3000/graphiql或 http://your_server_ip:3000/graphiql。 GraphiQL 查询编辑器在您的浏览器中显示:

GraphiQL IDE

GraphiQL IDE 的左侧接受 GraphQL 查询,右侧显示运行查询的结果。 GraphiQL 查询编辑器还具有由您的 GraphQL 计划驱动的语法亮点器和打字背面。

要尝试一个Hello World示例,请清除编辑器的左侧窗格中的默认文本,然后键入以下查询:

1query {
2    testField
3}

点击标题中的播放图标按钮,您将在屏幕上获得成功的响应,如下图所示:

GraphiQL IDE Response successful response

您已成功设置 Rails API 应用程序以与 GraphQL 工作,并测试了您的 GraphQL 终端,以确认它工作。

步骤 3 – 创建应用程序的类型

GraphQL 依赖其类型和方案来验证和响应查询. 在此步骤中,您将创建一个备注模型和您的备注 API 所需的 GraphQL 类型。

GraphQL 类型由字段和参数组成,这些字段和参数反过来定义了可能出现在该类型操作的任何 GraphQL 查询中的字段和参数。

查询类型和突变类型: 这些类型是定义每个 GraphQL 查询的输入点的特殊类型。每个 GraphQL 服务都有查询类型,可能或可能没有突变类型。
对象类型: 这些是 GraphQL 方案的基本组成部分。这些代表您可以从 GraphQL 服务中获取的对象和每个对象所拥有的字段。
尺度类型: 这些是与 GraphQL 出来的默认类型。它们包括 Int、 Float、 String、 Boolean 和 `ID。
编号类型: 这些类型定义了一组特定的允许值。

还有其他类型,包括联盟,列表,非无效和接口。你可以在官方的 GraphQL 文档中找到可用的 GraphQL 类型列表。

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

首先,使用 Rails 提供的生成模型子命令创建一个备注模型,并指定该模型的名称以及其列和数据类型。

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

此命令会创建一个包含两个字段的Note模型:title和body,并在title列中添加一个数据库index。

这个文件将包含所有与模型相关的逻辑。

A 20200617173228_create_notes.rb 文件(文件开始时的号码将有所不同,取决于您运行命令的日期)位于 db/migrate/202006173228_create_notes.rb。

要执行迁移文件中的指令,您将使用db:migrate子命令,该子命令在您的迁移文件中执行。

1rails db:migrate

一旦命令成功运行,您将看到类似于以下的输出:

1[secondary_label Output]
2== 20200617173228 CreateNotes: migrating ======================================
3-- create_table(:notes)
4   -> 0.0134s
5-- add_index(:notes, :title)
6   -> 0.0073s
7== 20200617173228 CreateNotes: migrated (0.0208s) =============================

有了笔记模型,您将创建一个NoteType。一个有效的笔记对象预计将具有一个id,一个标题和一个文本。

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

该命令指示 Rails 创建一个名为Note的 GraphQL 对象类型,其中包含三个字段:一个具有ID类型的id字段,以及每个字段的标题和体字段,每个字段都具有字符串类型。

运行前一条命令会创建位于app/graphql/types/note_type.rb的note_type.rb文件,其中包含一个Types::NoteType类,包含三个非可重置的字段。

最后,您将创建一个NoteInput类型来定义创建笔记所需的参数。首先,在app/graphql/types下创建一个input目录。

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

<$>[注] **注:**在输入目录中创建输入类型不是一个要求,它只是一个常见的惯例。你可以决定将所有类型保留在类型目录中,并且在每次访问时将类别嵌入到输入模块中。

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

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

将下列代码添加到文件中,以定义输入类型的字段:

1[label ~/rails_graphql/app/graphql/types/input/note_input_type.rb]
2module Types
3  module Input
4    class NoteInputType < Types::BaseInputObject
5      argument :title, String, required: true
6      argument :body, String, required: true
7    end
8  end
9end

在 'note_input_type.rb' 文件中,您添加了 'Types::Input::NoteInputType' 类,该类继承了 'Types::BaseInputObject' 类,并接受两个所需的参数; 'titel' 和 'body',两者都是字符串类型。

您为您的笔记应用程序创建了一个模型和两个 GraphQL 类型,在下一步,您将创建查询以获取现有笔记。

步骤 4 – 创建应用程序的查询

您的 GraphQL 驱动的 API 正在逐步聚集在一起. 在此步骤中,您将创建两个查询;一个是通过id获取单个笔记,另一个是通过id获取所有笔记。

首先,您将创建一个查询以检索所有笔记. 首先,创建一个查询目录来容纳所有查询:

1mkdir ~/rails_graphql/app/graphql/queries

在app/graphql/queries目录中,创建一个base_query.rb文件,所有其他查询类将继承:

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

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

1[label ~/rails_graphql/app/graphql/queries/base_query.rb]
2module Queries
3  class BaseQuery < GraphQL::Schema::Resolver
4  end
5end

在「base_query.rb」文件中,您添加了从「GraphQL::Schema::Resolver」类继承的「Queries::BaseQuery」类别。

查询::BaseQuery类也可以包含您打算在多个查询类中重复使用的任何代码。

接下来,在查询目录中创建一个fetch_notes.rb文件,该文件将包含捕捉所有现有笔记的逻辑,并附加到查询类型文件中的字段:

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

将下列代码添加到文件中,以定义返回对象类型并解决所需的注释:

 1[label ~/rails_graphql/app/graphql/queries/fetch_notes.rb]
 2module Queries
 3  class FetchNotes < Queries::BaseQuery
 4
 5    type [Types::NoteType], null: false
 6
 7    def resolve
 8      Note.all.order(created_at: :desc)
 9    end
10  end
11end

在fetch_notes.rb文件中,您创建了一个Queries::FetchNotes类,它继承了以前创建的Queries::BaseQuery。

Queries::FetchNotes还包含一个解决方法,该方法以下行顺序将所有现有笔记排序为其创建日期。

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

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

「query_type.rb」文件是所有 GraphQL 查询类型的输入点,包含查询字段及其相应的解析方法,用以下代码替文件中的样本代码:

1[label ~/rails_graphql/app/graphql/types/query_type.rb]
2module Types
3  class QueryType < Types::BaseObject
4    # Add root-level fields here.
5    # They will be entry points for queries on your schema.
6
7    field :fetch_notes, resolver: Queries::FetchNotes
8  end
9end

在query_type.rb文件中,您添加了一个fetch_notes字段,并使用resolver:将其附加到Queries::FetchNotes类中。

为了测试您的查询,您需要一些数据来检索,但您目前在您的数据库中没有任何笔记。您可以通过将一些种子数据添加到您的数据库来解决这个问题。

1nano ~/rails_graphql/db/seeds.rb

将以下代码添加到文件中,以创建五个笔记:

1[label ~/rails_graphql/db/seeds.rb]
25.times do |i|
3  Note.create(title: "Note #{i + 1}", body: 'Lorem ipsum saves lives')
4end

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

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

1rails db:seed

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

有了数据在您的数据库中,并且您的开发服务器正在运行,在浏览器中导航到localhost:3000/graphiql或http://your_server_ip:3000/graphiql以打开您的 GraphiQL IDE。在编辑器的左侧,键入以下查询:

1query {
2  fetchNotes {
3    id
4    title
5    body
6  }
7}

此 GraphQL 查询声明一个查询操作,表示您要提出查询请求。在查询操作中,您呼叫了一个fetchNotes字段,该字段匹配了 API 中声明的fetch_notes字段,并包含了您希望返回的注释中的字段。

点击标题中的 **播放 ** 图标按钮,您将在输出窗格中看到类似的答案:

 1{
 2  "data": {
 3    "fetchNotes": [
 4      {
 5        "id": "5",
 6        "title": "Note 5",
 7        "body": "Lorem ipsum saves lives"
 8      },
 9      {
10        "id": "4",
11        "title": "Note 4",
12        "body": "Lorem ipsum saves lives"
13      },
14      {
15        "id": "3",
16        "title": "Note 3",
17        "body": "Lorem ipsum saves lives"
18      },
19      {
20        "id": "2",
21        "title": "Note 2",
22        "body": "Lorem ipsum saves lives"
23      },
24      {
25        "id": "1",
26        "title": "Note 1",
27        "body": "Lorem ipsum saves lives"
28      }
29    ]
30  }
31}

答案包含一组 5 个笔记,匹配在左侧的查询中声明的字段. 如果您删除编辑器左侧的查询中的一些字段并重新运行查询,您将只收到您请求的字段的答案. 这是 GraphQL 的功能。

接下来,您将创建另一个查询以获取id的笔记,该查询将类似于fetch_notes的查询,但它将接受一个id参数。

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

将下列代码添加到文件中,以找到并返回附有id的笔记:

 1[label ~/rails_graphql/app/graphql/queries/fetch_note.rb]
 2module Queries
 3  class FetchNote < Queries::BaseQuery
 4    type Types::NoteType, null: false
 5    argument :id, ID, required: true
 6
 7    def resolve(id:)
 8      Note.find(id)
 9    rescue ActiveRecord::RecordNotFound => _e
10      GraphQL::ExecutionError.new('Note does not exist.')
11    rescue ActiveRecord::RecordInvalid => e
12      GraphQL::ExecutionError.new("Invalid attributes for #{e.record.class}:"\
13        " #{e.record.errors.full_messages.join(', ')}")
14    end
15  end
16end

这定义了从Queries::BaseQuery类继承的Queries::FetchNote类别,该类别不仅返回必须属于NoteType的单个项目,还接受具有ID类型的id参数。

接下来,您将附加Queries::FetchNote类到查询类型文件中的查询字段。

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

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

 1[label ~/rails_graphql/app/graphql/types/query_type.rb]
 2module Types
 3  class QueryType < Types::BaseObject
 4    # Add root-level fields here.
 5    # They will be entry points for queries on your schema.
 6
 7    field :fetch_notes, resolver: Queries::FetchNotes
 8    field :fetch_note, resolver: Queries::FetchNote
 9  end
10end

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

1query {
2  fetchNote(id: 1) {
3    id
4    title
5    body
6  }
7}

此查询操作要求一个fetchNote字段,该字段与fetch_note查询字段相匹配,并通过一个id参数。

点击标题中的 **播放 ** 图标按钮来运行查询,您将在输出窗格中获得如下答案:

1{
2  "data": {
3    "fetchNote": {
4      "id": "1",
5      "title": "Note 1",
6      "body": "Lorem ipsum saves lives"
7    }
8  }
9}

答案包含一个单一的注释,匹配请求中的id和与请求中的字段相匹配的字段。

在此步骤中,您创建了 GraphQL 查询以从 API 获取笔记,接下来您将编写突变来创建笔记。

步骤 5 — 创建 GraphQL 突变来修改笔记

除了查询之外,GraphQL 还定义了修改服务器侧数据的操作的突变类型,就像 REST 提供用于创建、更新和删除资源的POST,PUT,PATCH和DELETE请求一样,GraphQL 的突变类型定义了导致服务器侧写作的操作的惯例。

graphQL-ruby包括写变异的两个类别,它们是:

GraphQL::Schema::Mutation:这是编写突变的通用基础类别;如果你不希望在你的突变中需要一个输入参数,你应该使用这个类别。
GraphQL::Schema::RelayClassicMutation:这是一个具有某些惯例的基础类别;一个名为clientMutationId的参数,它总是被插入到响应中,并接受一个名为输入的参数的突变。

在位于app/graphql/mutations的突变目录中创建一个add_note.rb文件:

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

将下列代码添加到文件中,以定义添加新笔记的突变:

 1[label ~/rails_graphql/app/graphql/mutations/add_note.rb]
 2module Mutations
 3  class AddNote < Mutations::BaseMutation
 4    argument :params, Types::Input::NoteInputType, required: true
 5
 6    field :note, Types::NoteType, null: false
 7
 8    def resolve(params:)
 9      note_params = Hash params
10
11      begin
12        note = Note.create!(note_params)
13
14        { note: note }
15      rescue ActiveRecord::RecordInvalid => e
16        GraphQL::ExecutionError.new("Invalid attributes for #{e.record.class}:"\
17          " #{e.record.errors.full_messages.join(', ')}")
18      end
19    end
20  end
21end

这定义了从Mutations::BaseMutation类继承的Mutations::AddNote类,这是您在安装 GraphQL-Ruby 宝石时运行安装生成器时创建的类之一。

该类的解决方法接收参数,并将其转换为一个哈希,它使用它来创建并返回包含新笔记的新哈希。

<$>[注] 注: 突变中的解决方法必须返回一个符号匹配字段名称的哈希。

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

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

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

用以下代码代替文件中的代码,该代码添加了对应的突变类的add_note字段:

1[label ~/rails_graphql/app/graphql/types/mutation_type.rb]
2module Types
3  class MutationType < Types::BaseObject
4    field :add_note, mutation: Mutations::AddNote
5  end
6end

在此代码中,您将一个add_note字段添加到突变类文件中,并使用mutation:关键字将其附加到Mutations::AddNote类中。

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

1mutation {
2  addNote(input: { params: { title: "GraphQL notes", body: "A long body of text about GraphQL"  }}) {
3    note {
4      id
5      title
6      body
7    }
8  }
9}

这声明了一个addNote字段的突变操作,该字段接受一个单一的输入参数,而该参数则接受一个具有与NoteInputType匹配的键的param对象。

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

 1{
 2  "data": {
 3    "addNote": {
 4      "note": {
 5        "id": "6",
 6        "title": "GraphQL notes",
 7        "body": "A long body of text about GraphQL"
 8      }
 9    }
10  }
11}

返回的答案是新创建的笔记,其中包含突变请求中请求的字段。

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

结论

在本教程中,您创建了一个具有注意力的 API 应用程序,使用 PostgreSQL 作为您的数据库和 GraphQL 作为 API 查询语言。您可以在其官方网站上了解更多关于 GraphQL 的信息。