hq-graphql 2.0.6 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29c063cc8a29b6e30df91f11f8ed83bcaebee761fff76630bc2b2e80af9781d2
-  data.tar.gz: cb3e76b3c272ee517fd9de9b71c65695b5379e8cd3f2a2b412edb85419b12fe3
+  metadata.gz: 05c40fc2e6eaccc1277c1b6f36b19983af507721b011d6d25c9010f877c18db7
+  data.tar.gz: cf67ac6f3d02f3c6a5c5b0f1124e8aacd706d1e30b0077af69cad336d5dc1475
 SHA512:
-  metadata.gz: 992f59fa59af5c4d3d06a5902a85dde3a1839c881ac25fa15586ff8a92d15e4cde75192159a9ec0e939c286c99a2e83a2390203b84bf3de0c151bbf796945213
-  data.tar.gz: 242640df93c46a0a1d8f1af7851bf659901b896ae8c5f2e4088ece50909fdd31ea81cd20c6809a5e24f2c965b36db74bfdcb081c18ef698b062f3fb14ad54038
+  metadata.gz: 2f643af54cb80d2325dc8829c620f9c4d0c48a950aced92cb0313b2aacba52a3b797f42deb0c1f8848b9454cf70d014c4795f64d5e34444d87cc4fdbe36702c8
+  data.tar.gz: df55f4034030bed0f035a170d581bfe030f62a2545b2f4b7d15d48838c9777a7e4aa357e5f86618ee7bb692ba001c263df9973f8e546f8a1a902d0e8f61d4821

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,23 +54,29 @@ 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"
+require "hq/graphql/schema"
 require "hq/graphql/types"
 require "hq/graphql/engine"

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,15 +29,11 @@ module HQ
           if level >= CRITICALITY[:non_breaking]
             changes[:non_breaking] = result.non_breaking_changes
           end
+          return nil unless changes.values.flatten.any?
 
           changes
         end
 
-        def dump_schema_to_file(directory:, filename:, schema:)
-          ::FileUtils.mkdir_p(directory)
-          ::File.open(::File.join(directory, filename), "w") { |file| file.write(schema.to_definition) }
-        end
-
         private
 
         def convert_schema_to_string(schema)

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,78 @@
+# frozen_string_literal: true
+
+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
+
+require "hq/graphql/enum/sort_by"
+require "hq/graphql/enum/sort_order"