hq-graphql 2.1.10 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9dd3d2f47411b616e76f20e118b4a959af58a13223b5d8e758bb35919c5b2b02
-  data.tar.gz: 781c03507b71570f5e9c6b9dc34117f34649097d1e4026701fd740c78209acad
+  metadata.gz: 716058e2edc04ba4af8f3ab85fb2af83dd73a89257d26e91f972edc0272de856
+  data.tar.gz: 3c844bc5ba2473a40b43e3f4e591795eb6d6adb51e763066a53d42ffc3f55de0
 SHA512:
-  metadata.gz: f5be4f443b74567f67e082cec1ae52d83f3adb0b2ae7964afb2f49e74467ed0185c04f34f363f3a0bb153e97bf90c7d8eff2e831d9d137cb1ca7c669b9af2ac8
-  data.tar.gz: aecd6fcaf3f269d0bf2d7504cdebf4e022fd5e4c670d9ad5153f1658d127ba12ca0661711d7cfd1863615d0b94b7ab2098dd5d8e22a8fbb7271a41f5f5a89da5
+  metadata.gz: 518d168eda93dfccaacfcc4c50d0ec7b715db6053d9d41e5cc722078e3e967db75be980999f02bcf3e87b25667e0987205b0364065a817b60daa2ee6acfd0d4f
+  data.tar.gz: 170ee8cd55160692280044b3ac3e84fc4b615a059fbc4f8f2cc38e2c401eee6cc7e49eb48c1743b102a6ae35c3112f4640fd7f8d0822816245104cb96e888a4d

data/README.md

@@ -8,6 +8,7 @@ OneHQ GraphQL interface to [Ruby Graphql](https://github.com/rmosolgo/graphql-ru
 ## Configuration
 
 ### Default Scope
+
 Define a global default scope.
 
 ```ruby
@@ -18,10 +19,22 @@ Define a global default scope.
 end
 ```
 
+### Excluded Inputs
+
+Define a global excluded input fields. Useful for excluding (autogenerated | auto set) fields like below.
+
+```ruby
+::HQ::GraphQL.configure do |config|
+  config.excluded_inputs = [:id, :created_at, :updated_at]
+end
+```
+
 ## GraphQL Resource
+
 Connect to ActiveRecord to auto generate queries and mutations.
 
 ### Queries
+
 Include `::HQ::GraphQL::Resource` and set `self.model_name` to start using queries.
 Fields will be created for all active record columns. Association fields will be created if the association
 is also a GraphQL Resource.
@@ -36,6 +49,7 @@ end
 ```
 
 #### Customize
+
 ```ruby
 class AdvisorResource
   include ::HQ::GraphQL::Resource
@@ -57,6 +71,7 @@ end
 ```
 
 ### Mutations
+
 Mutations will not be created by default. Add `mutations` to a resource to build mutations for create, update, and destroy.
 
 ```ruby
@@ -79,34 +94,40 @@ 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    
+  id |    name
  --- +-------------
-  1  | Admin  
+  1  | Admin
   2  | Support User
  (2 rows)
 ```
 
 ```ruby
-class Enums::UserType < ::HQ::GraphQL::Enum
+class Enums::UserType < ::GraphQL::Schema::Enum
   with_model
 end
 ```
+
 This class automatically uses the UserType ActiveRecord model to generate an enum:
+
 ```graphql
-  enum UserType {
-    Admin
-    SupportUser
-  }
+enum UserType {
+  Admin
+  SupportUser
+}
 ```
 
 ### Root Mutations
+
 Add mutations to your schema
 
 ```ruby
@@ -118,7 +139,9 @@ end
 ```
 
 ### Default Root Queries
+
 Create a root query:
+
 ```ruby
 class AdvisorResource
   include ::HQ::GraphQL::Resource
@@ -135,6 +158,7 @@ end
 ```
 
 ### Custom Root Queries
+
 ```ruby
 class AdvisorResource
   include ::HQ::GraphQL::Resource
@@ -154,9 +178,10 @@ class AdvisorResource
 end
 ```
 
-## Create a new ::HQ::GraphQL::Object
+## Create a new ::GraphQL::Schema::Object
+
 ```ruby
-class AdvisorType < ::HQ::GraphQL::Object
+class AdvisorType < ::GraphQL::Schema::Object
   # Supports graphql-ruby functionality
   field :id, Int, null: false
 

data/lib/hq/graphql.rb

@@ -36,6 +36,10 @@ module HQ
       config.extract_class.call(klass)
     end
 
+    def self.excluded_inputs
+      config.excluded_inputs || []
+    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 }
@@ -47,6 +51,7 @@ module HQ
     end
 
     def self.reset!
+      @lazy_load_classes = nil
       @root_queries = nil
       @enums = nil
       @resources = nil
@@ -54,16 +59,28 @@ module HQ
       ::HQ::GraphQL::Types.reset!
     end
 
+    def self.load_types!
+      lazy_load_classes.pop.lazy_load! while lazy_load_classes.length > 0
+    end
+
+    def self.lazy_load(klass)
+      lazy_load_classes << klass unless lazy_load_classes.include?(klass)
+    end
+
+    def self.lazy_load_classes
+      @lazy_load_classes ||= []
+    end
+
     def self.root_queries
-      @root_queries ||= Set.new
+      @root_queries ||= []
     end
 
     def self.enums
-      @enums ||= Set.new
+      @enums ||= []
     end
 
     def self.resources
-      @resources ||= Set.new
+      @resources ||= []
     end
   end
 end
@@ -71,16 +88,12 @@ end
 require "hq/graphql/association_loader"
 require "hq/graphql/scalars"
 require "hq/graphql/comparator"
-require "hq/graphql/enum"
+require "hq/graphql/ext"
 require "hq/graphql/inputs"
-require "hq/graphql/input_object"
-require "hq/graphql/mutation"
-require "hq/graphql/object"
 require "hq/graphql/paginated_association_loader"
 require "hq/graphql/record_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/association_loader.rb

@@ -4,6 +4,7 @@ module HQ
   module GraphQL
     class AssociationLoader < ::GraphQL::Batch::Loader
       def initialize(model, association_name)
+        super()
         @model = model
         @association_name = association_name
         validate

data/lib/hq/graphql/comparator.rb

@@ -13,31 +13,32 @@ module HQ
         non_breaking: 2
       }
 
-      class << self
-        def compare(old_schema, new_schema, criticality: :breaking)
-          level = CRITICALITY[criticality]
-          raise ::ArgumentError, "Invalid criticality. Possible values are #{CRITICALITY.keys.join(", ")}" unless level
-
-          result = ::GraphQL::SchemaComparator.compare(convert_schema_to_string(old_schema), convert_schema_to_string(new_schema))
-          return nil if result.identical?
-
-          changes = {}
-          changes[:breaking] = result.breaking_changes
-          if level >= CRITICALITY[:dangerous]
-            changes[:dangerous] = result.dangerous_changes
-          end
-          if level >= CRITICALITY[:non_breaking]
-            changes[:non_breaking] = result.non_breaking_changes
-          end
-          return nil unless changes.values.flatten.any?
-
-          changes
+      def self.compare(old_schema, new_schema, criticality: :breaking)
+        level = CRITICALITY[criticality]
+        raise ::ArgumentError, "Invalid criticality. Possible values are #{CRITICALITY.keys.join(", ")}" unless level
+
+        result = ::GraphQL::SchemaComparator.compare(prepare_schema(old_schema), prepare_schema(new_schema))
+        return if result.identical?
+        changes = {}
+        changes[:breaking] = result.breaking_changes
+        if level >= CRITICALITY[:dangerous]
+          changes[:dangerous] = result.dangerous_changes
         end
+        if level >= CRITICALITY[:non_breaking]
+          changes[:non_breaking] = result.non_breaking_changes
+        end
+        return unless changes.values.flatten.any?
+
+        changes
+      end
 
+      class << self
         private
 
-        def convert_schema_to_string(schema)
-          schema.is_a?(::String) ? schema : schema.to_definition
+        def prepare_schema(schema)
+          schema = ::GraphQL::Schema.from_definition(schema) if schema.is_a?(String)
+          schema.load_types!
+          schema
         end
       end
     end

data/lib/hq/graphql/config.rb

@@ -10,6 +10,7 @@ module HQ
       :extract_class,
       :resource_lookup,
       :use_experimental_associations,
