graphiti 1.0.alpha.1 → 1.0.alpha.4

data/lib/graphiti/schema_diff.rb

@@ -0,0 +1,174 @@
+module Graphiti
+  class SchemaDiff
+    def initialize(old, new)
+      @old = old.deep_symbolize_keys
+      @new = new.deep_symbolize_keys
+      @errors = []
+    end
+
+    def compare
+      compare_each if @old != @new
+      @errors
+    end
+
+    private
+
+    def compare_each
+      compare_resources
+      compare_endpoints
+      compare_types
+    end
+
+    def compare_resources
+      @old[:resources].each_with_index do |r, index|
+        new_resource = @new[:resources].find { |n| n[:name] == r[:name] }
+        compare_resource(r, new_resource) do
+          compare_attributes(r, new_resource)
+          compare_extra_attributes(r, new_resource)
+          compare_filters(r, new_resource)
+          compare_relationships(r, new_resource)
+        end
+      end
+    end
+
+    def compare_resource(old_resource, new_resource)
+      unless new_resource
+        @errors << "#{old_resource[:name]} was removed."
+        return
+      end
+
+      if old_resource[:type] != new_resource[:type]
+        @errors << "#{old_resource[:name]} changed type from #{old_resource[:type].inspect} to #{new_resource[:type].inspect}."
+      end
+      yield
+    end
+
+    def compare_attributes(old_resource, new_resource)
+      old_resource[:attributes].each_pair do |name, old_att|
+        unless new_att = new_resource[:attributes][name]
+          @errors << "#{old_resource[:name]}: attribute #{name.inspect} was removed."
+          next
+        end
+
+        compare_attribute(old_resource[:name], name, old_att, new_att)
+      end
+    end
+
+    def compare_relationships(old_resource, new_resource)
+      old_resource[:relationships].each_pair do |name, old_rel|
+        unless new_rel = new_resource[:relationships][name]
+          @errors << "#{old_resource[:name]}: relationship #{name.inspect} was removed."
+          next
+        end
+
+        if new_rel[:resource] != old_rel[:resource]
+          @errors << "#{old_resource[:name]}: relationship #{name.inspect} changed resource from #{old_rel[:resource]} to #{new_rel[:resource]}."
+        end
+
+        if new_rel[:type] != old_rel[:type]
+          @errors << "#{old_resource[:name]}: relationship #{name.inspect} changed type from #{old_rel[:type].inspect} to #{new_rel[:type].inspect}."
+        end
+      end
+    end
+
+    def compare_extra_attributes(old_resource, new_resource)
+      old_resource[:extra_attributes].each_pair do |name, old_att|
+        unless new_att = new_resource[:extra_attributes][name]
+          @errors << "#{old_resource[:name]}: extra attribute #{name.inspect} was removed."
+          next
+        end
+
+        compare_attribute(old_resource[:name], name, old_att, new_att, extra: true)
+      end
+    end
+
+    def compare_filters(old_resource, new_resource)
+      old_resource[:filters].each_pair do |name, old_filter|
+        unless new_filter = new_resource[:filters][name]
+          @errors << "#{old_resource[:name]}: filter #{name.inspect} was removed."
+          next
+        end
+
+        if new_filter[:type] != old_filter[:type]
+          @errors << "#{old_resource[:name]}: filter #{name.inspect} changed type from #{old_filter[:type].inspect} to #{new_filter[:type].inspect}."
+          next
+        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}."
+          end
+        end
+
+        if new_filter[:required] && !old_filter[:required]
+          @errors << "#{old_resource[:name]}: filter #{name.inspect} went from optional to required."
+        end
+
+        if new_filter[:guard] && !old_filter[:guard]
+          @errors << "#{old_resource[:name]}: filter #{name.inspect} went from unguarded to guarded."
+        end
+      end
+    end
+
+    def compare_endpoints
+      @old[:endpoints].each_pair do |path, old_endpoint|
+        unless new_endpoint = @new[:endpoints][path]
+          @errors << "Endpoint \"#{path}\" was removed."
+          next
+        end
+
+        old_endpoint[:actions].each_pair do |name, old_action|
+          unless new_action = new_endpoint[:actions][name]
+            @errors << "Endpoint \"#{path}\" removed action #{name.inspect}."
+            next
+          end
+
+          if new_action[:sideload_whitelist] && !old_action[:sideload_whitelist]
+            @errors << "Endpoint \"#{path}\" added sideload whitelist."
+          end
+
+          if new_action[:sideload_whitelist]
+            if new_action[:sideload_whitelist] != old_action[:sideload_whitelist]
+              removal = Util::Hash.include_removed? \
+                new_action[:sideload_whitelist], old_action[:sideload_whitelist]
+              if removal
+                @errors << "Endpoint \"#{path}\" had incompatible sideload whitelist. Was #{old_action[:sideload_whitelist].inspect}, now #{new_action[:sideload_whitelist].inspect}."
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def compare_types
+      @old[:types].each_pair do |name, old_type|
+        unless new_type = @new[:types][name]
+          @errors << "Type #{name.inspect} was removed."
+          next
+        end
+
+        if new_type[:kind] != old_type[:kind]
+          @errors << "Type #{name.inspect} changed kind from #{old_type[:kind].inspect} to #{new_type[:kind].inspect}."
+        end
+      end
+    end
+
+    def compare_attribute(resource_name, att_name, old_att, new_att, extra: false)
+      prefix = extra ? "extra attribute" : "attribute"
+
+      if old_att[:type] != new_att[:type]
+        @errors << "#{resource_name}: #{prefix} #{att_name.inspect} changed type from #{old_att[:type].inspect} to #{new_att[:type].inspect}."
+      end
+
+      [:readable, :writable, :sortable].each do |flag|
+        if [true, 'guarded'].include?(old_att[flag]) && new_att[flag] == false
+          @errors << "#{resource_name}: #{prefix} #{att_name.inspect} changed flag #{flag.inspect} from #{old_att[flag].inspect} to #{new_att[flag].inspect}."
+        end
+
+        if new_att[flag] == 'guarded' && old_att[flag] == true
+          @errors << "#{resource_name}: #{prefix} #{att_name.inspect} changed flag #{flag.inspect} from #{old_att[flag].inspect} to #{new_att[flag].inspect}."
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/scoping/filter.rb

