Create the initial rack app and middleware with examples and tests

Author: betaflag

.gitignore

@@ -0,0 +1,7 @@
+.ruby-version
+doc/
+.yardoc/
+guides/yardoc/
+pkg/
+Gemfile.lock
+gemfiles/*.lock

Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'rack-test'
+gem 'rake'
+gem 'minitest'

README.md

@@ -0,0 +1,80 @@
+This is a simple spec-compliant GraphQL rack application and middleware based on the [graphql](https://github.com/rmosolgo/graphql-ruby) gem. Since it's built with Rack, it can be mounted with most ruby web servers.
+
+Install the gem:
+
+```
+gem install graphql-server
+```
+
+# Using the server
+
+## As a standalone application
+
+```ruby
+# app.ru
+require 'graphql_server'
+
+type_def = <<-GRAPHQL
+  type Query {
+    hello: String
+  }
+GRAPHQL
+
+resolver = {
+  "Query" => {
+    "hello" => Proc.new { "world" }
+  }
+}
+
+run GraphqlServer.new(type_def: type_def, resolver: resolver)
+```
+
+Start using `rackup`
+
+```
+rackup app.ru
+```
+
+## As a middleware in your application
+
+```ruby
+# app.ru
+require 'graphql_server'
+
+type_def = ...
+resolver = ...
+
+use GraphqlServer, type_def: type_def, resolver: resolver, path: '/graphql'
+```
+
+Start using `rackup`
+
+```
+rackup app.ru
+```
+
+# Options
+
+## Schema
+
+You can get started fast by writing a type defintions and a resolver hash
+
+```ruby
+GraphqlServer.new(type_def: type_def, resolver: resolver)
+```
+
+You can also provide your own schema
+
+```ruby
+GraphqlServer.new(schema: schema)
+```
+
+See the examples folder for more details
+
+## Middleware
+
+When using as a middleware, you can specify the path to mount the graphql endpoint (defaults to `/`)
+
+```ruby
+use GraphqlServer, type_def: type_def, resolver: resolver, path: '/graphql'
+```

Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb']
+end
+
+desc "Run tests"
+task :default => :test

examples/blog/app.ru

@@ -0,0 +1,11 @@
+require 'graphql'
+require 'graphql_server'
+
+require_relative 'models/comment'
+require_relative 'models/post'
+require_relative 'types/comment_type'
+require_relative 'types/post_type'
+require_relative 'types/query_type'
+require_relative 'schema'
+
+run GraphqlServer.new(schema: Schema)

examples/blog/models/comment.rb

@@ -0,0 +1,2 @@
+class Comment < OpenStruct  
+end

examples/blog/models/post.rb

@@ -0,0 +1,12 @@
+class Post < OpenStruct  
+  def self.find(id)
+    Post.new(
+      id: 1, 
+      title: 'first post', 
+      truncated_preview: 'Hello world!', 
+      comments: [
+        Comment.new(id: 1, message: 'first comment')
+      ]
+    )
+  end
+end

examples/blog/schema.rb

@@ -0,0 +1,3 @@
+class Schema < GraphQL::Schema
+  query Types::QueryType
+end

examples/blog/types/comment_type.rb

@@ -0,0 +1,6 @@
+module Types
+  class CommentType < GraphQL::Schema::Object
+    field :id, ID, null: false
+    field :message, String, null: false
+  end
+end

examples/blog/types/post_type.rb

@@ -0,0 +1,17 @@
+module Types
+  class PostType < GraphQL::Schema::Object
+    description "A blog post"
+
+    field :id, ID, null: false
+    
+    field :title, String, null: false
+    
+    # fields should be queried in camel-case (this will be `truncatedPreview`)
+    field :truncated_preview, String, null: false
+    
+    # Fields can return lists of other objects:
+    field :comments,  [Types::CommentType], null: true,
+      # And fields can have their own descriptions:
+      description: "This post's comments, or null if this post has comments disabled."
+  end
+end

examples/blog/types/query_type.rb

@@ -0,0 +1,16 @@
+module Types
+  class QueryType < GraphQL::Schema::Object
+    description "The query root of this schema"
+
+    # First describe the field signature:
+    field :post, Types::PostType, null: true do
+      description "Find a post by ID"
+      argument :id, ID, required: true
+    end
+
+    # Then provide an implementation:
+    def post(id:)
+      Post.find(id)
+    end
+  end
+end

examples/hello_world_app/hello_world_app.ru

@@ -0,0 +1,15 @@
+require 'graphql_server'
+
+type_def = <<-GRAPHQL
+  type Query {
+    hello: String
+  }
+GRAPHQL
+
+resolver = {
+  "Query" => { 
+    "hello" => Proc.new { "world" }
+  }
+}
+
+run GraphqlServer.new(type_def: type_def, resolver: resolver)

examples/hello_world_middleware/hello_world_middleware.ru

@@ -0,0 +1,16 @@
+require 'graphql_server'
+
+type_def = <<-GRAPHQL
+  type Query {
+    hello: String
+  }
+GRAPHQL
+
+resolver = {
+  "Query" => { 
+    "hello" => Proc.new { "world" }
+  }
+}
+
+use GraphqlServer, type_def: type_def, resolver: resolver, path: '/graphql'
+run ->(env) { [200, {"Content-Type" => "text/html"}, ["Hello World!"]] }

graphql_server.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name        = 'graphql_server'
+  s.version     = '0.0.1'
+  s.date        = '2019-01-18'
+  s.summary     = "A simple spec-compliant GraphQL rack application and middleware"
+  s.description = "A simple spec-compliant GraphQL rack application and middleware"
+  s.authors     = ["betaflag"]
+  s.email       = '[email protected]'
+  s.files       = ["README.md", "lib/graphql_server.rb"]
+  s.test_files  = s.files.select { |p| p =~ /^test\/.*_test.rb/ }
+  s.homepage    = 'https://github.com/betaflag/graphql-server-ruby'
+  s.license     = 'MIT'
+  
+  s.add_dependency 'rack', '~> 2.0'
+  s.add_dependency 'graphql', '~> 1.8.13'
+  s.add_dependency 'json', '~> 1.8.6'
+end

lib/graphql_server.rb

@@ -0,0 +1,63 @@
+require 'graphql'
+require 'json'
+require 'rack'
+
+class GraphqlServer
+  class InvalidRequestTypeError < Exception; end;
+  class PostBodyMissing < Exception; end;
+
+  # Initilizes GraphqlServer as a Rack app or middleware
+  #
+  # This Rack middleware (or app) implements a spec-compliant GraphQL server which can be queried from any GraphQL client.
+  # It can be used with a provided GraphQL schema or can build one from a type definition and a resolver hash.
+  #
+  # @param [Array<Object>] *args The first argument should be `app` when used as a middleware
+  # @param String path Also for middleware, we will use path to determine when to process GraphQL, defaults to '/'
+  # @param String type_def A schema definition string, or a path to a file containing the definition
+  # @param Hash resolver A hash with callables for handling field resolution
+  # @param GraphQL::Schema schema Use this schema if `type_def` and `resolver` is nil
+  # @param Hash context
+  def initialize(*args , path: nil, type_def: nil, resolver: nil, schema: nil, context: nil)
+    @app = args && args[0]
+    @context = context
+    @path = (@app && !path) ? '/' : path
+    @schema = type_def && resolver ? GraphQL::Schema.from_definition(type_def, default_resolve: resolver) : schema
+  end
+
+  def middleware?
+    !@app.nil?
+  end
+
+  def call(env)
+    request = Rack::Request.new(env)
+
+    # only resolve when url matches `path` if we're in a middleware
+    return @app.call(env) if middleware? && @path != request.path_info
+    
+    # graphql accepts GET and POST requests
+    raise InvalidRequestTypeError unless request.get? || request.post?
+
+    payload = if request.get?
+      request.params
+    elsif request.post?
+      body = request.body.read
+      raise PostBodyMissing if body.empty?
+      payload = JSON.parse(body)
+    end
+
+    response = @schema.execute(
+      payload['query'], 
+      variables: payload['variables'],
+      operation_name: payload['operationName'],
+      context: @context, 
+    ).to_json
+    
+    [200, {'Content-Type' => 'application/json', 'Content-Length' => response.bytesize.to_s}, [response]]
+  rescue InvalidRequestTypeError
+    # Method Not Allowed
+    [405, {"Content-Type" => "text/html"}, ["GraphQL Server supports only GET/POST requests"]]
+  rescue PostBodyMissing
+    # Bad Request
+    [400, {"Content-Type" => "text/html"}, ["POST body missing"]]
+  end
+end

test/graphql_server_test.rb

@@ -0,0 +1,62 @@
+require 'minitest/autorun'
+require "minitest/spec"
+
+require 'graphql_server'
+require 'rack/test'
+require 'graphql'
+require 'hello_world_server'
+
+describe GraphqlServer do
+  include Rack::Test::Methods
+
+  describe "app" do
+    describe "#call" do
+      let(:app) { HelloWorldServer.app }
+
+      it 'responds to a graphql query via get' do
+        get '/', {'query' => '{ hello }'}
+        assert_equal 200, last_response.status
+        expected_body = '{"data":{"hello":"world"}}'
+        assert_equal expected_body, last_response.body
+      end
+
+      it 'responds to a graphql query via post' do
+        post '/', {'query' => '{ hello }'}.to_json
+        assert_equal 200, last_response.status
+        expected_body = '{"data":{"hello":"world"}}'
+        assert_equal expected_body, last_response.body
+      end
+
+      it 'does not support PUT queries' do
+        put '/', {'query' => '{ hello }'}
+        assert_equal 405, last_response.status
+        assert_equal 'GraphQL Server supports only GET/POST requests', last_response.body
+      end
+
+      it 'does not support DELETE queries' do
+        delete '/', {'query' => '{ hello }'}
+        assert_equal 405, last_response.status
+        assert_equal 'GraphQL Server supports only GET/POST requests', last_response.body
+      end
+
+      it 'returns error 400 when post body is missing' do
+        post '/'
+        assert_equal 400, last_response.status
+        assert_equal 'POST body missing', last_response.body
+      end
+    end
+  end
+
+  describe "middleware" do
+    describe "#call" do
+      let(:app) { HelloWorldServer.middleware }
+
+      it 'responds to a graphql query via get' do
+        get '/', {'query' => '{ hello }'}
+        assert_equal 200, last_response.status
+        expected_body = '{"data":{"hello":"world"}}'
+        assert_equal expected_body, last_response.body
+      end
+    end
+  end
+end