graphiti 1.0.alpha.8 → 1.0.alpha.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68063fcedb7deeeb604ebb6c88e58fe525867ee8
-  data.tar.gz: cb720f2dcada7d2b92332e8b734ff9fcdc879c01
+  metadata.gz: caacb7b46b4b6380d1202102d599ea89292883e4
+  data.tar.gz: e1817089ad066f588c1b7b4d43e595e923bd93fc
 SHA512:
-  metadata.gz: 9bba382cda2e598726ab189f9b38e256fce145cbe911c9342d706811930da89ae76947f011ff86dacb3e7265b1da305e7074e9471eb7e7d9bbf45ee1ac24484f
-  data.tar.gz: aa1ab4574c5bb2a51fb0c76d251c0061e44af47287e7906121d566697fa9eb8a8f4cddf65d9dfe7bd2c33f402761a9b2911f4ac37925175cfe55233535f4b1bb
+  metadata.gz: c77ef723750a6220eafec17a1312886c75cb20e60fda62ea1a648916c8ddedf4f670abd0be7b7a62806755036aa674f78bb8ec98e587df2c8304e6c89c678d33
+  data.tar.gz: 97aa9cf93a8af91459b402b2379c81a461330fd47a467c5eb79a4a768569a6c15ba4ad2238f08bb41d7563607918d7b30c2dfdc2be5197e8d97cfaf77a3f6fe0

data/lib/graphiti.rb

@@ -62,12 +62,11 @@ require "graphiti/util/serializer_attributes"
 require "graphiti/util/serializer_relationships"
 require "graphiti/util/class"
 require "graphiti/util/link"
-
 require 'graphiti/adapters/null'
-
 require "graphiti/extensions/extra_attribute"
 require "graphiti/extensions/boolean_attribute"
 require "graphiti/extensions/temp_id"
+require "graphiti/serializer"
 
 if defined?(ActiveRecord)
   require 'graphiti/adapters/active_record'

data/lib/graphiti/context.rb

@@ -3,14 +3,14 @@ module Graphiti
     extend ActiveSupport::Concern
 
     module Overrides
-      def sideload_whitelist=(val)
+      def sideload_allowlist=(val)
         super(JSONAPI::IncludeDirective.new(val).to_hash)
       end
     end
 
     included do
-      class_attribute :sideload_whitelist
-      self.sideload_whitelist = {}
+      class_attribute :sideload_allowlist
+      self.sideload_allowlist = {}
       class << self;prepend Overrides;end
     end
   end

data/lib/graphiti/errors.rb

@@ -36,16 +36,16 @@ Remove the single: true option to bypass this error.
     end
 
     class UnsupportedSort < Base
-      def initialize(resource, attribute, whitelist, direction)
+      def initialize(resource, attribute, allowlist, direction)
         @resource = resource
         @attribute = attribute
-        @whitelist = whitelist
+        @allowlist = allowlist
         @direction = direction
       end
 
       def message
         <<-MSG
-#{@resource.class.name}: tried to sort on attribute #{@attribute.inspect}, but passed #{@direction.inspect} when only #{@whitelist.inspect} is supported.
+#{@resource.class.name}: tried to sort on attribute #{@attribute.inspect}, but passed #{@direction.inspect} when only #{@allowlist.inspect} is supported.
         MSG
       end
     end
@@ -72,12 +72,12 @@ Remove the single: true option to bypass this error.
 
       def message
         allow = @filter.values[0][:allow]
-        reject = @filter.values[0][:reject]
+        deny = @filter.values[0][:deny]
         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 << "\nAllowlist: #{allow.inspect}" if allow
+        msg << "\nDenylist: #{deny.inspect}" if deny
         msg
       end
     end
@@ -192,6 +192,19 @@ Graphiti.config.context_for_endpoint = ->(path, action) { ... }
       end
     end
 
+    class InvalidJSONArray < Base
+      def initialize(resource, value)
+        @resource = resource
+        @value = value
+      end
+
+      def message
+        <<-MSG
+#{@resource.class.name}: passed filter with value #{@value.inspect}, and failed attempting to parse as JSON array.
+        MSG
+      end
+    end
+
     class InvalidEndpoint < Base
       def initialize(resource_class, path, action)
         @resource_class = resource_class