@@ -44,7 +44,7 @@ module Graphiti
     def filter_scope(filter, operator, value)
       operator = operator.to_s.gsub('!', 'not_').to_sym
 
-      if custom_scope = filter.values.first[operator]
+      if custom_scope = filter.values[0][:operators][operator]
         custom_scope.call(@scope, value, resource.context)
       else
         filter_via_adapter(filter, operator, value)

data/lib/graphiti/sideload.rb

@@ -9,13 +9,15 @@ module Graphiti
       :foreign_key,
       :primary_key,
       :parent,
-      :group_name
+      :group_name,
+      :link
 
     class_attribute :scope_proc,
       :assign_proc,
       :assign_each_proc,
       :params_proc,
-      :pre_load_proc
+      :pre_load_proc,
+      :link_proc
 
     def initialize(name, opts)
       @name                  = name
@@ -28,6 +30,7 @@ module Graphiti
       @readable              = opts[:readable]
       @writable              = opts[:writable]
       @as                    = opts[:as]
+      @link                  = opts[:link]
 
       # polymorphic-specific
       @group_name            = opts[:group_name]
@@ -36,6 +39,8 @@ module Graphiti
       if polymorphic_child?
         parent.resource.polymorphic << resource_class
       end
+
+      check! if defined?(::Rails)
     end
 
     def self.scope(&blk)
@@ -58,6 +63,30 @@ module Graphiti
       self.pre_load_proc = blk
     end
 
+    def self.link(&blk)
+      self.link_proc = blk
+    end
+
+    def check!
+      case type
+      when :has_many, :has_one
+        unless resource.filters[foreign_key]
+          raise Errors::MissingSideloadFilter.new parent_resource_class,
+            self, foreign_key
+        end
+      when :belongs_to
+        unless resource.filters[primary_key]
+          raise Errors::MissingSideloadFilter.new parent_resource_class,
+            self, primary_key
+        end
+      when :many_to_many
+        unless resource.filters[true_foreign_key]
+          raise Errors::MissingSideloadFilter.new parent_resource_class,
+            self, true_foreign_key
+        end
+      end
+    end
+
     def readable?
       !!@readable
     end
