graphiti 1.0.alpha.4 → 1.0.alpha.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 736b8601bf09408a0fa6ed8f2a0c148a79f7c285
-  data.tar.gz: 9b0adbc770aea3e609f15804db1b33ddba1dee13
+  metadata.gz: a97ae8d131e23bc5acf8f8a4fcb97e7cdce25fdc
+  data.tar.gz: 04ae2c8cc7d56ffea5dc0f8a3fec1a7506a5baeb
 SHA512:
-  metadata.gz: 467e32b7154d37819d6bc4598872e66f3a138120ea2781253238ce4b6fc426b416184c79e5ce58a6d9b596b5754cc87bf7ffb2fc02ab2867bdc6eb00edbe8939
-  data.tar.gz: c8ec00841469671ef261283f3dd6f556c095742be04d31f1bfa9d633ee5066cd009a790560bc65a61845b6d2db366cff5aa2da7b0226e0a4a2ff7146677c2b78
+  metadata.gz: 254a66e4e0bd21eef9038bc8e756b2195cf0d4f0b817944e2f5c71ca139c40da3d0c3a99d7d540b92f77b4bdb5a6acade53efce5ffb839f61ca1a6dcfd01d46e
+  data.tar.gz: 7790a1eb890eeff8bdf7690df749b3841fbff88487d6ef39dc7f3e9679bdabb9854898ad833e9ed8c5427712f14af416ff6dee4d9ba92cecfe34f773997b1adc

data/lib/graphiti/adapters/abstract.rb

@@ -1,82 +1,27 @@
 module Graphiti
   module Adapters
-    # Adapters DRY up common resource logic.
-    #
-    # For instance, there's no reason to write ActiveRecord logic like this in
-    # every Resource:
-    #
-    #   allow_filter :title do |scope, value|
-    #     scope.where(title: value)
-    #   end
-    #
-    #   sort do |scope, att, dir|
-    #     scope.order(att => dir)
-    #   end
-    #
-    #   paginate do |scope, current_page, per_page|
-    #     scope.page(current_page).per(per_page)
-    #   end
-    #
-    # This logic can be re-used through an *Adapter*:
-    #
-    #   use_adapter Graphiti::Adapters::ActiveRecord
-    #   allow_filter :title
-    #
-    # Adapters are pretty simple to write. The corresponding code for the above
-    # ActiveRecord adapter, which should look pretty familiar:
-    #
-    #   class Graphiti::Adapters::ActiveRecord
-    #     def filter(scope, attribute, value)
-    #       scope.where(attribute => value)
-    #     end
-    #
-    #     def order(scope, attribute, direction)
-    #       scope.order(attribute => direction)
-    #     end
-    #
-    #     def paginate(scope, current_page, per_page)
-    #       scope.page(current_page).per(per_page)
-    #     end
-    #   end
-    #
-    # An adapter can have a corresponding +sideloading_module+. This module
-    # gets mixed in to a Sideload. In other words, *Resource* is to
-    # *Adapter* as *Sideload* is to *Adapter#sideloading_module*. Use this
-    # module to define DSL methods that wrap #allow_sideload:
-    #
-    #   class MyAdapter < Graphiti::Adapters::Abstract
-    #     # ... code ...
-    #     def sideloading_module
-    #       MySideloadingAdapter
-    #     end
-    #   end
-    #
-    #   module MySideloadingAdapter
-    #     def belongs_to(association_name)
-    #       allow_sideload association_name do
-    #         # ... code ...
-    #       end
-    #     end
-    #   end
-    #
-    #   # And now in your Resource:
-    #   class MyResource < ApplicationResource
-    #     # ... code ...
-    #     use_adapter MyAdapter
-    #
-    #     belongs_to :my_association
-    #   end
-    #
-    # If you need the adapter to do *nothing*, because perhaps the API you
-    # are hitting does not support sorting,
-    # use +Graphiti::Adapters::Null+.
-    #
-    # @see Resource.use_adapter
-    # @see Adapters::ActiveRecord
-    # @see Adapters::ActiveRecordSideloading
-    # @see Adapters::Null
     class Abstract
