hq-graphql 2.1.12 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34f3a14ee58de081c8d52088ebc7986cbc2ccf597392015bcb44aa629aef6556
-  data.tar.gz: 39a436fca18cae2f81e672e78ae3118c4893512781a594c24d086cbf0f7e00c1
+  metadata.gz: a158f615a83d3743a038f248bc82c04285631e6575f62b5124bbb5767ab6ede9
+  data.tar.gz: 630bea394ce6e073b1f4ee2bd62047fcf46ba433357d1c759b99d7ecf350bfec
 SHA512:
-  metadata.gz: '09606ace844e47c5c414a73d1f3b2ffd7a7183b173090ade1e6287bc42aa6cc84eed691dd3d3a2b8d7ad4f8045779550f619fab017ed0dd79c49621c007ad9d1'
-  data.tar.gz: d8a07ccf03a311b807c7669202ce54d64e89db640f15911f2a1c6ddc3237d9fa94410e8527ae70539659a86ca06cf89317409b00d98b589056b9d6db5ae80dfc
+  metadata.gz: b6076f33bc12f04a7e701f2deeb7420fc44792af3e99727029196d24d68280276a15c7c8d70d875de82c3ec48e41afdc13b5578a45fbcff2ddcc0edfa8971628
+  data.tar.gz: c85f1b1af47ddee4f049a431277ca63bb1728ab74738fe8bc1bbc0f7b31f9dedd14f12fb850045f82ff301d83729d3f896628154e0fcaecea17c117dfd6140d5

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

@@ -15,12 +15,13 @@ module HQ
 
       class << self
         def compare(old_schema, new_schema, criticality: :breaking)
+          old_schema.load_types! if old_schema < ::GraphQL::Schema
+          new_schema.load_types! if old_schema < ::GraphQL::Schema
           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))
+          result = ::GraphQL::SchemaComparator.compare(old_schema, new_schema)
           return nil if result.identical?
-
           changes = {}
           changes[:breaking] = result.breaking_changes
           if level >= CRITICALITY[:dangerous]
@@ -33,12 +34,6 @@ module HQ
 
           changes
         end
-
-        private
-
-        def convert_schema_to_string(schema)
-          schema.is_a?(::String) ? schema : schema.to_definition
-        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

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "hq/graphql/types"
+
+module HQ::GraphQL
+  module Ext
+    module EnumExtensions
+      ## 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 with_model(
+        klass = default_model_name.safe_constantize,
+        prefix: nil,
+        register: true,
+        scope: nil,
+        strip: /(^[^_a-zA-Z])|([^_a-zA-Z0-9]*)/,
+        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).gsub(strip, "")}", value: record
+          end
+        end
+      end
+
+      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 = []
+      end
+
+      def default_model_name
+        to_s.sub(/^((::)?\w+)::/, "")
+      end
+    end
+  end
+end
+
+
+::GraphQL::Schema::Enum.extend ::HQ::GraphQL::Ext::EnumExtensions