hq-graphql 0.0.2 → 1.0.0

data/lib/hq/graphql/resource.rb

@@ -0,0 +1,199 @@
+require "hq/graphql/resource/mutation"
+
+module HQ
+  module GraphQL
+    module Resource
+
+      def self.included(base)
+        ::HQ::GraphQL.types << base
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        attr_accessor :model_name
+
+        def find_record(attrs, context)
+          primary_key = model_klass.primary_key.to_sym
+          primary_key_value = attrs[primary_key]
+          scope(context).find_by(primary_key => primary_key_value)
+        end
+
+        def model_klass
+          @model_klass ||= model_name&.safe_constantize
+        end
+
+        def mutation_klasses
+          @mutation_klasses ||= {}.with_indifferent_access
+        end
+
+        def input_klass
+          @input_klass ||= begin
+            scoped_model_name = model_name
+            scoped_inputs_proc = inputs_proc
+            Class.new(::HQ::GraphQL::InputObject) do
+              graphql_name "#{scoped_model_name.demodulize}Input"
+              instance_eval(&scoped_inputs_proc)
+            end
+          end
+        end
+
+        def query_klass
+          @query_klass ||= build_graphql_object
+        end
+
+        protected
+
+        def inputs_proc
+          @inputs_proc ||= build_input_proc
+        end
+
+        def default_scope(&block)
+          @default_scope = block
+        end
+
+        def input(**options, &block)
+          @inputs_proc = build_input_proc(**options, &block)
+        end
+
+        def mutations(create: true, update: true, destroy: true)
+          model_display_name = model_name.demodulize
+          scoped_self = self
+          delayed_execute_inputs_proc = proc { scoped_self.inputs_proc }
+
+          if create
+            create_mutation = ::HQ::GraphQL::Resource::Mutation.build(model_name, graphql_name: "#{model_display_name}Create") do
+              define_method(:resolve) do |**attrs|
+                resource = scoped_self.model_klass.new
+                resource.assign_attributes(attrs)
+                if resource.save
+                  {
+                    resource: resource,
+                    errors: [],
+                  }
+                else
+                  {
+                    resource: nil,
+                    errors: resource.errors.full_messages
+                  }
+                end
+              end
+
+              lazy_load do
+                instance_eval(&delayed_execute_inputs_proc.call)
+              end
+            end
+
+            mutation_klasses["create_#{model_display_name.underscore}"] = create_mutation
+          end
+
+          if update
+            update_mutation = ::HQ::GraphQL::Resource::Mutation.build(
+              model_name,
+              graphql_name: "#{model_display_name}Update",
+              require_primary_key: true
+            ) do
+              define_method(:resolve) do |**attrs|
+                resource = scoped_self.find_record(attrs, context)
+
+                if resource
+                  resource.assign_attributes(attrs)
+                  if resource.save
+                    {
+                      resource: resource,
+                      errors: [],
+                    }
+                  else
+                    {
+                      resource: resource,
+                      errors: resource.errors.full_messages
+                    }
+                  end
+                else
+                  {
+                    resource: nil,
+                    errors: ["Unable to find #{model_display_name}"],
+                  }
+                end
+              end
+
+              lazy_load do
+                instance_eval(&delayed_execute_inputs_proc.call)
+              end
+            end
+
+            mutation_klasses["update_#{model_display_name.underscore}"] = update_mutation
+          end
+
+          if destroy
+            destroy_mutation = ::HQ::GraphQL::Resource::Mutation.build(
+              model_name,
+              graphql_name: "#{model_display_name}Destroy",
+              require_primary_key: true
+            ) do
+              define_method(:resolve) do |**attrs|
+                resource = scoped_self.find_record(attrs, context)
+
+                if resource
+                  if resource.destroy
+                    {
+                      resource: resource,
+                      errors: [],
+                    }
+                  else
+                    {
+                      resource: resource,
+                      errors: resource.errors.full_messages
+                    }
+                  end
+                else
+                  {
+                    resource: nil,
+                    errors: ["Unable to find #{model_display_name}"],
+                  }
+                end
+              end
+            end
+
+            mutation_klasses["destroy_#{model_display_name.underscore}"] = destroy_mutation
+          end
+        end
+
+        def query(**options, &block)
+          @query_klass = build_graphql_object(**options, &block)
+        end
+
+        def root_query
+          ::HQ::GraphQL.root_queries << self
+        end
+
+        def scope(context)
+          scope = model_klass
+          scope = ::HQ::GraphQL.default_scope(scope, context)
+          @default_scope&.call(scope, context) || scope
+        end
+
+        private
+
+        def build_graphql_object(**options, &block)
+          scoped_model_name = model_name
+          Class.new(::HQ::GraphQL::Object) do
+            graphql_name scoped_model_name
+
+            with_model scoped_model_name, **options
+
+            instance_eval(&block) if block
+          end
+        end
+
+        def build_input_proc(**options, &block)
+          scoped_model_name = model_name
+          proc do
+            with_model scoped_model_name, **options
+            instance_eval(&block) if block
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/hq/graphql/root_mutation.rb

