graphiti_gql 0.2.22 → 0.2.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a79d794e346a1f884170026503f4ca36a5c82529a47dd977b34335457d4a630
-  data.tar.gz: 0ee188c2f278895a47b27c8dbe57b1117dfe352350a99bec8a908702cc782411
+  metadata.gz: ae5d9ce0fe34ef8d53204f8c292b5d09cb58c821ec413804a169e3a562061ad2
+  data.tar.gz: 02fc540e3203efe6311fba2d30c3b8b75308103cffe4b5df1f01b29dac804e74
 SHA512:
-  metadata.gz: d4eb9c8bb29c513cc9b8eed6e7dafffbefa1de88ab9e1dbc32d1f921b0664ee066c671d36c05eeb15614accded9ba56d4247010ea9c83bf55e0f76ae4d036b31
-  data.tar.gz: 014ee03255a4c2b26bbe178d6c60f4f071955a288dac725aa75ae84dcd6624bde251442ea3f7e7811bae4ec9b7f463f024cdcc5c3c4f6f90ec8575e7eb071999
+  metadata.gz: e01483c436cbc15cb0c80598725a16440ba0254242554c9a2401c4dd72ca5cd4b847941fe3d02da7a4d023640b7ca20824e2537a04654dc2d46c192e53885863
+  data.tar.gz: 13478f1634bcb76c13cf9aef90c036fb5636a55c72643db21e854cca9679c4c735e848c6245e73d2194374fa54ee34eecda4cc17240f5cbe491acf14a0ef9db9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    graphiti_gql (0.2.21)
+    graphiti_gql (0.2.25)
       activemodel (> 6.0, < 8.0)
       graphiti (~> 1.3.9)
       graphql (~> 2.0)
@@ -21,9 +21,9 @@ GEM
     coderay (1.1.3)
     concurrent-ruby (1.1.10)
     diff-lcs (1.5.0)
-    dry-container (0.10.0)
+    dry-container (0.10.1)
       concurrent-ruby (~> 1.0)
-    dry-core (0.8.0)
+    dry-core (0.8.1)
       concurrent-ruby (~> 1.0)
     dry-inflector (0.3.0)
     dry-logic (1.2.0)
@@ -48,13 +48,13 @@ GEM
     graphql-batch (0.5.1)
       graphql (>= 1.10, < 3)
       promise.rb (~> 0.7.2)
-    i18n (1.10.0)
+    i18n (1.12.0)
       concurrent-ruby (~> 1.0)
     jsonapi-renderer (0.2.2)
     jsonapi-serializable (0.3.1)
       jsonapi-renderer (~> 0.2.0)
     method_source (1.0.0)
-    minitest (5.15.0)
+    minitest (5.16.2)
     promise.rb (0.7.4)
     pry (0.13.1)
       coderay (~> 1.1)
@@ -76,7 +76,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    tzinfo (2.0.4)
+    tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
 
 PLATFORMS

data/lib/graphiti_gql/graphiti_hax.rb

@@ -25,6 +25,10 @@ module GraphitiGql
       end
     end
 
+    def value_object?
+      self.class.value_object?
+    end
+
     def filterings
       @filterings ||= begin
         if @params.key?(:filter)
@@ -67,6 +71,11 @@ module GraphitiGql
     end
 
     class_methods do
+      def config
+        return @config if @config
+        super
+        @config = @config.merge(value_objects: {}, is_value_object: false)
+      end
 
       def attribute(*args)
         super(*args).tap do
@@ -79,7 +88,14 @@ module GraphitiGql
       end
 
       def filter(name, *args, &blk)
+        is_bool = (filters[name] && filters[name][:type] == :boolean) ||
+          args[0] == :boolean
+        opts = args.length == 1 ? args[0] : args[1]
+        boolean_array = is_bool && opts[:single] == false
         super
+        # default behavior is to force single: true
+        filters[name][:single] = false if boolean_array
+       
         opts = args.extract_options!
         if opts[:if]
           attributes[name][:filterable] = opts[:if]
@@ -93,6 +109,40 @@ module GraphitiGql
           super
         end
       end
+
+      def value_object?
+        !!config[:is_value_object]
+      end
+
+      def value_object!
+        config[:is_value_object] = true
+        self.adapter = ::Graphiti::Adapters::Null
+        config[:filters] = {}
+        config[:stats] = {}
+        config[:sorts] = {}
+        config[:attributes].delete(:id)
+        define_method :base_scope do
+          {}
+        end
+        define_method :resolve do |parent|
+          [parent]
+        end
+      end
+
+      def value_object(name, opts = {})
+        opts[:array] ||= false
+        opts[:null] ||= true
+        config[:value_objects][name] = Graphiti::ValueObjectAssociation.new(
+          name,
+          parent_resource_class: self,
+          resource_class: opts[:resource],
+          _alias: opts[:alias],
+          is_array: opts[:array],
+          null: opts[:null],
+          readable: opts[:readable],
+          deprecation_reason: opts[:deprecation_reason]
+        )
+      end
     end
   end
   Graphiti::Resource.send(:prepend, ResourceExtras)
@@ -196,26 +246,14 @@ module GraphitiGql
   module ManyToManyExtras
     def self.prepended(klass)
       klass.class_eval do
-        attr_reader :join_table_alias, :edge_magic
-
-        class << self
-          attr_reader :edge_resource
-
-          def attribute(*args, &blk)
-            @edge_resource ||= Class.new(Graphiti::Resource) do
-              def self.abstract_class?
-                true
-              end
-            end
-            @edge_resource.attribute(*args, &blk)
-          end
-        end
+        attr_reader :join_table_alias, :edge_magic, :edge_resource
       end
     end
     
     def initialize(name, opts = {})
       @join_table_alias = opts[:join_table_alias]
       @edge_magic = opts[:edge_magic] == false ? false : true
+      @edge_resource = opts[:edge_resource]
       super
     end
 
@@ -276,6 +314,20 @@ module GraphitiGql
     description: 'Datetime with milliseconds'
   }
 
+  [:string, :integer, :float, :datetime, :precise_datetime].each do |kind|
+    duped_hash = Graphiti::Util::Hash.deep_dup(Graphiti::Types[:hash])
+    type = Graphiti::Types[:"#{kind}_range"] = duped_hash
+    type[:canonical_name] = :"#{kind}_range"
+    Graphiti::Types[:"array_of_#{kind}_ranges"] = {
+      canonical_name: :"#{kind}_range",
+      params: Dry::Types["strict.array"].of(type[:params]),
+      read: Dry::Types["strict.array"].of(type[:read]),
+      write: Dry::Types["strict.array"].of(type[:write]),
+      kind: "array",
+      description: "Base Type."
+    }
+  end
+
   module ActiveRecordAdapterExtras
     extend ActiveSupport::Concern
 
@@ -375,6 +427,15 @@ module GraphitiGql
   
   Graphiti::Query.send(:prepend, QueryExtras)
   module ScopeExtras
+    def initialize(object, resource, query, opts = {})
+      if resource.value_object?
+        object = query.params[:parent]
+        super(object, resource, query, opts)
+      else
+        super
+      end
+    end
+
     def resolve(*args)
       results = super
       results.reverse! if @query.hash[:reverse]
@@ -395,4 +456,48 @@ module GraphitiGql
     ::Graphiti::Adapters::ActiveRecord::ManyToManySideload
       .send(:prepend, ActiveRecordManyToManyExtras)
   end
+end
+
+class Graphiti::ValueObjectAssociation
+  attr_reader :name,
+    :parent_resource_class,
+    :alias,
+    :readable,
+    :null,
+    :deprecation_reason
+
+  def initialize(
+    name,
+    parent_resource_class:,
+    resource_class:,
+    is_array: false,
+    readable: nil,
+    null: true,
+    _alias: nil,
+    deprecation_reason: nil
+  )
+    @name = name
+    @parent_resource_class = parent_resource_class
+    @resource_class = resource_class
+    @readable = readable
+    @array = is_array
+    @alias = _alias
+    @null = null
+    @deprecation_reason = deprecation_reason
+  end
+
+  def array?
+    !!@array
+  end
+
+  def resource_class
+    @resource_class ||= Graphiti::Util::Class
+      .infer_resource_class(@parent_resource_class, name)
+  end
+
+  def build_resource(parent)
+    instance = resource_class.new
+    instance.parent = parent
+    instance
+  end
 end

data/lib/graphiti_gql/loaders/many_to_many.rb

@@ -16,13 +16,15 @@ module GraphitiGql
 
       private
 