data/lib/graphiti/extensions/boolean_attribute.rb

@@ -27,7 +27,3 @@ module Graphiti
     end
   end
 end
-
-JSONAPI::Serializable::Resource.class_eval do
-  include Graphiti::Extensions::BooleanAttribute
-end

data/lib/graphiti/extensions/extra_attribute.rb

@@ -24,7 +24,7 @@ module Graphiti
     #     end
     #   end
     #
-    #   class SerializablePerson < JSONAPI::Serializable::Resource
+    #   class SerializablePerson < Graphiti::Serializer
     #     # ... code ...
     #     extra_attribute :net_worth do
     #       @object.assets.sum(&:value)
@@ -57,14 +57,3 @@ module Graphiti
     end
   end
 end
-
-JSONAPI::Serializable::Resource.class_eval do
-  def self.inherited(klass)
-    super
-    klass.class_eval do
-      extend JSONAPI::Serializable::Resource::ConditionalFields
-    end
-  end
-
-  include Graphiti::Extensions::ExtraAttribute
-end

data/lib/graphiti/extensions/temp_id.rb

@@ -20,7 +20,3 @@ module Graphiti
     end
   end
 end
-
-JSONAPI::Serializable::Resource.class_eval do
-  prepend Graphiti::SerializableTempId
-end

data/lib/graphiti/hash_renderer.rb

@@ -25,7 +25,6 @@ module Graphiti
       end
     end
   end
-  JSONAPI::Serializable::Resource.send(:include, SerializableHash)
 
   class HashRenderer
     def initialize(resource)

data/lib/graphiti/query.rb

@@ -156,13 +156,13 @@ module Graphiti
       @include_hash ||= begin
         requested = include_directive.to_hash
 
-        whitelist = nil
-        if @resource.context && @resource.context.respond_to?(:sideload_whitelist)
-          whitelist = @resource.context.sideload_whitelist
-          whitelist = whitelist[@resource.context_namespace] if whitelist
+        allowlist = nil
+        if @resource.context && @resource.context.respond_to?(:sideload_allowlist)
+          allowlist = @resource.context.sideload_allowlist
+          allowlist = allowlist[@resource.context_namespace] if allowlist
         end
 
-        whitelist ? Util::IncludeParams.scrub(requested, whitelist) : requested
+        allowlist ? Util::IncludeParams.scrub(requested, allowlist) : requested
       end
 
       @include_hash

data/lib/graphiti/resource.rb

@@ -62,7 +62,11 @@ module Graphiti
 
     def typecast(name, value, flag)
       att = get_attr!(name, flag, request: true)
-      type = Graphiti::Types[att[:type]]
+      type_name = att[:type]
+      if flag == :filterable
+        type_name = filters[name][:type]
+      end
+      type = Graphiti::Types[type_name]
       return if value.nil? && type[:kind] != 'array'
       begin
         flag = :read if flag == :readable

data/lib/graphiti/resource/configuration.rb

@@ -134,7 +134,7 @@ module Graphiti
 
         # @api private
         def infer_serializer_superclass
-          serializer_class = JSONAPI::Serializable::Resource
+          serializer_class = ::Graphiti::Serializer
           namespace = Util::Class.namespace_for(self)
           app_serializer = "#{namespace}::ApplicationSerializer"
             .safe_constantize
@@ -185,10 +185,6 @@ module Graphiti
           attributes.merge(extra_attributes)
         end
 
-        def attribute_cache
-          @attribute_cache ||= all_attributes
-        end
-
         def sideloads
           config[:sideloads]
         end

data/lib/graphiti/resource/dsl.rb

@@ -6,6 +6,7 @@ module Graphiti
       class_methods do
         def filter(name, *args, &blk)
           opts = args.extract_options!
+          type_override = args[0]
 
           if att = get_attr(name, :filterable, raise_error: :only_unsupported)
             aliases = [name, opts[:aliases]].flatten.compact