@@ -0,0 +1,20 @@
+module HQ
+  module GraphQL
+    class RootMutation < ::HQ::GraphQL::Object
+
+      def self.inherited(base)
+        super
+        base.class_eval do
+          lazy_load do
+            ::HQ::GraphQL.types.each do |type|
+              type.mutation_klasses.each do |mutation_name, klass|
+                field mutation_name, mutation: klass
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/root_query.rb

@@ -0,0 +1,29 @@
+module HQ
+  module GraphQL
+    class RootQuery < ::HQ::GraphQL::Object
+
+      def self.inherited(base)
+        super
+        base.class_eval do
+          lazy_load do
+            ::HQ::GraphQL.root_queries.each do |graphql|
+              klass = graphql.model_klass
+              field_name = klass.name.demodulize.underscore
+              primary_key = klass.primary_key
+              pk_column = klass.columns.detect { |c| c.name == primary_key.to_s }
+
+              field field_name, graphql.query_klass, null: true do
+                argument primary_key, ::HQ::GraphQL::Types.type_from_column(pk_column), required: true
+              end
+
+              define_method(field_name) do |**attrs|
+                graphql.find_record(attrs, context)
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hq/graphql/scalars.rb

@@ -0,0 +1,9 @@
+require "hq/graphql/types/uuid"
+
+module HQ
+  module GraphQL
+    module Scalars
+      UUID = ::HQ::GraphQL::Types::UUID
+    end
+  end
+end

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

@@ -5,11 +5,11 @@ module HQ
         description "UUID"
 
         class << self
-          def self.coerce_input(value, context)
+          def coerce_input(value, context)
             validate_and_return_uuid(value)
           end
 
-          def self.coerce_result(value, context)
+          def coerce_result(value, context)
             validate_and_return_uuid(value)
           end
 
@@ -24,7 +24,7 @@ module HQ
           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}$/)
+            !!value.to_s.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
           end
         end
       end

data/lib/hq/graphql/types.rb

@@ -1,14 +1,15 @@
-require "hq/graphql/types/uuid"
-
 module HQ
   module GraphQL
     module Types
+      class Error < StandardError
+        MISSING_TYPE_MSG = "The GraphQL type for `%{klass}` is missing.".freeze
+      end
 
       def self.[](key)
-        @schema_objects ||= Hash.new do |hash, klass|
+        @types ||= Hash.new do |hash, klass|
           hash[klass] = klass_for(klass)
         end
-        @schema_objects[key]
+        @types[key]
       end
 
       def self.type_from_column(column)
@@ -16,37 +17,28 @@ module HQ
         when :uuid
           ::HQ::GraphQL::Types::UUID
         when :integer
-          ::GraphQL::INT_TYPE
+          ::GraphQL::Types::Int
         when :decimal
-          ::GraphQL::FLOAT_TYPE
+          ::GraphQL::Types::Float
         when :boolean
-          ::GraphQL::BOOLEAN_TYPE
+          ::GraphQL::Types::Boolean
         else
-          ::GraphQL::STRING_TYPE
+          ::GraphQL::Types::String
         end
       end
 
       # Only being used in testing
       def self.reset!
-        @schema_objects = nil
+        @types = 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)
+        def klass_for(klass_or_string)
+          klass = klass_or_string.is_a?(String) ? klass_or_string.constantize : klass_or_string
+          ::HQ::GraphQL.types.detect { |t| t.model_klass == klass }&.query_klass ||
+             raise(Error, Error::MISSING_TYPE_MSG % { klass: klass.name })
         end
       end
 

data/lib/hq/graphql/version.rb

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

data/lib/hq/graphql.rb

@@ -2,6 +2,7 @@ require "graphql"
 
 module HQ
   module GraphQL
+
     def self.config
       @config ||= ::ActiveSupport::OrderedOptions.new
     end
@@ -10,23 +11,38 @@ module HQ
       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" }
+    def self.default_scope(scope, context)
+      config.default_scope&.call(scope, context) || scope
+    end
+
+    def self.reset!
+      @root_queries = nil
+      @types = nil
+      ::HQ::GraphQL::Inputs.reset!
+      ::HQ::GraphQL::Types.reset!
     end
 