@@ -66,6 +95,16 @@ module Graphiti
       !!@writable
     end
 
+    def link?
+      return true if link_proc
+
+      if @link.nil?
+        !!@parent_resource_class.autolink
+      else
+        !!@link
+      end
+    end
+
     def polymorphic_parent?
       resource.polymorphic?
     end
@@ -116,7 +155,7 @@ module Graphiti
 
     def load(parents, query)
       params = load_params(parents, query)
-      params_proc.call(params, parents, query) if params_proc
+      params_proc.call(params, parents) if params_proc
       opts = load_options(parents, query)
       proxy = resource.class._all(params, opts, base_scope)
       pre_load_proc.call(proxy) if pre_load_proc
@@ -157,8 +196,7 @@ module Graphiti
     end
 
     def resolve(parents, query)
-      # legacy / custom / many-to-many
-      if self.class.scope_proc || type == :many_to_many
+      if self.class.scope_proc
         sideload_scope = fire_scope(parents)
         sideload_scope = Scope.new sideload_scope,
           resource,
@@ -261,21 +299,12 @@ module Graphiti
       end
     end
 
-    def namespace_for(klass)
-      namespace = klass.name
-      split = namespace.split('::')
-      split[0,split.length-1].join('::')
+    def infer_resource_class
+      Util::Class.infer_resource_class(parent_resource.class, name)
     end
 
-    def infer_resource_class
-      namespace = namespace_for(parent_resource.class)
-      inferred_name = "#{name.to_s.singularize.classify}Resource"
-      klass = "#{namespace}::#{inferred_name}".safe_constantize
-      klass ||= inferred_name.safe_constantize
-      unless klass
-        raise Errors::ResourceNotFound.new(parent_resource, name)
-      end
-      klass
+    def namespace_for(klass)
+      Util::Class.namespace_for(klass)
     end
   end
 end

data/lib/graphiti/sideload/belongs_to.rb

@@ -6,10 +6,14 @@ class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
   def load_params(parents, query)
     query.to_hash.tap do |hash|
       hash[:filter] ||= {}
-      hash[:filter][primary_key] = ids_for_parents(parents)
+      hash[:filter].merge!(base_filter(parents))
     end
   end
 
+  def base_filter(parents)
+    { primary_key => ids_for_parents(parents).join(',') }
+  end
+
   def assign_each(parent, children)
     children.find { |c| c.send(primary_key) == parent.send(foreign_key) }
   end

data/lib/graphiti/sideload/has_many.rb

@@ -6,10 +6,14 @@ class Graphiti::Sideload::HasMany < Graphiti::Sideload
   def load_params(parents, query)
     query.to_hash.tap do |hash|
       hash[:filter] ||= {}
-      hash[:filter][foreign_key] = ids_for_parents(parents)
+      hash[:filter].merge!(base_filter(parents))
     end
   end
 
+  def base_filter(parents)
+    { foreign_key => ids_for_parents(parents).join(',') }
+  end
+
   def assign_each(parent, children)
     children.select { |c| c.send(foreign_key) == parent.send(primary_key) }
   end

data/lib/graphiti/sideload/many_to_many.rb

@@ -1,4 +1,4 @@
-class Graphiti::Sideload::ManyToMany < Graphiti::Sideload
+class Graphiti::Sideload::ManyToMany < Graphiti::Sideload::HasMany
   def type
     :many_to_many
   end
@@ -11,8 +11,12 @@ class Graphiti::Sideload::ManyToMany < Graphiti::Sideload
     foreign_key.values.first
   end
 
+  def base_filter(parents)
+    { true_foreign_key => ids_for_parents(parents).join(',') }
+  end
+
   def infer_foreign_key
-    raise 'You must explicitly pass :foreign_key for many-to-many relaitonships, or override in subclass to return a hash.'
+    raise 'You must explicitly pass :foreign_key for many-to-many relationships, or override in subclass to return a hash.'
   end
 
   def assign_each(parent, children)