@@ -19,9 +20,9 @@ module Graphiti
             config[:filters][name.to_sym] = {
               aliases: aliases,
               name: name.to_sym,
-              type: att[:type],
+              type: type_override || att[:type],
               allow: opts[:allow],
-              reject: opts[:reject],
+              deny: opts[:deny],
               single: !!opts[:single],
               dependencies: opts[:dependent],
               required: required,

data/lib/graphiti/schema.rb

@@ -57,9 +57,9 @@ module Graphiti
               end
 
               actions[a] = { resource: r.name }
-              if whitelist = ctx.sideload_whitelist
-                if whitelist[a]
-                  actions[a].merge!(sideload_whitelist: whitelist[a])
+              if allowlist = ctx.sideload_allowlist
+                if allowlist[a]
+                  actions[a].merge!(sideload_allowlist: allowlist[a])
                 end
               end
             end
@@ -165,7 +165,7 @@ module Graphiti
 
           config[:single] = true if filter[:single]
           config[:allow] = filter[:allow].map(&:to_s) if filter[:allow]
-          config[:reject] = filter[:reject].map(&:to_s) if filter[:reject]
+          config[:deny] = filter[:deny].map(&:to_s) if filter[:deny]
           config[:dependencies] = filter[:dependencies].map(&:to_s) if filter[:dependencies]
 
           attr = resource.attributes[name]

data/lib/graphiti/schema_diff.rb

@@ -173,16 +173,16 @@ module Graphiti
           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}."
+            @errors << "#{old_resource[:name]}: filter #{name.inspect} allowlist went from #{old.inspect} to #{new.inspect}."
           end
         end
 
-        if new_filter[:reject] != old_filter[:reject]
-          new = new_filter[:reject] || []
-          old = old_filter[:reject] || []
+        if new_filter[:deny] != old_filter[:deny]
+          new = new_filter[:deny] || []
+          old = old_filter[:deny] || []
           diff = new - old
           if diff.length > 0
-            @errors << "#{old_resource[:name]}: filter #{name.inspect} blacklist went from #{old.inspect} to #{new.inspect}."
+            @errors << "#{old_resource[:name]}: filter #{name.inspect} denylist went from #{old.inspect} to #{new.inspect}."
           end
         end
 
@@ -215,16 +215,16 @@ module Graphiti
             next
           end
 
-          if new_action[:sideload_whitelist] && !old_action[:sideload_whitelist]
-            @errors << "Endpoint \"#{path}\" added sideload whitelist."
+          if new_action[:sideload_allowlist] && !old_action[:sideload_allowlist]
+            @errors << "Endpoint \"#{path}\" added sideload allowlist."
           end
 
-          if new_action[:sideload_whitelist]
-            if new_action[:sideload_whitelist] != old_action[:sideload_whitelist]
+          if new_action[:sideload_allowlist]
+            if new_action[:sideload_allowlist] != old_action[:sideload_allowlist]
               removal = Util::Hash.include_removed? \
-                new_action[:sideload_whitelist], old_action[:sideload_whitelist]
+                new_action[:sideload_allowlist], old_action[:sideload_allowlist]
               if removal
-                @errors << "Endpoint \"#{path}\" had incompatible sideload whitelist. Was #{old_action[:sideload_whitelist].inspect}, now #{new_action[:sideload_whitelist].inspect}."
+                @errors << "Endpoint \"#{path}\" had incompatible sideload allowlist. Was #{old_action[:sideload_allowlist].inspect}, now #{new_action[:sideload_allowlist].inspect}."
               end
             end
           end

data/lib/graphiti/scoping/filter.rb

@@ -1,12 +1,12 @@
 module Graphiti
   # Apply filtering logic to the scope
   #
-  # If the user requests to filter a field that has not been whitelisted,
+  # If the user requests to filter a field that has not been allowlisted,
   # a +Graphiti::Errors::BadFilter+ error will be raised.
   #
-  #   allow_filter :title # :title now whitelisted
+  #   allow_filter :title # :title now allowlisted
   #
-  # If the user requests a filter field that has been whitelisted, but
+  # If the user requests a filter field that has been allowlisted, but
   # does not pass the associated `+:if+ clause, +BadFilter+ will be raised.
   #
   #   allow_filter :title, if: :admin?