-    def self.graphql_type_from_model(model_class)
-      model_to_graphql_type.call(model_class)
+    def self.root_queries
+      @root_queries ||= Set.new
     end
+
+    def self.types
+      @types ||= Set.new
+    end
+
   end
 end
 
+require "hq/graphql/active_record_extensions"
+require "hq/graphql/scalars"
+require "hq/graphql/input_extensions"
+
+require "hq/graphql/inputs"
+require "hq/graphql/input_object"
+require "hq/graphql/mutation"
 require "hq/graphql/object"
+require "hq/graphql/resource"
+require "hq/graphql/root_mutation"
+require "hq/graphql/root_query"
 require "hq/graphql/types"
 require "hq/graphql/engine"

data/spec/internal/db/schema.rb

@@ -6,13 +6,13 @@ ActiveRecord::Schema.define do
     t.timestamps                       null: false
   end
 
-  create_table "users", force: true do |t|
+  create_table "users", force: true, id: :uuid 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|
+  create_table "advisors", force: true, id: :uuid do |t|
     t.references  :organization,       null: false, index: true, foreign_key: true, type: :uuid
     t.string      :name,               null: false
     t.timestamps                       null: false

data/spec/lib/graphql/active_record_extensions_spec.rb

@@ -0,0 +1,63 @@
+require 'rails_helper'
+
+describe ::HQ::GraphQL::ActiveRecordExtensions do
+  let(:extended_klass) do
+    Class.new do
+      include ::HQ::GraphQL::ActiveRecordExtensions
+
+      @counter = 0
+
+      lazy_load do
+        @counter += 1
+      end
+
+      def self.counter
+        @counter
+      end
+    end
+  end
+
+  describe ".add_attributes" do
+    it "aliases add_attributes" do
+      add_attributes = extended_klass.method(:add_attributes)
+      aggregate_failures do
+        expect(add_attributes).to eql(extended_klass.method(:add_attribute))
+        expect(add_attributes).to eql(extended_klass.method(:add_attrs))
+        expect(add_attributes).to eql(extended_klass.method(:add_attr))
+      end
+    end
+  end
+
+  describe ".remove_attributes" do
+    it "aliases remove_attributes" do
+      remove_attributes = extended_klass.method(:remove_attributes)
+      aggregate_failures do
+        expect(remove_attributes).to eql(extended_klass.method(:remove_attribute))
+        expect(remove_attributes).to eql(extended_klass.method(:remove_attrs))
+        expect(remove_attributes).to eql(extended_klass.method(:remove_attr))
+      end
+    end
+  end
+
+  describe ".add_associations" do
+    it "aliases add_associations" do
+      expect(extended_klass.method(:add_associations)).to eql(extended_klass.method(:add_association))
+    end
+  end
+
+  describe ".remove_associations" do
+    it "aliases remove_associations" do
+      expect(extended_klass.method(:remove_associations)).to eql(extended_klass.method(:remove_association))
+    end
+  end
+
+  describe ".lazy_load" do
+    it "lazy loads once" do
+      # First time it works
+      expect { extended_klass.lazy_load! }.to change  { extended_klass.counter }.by(1)
+      # Second time it does nothing
+      expect { extended_klass.lazy_load! }.to change  { extended_klass.counter }.by(0)
+    end
+  end
+
+end

data/spec/lib/graphql/inputs_spec.rb

@@ -0,0 +1,40 @@
+require 'rails_helper'
+
+describe ::HQ::GraphQL::Inputs do
+
+  describe ".[]" do
+    let(:graphql_klass) do
+      Class.new do
+        include ::HQ::GraphQL::Resource
+
+        self.model_name = "Advisor"
+
+        input(attributes: false, associations: false) do
+          argument :customField, String, "Header for the post", required: true
+        end
+      end
+    end
+
+    it "finds the type" do
+      input_object = graphql_klass.input_klass
+
+      aggregate_failures do
+        expect(input_object.superclass).to eql(::HQ::GraphQL::InputObject)
+        expect(input_object).to eql(described_class[Advisor])
+        expect(input_object.arguments.keys).to contain_exactly("customField")
+        input_object.to_graphql
+        expect(input_object.arguments.keys).to contain_exactly("customField")
+      end
+    end
+
+    it "finds the type when lookup is a string" do
+      input_object = graphql_klass.input_klass
+      expect(input_object).to eql(described_class["Advisor"])
+    end
+
+    it "raises an exception for unknown types" do
+      expect { described_class[Advisor] }.to raise_error(described_class::Error)
+    end
+  end
+
+end