hq-graphql 2.0.7 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df65e3199361b5b97a2600a99ff594ba2194032a7c9f7d5553ba045264e311c4
-  data.tar.gz: 7ada8061fd1cb4a5f4b5f66d42d0ab9304698320001ec0a97a6e8ca5962e4860
+  metadata.gz: 5aefcd1b96fb05c456ebdef007f9bcad196e7aba2cd864d6dd7c83f3b3fbc95c
+  data.tar.gz: 0173c91a781e4872cbf65c597f3266030850c8e0ba31b05d8f9b578f11263216
 SHA512:
-  metadata.gz: a83be3fbfba6ca63deffcbcb379f5f21943d542e812eda2ff6d11e37eacb522d02b63d59bb66f9f9d22d0b8a6ef4d3920fe0b884e72bda0c46ea9b5819e7f859
-  data.tar.gz: 03da6a427384a58b832e62119f21337b824b3129d3b2b73e7ee0a8cf79c7e6013ed04594f876aa322e631f4f0535189a0e02b88f64bd575b2f4f8cce0e1e9de7
+  metadata.gz: 8a7b74ef1631a0d98004beb6bec61ea6898994c3ff25366afbc1fa5ba47bc60e36061ea3875c655ecfc9ac088b5f809b28fb411c05bfaeeda4e7256742345d5e
+  data.tar.gz: 3f6ecdc50f8a59d0e4c5c204fe4ed5967064e82f0f4a9aa961277532d6a49be5fb534204fa03a928777133e1b9541ec86fd2f9b196c383ff9da2ce1c94736cdc

data/README.md