-      def default_operators
+      attr_reader :resource
+
+      def initialize(resource)
+        @resource = resource
+      end
+
+      # You want to override this!
+      # Map of association_type => sideload_class
+      # e.g.
+      # { has_many: Adapters::ActiveRecord::HasManySideload }
+      def self.sideloading_classes
+        {
+          has_many: ::Graphiti::Sideload::HasMany,
+          belongs_to: ::Graphiti::Sideload::BelongsTo,
+          has_one: ::Graphiti::Sideload::HasOne,
+          many_to_many: ::Graphiti::Sideload::ManyToMany,
+          polymorphic_belongs_to: ::Graphiti::Sideload::PolymorphicBelongsTo
+        }
+      end
+
+      def self.default_operators
         {
           string: [
             :eq,
@@ -423,7 +368,11 @@ module Graphiti
             parent, child, association_name, association_type
         else
           if [:has_many, :many_to_many].include?(association_type)
-            parent.send(:"#{association_name}") << child
+            if parent.send(:"#{association_name}").nil?
+              parent.send(:"#{association_name}=", [child])
+            else
+              parent.send(:"#{association_name}") << child
+            end
           else
             parent.send(:"#{association_name}=", child)
           end
@@ -470,20 +419,6 @@ module Graphiti
         raise 'you must override #disassociate in an adapter subclass'
       end
 
-      # You want to override this!
-      # Map of association_type => sideload_class
-      # e.g.
-      # { has_many: Adapters::ActiveRecord::HasManySideload }
-      def sideloading_classes
-        {
-          has_many: ::Graphiti::Sideload::HasMany,
-          belongs_to: ::Graphiti::Sideload::BelongsTo,
-          has_one: ::Graphiti::Sideload::HasOne,
-          many_to_many: ::Graphiti::Sideload::ManyToMany,
-          polymorphic_belongs_to: ::Graphiti::Sideload::PolymorphicBelongsTo
-        }
-      end
-
       # @param [Class] model_class The configured model class (see Resource.model)
       # @param [Hash] create_params Attributes + id
       # @return the model instance just created
@@ -528,13 +463,13 @@ module Graphiti
 
       private
 
-      def numerical_operators
+      def self.numerical_operators
         [:eq, :not_eq, :gt, :gte, :lt, :lte]
       end
 
       def activerecord_adapter
         @activerecord_adapter ||=
-          ::Graphiti::Adapters::ActiveRecord::Base.new
+          ::Graphiti::Adapters::ActiveRecord::Base.new(resource)
       end
 
       def activerecord_associate?(parent, child, association_name)

data/lib/graphiti/adapters/active_record/base.rb

@@ -2,6 +2,24 @@ module Graphiti
   module Adapters
     module ActiveRecord
       class Base < ::Graphiti::Adapters::Abstract
+        def filter_eq(scope, attribute, value)
+          scope.where(attribute => value)
+        end
+        alias :filter_integer_eq :filter_eq
+        alias :filter_float_eq :filter_eq
+        alias :filter_big_decimal_eq :filter_eq
+        alias :filter_date_eq :filter_eq
+        alias :filter_boolean_eq :filter_eq
+
+        def filter_not_eq(scope, attribute, value)
+          scope.where.not(attribute => value)
+        end
+        alias :filter_integer_not_eq :filter_not_eq
+        alias :filter_float_not_eq :filter_not_eq
+        alias :filter_big_decimal_not_eq :filter_not_eq
+        alias :filter_date_not_eq :filter_not_eq
+        alias :filter_boolean_not_eq :filter_not_eq
+
         def filter_string_eq(scope, attribute, value, is_not: false)
           column = scope.klass.arel_table[attribute]
           clause = column.lower.eq_any(value.map(&:downcase))
@@ -54,56 +72,44 @@ module Graphiti
           filter_string_match(scope, attribute, value, is_not: true)
         end
 
-        def filter_integer_eq(scope, attribute, value, is_not: false)
-          clause = { attribute => value }
-          is_not ? scope.where.not(clause) : scope.where(clause)
-        end
-        alias :filter_float_eq :filter_integer_eq
-        alias :filter_big_decimal_eq :filter_integer_eq
-        alias :filter_date_eq :filter_integer_eq
-        alias :filter_boolean_eq :filter_integer_eq
-
-        def filter_integer_not_eq(scope, attribute, value)
-          filter_integer_eq(scope, attribute, value, is_not: true)
-        end
-        alias :filter_float_not_eq :filter_integer_not_eq
-        alias :filter_big_decimal_not_eq :filter_integer_not_eq
-        alias :filter_date_not_eq :filter_integer_not_eq
-
-        def filter_integer_gt(scope, attribute, value)
+        def filter_gt(scope, attribute, value)
           column = scope.klass.arel_table[attribute]
           scope.where(column.gt_any(value))
         end
-        alias :filter_float_gt :filter_integer_gt
-        alias :filter_big_decimal_gt :filter_integer_gt
-        alias :filter_datetime_gt :filter_integer_gt
-        alias :filter_date_gt :filter_integer_gt
+        alias :filter_integer_gt :filter_gt
+        alias :filter_float_gt :filter_gt
+        alias :filter_big_decimal_gt :filter_gt
+        alias :filter_datetime_gt :filter_gt
+        alias :filter_date_gt :filter_gt
 
-        def filter_integer_gte(scope, attribute, value)
+        def filter_gte(scope, attribute, value)
           column = scope.klass.arel_table[attribute]
           scope.where(column.gteq_any(value))
         end
-        alias :filter_float_gte :filter_integer_gte
-        alias :filter_big_decimal_gte :filter_integer_gte
-        alias :filter_datetime_gte :filter_integer_gte
-        alias :filter_date_gte :filter_integer_gte
+        alias :filter_integer_gte :filter_gte
+        alias :filter_float_gte :filter_gte
+        alias :filter_big_decimal_gte :filter_gte
+        alias :filter_datetime_gte :filter_gte
+        alias :filter_date_gte :filter_gte
 
-        def filter_integer_lt(scope, attribute, value)
+        def filter_lt(scope, attribute, value)
           column = scope.klass.arel_table[attribute]
           scope.where(column.lt_any(value))
         end
-        alias :filter_float_lt :filter_integer_lt
-        alias :filter_big_decimal_lt :filter_integer_lt
-        alias :filter_datetime_lt :filter_integer_lt
-        alias :filter_date_lt :filter_integer_lt
+        alias :filter_integer_lt :filter_lt
+        alias :filter_float_lt :filter_lt
+        alias :filter_big_decimal_lt :filter_lt
+        alias :filter_datetime_lt :filter_lt
+        alias :filter_date_lt :filter_lt
 
-        def filter_integer_lte(scope, attribute, value)
+        def filter_lte(scope, attribute, value)
           column = scope.klass.arel_table[attribute]
           scope.where(column.lteq_any(value))
         end
-        alias :filter_float_lte :filter_integer_lte
-        alias :filter_big_decimal_lte :filter_integer_lte
-        alias :filter_date_lte :filter_integer_lte
+        alias :filter_integer_lte :filter_lte
+        alias :filter_float_lte :filter_lte
+        alias :filter_big_decimal_lte :filter_lte
+        alias :filter_date_lte :filter_lte
 
         # Ensure fractional seconds don't matter
         def filter_datetime_eq(scope, attribute, value, is_not: false)
@@ -180,7 +186,7 @@ module Graphiti
           end
         end
 
-        def sideloading_classes
+        def self.sideloading_classes
           {
             has_many: HasManySideload,
             has_one: HasOneSideload,
@@ -198,26 +204,34 @@ module Graphiti
         end
 
         def associate_all(parent, children, association_name, association_type)
-          association = parent.association(association_name)
-          association.loaded!
-
-          children.each do |child|
-            if association_type == :many_to_many &&
-                !parent.send(association_name).exists?(child.id) &&
-                [:create, :update].include?(Graphiti.context[:namespace])
-              parent.send(association_name) << child
-            else
-              target = association.instance_variable_get(:@target)
-              target |= [child]
-              association.instance_variable_set(:@target, target)
+          if activerecord_associate?(parent, children[0], association_name)
+            association = parent.association(association_name)
+            association.loaded!
+
+            children.each do |child|
+              if association_type == :many_to_many &&
+                  !parent.send(association_name).exists?(child.id) &&
+                  [:create, :update].include?(Graphiti.context[:namespace])
+                parent.send(association_name) << child
+              else
+                target = association.instance_variable_get(:@target)
+                target |= [child]
+                association.instance_variable_set(:@target, target)
+              end
             end
+          else
+            super
           end
         end
 
         def associate(parent, child, association_name, association_type)
-          association = parent.association(association_name)
-          association.loaded!
-          association.instance_variable_set(:@target, child)
+          if activerecord_associate?(parent, child, association_name)
+            association = parent.association(association_name)
+            association.loaded!
+            association.instance_variable_set(:@target, child)
+          else
+            super
+          end
         end
 
         # When a has_and_belongs_to_many relationship, we don't have a foreign

data/lib/graphiti/errors.rb

@@ -16,23 +16,59 @@ The adapter #{@adapter.class} does not implement method '#{@method}', which was
       end
     end
 
+    class InvalidFilterValue < Base
+      def initialize(resource, filter, value)
+        @resource = resource
+        @filter = filter
+        @value = value
+      end
+
+      def message
+        allow = @filter.values[0][:allow]
+        reject = @filter.values[0][:reject]
+        msg = <<-MSG
+#{@resource.class.name}: tried to filter on #{@filter.keys[0].inspect}, but passed invalid value #{@value.inspect}.
+        MSG
+        msg << "\nWhitelist: #{allow.inspect}" if allow
+        msg << "\nBlacklist: #{reject.inspect}" if reject
+        msg
+      end
+    end
+
     class InvalidLink < Base
-      def initialize(resource_class, sideload)
+      def initialize(resource_class, sideload, action)
         @resource_class = resource_class
         @sideload = sideload
+        @action = action
       end
 
       def message
         <<-MSG
 #{@resource_class.name}: Cannot link to sideload #{@sideload.name.inspect}!
 
-Make sure the endpoint "#{@sideload.resource.endpoint[:full_path]}" exists, or customize the endpoint for #{@sideload.resource.class.name}.
+Make sure the endpoint "#{@sideload.resource.endpoint[:full_path]}" exists with action #{@action.inspect}, or customize the endpoint for #{@sideload.resource.class.name}.
 
 If you do not wish to generate a link, pass link: false or set self.relationship_links_by_default = false.
         MSG
       end
     end
 
+    class SingularFilter < Base
+      def initialize(resource, filter, value)
+        @resource = resource
+        @filter = filter
+        @value = value
+      end
+
+      def message
+        <<-MSG
+#{@resource.class.name}: passed multiple values to filter #{@filter.keys[0].inspect}, which was marked single: true.
+
+Value was: #{@value.inspect}
+        MSG
+      end
+    end
+
     class Unlinkable < Base
       def initialize(resource_class, sideload)
         @resource_class = resource_class

data/lib/graphiti/resource.rb

@@ -49,6 +49,7 @@ module Graphiti
     def typecast(name, value, flag)
       att = get_attr!(name, flag)
       type = Graphiti::Types[att[:type]]
+      return if value.nil? && type[:kind] != 'array'
       begin
         flag = :read if flag == :readable
         flag = :write if flag == :writable

data/lib/graphiti/resource/configuration.rb

@@ -44,8 +44,8 @@ module Graphiti
           attr_writer :config
         end
 
-        class_attribute :adapter,
-          :model,
+        class_attribute :adapter, instance_reader: false
+        class_attribute :model,
           :type,
           :polymorphic,
           :polymorphic_child,
@@ -66,7 +66,7 @@ module Graphiti
         def self.inherited(klass)
           super
           klass.config = Util::Hash.deep_dup(config)
-          klass.adapter ||= Adapters::Abstract.new
+          klass.adapter ||= Adapters::Abstract
           klass.default_sort ||= []
           klass.default_page_size ||= 20
           # re-assigning causes a new Class.new
@@ -200,6 +200,10 @@ module Graphiti
         Util::AttributeCheck.run(self, name, flag, request, raise_error)
       end
 
+      def adapter
+        @adapter ||= self.class.adapter.new(self)
+      end
+
       def filters
         self.class.filters
       end

data/lib/graphiti/resource/dsl.rb

@@ -10,9 +10,17 @@ module Graphiti
           if att = get_attr(name, :filterable, raise_error: :only_unsupported)
             aliases = [name, opts[:aliases]].flatten.compact
             operators = FilterOperators.build(self, att[:type], opts, &blk)
+
+            if Graphiti::Types[att[:type]][:canonical_name] == :boolean
+              opts[:single] = true
+            end
+
             config[:filters][name.to_sym] = {
               aliases: aliases,
               type: att[:type],
+              allow: opts[:allow],
+              reject: opts[:reject],
+              single: !!opts[:single],
               operators: operators.to_hash
             }
           else
@@ -53,7 +61,7 @@ module Graphiti
         end
 
         def stat(symbol_or_hash, &blk)
-          dsl = Stats::DSL.new(adapter, symbol_or_hash)
+          dsl = Stats::DSL.new(new.adapter, symbol_or_hash)
           dsl.instance_eval(&blk) if blk
           config[:stats][dsl.name] = dsl
         end

data/lib/graphiti/resource/polymorphism.rb

@@ -25,7 +25,7 @@ module Graphiti
       def associate(parent, child, association_name, type)
         child_resource = self.class.resource_for_model(parent)
         if child_resource.sideloads[association_name]
-          child_resource.adapter
+          child_resource.new.adapter
             .associate(parent, child, association_name, type)
         end
       end

data/lib/graphiti/resource/sideloading.rb

@@ -61,10 +61,10 @@ module Graphiti
           resource = resource ||= Util::Class.infer_resource_class(self, name)
           sideload = resource.sideload(as)
 
-          _adapter = adapter
+          _resource = resource
           filter sideload.true_foreign_key, resource.attributes[:id][:type] do
             eq do |scope, value|
-              _adapter.belongs_to_many_filter(sideload, scope, value)
+              _resource.new.adapter.belongs_to_many_filter(sideload, scope, value)
             end
           end
         end

data/lib/graphiti/schema.rb

@@ -132,11 +132,15 @@ module Graphiti
 
     def filters(resource)
       {}.tap do |f|
-        resource.filters.each_pair do |name, config|
+        resource.filters.each_pair do |name, filter|
           config = {
-            type: config[:type].to_s,
-            operators: config[:operators].keys.map(&:to_s)
+            type: filter[:type].to_s,
+            operators: filter[:operators].keys.map(&:to_s)
           }
+          config[:single] = true if filter[:single]
+          config[:allow] = filter[:allow] if filter[:allow]
+          config[:reject] = filter[:reject] if filter[:reject]
+
           attr = resource.attributes[name]
           if attr[:filterable].is_a?(Symbol)
             if attr[:filterable] == :required

data/lib/graphiti/schema_diff.rb

@@ -94,6 +94,28 @@ module Graphiti
           next
         end
 
+        if new_filter[:single] && !old_filter[:single]
+          @errors << "#{old_resource[:name]}: filter #{name.inspect} became singular."
+        end
+
+        if new_filter[:allow] != old_filter[:allow]
+          new = new_filter[:allow] || []
+          old = old_filter[:allow] || []
+          diff = new - old
+          if diff.length > 0
+            @errors << "#{old_resource[:name]}: filter #{name.inspect} whitelist went from #{old.inspect} to #{new.inspect}."
+          end
+        end
+
+        if new_filter[:reject] != old_filter[:reject]
+          new = new_filter[:reject] || []
+          old = old_filter[:reject] || []
+          diff = new - old
+          if diff.length > 0
+            @errors << "#{old_resource[:name]}: filter #{name.inspect} blacklist went from #{old.inspect} to #{new.inspect}."
+          end
+        end
+
         if (diff = old_filter[:operators] - new_filter[:operators]).length > 0
           diff.each do |op|
             @errors << "#{old_resource[:name]}: filter #{name.inspect} removed operator #{op.inspect}."

data/lib/graphiti/scoping/filter.rb

@@ -72,7 +72,28 @@ module Graphiti
         operator = param_value.keys.first
         value = param_value.values.first unless filter.values[0][:type] == :hash
         value = value.split(',') if value.is_a?(String) && value.include?(',')
+
+        if filter.values[0][:single] && value.is_a?(Array)
+          raise Errors::SingularFilter.new(resource, filter, value)
+        end
+
         value = coerce_types(param_name.to_sym, value)
+
+        value.each do |v|
+          if allow = filter.values[0][:allow]
+            unless allow.include?(v)
+              raise Errors::InvalidFilterValue.new(resource, filter, value)
+            end
+          end
+
+          if reject = filter.values[0][:reject]
+            if reject.include?(v)
+              raise Errors::InvalidFilterValue.new(resource, filter, value)
+            end
+          end
+        end
+
+        value = value[0] if filter.values[0][:single]
         yield filter, operator, value
       end
     end

data/lib/graphiti/sideload.rb

@@ -68,6 +68,7 @@ module Graphiti
     end
 
     def check!
+      return if scope_proc
       case type
       when :has_many, :has_one
         unless resource.filters[foreign_key]

data/lib/graphiti/util/link.rb

@@ -14,14 +14,33 @@ module Graphiti
       end
 
       def generate
-        if params.empty?
-          path
+        on_demand_links(raw_url)
+      end
+
+      private
+
+      def raw_url
+        if @sideload.link_proc
+          @sideload.link_proc.call(@model)
         else
-          "#{path}?#{URI.unescape(params.to_query)}"
+          if params.empty?
+            path
+          else
+            "#{path}?#{URI.unescape(params.to_query)}"
+          end
         end
       end
 
-      private
+      def on_demand_links(url)
+        return url unless Graphiti.config.links_on_demand
+
+        if url.include?('?')
+          url << '&links=true'
+        else
+          url << '?links=true'
+        end
+        url
+      end
 
       def params
         @params ||= {}.tap do |params|

data/lib/graphiti/util/serializer_attributes.rb

@@ -66,10 +66,11 @@ module Graphiti
       end
 
       def wrap_proc(inner)
-        type_name = @attr[:type]
+        _resource = @resource.new
+        _name = @name
         ->(serializer_instance = nil) {
-          type = Graphiti::Types[type_name]
-          type[:read][serializer_instance.instance_eval(&inner)]
+           value = serializer_instance.instance_eval(&inner)
+          _resource.typecast(_name, value, :readable)
         }
       end
 

data/lib/graphiti/util/serializer_relationships.rb

@@ -44,11 +44,7 @@ module Graphiti
           proc do
             if @proxy.query.links?
               link(:related) do
-                if prc = sl.link_proc
-                  prc.call(@object)
-                else
-                  ::Graphiti::Util::Link.new(sl, @object).generate
-                end
+                ::Graphiti::Util::Link.new(sl, @object).generate
               end
             end
           end
@@ -75,7 +71,7 @@ module Graphiti
         action = sideload.type == :belongs_to ? :show : :index
         prc = Graphiti.config.context_for_endpoint
         unless prc.call(sideload.resource.endpoint[:full_path], action)
-          raise Errors::InvalidLink.new(@resource_class, sideload)
+          raise Errors::InvalidLink.new(@resource_class, sideload, action)
         end
       end
 

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.alpha.4"
+  VERSION = "1.0.alpha.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.0.alpha.4
+  version: 1.0.alpha.5
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-07 00:00:00.000000000 Z
+date: 2018-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable