hq-graphql 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: be9de36cb5b0f12696e98d85156404d89acdc6d5
+  data.tar.gz: 0e887aabc0d14374ad192e464a8b1e3e4ac4ea8f
+SHA512:
+  metadata.gz: 7ec2755f98cd6045e93da317edec985a3a148c4baef5a7e30d24c1568020327f455d4a7efb14b117d482c0b51106e69ad67f0db33c6051c8b42d750f951086c8
+  data.tar.gz: aae1f46e971c88db6a4e87d919dc354e0235931041bf485172df0109520892f1e0294a10b99c81943ca71132b92ed1bfd56f76fdda5d2cb0e3b9e9323bc56665

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 Danny Jones
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,55 @@
+# HQ::GraphQL
+
+OneHQ GraphQL interface to [Ruby Graphql](https://github.com/rmosolgo/graphql-ruby).
+
+[![CircleCI](https://img.shields.io/circleci/project/github/OneHQ/hq-graphql.svg)](https://circleci.com/gh/OneHQ/hq-graphql/tree/master)
+[![GitHub tag](https://img.shields.io/github/tag/OneHQ/hq-graphql.svg)](https://github.com/OneHQ/hq-graphql)
+
+## Configuration
+
+You can pass configuration options as a block to `::HQ::GraphQL.configure`.
+
+```ruby
+# The gem assumes that if your model is called `MyModel`, the corresponding type is `MyModelType`.
+# You can override that convention.
+# Default is: -> (model_class) { "#{model_class.name.demodulize}Type" }
+::HQ::GraphQL.config do |config|
+  config.model_to_graphql_type = -> (model_class) { "::CustomNameSpace::#{model_class.name}Type" }
+end
+```
+
+## Usage
+
+Create a new ::HQ::GraphQL::Object
+```ruby
+class AdvisorType < ::HQ::GraphQL::Object
+  # Supports graphql-ruby functionality
+  field :id, Int, null: false
+
+  # Lazy Loading
+  # Useful for loading data from the database to generate a schema
+  lazy_load do
+    load_data_from_db.each do |name|
+      field name, String, null: false
+    end
+  end
+
+  # Attach the GraphQL object to an ActiveRecord Model
+  # First argument is the string form of your ActiveRecord model.
+  #
+  # attributes:
+  #  Set it to false if you don't want to auto-include your model's attributes.
+  #  Defaults to true.
+  #
+  # associations:
+  #  Set it to false if you don't want to auto-include your model's associations.
+  #  Defaults to true.
+  with_model "Advisor", attributes: true, associations: false
+
+  # Remove attributes that were included by `with_model`
+  remove_attrs :id, :created_at, :updated_at
+
+  # Remove associations that were included by `with_model`
+  remove_associations :organization, :created_by
+end
+```

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'HQ::GraphQL'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'bundler/gem_tasks'

data/lib/hq-graphql.rb

@@ -0,0 +1 @@
+require "hq/graphql"

data/lib/hq/graphql.rb

@@ -0,0 +1,32 @@
+require "graphql"
+
+module HQ
+  module GraphQL
+    def self.config
+      @config ||= ::ActiveSupport::OrderedOptions.new
+    end
+
+    def self.configure(&block)
+      config.instance_eval(&block)
+    end
+
+    # The gem assumes that if your model is called `MyModel`, the corresponding type is `MyModelType`.
+    # You can override that convention.
+    #
+    # ::HQ::GraphQL.config do |config|
+    #   config.model_to_graphql_type = -> (model_class) { "::CustomNameSpace::#{model_class.name}Type" }
+    # end
+    def self.model_to_graphql_type
+      config.model_to_graphql_type ||
+        @model_to_graphql_type ||= -> (model_class) { "#{model_class.name.demodulize}Type" }
+    end
+
+    def self.graphql_type_from_model(model_class)
+      model_to_graphql_type.call(model_class)
+    end
+  end
+end
+
+require "hq/graphql/object"
+require "hq/graphql/types"
+require "hq/graphql/engine"

data/lib/hq/graphql/engine.rb

@@ -0,0 +1,6 @@
+module HQ
+  module GraphQL
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/hq/graphql/object.rb

@@ -0,0 +1,117 @@
+module HQ
+  module GraphQL
+    class Object < ::GraphQL::Schema::Object
+      class Error < StandardError
+        MISSING_MODEL_MSG = "Can't perform %{action} without connecting to a model: `::HQ::GraphQL::Object.with_model 'User'`".freeze
+        MISSING_ATTR_MSG = "Can't find attr %{model}.%{attr}'`".freeze
+        MISSING_ASSOC_MSG = "Can't find association %{model}.%{assoc}'`".freeze
+      end
+
+      def self.lazy_load(&block)
+        @lazy_load ||= []
+        @lazy_load << block if block
+        @lazy_load
+      end
+
+      def self.with_model(model_name, attributes: true, associations: true)
+        self.model_name = model_name
+
+        lazy_load do
+          if attributes
+            model_klass.columns.reject { |c| removed_attrs.include?(c.name.to_sym) }.each do |column|
+              field_from_column column
+            end
+          end
+
+          if associations
+            model_klass.reflect_on_all_associations.reject { |a| removed_associations.include?(a.name.to_sym) }.each do |association|
+              field_from_association association
+            end
+          end
+        end
+      end
+
+      def self.add_attr(attr)
+        lazy_load do
+          validate_model!(:add_attr)
+          field_from_column model_column(attr)
+        end
+      end
+
+      def self.remove_attrs(*attrs)
+        removed_attrs.concat attrs.map(&:to_sym)
+      end
+
+      def self.remove_associations(*associations)
+        removed_associations.concat associations.map(&:to_sym)
+      end
+
+      def self.add_association(association)
+        lazy_load do
+          validate_model!(:add_association)
+          field_from_association model_association(association)
+        end
+      end
+
+      def self.to_graphql
+        lazy_load!
+        super
+      end
+
+      class << self
+        private
+
+        attr_accessor :model_name
+        attr_writer :removed_attrs, :removed_associations
+
+        def lazy_load!
+          lazy_load.map(&:call)
+          @lazy_load = []
+        end
+
+        def model_klass
+          @model_klass ||= model_name&.constantize
+        end
+
+        def model_column(attr)
+          model_klass.columns_hash[attr.to_s] || raise(Error, Error::MISSING_ATTR_MSG % { model: model_name, attr: attr })
+        end
+
+        def model_association(association)
+          model_klass.reflect_on_association(association) || raise(Error, Error::MISSING_ASSOC_MSG % { model: model_name, assoc: association })
+        end
+
+        def removed_attrs
+          @removed_attrs ||= []
+        end
+
+        def removed_associations
+          @removed_associations ||= []
+        end
+
+        def validate_model!(action)
+          unless model_name
+            raise Error, Error::MISSING_MODEL_MSG % { action: action }
+          end
+        end
+
+        def field_from_association(association)
+          name = association.name
+          type = ::HQ::GraphQL::Types[association.klass]
+          case association.macro
+          when :has_many
+            field name, [type], null: false
+          else
+            field name, type, null: true
+          end
+        end
+
+        def field_from_column(column)
+          field column.name, ::HQ::GraphQL::Types.type_from_column(column), null: column.null
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/types.rb

@@ -0,0 +1,55 @@
+require "hq/graphql/types/uuid"
+
+module HQ
+  module GraphQL
+    module Types
+
+      def self.[](key)
+        @schema_objects ||= Hash.new do |hash, klass|
+          hash[klass] = klass_for(klass)
+        end
+        @schema_objects[key]
+      end
+
+      def self.type_from_column(column)
+        case column&.cast_type&.type
+        when :uuid
+          ::HQ::GraphQL::Types::UUID
+        when :integer
+          ::GraphQL::INT_TYPE
+        when :decimal
+          ::GraphQL::FLOAT_TYPE
+        when :boolean
+          ::GraphQL::BOOLEAN_TYPE
+        else
+          ::GraphQL::STRING_TYPE
+        end
+      end
+
+      # Only being used in testing
+      def self.reset!
+        @schema_objects = nil
+      end
+
+      class << self
+        private
+
+        def klass_for(klass)
+          hql_klass_name = ::HQ::GraphQL.graphql_type_from_model(klass)
+          hql_klass = hql_klass_name.safe_constantize
+          return hql_klass if hql_klass
+
+          module_name = hql_klass_name.deconstantize.presence
+          hql_module = module_name ? (module_name.safe_constantize || ::Object.const_set(module_name, Module.new)) : ::Object
+
+          hql_klass = Class.new(::HQ::GraphQL::Object) do
+            with_model klass.name
+          end
+
+          hql_module.const_set(hql_klass_name.demodulize, hql_klass)
+        end
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/types/uuid.rb

@@ -0,0 +1,33 @@
+module HQ
+  module GraphQL
+    module Types
+      class UUID < ::GraphQL::Schema::Scalar
+        description "UUID"
+
+        class << self
+          def self.coerce_input(value, context)
+            validate_and_return_uuid(value)
+          end
+
+          def self.coerce_result(value, context)
+            validate_and_return_uuid(value)
+          end
+
+          private
+
+          def validate_and_return_uuid(value)
+            if validate_uuid(value)
+              value
+            else
+              raise ::GraphQL::CoercionError, "#{value.inspect} is not a valid UUID"
+            end
+          end
+
+          def validate_uuid(value)
+            !!value.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hq/graphql/version.rb

@@ -0,0 +1,5 @@
+module HQ
+  module GraphQL
+    VERSION = "0.0.2"
+  end
+end

data/spec/factories/advisors.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :advisor do
+    name                    { Faker::Name.name }
+    organization            { FactoryBot.build(:organization) }
+  end
+end

data/spec/factories/organizations.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :organization do
+    name                         { Faker::Company.name }
+  end
+end

data/spec/factories/users.rb

@@ -0,0 +1,6 @@
+FactoryBot.define do
+  factory :user do
+    name                { Faker::Name.name }
+    organization        { FactoryBot.build(:organization) }
+  end
+end

data/spec/internal/app/graphql/query.rb

@@ -0,0 +1,18 @@
+class Query < GraphQL::Schema::Object
+  graphql_name "Query"
+
+  field :users, [HQ::GraphQL::Types[User]], null: false
+  field :advisors, [HQ::GraphQL::Types[Advisor]], null: false
+
+  def users
+    User.all
+  end
+
+  def users_custom
+    users
+  end
+
+  def advisors
+    Advisor.all
+  end
+end

data/spec/internal/app/graphql/schema.rb

@@ -0,0 +1,3 @@
+class Schema < GraphQL::Schema
+  query(Query)
+end

data/spec/internal/app/graphql/user_type.rb

@@ -0,0 +1,3 @@
+class UserType < HQ::GraphQL::Object
+  with_model "User"
+end

data/spec/internal/app/models/advisor.rb

@@ -0,0 +1,3 @@
+class Advisor < ActiveRecord::Base
+  belongs_to :organization
+end

data/spec/internal/app/models/organization.rb

@@ -0,0 +1,3 @@
+class Organization < ::ActiveRecord::Base
+  has_many :users, inverse_of: :organization
+end

data/spec/internal/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ::ActiveRecord::Base
+  belongs_to :organization, inverse_of: :users
+end

data/spec/internal/config/database.circleci.yml

@@ -0,0 +1,24 @@
+common: &common
+  adapter: postgresql
+  encoding: utf8
+  host: <%= ENV["DBHOST"] || "127.0.0.1" %>
+  port: <%= ENV["DBPORT"] || "5432" %>
+  database: <%= ENV["DBNAME"] || "hq-graphql" %>
+  username: <%= ENV["DBUSER"] || "postgres" %>
+  password: <%= ENV["DBPASSWORD"] || "" %>
+  pool: 5
+  reconnect: true
+  timeout: 5000
+
+development:
+  <<: *common
+
+test:
+  <<: *common
+
+staging:
+  <<: *common
+
+production:
+  <<: *common
+  pool: 10

data/spec/internal/config/database.yml

@@ -0,0 +1,8 @@
+test:
+  adapter: postgresql
+  database: <%= ENV['DB'] || 'hq-graphql_test' %>
+  username: <%= ENV['DB_USERNAME'] || %x[id -un] %> # `id -un` returns the active user in OSX (at least as of 10.10)
+  password:
+  timeout: 5000
+  encoding: utf8
+  pool: 25

data/spec/internal/db/schema.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Schema.define do
+  enable_extension "uuid-ossp"
+
+  create_table "organizations", force: true, id: :uuid do |t|
+    t.string   :name,                  limit: 63, null: false
+    t.timestamps                       null: false
+  end
+
+  create_table "users", force: true do |t|
+    t.belongs_to  :organization,       null: false, index: true, foreign_key: true, type: :uuid
+    t.string      :name,               null: false
+    t.timestamps                       null: false
+  end
+
+  create_table "advisors", force: true do |t|
+    t.references  :organization,       null: false, index: true, foreign_key: true, type: :uuid
+    t.string      :name,               null: false
+    t.timestamps                       null: false
+  end
+
+end

data/spec/lib/object_spec.rb

@@ -0,0 +1,198 @@
+require 'rails_helper'
+
+describe ::HQ::GraphQL::Object do
+
+  describe ".lazy_load" do
+    let(:lazy_load_class) do
+      Class.new(described_class) do
+        graphql_name "LazyLoadQuery"
+
+        @counter = 0
+
+        lazy_load do
+          @counter += 1
+        end
+
+        def self.counter
+          @counter
+        end
+      end
+    end
+
+    it "lazy loads once" do
+      # First time it works
+      expect { lazy_load_class.to_graphql }.to change  { lazy_load_class.counter }.by(1)
+      # Second time it does nothing
+      expect { lazy_load_class.to_graphql }.to change  { lazy_load_class.counter }.by(0)
+    end
+  end
+
+  describe ".with_model" do
+    let(:hql_object_klass) do
+      Class.new(described_class) do
+        graphql_name "TestQuery"
+      end
+    end
+
+    it "adds everything by default" do
+      hql_object_klass.class_eval do
+        with_model "Advisor"
+      end
+
+      expect(hql_object_klass.fields.keys).to be_empty
+      hql_object_klass.to_graphql
+      expected = ["createdAt", "id", "name", "organization", "organizationId", "updatedAt"]
+      expect(hql_object_klass.fields.keys).to contain_exactly(*expected)
+    end
+
+    it "removes an attribute" do
+      hql_object_klass.class_eval do
+        remove_attrs :created_at, :id, :organization_id
+        with_model "Advisor"
+      end
+
+      expect(hql_object_klass.fields.keys).to be_empty
+      hql_object_klass.to_graphql
+      expected = ["name", "organization", "updatedAt"]
+      expect(hql_object_klass.fields.keys).to contain_exactly(*expected)
+    end
+
+    it "removes an association" do
+      hql_object_klass.class_eval do
+        remove_associations :organization, :doesntexist
+        with_model "Advisor"
+      end
+
+      expect(hql_object_klass.fields.keys).to be_empty
+      hql_object_klass.to_graphql
+      expected = ["createdAt", "id", "name", "organizationId", "updatedAt"]
+      expect(hql_object_klass.fields.keys).to contain_exactly(*expected)
+    end
+
+    context "with attributes and associations turned off" do
+      it "doesn't have any fields by default" do
+        hql_object_klass.to_graphql
+        expect(hql_object_klass.fields.keys).to be_empty
+      end
+
+      it "doesn't have any fields when disabling model attrs/associations" do
+        hql_object_klass.class_eval do
+          with_model "Advisor", attributes: false, associations: false
+        end
+        hql_object_klass.to_graphql
+        expect(hql_object_klass.fields.keys).to be_empty
+      end
+
+      it "blows up when adding an attribute to an object without a model" do
+        hql_object_klass.class_eval do
+          add_attr :name
+        end
+
+        expect { hql_object_klass.to_graphql }.to raise_error(described_class::Error)
+      end
+
+      it "blows up when adding an attribute that doesn't exist" do
+        hql_object_klass.class_eval do
+          add_attr :doesnt_exist
+
+          with_model "Advisor", attributes: false, associations: false
+        end
+
+        expect { hql_object_klass.to_graphql }.to raise_error(described_class::Error)
+      end
+
+      it "adds attributes once connected to a model" do
+        hql_object_klass.class_eval do
+          # Order shouldn't matter....but let's test it anyway
+
+          # First
+          add_attr :name
+
+          # Second
+          with_model "Advisor", attributes: false, associations: false
+        end
+
+        expect(hql_object_klass.fields.keys).to be_empty
+        hql_object_klass.to_graphql
+        expect(hql_object_klass.fields.keys).to contain_exactly("name")
+      end
+
+      it "blows up when adding an association to an object without a model" do
+        hql_object_klass.class_eval do
+          add_association :organization
+        end
+
+        expect { hql_object_klass.to_graphql }.to raise_error(described_class::Error)
+      end
+
+      it "blows up when adding an association that doesn't exist" do
+        hql_object_klass.class_eval do
+          add_association :doesnt_exist
+
+          with_model "Advisor", attributes: false, associations: false
+        end
+
+        expect { hql_object_klass.to_graphql }.to raise_error(described_class::Error)
+      end
+
+      it "adds associations once connected to a model" do
+        hql_object_klass.class_eval do
+          # Order shouldn't matter....but let's test it anyway
+
+          # First
+          add_association :organization
+
+          # Second
+          with_model "Advisor", attributes: false, associations: false
+        end
+
+        expect(hql_object_klass.fields.keys).to be_empty
+        hql_object_klass.to_graphql
+        expect(hql_object_klass.fields.keys).to contain_exactly("organization")
+      end
+
+    end
+
+    context "with a schema" do
+      let(:user_1) { FactoryBot.create(:user) }
+      let(:user_2) { FactoryBot.create(:user, organization: user_1.organization) }
+
+      before(:each) do
+        user_1
+        user_2
+      end
+
+      it "executes graphql" do
+        query_str = <<-GRAPHQ
+          query {
+            users {
+              name
+              organizationId
+
+              organization {
+                name
+              }
+            }
+          }
+        GRAPHQ
+
+        result = ::Schema.execute(query_str)
+
+        aggregate_failures do
+          user_1_data, user_2_data = result["data"]["users"]
+          # User 1
+          expect(user_1_data["name"]).to eql(user_1.name)
+          expect(user_1_data["organizationId"]).to eql(user_1.organization_id)
+          expect(user_1_data["organization"]["name"]).to eql(user_1.organization.name)
+
+          # User 2
+          expect(user_2_data["name"]).to eql(user_2.name)
+          expect(user_2_data["organizationId"]).to eql(user_2.organization_id)
+          expect(user_2_data["organization"]["name"]).to eql(user_2.organization.name)
+        end
+      end
+    end
+
+  end
+
+end

data/spec/lib/types_spec.rb

@@ -0,0 +1,60 @@
+require 'rails_helper'
+
+describe ::HQ::GraphQL::Types do
+
+  describe ".[]" do
+    before(:each) do
+      described_class.reset!
+    end
+
+    after(:each) do
+      described_class.reset!
+    end
+
+    it "generates a new class with columns & associations" do
+      # Unique Classes
+      allow(::HQ::GraphQL).to receive(:model_to_graphql_type) { -> (model_class) { "#{model_class.name.demodulize}TypeTest" } }
+
+      advisor_klass = described_class[Advisor]
+      user_klass = described_class[User]
+      advisor_user_fields = ["id", "organizationId", "name", "createdAt", "updatedAt", "organization"]
+
+      #### Advisor Schema ####
+      expect(advisor_klass.name).to eql(::HQ::GraphQL.graphql_type_from_model(Advisor))
+      expect(advisor_klass.fields.keys).to be_empty
+      ### Build GraphQL schema
+      advisor_klass.to_graphql
+      expect(advisor_klass.fields.keys).to contain_exactly(*advisor_user_fields)
+
+      #### User Schema ####
+      expect(user_klass.name).to eql(::HQ::GraphQL.graphql_type_from_model(User))
+      expect(user_klass.fields.keys).to be_empty
+      user_klass.to_graphql
+      expect(user_klass.fields.keys).to contain_exactly(*advisor_user_fields)
+
+      organization_klass = ::HQ::GraphQL.graphql_type_from_model(Organization).constantize
+      expect(organization_klass.fields.keys).to be_empty
+      organization_klass.to_graphql
+      organization_fields = ["id", "name", "createdAt", "updatedAt", "users"]
+      expect(organization_klass.fields.keys).to contain_exactly(*organization_fields)
+    end
+
+    it "users the existing class if one exists" do
+      allow(::HQ::GraphQL).to receive(:model_to_graphql_type) { -> (model_class) { "#{model_class.name.demodulize}TypeTestTwo" } }
+
+      klass = Class.new(::HQ::GraphQL::Object) do
+        graphql_name "TestQuery"
+
+        field :custom_field, String, null: false
+      end
+      advisor_klass = stub_const(::HQ::GraphQL.graphql_type_from_model(Advisor), klass)
+
+      expect(advisor_klass).to eql(described_class[Advisor])
+      expect(advisor_klass.fields.keys).to contain_exactly("customField")
+      advisor_klass.to_graphql
+      expect(advisor_klass.fields.keys).to contain_exactly("customField")
+    end
+
+  end
+
+end

data/spec/rails_helper.rb

@@ -0,0 +1,41 @@
+require "testhq/coverage"  # Needs to be require at the top of this file!
+                           # Coverage must also be enabled in the environment by setting
+                           # environment variables, e.g. `COVERAGE=true` or `CODECLIMATE_REPO_TOKEN=...`.
+                           # See https://github.com/OneHQ/testhq#code-coverage.
+
+require "bundler/setup"
+require "combustion"
+
+silence_stream(STDOUT) do  # Hides a lot of output from Combustion init such as schema loading.
+  Combustion.initialize! :all do
+    # Disable strong parameters
+    config.action_controller.permit_all_parameters = true
+  end
+end
+
+require "byebug"
+require "rspec/rails"
+require "testhq"
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:expect]
+  end
+
+  config.use_transactional_fixtures = false
+
+  config.include FactoryBot::Syntax::Methods
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with :truncation # Clear everything
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+  config.order = :random
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: hq-graphql
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Danny Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.7
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: testhq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: OneHQ GraphQL Library
+email:
+- dpjones09@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/hq-graphql.rb
+- lib/hq/graphql.rb
+- lib/hq/graphql/engine.rb
+- lib/hq/graphql/object.rb
+- lib/hq/graphql/types.rb
+- lib/hq/graphql/types/uuid.rb
+- lib/hq/graphql/version.rb
+- spec/factories/advisors.rb
+- spec/factories/organizations.rb
+- spec/factories/users.rb
+- spec/internal/app/graphql/query.rb
+- spec/internal/app/graphql/schema.rb
+- spec/internal/app/graphql/user_type.rb
+- spec/internal/app/models/advisor.rb
+- spec/internal/app/models/organization.rb
+- spec/internal/app/models/user.rb
+- spec/internal/config/database.circleci.yml
+- spec/internal/config/database.yml
+- spec/internal/db/schema.rb
+- spec/lib/object_spec.rb
+- spec/lib/types_spec.rb
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+homepage: https://github.com/OneHQ/hq-graphql
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.2
+signing_key: 
+specification_version: 4
+summary: OneHQ GraphQL Library
+test_files:
+- spec/spec_helper.rb
+- spec/internal/app/models/advisor.rb
+- spec/internal/app/models/organization.rb
+- spec/internal/app/models/user.rb
+- spec/internal/app/graphql/schema.rb
+- spec/internal/app/graphql/query.rb
+- spec/internal/app/graphql/user_type.rb
+- spec/internal/config/database.circleci.yml
+- spec/internal/config/database.yml
+- spec/internal/db/schema.rb
+- spec/factories/organizations.rb
+- spec/factories/advisors.rb
+- spec/factories/users.rb
+- spec/lib/object_spec.rb
+- spec/lib/types_spec.rb
+- spec/rails_helper.rb