hq-graphql 2.1.12 → 2.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34f3a14ee58de081c8d52088ebc7986cbc2ccf597392015bcb44aa629aef6556
-  data.tar.gz: 39a436fca18cae2f81e672e78ae3118c4893512781a594c24d086cbf0f7e00c1
+  metadata.gz: ad646bb38a0bd0920ca49428245d5183377719ef6b4802a0a619dc5c8bdbbcdf
+  data.tar.gz: 53f4c4b248e1fe424d34eb37e86002a18e6a39a54c91141f939d6aa9d85438db
 SHA512:
-  metadata.gz: '09606ace844e47c5c414a73d1f3b2ffd7a7183b173090ade1e6287bc42aa6cc84eed691dd3d3a2b8d7ad4f8045779550f619fab017ed0dd79c49621c007ad9d1'
-  data.tar.gz: d8a07ccf03a311b807c7669202ce54d64e89db640f15911f2a1c6ddc3237d9fa94410e8527ae70539659a86ca06cf89317409b00d98b589056b9d6db5ae80dfc
+  metadata.gz: c5978e1805f3097aaf708f667fbfb669b74205edc8c4f73f7e859f768636a41e6fd72de00dc62322e90a6e127850467b7bf0a9ebd82507f50b197625259cf7cd
+  data.tar.gz: fc94b8611372d29218b621e762ccbfac2de279a5b16276eeaf8043a8f9f19a03539ceb90c9270fe22b306b4a3191c7ab7e8e50bcf6d989d512ff3db94e23edd1

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
@@ -19,6 +20,7 @@ end
 ```
 
 ### Excluded Inputs
+
 Define a global excluded input fields. Useful for excluding (autogenerated | auto set) fields like below.
 
 ```ruby
@@ -28,9 +30,11 @@ 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.
@@ -45,6 +49,7 @@ end
 ```
 
 #### Customize
+
 ```ruby
 class AdvisorResource
   include ::HQ::GraphQL::Resource
@@ -66,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
@@ -88,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
@@ -127,7 +139,9 @@ end
 ```
 
 ### Default Root Queries
+
 Create a root query:
+
 ```ruby
 class AdvisorResource
   include ::HQ::GraphQL::Resource
@@ -144,6 +158,7 @@ end
 ```
 
 ### Custom Root Queries
+
 ```ruby
 class AdvisorResource
   include ::HQ::GraphQL::Resource
@@ -163,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

@@ -51,6 +51,7 @@ module HQ
     end
 
     def self.reset!
+      @lazy_load_classes = nil
       @root_queries = nil
       @enums = nil
       @resources = nil
@@ -58,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
@@ -75,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/enum/filter_operation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "hq/graphql/filter_operations"
+
+module HQ
+  module GraphQL
+    module Enum
+      class FilterOperation < ::GraphQL::Schema::Enum
+        ::HQ::GraphQL::FilterOperations::OPERATIONS.each do |filter_operation|
+          value filter_operation.name, value: filter_operation
+        end
+      end
+    end
+  end
+end

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