data/lib/graphiti/sideload/polymorphic_belongs_to.rb

@@ -23,12 +23,14 @@ class Graphiti::Sideload::PolymorphicBelongsTo < Graphiti::Sideload::BelongsTo
     def on(name, &blk)
       group = Group.new(name)
       @groups << group
-      group.belongs_to(name.to_s.underscore.to_sym)
       group
     end
 
     def apply(sideload, resource_class)
       @groups.each do |group|
+        if group.calls.empty?
+          group.belongs_to(group.name.to_s.underscore.to_sym)
+        end
         group.calls.each do |call|
           args = call[1]
           opts = args.extract_options!

data/lib/graphiti/types.rb

@@ -72,6 +72,8 @@ module Graphiti
       Dry::Types['params.hash'][input].deep_symbolize_keys
     end
 
+    REQUIRED_KEYS = [:params, :read, :write, :kind, :description]
+
     def self.map
       @map ||= begin
         hash = {
@@ -79,52 +81,72 @@ module Graphiti
             canonical_name: :integer,
             params: Dry::Types['coercible.integer'],
             read: Dry::Types['coercible.string'],
-            write: Dry::Types['coercible.integer']
+            write: Dry::Types['coercible.integer'],
+            kind: 'scalar',
+            description: 'Base Type. Query/persist as integer, render as string.'
           },
           string: {
             params: Dry::Types['coercible.string'],
             read: Dry::Types['coercible.string'],
-            write: Dry::Types['coercible.string']
+            write: Dry::Types['coercible.string'],
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           integer: {
             params: PresentInteger,
             read: Integer,
-            write: Integer
+            write: Integer,
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           big_decimal: {
             params: ParamDecimal,
             read: Dry::Types['json.decimal'],
-            write: Dry::Types['json.decimal']
+            write: Dry::Types['json.decimal'],
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           float: {
             params: Dry::Types['coercible.float'],
             read: Float,
-            write: Float
+            write: Float,
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           boolean: {
             params: PresentBool,
             read: Bool,
-            write: Bool
+            write: Bool,
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           date: {
             params: PresentDate,
             read: Date,
-            write: Date
+            write: Date,
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           datetime: {
             params: PresentParamsDateTime,
             read: ReadDateTime,
-            write: WriteDateTime
+            write: WriteDateTime,
+            kind: 'scalar',
+            description: 'Base Type.'
           },
           hash: {
             params: PresentParamsHash,
             read: Dry::Types['strict.hash'],
-            write: Dry::Types['strict.hash']
+            write: Dry::Types['strict.hash'],
+            kind: 'record',
+            description: 'Base Type.'
           },
           array: {
             params: Dry::Types['strict.array'],
             read: Dry::Types['strict.array'],
-            write: Dry::Types['strict.array']
+            write: Dry::Types['strict.array'],
+            kind: 'array',
+            description: 'Base Type.'
           }
         }
 
@@ -134,12 +156,16 @@ module Graphiti
 
         arrays = {}
         hash.each_pair do |name, map|
+          next if [:boolean, :hash, :array].include?(name)
+
           arrays[:"array_of_#{name.to_s.pluralize}"] = {
             canonical_name: name,
             params: Dry::Types['strict.array'].of(map[:params]),
             read: Dry::Types['strict.array'].of(map[:read]),
             test: Dry::Types['strict.array'].of(map[:test]),
-            write: Dry::Types['strict.array'].of(map[:write])
+            write: Dry::Types['strict.array'].of(map[:write]),
+            kind: 'array',
+            description: 'Base Type.'
           }
         end
         hash.merge!(arrays)
@@ -153,12 +179,8 @@ module Graphiti
     end
 
     def self.[]=(key, value)
-      unless value.is_a?(Hash)
-        value = {
-          read: value,
-          params: value,
-          test: value
-        }
+      unless value.is_a?(Hash) && (REQUIRED_KEYS - value.keys).length.zero?
+        raise Errors::InvalidType.new(key, value)
       end
       map[key.to_sym] = value
     end