+      def thru_model
+        thru = @sideload.foreign_key.keys.first
+        reflection = @sideload.parent_resource.model.reflect_on_association(thru)
+        reflection.klass
+      end
+
       def add_join_table_magic(proxy)
         return unless @sideload.edge_magic
         if defined?(ActiveRecord) && proxy.resource.model.ancestors.include?(ActiveRecord::Base)
-          thru = @sideload.foreign_key.keys.first
-          reflection = @sideload.parent_resource.model.reflect_on_association(thru)
-          thru_model = reflection.klass
-
           thru_table_name = @sideload.join_table_alias || thru_model.table_name
           names = thru_model.column_names.map do |n|
             next if n == :id

data/lib/graphiti_gql/schema/fields/attribute.rb

@@ -3,12 +3,11 @@ module GraphitiGql
     module Fields
       class Attribute
         # If sideload is present, we're applying m2m metadata to an edge
-        def initialize(resource, name, config, sideload = nil)
+        def initialize(resource, name, config)
           @resource = resource
           @config = config
           @name = name
           @alias = config[:alias]
-          @sideload = sideload # is_edge: true
         end
 
         def apply(type)
@@ -16,13 +15,11 @@ module GraphitiGql
           _config = @config
           _name = @name
           _alias = @alias 
-          _sideload = @sideload
           opts = @config.slice(:null, :deprecation_reason)
           type.field(_name, field_type, **opts)
           type.define_method _name do
             if (readable = _config[:readable]).is_a?(Symbol)
               obj = object
-              obj = object.node if _sideload
               resource = obj.instance_variable_get(:@__graphiti_resource)
               unless resource.send(readable)
                 path = Graphiti.context[:object][:current_path].join(".")
@@ -30,22 +27,11 @@ module GraphitiGql
               end
             end
 
-            edge_attrs = nil
-            if _sideload
-              edge_attrs = object.node.attributes
-                .select { |k, v| k.to_s.starts_with?("_edge_") }
-              edge_attrs.transform_keys! { |k| k.to_s.gsub("_edge_", "").to_sym }
-            end
-
             value = if _config[:proc]
-              if _sideload
-                instance_exec(edge_attrs, object.node, &_config[:proc])
-              else
-                instance_eval(&_config[:proc])
-              end
+              instance_eval(&_config[:proc])
             else
-              if _sideload
-                edge_attrs[_alias || _name]
+              if object.is_a?(Hash)
+                object[_name] || object[_name.to_s]
               else
                 object.send(_alias || _name)
               end

data/lib/graphiti_gql/schema/fields/to_many.rb

@@ -35,7 +35,7 @@ module GraphitiGql
         end
 
         def customized_edge?
-          @sideload.type == :many_to_many && @sideload.class.edge_resource
+          @sideload.type == :many_to_many && @sideload.edge_resource
         end
 
         def find_or_build_connection
@@ -59,21 +59,61 @@ module GraphitiGql
         end
 
         def build_edge_type_class(sideload_type)
-          prior_edge_type_class = sideload_type.edge_type_class
-          edge_type_class = Class.new(prior_edge_type_class)
-          edge_resource = @sideload.class.edge_resource
-          edge_resource.attributes.each_pair do |name, config|
-            next if name == :id
-            Schema::Fields::Attribute.new(edge_resource, name, config, @sideload).apply(edge_type_class)
+          klass = build_friendly_graphql_edge_type_class \
+            sideload_type.edge_type_class
+          name = edge_type_class_name(sideload_type)
+          klass.define_method(:graphql_name) { name }
+          klass.graphql_name(name)
+          edge_resource = @sideload.edge_resource
+          ResourceType.add_fields(klass, edge_resource, id: false)
+          ResourceType.add_relationships(edge_resource, klass)
+          ResourceType.add_value_objects(edge_resource, klass)
+          klass
+        end
+
+        # Normally we reference 'object', but edges work differently
+        # This makes 'object' work everywhere
+        # Needed when evaluating fields/relationships for consistent interface
+        def build_friendly_graphql_edge_type_class(superklass)
+          klass = Class.new(superklass) do
+            alias :original_object :object
+            def object
+              return @_object if @_object # avoid conflict
+
+              node = original_object.node # the 'parent' record we joined with
+              edge_attrs = node.attributes.select { |k,v| k.to_s.starts_with?('_edge') }
+              edge_attrs.transform_keys! { |k| k.to_s.gsub('_edge_', '') }
+              edge_model = model.new(edge_attrs)
+              edge_model.instance_variable_set(:@__graphiti_resource, resource)
+              @_object = edge_model
+              @_object
+            end
+
+            def cursor
+              original_object.cursor
+            end
+
+            def node
+              original_object.node
+            end
           end
-          registered_parent = Schema.registry.get(@sideload.parent_resource.class)
+
+          # used in #object
+          thru = @sideload.foreign_key.keys.first
+          reflection = @sideload.parent_resource.model.reflect_on_association(thru)
+          thru_model = reflection.klass
+          edge_resource = @sideload.edge_resource.new
+          klass.define_method(:model) { thru_model }
+          klass.define_method(:resource) { edge_resource }
+
+          klass
+        end
+
+        def edge_type_class_name(sideload_type)
+          registered_parent = Schema.registry.get \
+            @sideload.parent_resource.class
           parent_name = registered_parent[:type].graphql_name
-          edge_type_class_name = "#{parent_name}To#{sideload_type.graphql_name}Edge"
-          edge_type_class.define_method :graphql_name do
-            edge_type_class_name
-          end
-          edge_type_class.graphql_name(edge_type_class_name)
-          edge_type_class
+          "#{parent_name}To#{sideload_type.graphql_name}Edge"
         end
       end
     end

data/lib/graphiti_gql/schema/query.rb

@@ -10,6 +10,7 @@ module GraphitiGql
       def build
         @resources.each { |resource| ResourceType.new(resource).build }
         define_entrypoints
+        add_value_objects
         add_relationships
         @query_class
       end
@@ -30,30 +31,16 @@ module GraphitiGql
       end
 
       def add_relationships
-        each_relationship do |type, sideload_type, sideload|
-          if [:has_many, :many_to_many, :has_one].include?(sideload.type)
-            Fields::ToMany.new(sideload, sideload_type).apply(type)
-          else
-            Fields::ToOne.new(sideload, sideload_type).apply(type)
-          end
+        registry.resource_types.each do |registered|
+          resource, type = registered[:resource], registered[:type]
+          ResourceType.add_relationships(resource, type)
         end
       end
 
-      def each_relationship
+      def add_value_objects
         registry.resource_types.each do |registered|
-          registered[:resource].sideloads.each do |name, sl|
-            next unless sl.readable?
-
-            registered_sl = if sl.type == :polymorphic_belongs_to
-              PolymorphicBelongsToInterface
-                .new(registered[:resource], sl)
-                .build
-            else
-              registry.get(sl.resource.class)
-            end
-
-            yield registered[:type], registered_sl[:type], sl
-          end
+          resource, type = registered[:resource], registered[:type]
+          ResourceType.add_value_objects(resource, type)
         end
       end
     end

data/lib/graphiti_gql/schema/registry.rb

@@ -52,7 +52,8 @@ module GraphitiGql
       # When polymorphic parent, returns the Interface not the Class
       def resource_types
         values
-          .select { |v| v.key?(:resource) && !v[:interface] }
+          .select { |v| v.key?(:resource) }
+          .reject { |v| v[:interface] || v[:resource].value_object? }
           .map { |registered| get(registered[:resource]) }
       end
 

data/lib/graphiti_gql/schema/resource_type.rb

@@ -14,6 +14,69 @@ module GraphitiGql
         end
       end
 
+      def self.add_fields(type, resource, id: true) # id: false for edges
+        resource.attributes.each_pair do |name, config|
+          next if name == :id && id == false
+          if config[:readable]
+            Fields::Attribute.new(resource, name, config).apply(type)
+          end
+        end
+      end
+
+      def self.add_value_objects(resource, type)
+        resource.config[:value_objects].each_pair do |name, vo_association|
+          vo_resource_class = vo_association.resource_class
+          value_object_type = Schema.registry.get(vo_resource_class)[:type]
+          if vo_association.array?
+            value_object_type = [value_object_type]
+          end
+
+          _array = vo_association.array?
+          opts = { null: vo_association.null }
+          opts[:deprecation_reason] = vo_association.deprecation_reason if vo_association.deprecation_reason
+          type.field name, value_object_type, **opts
+          type.define_method name do
+            if (method_name = vo_association.readable)
+              unless vo_association.parent_resource_class.new.send(method_name)
+                raise ::Graphiti::Errors::UnreadableAttribute
+                  .new(vo_association.parent_resource_class, name)
+              end
+            end
+
+            result = vo_resource_class.all({ parent: object }).to_a
+            if result.is_a?(Array) && !_array
+              result = result.first
+            end
+            if result == object || result == [object]
+              method_name = vo_association.alias.presence || name
+              result = object.send(method_name)
+            end
+            result
+          end
+        end
+      end
+
+      def self.add_relationships(resource, type)
+        resource.sideloads.each do |name, sideload|
+          next unless sideload.readable?
+
+          registered_sl = if sideload.type == :polymorphic_belongs_to
+            PolymorphicBelongsToInterface
+              .new(resource, sideload)
+              .build
+          else
+            Schema.registry.get(sideload.resource.class)
+          end
+          sideload_type = registered_sl[:type]
+
+          if [:has_many, :many_to_many, :has_one].include?(sideload.type)
+            Fields::ToMany.new(sideload, sideload_type).apply(type)
+          else
+            Fields::ToOne.new(sideload, sideload_type).apply(type)
+          end
+        end
+      end
+
       def initialize(resource, implements: nil)
         @resource = resource
         @implements = implements