@@ -78,6 +78,34 @@ class AdvisorResource
 end
 ```
 
+### Enums
+Auto generate enums from the database using ActiveRecord
+This comes in handy when we have constants that we want represented as enums.
+
+#### Example
+Let's assume we're saving data into a user types table
+```postgresl
+# select * from user_types;
+  id |    name    
+ --- +-------------
+  1  | Admin  
+  2  | Support User
+ (2 rows)
+```
+
+```ruby
+class Enums::UserType < ::HQ::GraphQL::Enum
+  with_model
+end
+```
+This class automatically uses the UserType ActiveRecord model to generate an enum:
+```graphql
+  enum UserType {
+    Admin
+    SupportUser
+  }
+```
+
 ### Root Mutations
 Add mutations to your schema
 

data/lib/hq-graphql.rb

@@ -2,6 +2,4 @@
 # rubocop:enable Naming/FileName
 # frozen_string_literal: true
 
-# typed: strict
-
 require "hq/graphql"

data/lib/hq/graphql.rb

@@ -1,48 +1,51 @@
-# typed: true
 # frozen_string_literal: true
 
 require "rails"
 require "graphql"
 require "graphql/batch"
-require "sorbet-runtime"
 require "hq/graphql/field"
 require "hq/graphql/config"
 
 module HQ
   module GraphQL
-    extend T::Sig
-    extend T::Generic
-
-    @config = T.let(::HQ::GraphQL::Config.new, ::HQ::GraphQL::Config)
-
-    sig { returns(::HQ::GraphQL::Config) }
     def self.config
-      @config
+      @config ||= ::HQ::GraphQL::Config.new
     end
 
     def self.configure(&block)
       config.instance_eval(&block)
     end
 
-    sig { params(action: T.untyped, object: T.untyped, context: ::GraphQL::Query::Context).returns(T::Boolean) }
     def self.authorized?(action, object, context)
-      !config.authorize || T.must(config.authorize).call(action, object, context)
+      !config.authorize || config.authorize.call(action, object, context)
     end
 
-    sig { params(action: T.untyped, field: ::HQ::GraphQL::Field, object: T.untyped, context: ::GraphQL::Query::Context).returns(T::Boolean) }
     def self.authorize_field(action, field, object, context)
-      !config.authorize_field || T.must(config.authorize_field).call(action, field, object, context)
+      !config.authorize_field || config.authorize_field.call(action, field, object, context)
     end
 
-    sig { params(scope: T.untyped, context: ::GraphQL::Query::Context).returns(T.untyped) }
     def self.default_scope(scope, context)
       config.default_scope.call(scope, context)
     end
 
-    sig { void }
+    def self.extract_class(klass)
+      config.extract_class.call(klass)
+    end
+
+    def self.lookup_resource(klass)
+      [klass, klass.base_class, klass.superclass].lazy.map do |k|
+        config.resource_lookup.call(k) || resources.detect { |r| r.model_klass == k }
+      end.reject(&:nil?).first
+    end
+
+    def self.use_experimental_associations?
+      !!config.use_experimental_associations
+    end
+
     def self.reset!
       @root_queries = nil
-      @types = nil
+      @enums = nil
+      @resources = nil
       ::HQ::GraphQL::Inputs.reset!
       ::HQ::GraphQL::Types.reset!
     end
@@ -51,21 +54,25 @@ module HQ
       @root_queries ||= Set.new
     end
 
-    # sig { returns(T::Set[::HQ::GraphQL::Resource]) }
-    def self.types
-      @types ||= Set.new
+    def self.enums
+      @enums ||= Set.new
+    end
+
+    def self.resources
+      @resources ||= Set.new
     end
   end
 end
 
-require "hq/graphql/active_record_extensions"
+require "hq/graphql/association_loader"
 require "hq/graphql/scalars"
 require "hq/graphql/comparator"
+require "hq/graphql/enum"
 require "hq/graphql/inputs"
 require "hq/graphql/input_object"
-require "hq/graphql/loaders"
 require "hq/graphql/mutation"
 require "hq/graphql/object"
+require "hq/graphql/paginated_association_loader"
 require "hq/graphql/resource"
 require "hq/graphql/root_mutation"
 require "hq/graphql/root_query"

data/lib/hq/graphql/active_record_extensions.rb

@@ -1,35 +1,31 @@
-# typed: true
 # frozen_string_literal: true
 
 module HQ
   module GraphQL
     module ActiveRecordExtensions
-      extend T::Sig
-      extend T::Helpers
-
       class Error < StandardError
         MISSING_MODEL_MSG = "Your GraphQL object must be connected to a model: `::HQ::GraphQL::Object.with_model 'User'`"
         MISSING_ATTR_MSG = "Can't find attr %{model}.%{attr}'`"
         MISSING_ASSOC_MSG = "Can't find association %{model}.%{assoc}'`"
       end
 
-      module ClassMethods
-        extend T::Sig
-        include Kernel
+      def self.included(klass)
+        klass.extend(ClassMethods)
+      end
 
+      module ClassMethods
         attr_accessor :model_name,
                       :authorize_action,
                       :auto_load_attributes,
-                      :auto_load_associations
+                      :auto_load_associations,
+                      :auto_load_enums
 
-        sig { params(block: T.nilable(T.proc.void)).returns(T::Array[T.proc.void]) }
         def lazy_load(&block)
           @lazy_load ||= []
           @lazy_load << block if block
           @lazy_load
         end
 
-        sig { void }
         def lazy_load!
           lazy_load.map(&:call)
           @lazy_load = []
@@ -50,12 +46,19 @@ module HQ
         end
 
         def model_associations
-          model_associations =
-            if auto_load_associations
-              model_klass.reflect_on_all_associations
-            else
-              added_associations.map { |association| association_from_model(association) }
-            end
+          model_associations = []
+          enums = model_klass.reflect_on_all_associations.select { |a| is_enum?(a) }
+          associatons = model_klass.reflect_on_all_associations - enums
+
+          if auto_load_enums
+            model_associations.concat(enums)
+          end
+
+          if auto_load_associations
+            model_associations.concat(associatons)
+          end
+
+          model_associations.concat(added_associations.map { |association| association_from_model(association) }).uniq
 
           # validate removed_associations exist
           removed_associations.each { |association| association_from_model(association) }
@@ -65,7 +68,6 @@ module HQ
 
         private
 