@@ -72,39 +72,19 @@ module Graphiti
     def each_filter
       filter_param.each_pair do |param_name, param_value|
         filter = find_filter!(param_name)
-        param_value = { eq: param_value } unless param_value.is_a?(Hash)
-        value = param_value.values.first
-        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, operator = normalize_param(filter, param_value)
+        value  = parse_string_value(filter.values[0], value) if value.is_a?(String)
+        validate_singular(resource, filter, value)
+        value = coerce_types(filter.values[0], param_name.to_sym, value)
+        validate_allowlist(resource, filter, value)
+        validate_denylist(resource, filter, value)
         value = value[0] if filter.values[0][:single]
         yield filter, operator, value
       end
     end
 
-    def coerce_types(name, value)
-      type_name = @resource.all_attributes[name][:type]
+    def coerce_types(filter, name, value)
+      type_name = filter[:type]
       is_array = type_name.to_s.starts_with?('array_of') ||
         Types[type_name][:canonical_name] == :array
 
@@ -115,5 +95,98 @@ module Graphiti
         value.map { |v| @resource.typecast(name, v, :filterable) }
       end
     end
+
+    def normalize_param(filter, param_value)
+      param_value = { eq: param_value } unless param_value.is_a?(Hash)
+      value = param_value.values.first
+      operator = param_value.keys.first
+
+      if filter.values[0][:type] == :hash
+        value, operator = \
+          parse_hash_value(filter, param_value, value, operator)
+      else
+        value = param_value.values.first
+      end
+
+      [value, operator]
+    end
+
+    def validate_singular(resource, filter, value)
+      if filter.values[0][:single] && value.is_a?(Array)
+        raise Errors::SingularFilter.new(resource, filter, value)
+      end
+    end
+
+    def validate_allowlist(resource, filter, values)
+      values.each do |v|
+        if allow = filter.values[0][:allow]
+          unless allow.include?(v)
+            raise Errors::InvalidFilterValue.new(resource, filter, v)
+          end
+        end
+      end
+    end
+
+    def validate_denylist(resource, filter, values)
+      values.each do |v|
+        if deny = filter.values[0][:deny]
+          if deny.include?(v)
+            raise Errors::InvalidFilterValue.new(resource, filter, v)
+          end
+        end
+      end
+    end
+
+    def parse_hash_value(filter, param_value, value, operator)
+      if operator != :eq
+        operator = :eq
+        value = param_value
+      end
+
+      if value.is_a?(String)
+        value = value.gsub('{{{', '{').gsub('}}}', '}')
+      end
+
+      [value, operator]
+    end
+
+    # foo,bar,baz becomes ["foo", "bar", "baz"] (unless array type)
+    # {{foo}} becomes ["foo"]
+    # {{foo,bar}},baz becomes ["foo,bar", "baz"]
+    #
+    # JSON of
+    # {{{ "id": 1 }}} becomes { 'id' => 1 }
+    def parse_string_value(filter, value)
+      type = Graphiti::Types[filter[:type]]
+      array_or_string = [:string, :array].include?(type[:canonical_name])
+      if (arr = value.scan(/\[.*?\]/)).present? && array_or_string
+        value = arr.map do |json|
+          begin
+            JSON.parse(json)
+          rescue
+            raise Errors::InvalidJSONArray.new(resource, value)
+          end
+        end
+        value = value[0] if value.length == 1
+      else
+        value = parse_string_arrays(value)
+      end
+      value
+    end
+
+    def parse_string_arrays(value)
+      # Find the quoted strings
+      quotes = value.scan(/{{.*?}}/)
+      # remove them from the rest
+      quotes.each { |q| value.gsub!(q, '') }
+      # remove the quote characters from the quoted strings
+      quotes.each { |q| q.gsub!('{{', '').gsub!('}}', '') }
+      # merge everything back together into an array
+      value = Array(value.split(',')) + quotes
+      # remove any blanks that are left
+      value.reject! { |v| v.length.zero? }
+      value = value[0] if value.length == 1
+      value
+    end
   end
 end