@@ -86,14 +149,10 @@ module GraphitiGql
       def name
         registry.key_for(@resource)
       end
-  
+
       def add_fields(type, resource)
-        resource.attributes.each_pair do |name, config|
-          if config[:readable]
-            Fields::Attribute.new(@resource, name, config).apply(type)
-          end
-        end
-      end
+        self.class.add_fields(type, resource)
+      end 
 
       def build_connection_class
         klass = Class.new(GraphQL::Types::Relay::BaseConnection)

data/lib/graphiti_gql/schema.rb

@@ -4,6 +4,31 @@ module GraphitiGql
       self.time_precision = 6
     end
 
+    class DatetimeRange < GraphQL::Schema::Object
+      field :from, GraphQL::Types::ISO8601DateTime
+      field :to, GraphQL::Types::ISO8601DateTime
+    end
+
+    class PreciseDatetimeRange < GraphQL::Schema::Object
+      field :from, PreciseDatetime
+      field :to, PreciseDatetime
+    end
+
+    class StringRange < GraphQL::Schema::Object
+      field :from, String
+      field :to, String
+    end
+
+    class IntegerRange < GraphQL::Schema::Object
+      field :from, Integer
+      field :to, Integer
+    end
+
+    class FloatRange < GraphQL::Schema::Object
+      field :from, Float
+      field :to, Float
+    end
+
     GQL_TYPE_MAP = {
       integer_id: String,
       string: String,
@@ -11,18 +36,28 @@ module GraphitiGql
       integer: Integer,
       big_integer: GraphQL::Types::BigInt,
       float: Float,
-      boolean: GraphQL::Schema::Member::GraphQLTypeNames::Boolean,
+      boolean: GraphQL::Types::Boolean,
       date: GraphQL::Types::ISO8601Date,
       datetime: GraphQL::Types::ISO8601DateTime,
       precise_datetime: PreciseDatetime,
       hash: GraphQL::Types::JSON,
+      string_range: StringRange,
+      integer_range: IntegerRange,
+      float_range: FloatRange,
+      datetime_range: DatetimeRange,
+      precise_datetime_range: PreciseDatetimeRange,
       array: [GraphQL::Types::JSON],
       array_of_strings: [String],
       array_of_integers: [Integer],
       array_of_floats: [Float],
       array_of_dates: [GraphQL::Types::ISO8601Date],
       array_of_datetimes: [GraphQL::Types::ISO8601DateTime],
-      array_of_precise_datetimes: [PreciseDatetime]
+      array_of_precise_datetimes: [PreciseDatetime],
+      array_of_string_ranges: [StringRange],
+      array_of_integer_ranges: [IntegerRange],
+      array_of_float_ranges: [FloatRange],
+      array_of_datetime_ranges: [DatetimeRange],
+      array_of_precise_datetime_ranges: [PreciseDatetimeRange]
     }
 
     class RelayConnectionExtension < GraphQL::Schema::Field::ConnectionExtension

data/lib/graphiti_gql/version.rb

@@ -1,3 +1,3 @@
 module GraphitiGql
-  VERSION = "0.2.22"
+  VERSION = "0.2.25"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti_gql
 version: !ruby/object:Gem::Version
-  version: 0.2.22
+  version: 0.2.25
 platform: ruby
 authors:
 - Lee Richmond
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-08-09 00:00:00.000000000 Z
+date: 2022-08-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql