gqli 0.1.0

data/spec/lib/gqli/client_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe GQLi::Client do
+  let(:client) do
+    vcr('client') {
+      space_id = 'cfexampleapi'
+      token = 'b4c0n73n7fu1'
+      GQLi::Client.new(
+        "https://graphql.contentful.com/content/v1/spaces/#{space_id}",
+        headers: { "Authorization" => "Bearer #{token}" }
+      )
+    }
+  end
+
+  let(:client_no_validations) do
+    vcr('client') {
+      space_id = 'cfexampleapi'
+      token = 'b4c0n73n7fu1'
+      GQLi::Client.new(
+        "https://graphql.contentful.com/content/v1/spaces/#{space_id}",
+        headers: { "Authorization" => "Bearer #{token}" },
+        validate_query: false
+      )
+    }
+  end
+
+  let(:dsl) { GQLi::DSL }
+
+  context 'validations enabled' do
+    subject { client }
+
+    it 'upon instantiation caches the schema' do
+      expect(subject.schema.types).not_to be_empty
+    end
+
+    it 'when executing a query performs schema validation' do
+      vcr('catCollection') {
+        expect(subject.execute(
+          dsl.query {
+            catCollection {
+              items {
+                name
+              }
+            }
+          }).data
+        ).not_to be_empty
+
+        expect { subject.execute(
+          dsl.query {
+            foobar
+          }
+        )}.to raise_exception 'Validation Error: query is invalid - HTTP Request not sent'
+      }
+    end
+
+    it 'can skip validations when using `#execute!`' do
+      vcr('validation_error') {
+        expect { subject.execute!(
+          dsl.query {
+            foobar
+          }
+        )}.to raise_exception([
+          "Error: Bad Request",
+          'Body: {"errors":[{"message":"Cannot query field \"foobar\" on type \"Query\".","locations":[{"line":2,"column":3}]}]}'
+        ].join("\n"))
+      }
+    end
+  end
+
+  context 'validations disabled' do
+    subject { client_no_validations }
+
+    it 'upon instantiation doesnt cache the schema' do
+      expect(subject.schema).to be_nil
+    end
+
+    it 'when executing a query doesnt perform schema validation' do
+      vcr('validation_error') {
+        expect { subject.execute(
+          dsl.query {
+            foobar
+          }
+        )}.to raise_exception([
+          "Error: Bad Request",
+          'Body: {"errors":[{"message":"Cannot query field \"foobar\" on type \"Query\".","locations":[{"line":2,"column":3}]}]}'
+        ].join("\n"))
+      }
+    end
+  end
+end

data/spec/lib/gqli/dsl_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+class MockGQLInterface
+  include GQLi::DSL
+end
+
+describe GQLi::DSL do
+  subject { described_class }
+
+  describe 'module level methods' do
+    describe '::query' do
+      it 'can create a query without name' do
+        query = subject.query {
+          someField
+        }
+
+        expect(query).to be_a GQLi::Query
+        expect(query.to_gql).to eq <<~GRAPHQL
+          query {
+            someField
+          }
+        GRAPHQL
+      end
+
+      it 'can create a query with a name' do
+        query = subject.query('FooBar') {
+          someOtherField
+        }
+
+        expect(query).to be_a GQLi::Query
+        expect(query.to_gql).to eq <<~GRAPHQL
+          query FooBar {
+            someOtherField
+          }
+        GRAPHQL
+      end
+    end
+
+    describe '::fragment' do
+      it 'can create a fragment' do
+        fragment = subject.fragment('FooBar', 'Foo') {
+          someFooField
+        }
+
+        expect(fragment).to be_a GQLi::Fragment
+        expect(fragment.to_gql).to eq <<~GRAPHQL
+          fragment FooBar on Foo {
+            someFooField
+          }
+        GRAPHQL
+      end
+    end
+  end
+
+  describe 'instance level methods' do
+    subject { MockGQLInterface.new }
+
+    describe '#query does the same as ::query' do
+      it 'can create a query without name' do
+        query = subject.query {
+          someField
+        }
+
+        expect(query).to be_a GQLi::Query
+        expect(query.to_gql).to eq <<~GRAPHQL
+          query {
+            someField
+          }
+        GRAPHQL
+      end
+
+      it 'can create a query with a name' do
+        query = subject.query('FooBar') {
+          someOtherField
+        }
+
+        expect(query).to be_a GQLi::Query
+        expect(query.to_gql).to eq <<~GRAPHQL
+          query FooBar {
+            someOtherField
+          }
+        GRAPHQL
+      end
+    end
+
+    describe '#fragment does the same as ::fragment' do
+      it 'can create a fragment' do
+        fragment = subject.fragment('FooBar', 'Foo') {
+          someFooField
+        }
+
+        expect(fragment).to be_a GQLi::Fragment
+        expect(fragment.to_gql).to eq <<~GRAPHQL
+          fragment FooBar on Foo {
+            someFooField
+          }
+        GRAPHQL
+      end
+    end
+  end
+
+  describe 'node DSL' do
+    it 'nodes can have arguments' do
+      query = subject.query {
+        someNode(arg1: 100)
+        otherNode(arg2: 'some_string')
+        moreNodes(arg3: { nestedArg: [1, 2] })
+      }
+
+      expect(query.to_gql).to eq <<~GRAPHQL
+        query {
+          someNode(arg1: 100)
+          otherNode(arg2: "some_string")
+          moreNodes(arg3: {nestedArg: [1, 2]})
+        }
+      GRAPHQL
+    end
+
+    it 'nodes can have arbitrarily nested nodes' do
+      query = subject.query {
+        aNode {
+          withChild {
+            moreChildren
+            andASibiling(someParameterHere: 'just for fun') {
+              withEvenMore
+            }
+          }
+          alsoASibiling
+        }
+        withoutChild
+      }
+
+      expect(query.to_gql).to eq <<~GRAPHQL
+        query {
+          aNode {
+            withChild {
+              moreChildren
+              andASibiling(someParameterHere: "just for fun") {
+                withEvenMore
+              }
+            }
+            alsoASibiling
+          }
+          withoutChild
+        }
+      GRAPHQL
+    end
+
+    it 'queries can have inlined fragments at any level' do
+      NameFragment = subject.fragment('NameFragment', 'Foo') {
+        name
+      }
+
+      AgeFragment = subject.fragment('AgeFragment', 'Foo') {
+        age
+      }
+
+      query = subject.query {
+        peopleCollection {
+          ___ NameFragment
+          ___ AgeFragment
+        }
+      }
+
+      expect(query.to_gql).to eq <<~GRAPHQL
+        query {
+          peopleCollection {
+            name
+            age
+          }
+        }
+      GRAPHQL
+    end
+
+    it 'queries can have type matchers' do
+      query = subject.query {
+        catCollection {
+          items {
+            name
+            bestFriend {
+              __on('Cat') {
+                name
+              }
+            }
+          }
+        }
+      }
+
+      expect(query.to_gql).to eq <<~GRAPHQL
+        query {
+          catCollection {
+            items {
+              name
+              bestFriend {
+                ... on Cat {
+                  name
+                }
+              }
+            }
+          }
+        }
+      GRAPHQL
+    end
+  end
+end

data/spec/lib/gqli/introspection_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+describe GQLi::Introspection do
+  let(:dsl) { GQLi::DSL }
+  let(:client) do
+    vcr('client') {
+      space_id = 'cfexampleapi'
+      token = 'b4c0n73n7fu1'
+      GQLi::Client.new(
+        "https://graphql.contentful.com/content/v1/spaces/#{space_id}",
+        headers: { "Authorization" => "Bearer #{token}" }
+      )
+    }
+  end
+
+  subject { client.schema }
+
+  describe 'introspection schema' do
+    it 'queries the API for the schema' do
+      expect(subject.types).not_to be_empty
+
+      expect(subject.types.map(&:name)).to include('Cat', 'CatCollection', 'Human')
+    end
+  end
+
+  describe 'validations' do
+    it 'valid query returns true' do
+      query = dsl.query {
+        catCollection(
+          locale:"en-US",
+          limit: 1,
+          where: {
+            name:"Nyan Cat",
+            OR: {
+              name:"Happy Cat"
+            }
+          }
+        ) {
+          items {
+            name
+            color
+            birthday
+            lives
+            bestFriend {
+              __on('Cat') {
+                name
+              }
+            }
+            image {
+              url
+            }
+          }
+        }
+      }
+
+      expect(subject.valid?(query)).to be_truthy
+    end
+
+    it 'wrong node returns false' do
+      query = dsl.query {
+        foo
+      }
+
+      expect(subject.valid?(query)).to be_falsey
+    end
+
+    it 'object node that doesnt have proper values returns false' do
+      query = dsl.query {
+        catCollection
+      }
+
+      expect(subject.valid?(query)).to be_falsey
+    end
+
+    it 'object list node that doesnt have proper values returns false' do
+      query = dsl.query {
+        catCollection {
+          items
+        }
+      }
+
+      expect(subject.valid?(query)).to be_falsey
+    end
+
+    it 'type matching on invalid type returns false' do
+      query = dsl.query {
+        catCollection {
+          items {
+            bestFriend {
+              __on('InvalidType') {
+                foo
+              }
+            }
+          }
+        }
+      }
+
+      expect(subject.valid?(query)).to be_falsey
+    end
+
+    it 'invalid arguments return false' do
+      query = dsl.query {
+        catCollection(invalidParam: 1) {
+          items {
+            name
+          }
+        }
+      }
+
+      expect(subject.valid?(query)).to be_falsey
+    end
+
+    it 'invalid argument type returns false' do
+      query = dsl.query {
+        catCollection(limit: 'foo') {
+          items {
+            name
+          }
+        }
+      }
+
+      expect(subject.valid?(query)).to be_falsey
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+require 'vcr'
+
+Dir[File.join('..', File.dirname(__FILE__), 'lib', '**', '*.rb')].each { |f| require f }
+
+require 'gqli'
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+end
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/fixtures/vcr_cassettes'
+  c.ignore_localhost = true
+  c.hook_into :webmock
+  c.default_cassette_options = { record: :once }
+end
+
+def vcr(name, &block)
+  VCR.use_cassette(name, &block)
+end

data/usage.rb