data/lib/graphiti/serializer.rb

@@ -0,0 +1,30 @@
+module Graphiti
+  class Serializer < JSONAPI::Serializable::Resource
+    include Graphiti::Extensions::BooleanAttribute
+    include Graphiti::Extensions::ExtraAttribute
+    include Graphiti::SerializableHash
+    prepend Graphiti::SerializableTempId
+
+    def self.inherited(klass)
+      super
+      klass.class_eval do
+        extend JSONAPI::Serializable::Resource::ConditionalFields
+      end
+    end
+
+    # Temporary fix until fixed upstream
+    # https://github.com/jsonapi-rb/jsonapi-serializable/pull/102
+    def requested_relationships(fields)
+      @_relationships
+    end
+
+    # Allow access to resource methods
+    def method_missing(id, *args, &blk)
+      if @resource.respond_to?(id, true)
+        @resource.send(id, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/graphiti/types.rb

@@ -69,7 +69,8 @@ module Graphiti
     end
 
     PresentParamsHash = create(::Hash) do |input|
-      Dry::Types['params.hash'][input].deep_symbolize_keys
+      input = JSON.parse(input) if input.is_a?(String)
+      Dry::Types['params.hash'][input]
     end
 
     REQUIRED_KEYS = [:params, :read, :write, :kind, :description]

data/lib/graphiti/util/attribute_check.rb

@@ -56,10 +56,6 @@ module Graphiti
           attribute[flag] != :required
       end
 
-      def cache?
-        !!@cache
-      end
-
       def error_class
         Errors::AttributeError
       end
@@ -68,15 +64,8 @@ module Graphiti
         attribute[flag] != false
       end
 
-      # If running in a request context, we've already loaded everything
-      # and there's no reason to perform logic, so go through attriubte cache
-      # Otherwise, this is a performance hit during typecasting
       def attribute
-        @attribute ||= if request?
-          resource.class.attribute_cache[name]
-        else
-          resource.all_attributes[name]
-        end
+        @attribute ||= resource.all_attributes[name]
       end
 
       def attribute?

data/lib/graphiti/util/include_params.rb

@@ -9,7 +9,7 @@ module Graphiti
         #
         # But our resource had this code:
         #
-        #   sideload_whitelist({ index: [:comments] })
+        #   sideload_allowlist({ index: [:comments] })
         #
         # We should drop the 'author' sideload from the request.
         #

data/lib/graphiti/util/serializer_attributes.rb

@@ -57,20 +57,34 @@ module Graphiti
         end
       end
 
+      def typecast(type)
+        _resource = @resource
+        _name = @name
+        _type = type
+        ->(value) {
+          begin
+            _type[value] unless value.nil?
+          rescue Exception => e
+            raise Errors::TypecastFailed.new(_resource, _name, value, e)
+          end
+        }
+      end
+
       def default_proc
         _name = @name
         _resource = @resource.new
+        _typecast = typecast(Graphiti::Types[@attr[:type]][:read])
         ->(_) {
-          _resource.typecast(_name, @object.send(_name), :readable)
+          _typecast.call(@object.send(_name))
         }
       end
 
       def wrap_proc(inner)
         _resource = @resource.new
         _name = @name
+        _typecast = typecast(Graphiti::Types[@attr[:type]][:read])
         ->(serializer_instance = nil) {
-           value = serializer_instance.instance_eval(&inner)
-          _resource.typecast(_name, value, :readable)
+          _typecast.call(serializer_instance.instance_eval(&inner))
         }
       end
 

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.alpha.8"
+  VERSION = "1.0.alpha.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.0.alpha.8
+  version: 1.0.alpha.9
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-22 00:00:00.000000000 Z
+date: 2018-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -278,6 +278,7 @@ files:
 - lib/graphiti/scoping/filterable.rb
 - lib/graphiti/scoping/paginate.rb
 - lib/graphiti/scoping/sort.rb
+- lib/graphiti/serializer.rb
 - lib/graphiti/sideload.rb
 - lib/graphiti/sideload/belongs_to.rb
 - lib/graphiti/sideload/has_many.rb