+      :excluded_inputs,
       keyword_init: true
     )
       def initialize(

data/lib/hq/graphql/enum/sort_by.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require "hq/graphql/enum"
+require "hq/graphql/ext/enum_extensions"
 
 module HQ
-  class GraphQL::Enum::SortBy < ::HQ::GraphQL::Enum
-    value "CreatedAt", value: :created_at
-    value "UpdatedAt", value: :updated_at
+  module GraphQL
+    module Enum
+      class SortBy < ::GraphQL::Schema::Enum
+        value "CreatedAt", value: :created_at
+        value "UpdatedAt", value: :updated_at
+      end
+    end
   end
 end

data/lib/hq/graphql/enum/sort_order.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
-require "hq/graphql/enum"
+require "hq/graphql/ext/enum_extensions"
 
 module HQ
-  class GraphQL::Enum::SortOrder < ::HQ::GraphQL::Enum
-    value "ASC", value: :asc
-    value "DESC", value: :desc
+  module GraphQL
+    module Enum
+      class SortOrder < ::GraphQL::Schema::Enum
+        value "ASC", value: :asc
+        value "DESC", value: :desc
+      end
+    end
   end
 end

data/lib/hq/graphql/ext.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "hq/graphql/ext/active_record_extensions"
+require "hq/graphql/ext/enum_extensions"
+require "hq/graphql/ext/input_object_extensions"
+require "hq/graphql/ext/mutation_extensions"
+require "hq/graphql/ext/object_extensions"
+require "hq/graphql/ext/schema_extensions"

data/lib/hq/graphql/ext/active_record_extensions.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module HQ
+  module GraphQL
+    module Ext
+      module ActiveRecordExtensions
+        class ActiveRecordError < StandardError
+          MISSING_MODEL_MSG = "Your GraphQL object must be connected to a model: `::GraphQL::Schema::Object.with_model 'User'`"
+          MISSING_ATTR_MSG = "Can't find attr %{model}.%{attr}'`"
+          MISSING_ASSOC_MSG = "Can't find association %{model}.%{assoc}'`"
+        end
+
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          attr_accessor :model_name,
+                        :authorize_action,
+                        :auto_load_attributes,
+                        :auto_load_associations,
+                        :auto_load_enums
+
+          def lazy_load(&block)
+            @lazy_load ||= []
+            if block
+              ::HQ::GraphQL.lazy_load(self)
+              @lazy_load << block
+            end
+            @lazy_load
+          end
+
+          def lazy_load!
+            lazy_load.shift.call while lazy_load.length > 0
+            @lazy_load = nil
+          end
+
+          def model_columns
+            model_columns =
+              if auto_load_attributes
+                model_klass.columns
+              else
+                added_attributes.map { |attr| column_from_model(attr) }
+              end
+
+            # validate removed_attributes exist
+            removed_attributes.each { |attr| column_from_model(attr) }
+
+            model_columns.reject { |c| removed_attributes.include?(c.name.to_sym) }.sort_by(&:name)
+          end
+
+          def model_associations
+            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) }
+
+            model_associations.reject { |a| removed_associations.include?(a.name.to_sym) }.sort_by(&:name)
+          end
+
+          private
+
+          def add_attributes(*attrs)
+            validate_model!
+            added_attributes.concat attrs.map(&:to_sym)
+          end
+          alias_method :add_attribute, :add_attributes
+          alias_method :add_attrs, :add_attributes
+          alias_method :add_attr, :add_attributes
+
+          def remove_attributes(*attrs)
+            validate_model!
+            removed_attributes.concat attrs.map(&:to_sym)
+          end
+          alias_method :remove_attribute, :remove_attributes
+          alias_method :remove_attrs, :remove_attributes
+          alias_method :remove_attr, :remove_attributes
+
+          def add_associations(*associations)
+            validate_model!
+            added_associations.concat associations.map(&:to_sym)
+          end
+          alias_method :add_association, :add_associations
+
+          def remove_associations(*associations)
+            validate_model!
+            removed_associations.concat associations.map(&:to_sym)
+          end
+          alias_method :remove_association, :remove_associations
+
+          def model_klass
+            @model_klass ||= model_name.constantize
+          end
+
+          def column_from_model(attr)
+            model_klass.columns_hash[attr.to_s] || raise(ActiveRecordError, ActiveRecordError::MISSING_ATTR_MSG % { model: model_name, attr: attr })
+          end
+
+          def association_from_model(association)
+            model_klass.reflect_on_association(association) || raise(ActiveRecordError, ActiveRecordError::MISSING_ASSOC_MSG % { model: model_name, assoc: association })
+          end
+
+          def added_attributes
+            @added_attributes ||= []
+          end
+
+          def removed_attributes
+            @removed_attributes ||= []
+          end
+
+          def added_associations
+            @added_associations ||= []
+          end
+
+          def removed_associations
+            @removed_associations ||= []
+          end
+
+          def camelize(name)
+            name.to_s.camelize(:lower)
+          end
+
+          def is_enum?(association)
+            ::HQ::GraphQL.enums.include?(association.klass)
+          end
+
+          def validate_model!
+            lazy_load do
+              model_name || raise(ActiveRecordError, ActiveRecordError::MISSING_MODEL_MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end