Ein Projekt mit Ruby on Rails, PostgreSQL und GraphQL aufsetzen

Ein Projekt mit Ruby on Rails, PostgreSQL und GraphQL aufzusetzen, ist tatsächlich ziemlich unkompliziert.

Vorab ein paar Voraussetzungen. Für dieses Tutorial (getestet mit den Versionen 2.7.3, 6.1.4.1 und 11.0) musst du alle drei, Ruby on Rails, PostgreSQL und GraphQL, auf deiner Entwicklungsmaschine installiert haben.

Grundkenntnisse in Ruby und Rails sind ebenfalls empfehlenswert.

Bevor wir anfangen, fragst du dich vielleicht, warum man die solide Erfahrung einer klassischen REST-API überhaupt durch GraphQL ersetzen sollte. Ein naheliegender Grund: GraphQL löst Over- und Under-Fetching von Ressourcen elegant. Mit GraphQL bekommst du genau die Informationen, die du anfragst – nicht mehr und nicht weniger. Außerdem ist es quasi selbst-dokumentierend, was dir einen Punkt auf der To-do-Liste abnimmt. Weitere Vorteile von GraphQL sind unter anderem das starke Typsystem sowie die Sprach- und Datenbankunabhängigkeit. Den Rest kannst du in Ruhe selbst erkunden.

Also, legen wir los und richten unsere erste GraphQL-API auf Ruby on Rails ein.

GraphQL für Rails einrichten

Schritt 1 - PostgreSQL-Datenbank

Lass uns eine Ruby on Rails API-App mit PostgreSQL als Datenbank erstellen. Wir bauen eine ganz einfache Bookshelf-API.

rails new bookshelf_app -d=postgresql -T —api

Schritt 2 - GraphQL zur Gemfile

Fügen wir GraphQL zu unserem Projekt hinzu. Trage dazu gem ‘graphql’ in deiner Gemfile ein.

Zum Testen deiner Queries in der Entwicklung füge unter development noch gem ‘graphiql-rails’ hinzu.

Jetzt installieren wir die Gems.

bundle install
rails g graphql:install

Stelle sicher, dass deine config/routes.rb Folgendes enthält:

if Rails.env.development?
 mount GraphiQL::Rails::Engine, at: 'graphiql', graphql_path: 
 ‘graphql#execute’
end

post ‘/graphql', to: ‘graphql#execute’

Schritt 3 - Datenbank erstellen

Zeit, die Datenbank zu erstellen und den Server zu starten. 

rails db:create db:migrate
rails s

Rufe anschließend im Browser localhost:3000/graphiql auf (oder einen anderen Port, falls angegeben). Wenn du das GraphiQL-Interface siehst, kannst du Schritt 4 überspringen.

Schritt 4 - Loading...

Falls weiterhin die Seite Loading… angezeigt wird, gehe zu config/application.rb und kommentiere die Zeile mit “sprockets/railtie” wieder ein. Erstelle anschließend eine leere Datei app/assets/config/manifest.js.

Starte den Server neu. Nun solltest du Zugriff auf das GraphiQL-Interface haben.

Schritt 5 - Author, Books

Als Nächstes erzeugen wir Ressourcen, indem wir die Models Author und Book generieren. Ein Author kann viele Books haben, und jedes Book gehört zu einem Author.

rails g model Author name
rails g model Book title:text author:references genre:text description
rails db:migrate

Öffne dein Author-Model, füge has_many :books hinzu und speichere – so passen unsere Assoziationen. 

Super – jetzt sind wir bereit für GraphQL!

Schritt 6 - Author/Book-Typen

Lass uns die Typen für Author und Book anlegen. 

rails generate graphql:object author
rails generate graphql:object book

Öffne die Datei author_type.rb und füge unter den anderen Feldern field :books, [Types::BookType], null: true hinzu, damit wir bei Author-Queries auch Informationen zu ihren Books abfragen können. Du kannst dir die Typen als Schemata für spezifische Ressourcen vorstellen.

Schritt 7 - Mutations

Jetzt, da unsere Typen bereitstehen, erstellen wir unsere erste Mutation. Mutations werden verwendet, um Ressourcen in der Datenbank zu verändern.

Beginnen wir mit der Mutation zum Erstellen von Authors. Lege die Datei create_author.rb unter app/graphql/mutations an und fülle sie wie folgt: 

module Mutations
  class CreateAuthor < BaseMutation
    argument :name, String, required: true
  
    type Types::AuthorType

    def resolve(name:)
      Author.create!(name: name)
    end
  end
end

Ebenso fügen wir eine Mutation zum Erstellen von Books hinzu. Lege die Datei create_book.rb an:

module Mutations
  class CreateBook < BaseMutation
    argument :title, String, required: false
    argument :genre, String, required: false
    argument :description, String, required: false
    argument :author_id, ID, required: true
  
    type Types::BookType

    def resolve(**attributes)
      Book.create!(attributes)
    end
  end
end

Ähnliche Mutations kannst du zum Aktualisieren und Löschen von Ressourcen erstellen.

Füge anschließend Folgendes in deiner mutation_type.rb-Datei hinzu:

field :create_author, mutation: Mutations::CreateAuthor
field :create_book, mutation: Mutations::CreateBook

Zum Testen der Mutations erstellen wir unseren ersten Author. Öffne das GraphiQL-Interface, schreibe Folgendes und führe die Query aus.

mutation {
  createAuthor(input: {
    name: "Jane Doe"
  }) {
    id
    name
  }
}

Als Antwort solltest du etwas in dieser Art erhalten:

{
  "data": {
    "createAuthor": {
      "id": "1",
      "name": "Jane Doe"
    }
   }

Erstelle anschließend auf dieselbe Weise dein erstes Book.

Schritt 8 - Erste Queries

Zum Schluss erstellen wir unsere ersten Queries. Aktualisiere dazu deine query_type.rb-Datei wie folgt. Alle hier definierten Felder stehen uns über die API zur Verfügung.

field :authors, [AuthorType], null: false
field :books, [BookType], null: false
field :author, AuthorType, null: false do
  argument :id, ID, required: true
end
field :book, BookType, null: false do
  argument :id, ID, required: true
end

def authors
  Author.all
end

def books
  Book.all
end

def author(id:)
  Author.find(id)
end

def book(id:)
  Book.find(id)
end

Führe diese Query in GraphiQL aus:

query {
  author(id: 1) {
    id
    name
    books {
      id
      title
    }
  }
}

Wenn du bereits einige Books zur Datenbank hinzugefügt hast, sollte die Antwort in etwa so aussehen:

{
  "data": {
    "author": {
      "id": "1",
      "name": "Jane Doe",
      "books": [
        {
          "id": "1",
          "title": "Book 1"
        },
        {
          "id": "2",
          "title": "Book 2"
        },
        {
          "id": "3",
          "title": "Book 3"
        }
      ]
    }
  }
}

Nachwort

Und das war’s schon. Glückwunsch – du hast gerade deine erste Rails-GraphQL-API erstellt! Wenn du nach einer Lösung für Autorisierung suchst, schau dir das Gem action_policy-graphql an. Weitere Tipps zu GraphQL in Ruby on Rails findest du unter: https://www.howtographql.com/graphql-ruby/0-introduction. 

Viel Erfolg! 

Wenn du mehr über andere Programmiersprachen und Technologien erfahren möchtest, die bei SDH zum Einsatz kommen, kontaktiere uns gern unter hello@start-up.house.