@@ -0,0 +1,100 @@
+require_relative './lib/gqli'
+
+puts GQLi::DSL.query {
+  __on('Foo') {
+    bar
+  }
+}.to_gql
+
+
+puts GQLi::DSL.query {
+  viewer {
+    login
+    repositories(first: 10) {
+      edges {
+        node {
+          nameWithOwner
+          watchers(first: 10) {
+            edges {
+              node {
+                login
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}.to_gql
+
+FragmentFoo = GQLi::DSL.fragment('Foo', 'Bar') {
+  foo
+  bar(b: 10)
+  baz {
+    qux(c: 3)
+  }
+}
+
+puts FragmentFoo.to_gql
+
+puts GQLi::DSL.query {
+  ___ FragmentFoo
+}.to_gql
+
+puts "-------------"
+
+SPACE_ID = 'cfexampleapi'
+ACCESS_TOKEN = 'b4c0n73n7fu1'
+CONTENTFUL_GQL = GQLi::Client.new(
+  "https://graphql.contentful.com/content/v1/spaces/#{SPACE_ID}",
+  headers: { "Authorization" => "Bearer #{ACCESS_TOKEN}" }
+)
+
+CatBase = GQLi::DSL.fragment('CatBase', 'Cat') {
+  name
+  likes
+  lives
+}
+
+CatBestFriend = GQLi::DSL.fragment('CatBestFriend', 'Cat') {
+  bestFriend {
+    __on('Cat') {
+      ___ CatBase
+    }
+  }
+}
+
+CatImportantFields = GQLi::DSL.fragment('CatImportantFields', 'Cat') {
+  ___ CatBase
+  ___ CatBestFriend
+}
+
+Query = GQLi::DSL.query {
+  catCollection(limit: 1) {
+    items {
+      ___ CatImportantFields
+      image {
+        url
+      }
+    }
+  }
+}
+
+response = CONTENTFUL_GQL.execute(Query)
+
+puts "Query sent:"
+puts response.query.to_gql
+
+puts
+puts "Response received"
+response.data.catCollection.items.each do |c|
+  puts "Name:    #{c.nam}e"
+  puts "Likes:   #{c.likes.join(", ")}"
+  puts "Lives #: #{c.lives}"
+  c.bestFriend.tap do |bf|
+    puts "Best Friend:"
+    puts "\tName:    #{bf.name}"
+    puts "\tLikes:   #{bf.likes.join(", ")}"
+    puts "\tLives #: #{bf.lives}"
+  end
+end

data/usage_introspection.rb

@@ -0,0 +1,63 @@
+require_relative './lib/gqli'
+
+SPACE_ID = 'cfexampleapi'
+ACCESS_TOKEN = 'b4c0n73n7fu1'
+CONTENTFUL_GQL = GQLi::Client.new(
+  "https://graphql.contentful.com/content/v1/spaces/#{SPACE_ID}",
+  headers: { "Authorization" => "Bearer #{ACCESS_TOKEN}" }
+)
+
+CatBase = GQLi::DSL.fragment('CatBase', 'Cat') {
+  name
+  likes
+  lives
+}
+
+CatBestFriend = GQLi::DSL.fragment('CatBestFriend', 'Cat') {
+  bestFriend {
+    __on('Cat') {
+      ___ CatBase
+    }
+  }
+}
+
+CatImportantFields = GQLi::DSL.fragment('CatImportantFields', 'Cat') {
+  ___ CatBase
+  ___ CatBestFriend
+}
+
+Query = GQLi::DSL.query {
+  catCollection(limit: 1) {
+    items {
+      ___ CatImportantFields
+      image {
+        url
+      }
+    }
+  }
+}
+
+response = CONTENTFUL_GQL.execute(Query)
+
+puts "Query sent:"
+puts response.query.to_gql
+
+puts
+puts "Response received"
+response.data.catCollection.items.each do |c|
+  puts "Name:    #{c.nam}e"
+  puts "Likes:   #{c.likes.join(", ")}"
+  puts "Lives #: #{c.lives}"
+  c.bestFriend.tap do |bf|
+    puts "Best Friend:"
+    puts "\tName:    #{bf.name}"
+    puts "\tLikes:   #{bf.likes.join(", ")}"
+    puts "\tLives #: #{bf.lives}"
+  end
+end
+
+puts "Trying to execute invalid query"
+
+CONTENTFUL_GQL.execute!(GQLi::DSL.query {
+  invalidNode
+})

data/usage_with_inlined_dsl.rb

@@ -0,0 +1,69 @@
+require_relative './lib/gqli'
+
+class ContentfulClient
+  extend GQLi::DSL # Makes DSL available at a class level
+  include GQLi::DSL # Makes DSL available at an object level
+
+  SPACE_ID = 'cfexampleapi'
+  ACCESS_TOKEN = 'b4c0n73n7fu1'
+  CONTENTFUL_GQL = GQLi::Client.new(
+    "https://graphql.contentful.com/content/v1/spaces/#{SPACE_ID}",
+    headers: { "Authorization" => "Bearer #{ACCESS_TOKEN}" }
+  )
+
+  CatBase = fragment('CatBase', 'Cat') {
+    name
+    likes
+    lives
+  }
+
+  CatBestFriend = fragment('CatBestFriend', 'Cat') {
+    bestFriend {
+      __on('Cat') {
+        ___ CatBase
+      }
+    }
+  }
+
+  CatImportantFields = fragment('CatImportantFields', 'Cat') {
+    ___ CatBase
+    ___ CatBestFriend
+  }
+
+  def cats
+    CONTENTFUL_GQL.execute(
+      query {
+        catCollection(limit: 10, locale: 'tlh') {
+          items {
+            ___ CatImportantFields
+            image {
+              url
+            }
+          }
+        }
+      }
+    )
+  end
+end
+
+response = ContentfulClient.new.cats
+
+puts "Query sent:"
+puts response.query.to_gql
+
+puts
+puts "Response received"
+response.data.catCollection.items.each do |c|
+  puts "Name:    #{c.name}"
+  puts "Likes:   #{c.likes.join(", ")}"
+  puts "Lives #: #{c.lives}"
+  puts "Image:   #{c.image.url}" if c.image?
+  c.bestFriend.tap do |bf|
+    next if bf.nil?
+    puts "Best Friend:"
+    puts "\tName:    #{bf.name}"
+    puts "\tLikes:   #{bf.likes.join(", ")}"
+    puts "\tLives #: #{bf.lives}"
+  end
+  puts
+end