-        sig { params(attrs: T.any(String, Symbol)).void }
         def add_attributes(*attrs)
           validate_model!
           added_attributes.concat attrs.map(&:to_sym)
@@ -74,7 +76,6 @@ module HQ
         alias_method :add_attrs, :add_attributes
         alias_method :add_attr, :add_attributes
 
-        sig { params(attrs: T.any(String, Symbol)).void }
         def remove_attributes(*attrs)
           validate_model!
           removed_attributes.concat attrs.map(&:to_sym)
@@ -83,14 +84,12 @@ module HQ
         alias_method :remove_attrs, :remove_attributes
         alias_method :remove_attr, :remove_attributes
 
-        sig { params(associations: T.any(String, Symbol)).void }
         def add_associations(*associations)
           validate_model!
           added_associations.concat associations.map(&:to_sym)
         end
         alias_method :add_association, :add_associations
 
-        sig { params(associations: T.any(String, Symbol)).void }
         def remove_associations(*associations)
           validate_model!
           removed_associations.concat associations.map(&:to_sym)
@@ -101,7 +100,6 @@ module HQ
           @model_klass ||= model_name.constantize
         end
 
-        sig { params(attr: Symbol).returns(T.untyped) }
         def column_from_model(attr)
           model_klass.columns_hash[attr.to_s] || raise(Error, Error::MISSING_ATTR_MSG % { model: model_name, attr: attr })
         end
@@ -110,34 +108,32 @@ module HQ
           model_klass.reflect_on_association(association) || raise(Error, Error::MISSING_ASSOC_MSG % { model: model_name, assoc: association })
         end
 
-        sig { returns(T::Array[Symbol]) }
         def added_attributes
           @added_attributes ||= []
         end
 
-        sig { returns(T::Array[Symbol]) }
         def removed_attributes
           @removed_attributes ||= []
         end
 
-        sig { returns(T::Array[Symbol]) }
         def added_associations
           @added_associations ||= []
         end
 
-        sig { returns(T::Array[Symbol]) }
         def removed_associations
           @removed_associations ||= []
         end
 
-        sig { void }
+        def is_enum?(association)
+          ::HQ::GraphQL.enums.include?(association.klass)
+        end
+
         def validate_model!
           lazy_load do
             model_name || raise(Error, Error::MISSING_MODEL_MSG)
           end
         end
       end
-      mixes_in_class_methods(ClassMethods)
     end
   end
 end

data/lib/hq/graphql/association_loader.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    class AssociationLoader < ::GraphQL::Batch::Loader
+      def initialize(model, association_name)
+        @model = model
+        @association_name = association_name
+        validate
+      end
+
+      def load(record)
+        raise TypeError, "#{@model} loader can't load association for #{record.class}" unless record.is_a?(@model)
+        return Promise.resolve(read_association(record)) if association_loaded?(record)
+        super
+      end
+
+      # We want to load the associations on all records, even if they have the same id
+      def cache_key(record)
+        record.object_id
+      end
+
+      def perform(records)
+        preload_association(records)
+        records.each { |record| fulfill(record, read_association(record)) }
+      end
+
+      private
+
+      def validate
+        unless @model.reflect_on_association(@association_name)
+          raise ArgumentError, "No association #{@association_name} on #{@model}"
+        end
+      end
+
+      def preload_association(records)
+        ::ActiveRecord::Associations::Preloader.new.preload(records, @association_name)
+      end
+
+      def read_association(record)
+        record.public_send(@association_name)
+      end
+
+      def association_loaded?(record)
+        record.association(@association_name).loaded?
+      end
+    end
+  end
+end

data/lib/hq/graphql/comparator.rb

@@ -1,4 +1,3 @@
-# typed: true
 # frozen_string_literal: true
 
 require "graphql/schema_comparator"
@@ -30,6 +29,7 @@ module HQ
           if level >= CRITICALITY[:non_breaking]
             changes[:non_breaking] = result.non_breaking_changes
           end
+          return nil unless changes.values.flatten.any?
 
           changes
         end

data/lib/hq/graphql/config.rb

@@ -1,18 +1,24 @@
 # frozen_string_literal: true
 
-# typed: strict
-
 module HQ
   module GraphQL
-    class Config < T::Struct
-      AuthorizeProc = T.type_alias { T.nilable(T.proc.params(action: T.untyped, object: T.untyped, context: ::GraphQL::Query::Context).returns(T::Boolean)) }
-      prop :authorize, AuthorizeProc, default: nil
-
-      AuthorizeFieldProc = T.type_alias { T.nilable(T.proc.params(action: T.untyped, field: ::HQ::GraphQL::Field, object: T.untyped, context: ::GraphQL::Query::Context).returns(T::Boolean)) }
-      prop :authorize_field, AuthorizeFieldProc, default: nil
-
-      DefaultScopeProc = T.type_alias { T.proc.params(arg0: T.untyped, arg1: ::GraphQL::Query::Context).returns(T.untyped) }
-      prop :default_scope, DefaultScopeProc, default: ->(scope, _context) { scope }
+    class Config < Struct.new(
+      :authorize,
+      :authorize_field,
+      :default_scope,
+      :extract_class,
+      :resource_lookup,
+      :use_experimental_associations,
+      keyword_init: true
+    )
+      def initialize(
+        default_scope: ->(scope, _context) { scope },
+        extract_class: ->(klass) { klass.to_s.gsub(/^Resources|Resource$/, "") },
+        resource_lookup: ->(klass) { "::Resources::#{klass}Resource".safe_constantize || "::Resources::#{klass}".safe_constantize },
+        **options
+      )
+        super
+      end
     end
   end
 end

data/lib/hq/graphql/engine.rb

@@ -1,4 +1,3 @@
-# typed: strong
 # frozen_string_literal: true
 
 module HQ

data/lib/hq/graphql/enum.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "hq/graphql/types"
+
+module HQ::GraphQL
+  class Enum < ::GraphQL::Schema::Enum
+    ## Auto generate enums from the database using ActiveRecord
+    #  This comes in handy when we have constants that we want represented as enums.
+    #
+    # == Example
+    #   Let's assume we're saving data into a user types table
+    #     # select * from user_types;
+    #      id |    name
+    #     --- +-------------
+    #      1  | Admin
+    #      2  | Support User
+    #     (2 rows)
+    #
+    #  ```ruby
+    #    class Enums::UserType < ::HQ::GraphQL::Enum
+    #      with_model
+    #    end
+    #  ```
+    #
+    #  Creates the following enum:
+    #  ```graphql
+    #    enum UserType {
+    #      Admin
+    #      SupportUser
+    #    }
+    #  ```
+    def self.with_model(
+      klass = default_model_name.safe_constantize,
+      prefix: nil,
+      register: true,
+      scope: nil,
+      value_method: :name
+    )
+      raise ArgumentError.new(<<~ERROR) if !klass
+        `::HQ::GraphQL::Enum.with_model {...}' had trouble automatically inferring the class name.
+        Avoid this by manually passing in the class name: `::HQ::GraphQL::Enum.with_model(#{default_model_name}) {...}`
+      ERROR
+
+      if register
+        ::HQ::GraphQL.enums << klass
+        ::HQ::GraphQL::Types.register(klass, self)
+      end
+
+      lazy_load do
+        records = scope ? klass.instance_exec(&scope) : klass.all
+        records.each do |record|
+          value "#{prefix}#{record.send(value_method).delete(" ")}", value: record
+        end
+      end
+    end
+
+    def self.lazy_load(&block)
+      @lazy_load ||= []
+      @lazy_load << block if block
+      @lazy_load
+    end
+
+    def self.lazy_load!
+      lazy_load.map(&:call)
+      @lazy_load = []
+    end
+
+    def self.to_graphql
+      lazy_load!
+      super
+    end
+
+    def self.default_model_name
+      to_s.sub(/^((::)?\w+)::/, "")
+    end
+  end
+end