graphiti 1.0.rc.2 → 1.0.rc.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 26fc322fc29632b3e24f85bcbe535a3542c0d142
-  data.tar.gz: a7125ea4aada6e5d04d4f58109ef931593f39273
+  metadata.gz: 673ff2ee2d99cc9cb04d8cfb86b5b2b03839b227
+  data.tar.gz: a07ef309b47401d52a75f9bdbd6675d09fd83117
 SHA512:
-  metadata.gz: 7e7410a027fa7a72a15fb90af367680069c9c1842a83aa96eb137e77596880bd803fa8478379c7724213930cc1c51db150bacd18e62681d9cb0d6080a16c0227
-  data.tar.gz: 01a535771b79dcaa05a78cf7a938e3a59261380762c6dd8118b889339cff0647774d8d8ca881c55ddcea361f18dc3857089bea67d0800a5cc4fe4b783f76f482
+  metadata.gz: 2f8911140b4fe3eb64420469e5ea428a7f7b9dc613d5eb5cf0acfa2169b4e20191e5be00f9c526770b8a05aa7de37d6dc5a84551bd0c4784532d6e7dde4c2d33
+  data.tar.gz: b920e16d339cbbd8c2b7f19fe539c02cf1ae8426b83fe9125854132474f46163075f945f4e29416b86febcf6458ac24828f3a956db7c8dc5cc9a8b39a7740362

data/graphiti.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'concurrent-ruby', '~> 1.0'
   spec.add_dependency 'activesupport', ['>= 4.1', '< 6']
 
+  spec.add_development_dependency "faraday", '~> 0.15'
   spec.add_development_dependency "activerecord", ['>= 4.1', '< 6']
   spec.add_development_dependency "kaminari", '~> 0.17'
   spec.add_development_dependency "bundler"

data/lib/graphiti.rb

@@ -29,6 +29,7 @@ require "graphiti/resource/interface"
 require "graphiti/resource/polymorphism"
 require "graphiti/resource/documentation"
 require "graphiti/resource/persistence"
+require "graphiti/resource/remote"
 require "graphiti/sideload"
 require "graphiti/sideload/has_many"
 require "graphiti/sideload/belongs_to"
@@ -65,7 +66,10 @@ require "graphiti/util/serializer_attributes"
 require "graphiti/util/serializer_relationships"
 require "graphiti/util/class"
 require "graphiti/util/link"
+require "graphiti/util/remote_serializer"
+require "graphiti/util/remote_params"
 require 'graphiti/adapters/null'
+require 'graphiti/adapters/graphiti_api'
 require "graphiti/extensions/extra_attribute"
 require "graphiti/extensions/boolean_attribute"
 require "graphiti/extensions/temp_id"

data/lib/graphiti/adapters/graphiti_api.rb

@@ -0,0 +1,89 @@
+module Graphiti
+  module Adapters
+    class GraphitiAPI < ::Graphiti::Adapters::Null
+      def base_scope(model)
+        {}
+      end
+
+      def resolve(scope)
+        url = build_url(scope)
+        response = resource.make_request(url)
+        json = JSON.parse(response.body)
+
+        if json['errors']
+          handle_remote_error(url, json)
+        else
+          models = json['data'].map { |d| build_entity(json, d) }
+          Util::RemoteSerializer.for(resource.class.serializer, models)
+          models
+        end
+      end
+
+      private
+
+      def handle_remote_error(url, json)
+        errors = json['errors'].map do |error|
+          if raw = error['meta'].try(:[], '__raw_error__')
+            { message: raw['message'], backtrace: raw['backtrace'] }
+          else
+            { message: "#{error['title']} - #{error['detail']}" }
+          end
+        end.compact
+        raise Errors::Remote.new(url, errors)
+      end
+
+      def build_url(scope)
+        url = resource.remote_url
+        params = scope[:params].merge(scope.except(:params))
+        params = CGI.unescape(params.to_query)
+        url = "#{url}?#{params}" unless params.blank?
+        url
+      end
+
+      def find_entity(json, id, type)
+        lookup = Array(json['data']) | Array(json['included'])
+        lookup.find { |l| l['id'] == id.to_s && l['type'] == type }
+      end
+
+      def build_entity(json, node)
+        entity = OpenStruct.new(node['attributes'])
+        entity.id = node['id']
+        entity._type = node['type']
+        process_relationships(entity, json, node['relationships'] || {})
+        entity
+      end
+
+      def process_relationships(entity, json, relationship_json)
+        entity._relationships = {}
+        relationship_json.each_pair do |name, hash|
+          if data = hash['data']
+            if data.is_a?(Array)
+              data.each do |d|
+                rel = find_entity(json, d['id'], d['type'])
+                related_entity = build_entity(json, rel)
+                add_relationship(entity, related_entity, name, true)
+              end
+            else
+              rel = find_entity(json, hash['data']['id'], hash['data']['type'])
+              related_entity = build_entity(json, rel)
+              add_relationship(entity, related_entity, name)
+            end
+          end
+          Util::RemoteSerializer.for(Graphiti::Serializer, Array(entity[name]))
+        end
+      end
+
+      def add_relationship(entity, related_entity, name, many = false)
+        if many
+          entity[name] ||= []
+          entity[name] << related_entity
+          entity._relationships[name] ||= []
+          entity._relationships[name] << related_entity
+        else
+          entity[name] = related_entity
+          entity._relationships[name] = related_entity
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/debugger.rb

@@ -17,7 +17,9 @@ module Graphiti
           on_data_exception(payload, params)
         else
           if payload[:sideload]
-            on_sideload_data(payload, params, took)
+            if payload[:results]
+              on_sideload_data(payload, params, took)
+            end
           else
             on_primary_data(payload, params, took)
           end

data/lib/graphiti/errors.rb

@@ -16,6 +16,36 @@ The adapter #{@adapter.class} does not implement method '#{@method}', which was
       end
     end
 
+    class SideloadConfig < Base
+      def initialize(name, parent_resource_class, message)
+        @name = name
+        @parent_resource_class = parent_resource_class
+        @message = message
+      end
+
+      def message
+        <<-MSG
+#{@parent_resource_class} sideload :#{@name} - #{@message}
+        MSG
+      end
+    end
+
+    class Remote < Base
+      def initialize(url, errors)
+        @url = url
+        @errors = errors
+      end
+
+      def message
+        msg = "Error hitting remote API: #{@url}"
+        @errors.each do |e|
+          msg << "\n\n#{e[:message]}"
+          msg << "\n\n#{e[:backtrace].join("\n")}\n\n\n\n" if e[:backtrace]
+        end
+        msg
+      end
+    end
+
     class AroundCallbackProc < Base
       def initialize(resource_class, method_name)
         @resource_class = resource_class
@@ -29,6 +59,18 @@ The adapter #{@adapter.class} does not implement method '#{@method}', which was
       end
     end
 
+    class RemoteWrite < Base
+      def initialize(resource_class)
+        @resource_class = resource_class
+      end
+
+      def message
+        <<-MSG
+#{@resource_class}: Tried to perform write operation. Writes are not supported for remote resources - hit the endpoint directly.
+        MSG
+      end
+    end
+
     class UnsupportedOperator < Base
       def initialize(resource, filter_name, supported, operator)
         @resource = resource

data/lib/graphiti/query.rb

@@ -64,15 +64,27 @@ module Graphiti
       end
     end
 
+    def resource_for_sideload(sideload)
+      if @resource.remote?
+        Class.new(Graphiti::Resource) do
+          self.remote = '_remote_sideload_'
+        end.new
+      else
+        sideload.resource
+      end
+    end
+
     def sideloads
       @sideloads ||= begin
         {}.tap do |hash|
           include_hash.each_pair do |key, sub_hash|
             sideload = @resource.class.sideload(key)
-            if sideload
+
+            if sideload || @resource.remote?
+              sl_resource = resource_for_sideload(sideload)
               _parents = parents + [self]
               sub_hash = sub_hash[:include] if sub_hash.has_key?(:include)
-              hash[key] = Query.new(sideload.resource, @params, key, sub_hash, _parents)
+              hash[key] = Query.new(sl_resource, @params, key, sub_hash, _parents)
             else
               handle_missing_sideload(key)
             end
@@ -131,7 +143,9 @@ module Graphiti
         [].tap do |arr|
           sort_hashes do |key, value, type|
             if legacy_nested?(type)
-              @resource.get_attr!(key, :sortable, request: true)
+              unless @resource.remote?
+                @resource.get_attr!(key, :sortable, request: true)
+              end
               arr << { key => value }
             elsif !type && top_level? && validate!(key, :sortable)
               arr << { key => value }
@@ -196,6 +210,24 @@ module Graphiti
       not [false, 'false'].include?(@params[:paginate])
     end
 
+    # If this is a remote call, we don't care about local parents
+    def chain
+      if @resource.remote
+        top_remote_parent = parents.find { |p| p.resource.remote? }
+        [].tap do |chain|
+          parents.each do |p|
+            chain << p.association_name unless p == top_remote_parent
+          end
+          immediate_parent = parents.reverse[0]
+          # This is not currently checking that it is a remote of the same API
+          chain << association_name if immediate_parent && immediate_parent.resource.remote
+          chain.compact
+        end.compact
+      else
+        parents.map(&:association_name).compact + [association_name].compact
+      end
+    end
+
     private
 
     # Try to find on this resource
@@ -204,6 +236,7 @@ module Graphiti
     # TODO: Eventually, remove the legacy logic
     def validate!(name, flag)
       return false if name.to_s.include?('.') # nested
+      return true if @resource.remote?
 
       if att = @resource.get_attr(name, flag, request: true)
         return att
@@ -248,7 +281,7 @@ module Graphiti
     end
 
     def handle_missing_sideload(name)
-      if Graphiti.config.raise_on_missing_sideload
+      if Graphiti.config.raise_on_missing_sideload && !@resource.remote?
         raise Graphiti::Errors::InvalidInclude
           .new(@resource, name)
       end

data/lib/graphiti/resource.rb

@@ -106,6 +106,10 @@ module Graphiti
       stats_dsl.calculation(calculation)
     end
 
+    def before_resolve(scope, query)
+      scope
+    end
+
     def resolve(scope)
       adapter.resolve(scope)
     end

data/lib/graphiti/resource/configuration.rb

@@ -35,6 +35,11 @@ module Graphiti
           stat total: [:count]
         end
 
+        def remote=(val)
+          super
+          include ::Graphiti::Resource::Remote
+        end
+
         def model
           klass = super
           unless klass || abstract_class?
@@ -55,6 +60,8 @@ module Graphiti
 
         class_attribute :adapter, instance_reader: false
         class_attribute :model,
+          :remote,
+          :remote_base_url,
           :type,
           :polymorphic,
           :polymorphic_child,

data/lib/graphiti/resource/persistence.rb

@@ -65,7 +65,7 @@ module Graphiti
         def add_callback(kind, lifecycle, method = nil, only, &blk)
           config[:callbacks][kind] ||= {}
           config[:callbacks][kind][lifecycle] ||= []
-          config[:callbacks][kind][lifecycle] << { callback: (method || blk), only: only }
+          config[:callbacks][kind][lifecycle] << { callback: (method || blk), only: Array(only) }
         end
       end
 

data/lib/graphiti/resource/remote.rb

@@ -0,0 +1,68 @@
+module Graphiti
+  class Resource
+    module Remote
+      extend ActiveSupport::Concern
+
+      included do
+        self.adapter = Graphiti::Adapters::GraphitiAPI
+        self.model = OpenStruct
+        self.validate_endpoints = false
+
+        class_attribute :timeout,
+          :open_timeout
+      end
+
+      class_methods do
+        def remote_url
+          [remote_base_url, remote].join
+        end
+      end
+
+      def save(*args)
+        raise Errors::RemoteWrite.new(self.class)
+      end
+
+      def destroy(*args)
+        raise Errors::RemoteWrite.new(self.class)
+      end
+
+      def before_resolve(scope, query)
+        scope[:params] = Util::RemoteParams.generate(self, query)
+        scope
+      end
+
+      # Forward all headers
+      def request_headers
+        if defined?(Rails)
+          context.request.headers.to_h.reject { |k, v| k.include?('.') }
+        else
+          {}
+        end
+      end
+
+      def remote_url
+        self.class.remote_url
+      end
+
+      def make_request(url)
+        headers = request_headers.dup
+        headers['Content-Type'] = 'application/vnd.api+json'
+        faraday.get(url, nil, headers) do |req|
+          yield req if block_given? # for super do ... end
+          req.options.timeout = timeout if timeout
+          req.options.open_timeout = open_timeout if open_timeout
+        end
+      end
+
+      private
+
+      def faraday
+        if defined?(Faraday)
+          Faraday
+        else
+          raise "Faraday not defined. Please require the 'faraday' gem to use remote resources"
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/resource/sideloading.rb

@@ -63,6 +63,7 @@ module Graphiti
 
         def polymorphic_has_many(name, opts = {}, as:, &blk)
           opts[:foreign_key] ||= :"#{as}_id"
+          opts[:polymorphic_as] ||= as
           _model = model
           has_many name, opts do
             params do |hash|

data/lib/graphiti/resource_proxy.rb

@@ -83,12 +83,17 @@ module Graphiti
     def save(action: :create)
       # TODO: remove this. Only used for persisting many-to-many with AR
       # (see activerecord adapter)
-      Graphiti.context[:namespace] = action
-      validator = persist do
-        @resource.persist_with_relationships \
-          @payload.meta(action: action),
-          @payload.attributes,
-          @payload.relationships
+      original = Graphiti.context[:namespace]
+      begin
+        Graphiti.context[:namespace] = action
+        validator = persist do
+          @resource.persist_with_relationships \
+            @payload.meta(action: action),
+            @payload.attributes,
+            @payload.relationships
+        end
+      ensure
+        Graphiti.context[:namespace] = original
       end
       @data, success = validator.to_a
 

data/lib/graphiti/schema.rb

@@ -23,6 +23,8 @@ module Graphiti
 
     def initialize(resources)
       @resources = resources.sort_by(&:name)
+      @remote_resources = resources.select(&:remote?)
+      @resources = @resources - @remote_resources
     end
 
     def generate
@@ -79,7 +81,7 @@ module Graphiti
     end
 
     def generate_resources
-      @resources.map do |r|
+      arr = @resources.map do |r|
         config = {
           name: r.name,
           type: r.type.to_s,
@@ -108,6 +110,17 @@ module Graphiti
 
         config
       end
+
+      arr |= @remote_resources.map do |r|
+        {
+          name: r.name,
+          description: r.description,
+          remote: r.remote_url,
+          relationships: relationships(r)
+        }
+      end
+
+      arr
     end
 
     def attributes(resource)

data/lib/graphiti/scope.rb

@@ -18,6 +18,7 @@ module Graphiti
         []
       else
         resolved = broadcast_data do |payload|
+          @object = @resource.before_resolve(@object, @query)
           payload[:results] = @resource.resolve(@object)
           payload[:results]
         end
@@ -40,6 +41,7 @@ module Graphiti
 
       @query.sideloads.each_pair do |name, q|
         sideload = @resource.class.sideload(name)
+        next if sideload.nil? || sideload.shared_remote?
         _parent = @resource
         _context = Graphiti.context
         resolve_sideload = -> {
@@ -94,11 +96,15 @@ module Graphiti
 
     def apply_scoping(scope, opts)
       @object = scope
-      opts[:default_paginate] = false unless @query.paginate?
-      add_scoping(nil, Graphiti::Scoping::DefaultFilter, opts)
-      add_scoping(:filter, Graphiti::Scoping::Filter, opts)
-      add_scoping(:sort, Graphiti::Scoping::Sort, opts)
-      add_scoping(:paginate, Graphiti::Scoping::Paginate, opts)
+
+      unless @resource.remote?
+        opts[:default_paginate] = false unless @query.paginate?
+        add_scoping(nil, Graphiti::Scoping::DefaultFilter, opts)
+        add_scoping(:filter, Graphiti::Scoping::Filter, opts)
+        add_scoping(:sort, Graphiti::Scoping::Sort, opts)
+        add_scoping(:paginate, Graphiti::Scoping::Paginate, opts)
+      end
+
       @object
     end
 

data/lib/graphiti/sideload.rb

@@ -11,7 +11,8 @@ module Graphiti
       :parent,
       :group_name,
       :link,
-      :description
+      :description,
+      :polymorphic_as
 
     class_attribute :scope_proc,
       :assign_proc,
@@ -22,6 +23,7 @@ module Graphiti
 
     def initialize(name, opts)
       @name                  = name
+      validate_options!(opts)
       @parent_resource_class = opts[:parent_resource]
       @resource_class        = opts[:resource]
       @primary_key           = opts[:primary_key]
@@ -33,17 +35,25 @@ module Graphiti
       @as                    = opts[:as]
       @link                  = opts[:link]
       @single                = opts[:single]
+      @remote                = opts[:remote]
       apply_belongs_to_many_filter if type == :many_to_many
 
       @description           = opts[:description]
 
-      # polymorphic-specific
+      # polymorphic has_many
+      @polymorphic_as        = opts[:polymorphic_as]
+      # polymorphic_belongs_to-specific
       @group_name            = opts[:group_name]
       @polymorphic_child     = opts[:polymorphic_child]
       @parent                = opts[:parent]
       if polymorphic_child?
         parent.resource.polymorphic << resource_class
       end
+
+      if remote?
+        @link = false
+        @resource_class = create_remote_resource
+      end
     end
 
     def self.scope(&blk)
@@ -70,10 +80,27 @@ module Graphiti
       self.link_proc = blk
     end
 
+    def create_remote_resource
+      _remote = @remote
+      klass = Class.new(Graphiti::Resource) do
+        self.adapter = Graphiti::Adapters::GraphitiAPI
+        self.model = OpenStruct
+        self.remote = _remote
+        self.validate_endpoints = false
+      end
+      name = "#{parent_resource_class.name}.#{@name}.remote"
+      klass.class_eval("def self.name;'#{name}';end")
+      klass
+    end
+
     def errors
       @errors ||= []
     end
 
+    def remote?
+      !!@remote
+    end
+
     def readable?
       !!@readable
     end
@@ -86,6 +113,10 @@ module Graphiti
       !!@single
     end
 
+    def polymorphic_has_many?
+      !!@polymorphic_as
+    end
+
     def link?
       return true if link_proc
 
@@ -96,6 +127,13 @@ module Graphiti
       end
     end
 
+    # The parent resource is a remote,
+    # AND the sideload is a remote to the same endpoint
+    def shared_remote?
+      resource.remote? &&
+        resource.remote_base_url = parent_resource_class.remote_base_url
+    end
+
     def polymorphic_parent?
       resource.polymorphic?
     end
@@ -288,6 +326,18 @@ module Graphiti
 
     private
 
+    def validate_options!(opts)
+      if opts[:remote]
+        if opts[:resource]
+          raise Errors::SideloadConfig.new(@name, opts[:parent_resource], 'cannot pass :remote and :resource options together')
+        end
+
+        if opts[:link]
+          raise Errors::SideloadConfig.new(@name, opts[:parent_resource], 'remote sideloads do not currently support :link')
+        end
+      end
+    end
+
     def apply_belongs_to_many_filter
       _self = self
       fk_type = parent_resource_class.attributes[:id][:type]

data/lib/graphiti/sideload/belongs_to.rb

@@ -48,6 +48,16 @@ class Graphiti::Sideload::BelongsTo < Graphiti::Sideload
   end
 
   def children_for(parent, map)
-    map[parent.send(foreign_key)]
+    fk = parent.send(foreign_key)
+    children = map[fk]
+    return children if children
+
+    keys = map.keys
+    if fk.is_a?(String) && keys[0].is_a?(Integer)
+      fk = fk.to_i
+    elsif fk.is_a?(Integer) && keys[0].is_a?(String)
+      fk = fk.to_s
+    end
+    map[fk] || []
   end
 end

data/lib/graphiti/sideload/has_many.rb

@@ -21,6 +21,16 @@ class Graphiti::Sideload::HasMany < Graphiti::Sideload
   end
 
   def children_for(parent, map)
-    map[parent.send(primary_key)] || []
+    pk = parent.send(primary_key)
+    children = map[pk]
+    return children if children
+
+    keys = map.keys
+    if pk.is_a?(String) && keys[0].is_a?(Integer)
+      pk = pk.to_i
+    elsif pk.is_a?(Integer) && keys[0].is_a?(String)
+      pk = pk.to_s
+    end
+    map[pk] || []
   end
 end

data/lib/graphiti/util/persistence.rb

@@ -83,6 +83,9 @@ class Graphiti::Util::Persistence
       attrs[x[:foreign_key]] = nil
       update_foreign_type(attrs, x, null: true) if x[:is_polymorphic]
     else
+      if x[:sideload].polymorphic_has_many?
+        attrs[:"#{x[:sideload].polymorphic_as}_type"] = parent_object.class.name
+      end
       attrs[x[:foreign_key]] = parent_object.send(x[:primary_key])
       update_foreign_type(attrs, x) if x[:is_polymorphic]
     end

data/lib/graphiti/util/remote_params.rb

@@ -0,0 +1,115 @@
+# Todo: class purpose
+module Graphiti
+  module Util
+    class RemoteParams
+      def self.generate(resource, query)
+        new(resource, query).generate
+      end
+
+      def initialize(resource, query)
+        @resource = resource
+        @query = query
+        @sorts = []
+        @filters = {}
+        @fields = {}
+        @extra_fields = {}
+        @pagination = {}
+        @params = {}
+      end
+
+      def generate
+        if include_hash = @query.include_hash.presence
+          @params[:include] = trim_sideloads(include_hash)
+        end
+        collect_params(@query)
+        @params[:sort] = @sorts.join(',') if @sorts.present?
+        @params[:filter] = @filters if @filters.present?
+        @params[:page] = @pagination if @pagination.present?
+        @params[:fields] = @fields if @fields.present?
+        @params[:extra_fields] = @extra_fields if @extra_fields.present?
+        @params[:stats] = @stats if @stats.present?
+        @params
+      end
+
+      private
+
+      def collect_params(query)
+        query_hash = query.hash
+        process_sorts(query_hash[:sort], query)
+        process_fields(query_hash[:fields])
+        process_extra_fields(query_hash[:extra_fields])
+        process_filters(query_hash[:filter], query)
+        process_pagination(query_hash[:page], query)
+        process_stats(query_hash[:stats])
+
+        query.sideloads.each_pair do |assn_name, nested_query|
+          unless @resource.class.sideload(assn_name)
+            collect_params(nested_query)
+          end
+        end
+      end
+
+      def process_stats(stats)
+        return unless stats.present?
+        @stats = { stats.keys.first => stats.values.join(',') }
+      end
+
+      def process_pagination(page, query)
+        return unless page.present?
+        if size = page[:size]
+          key = (query.chain + [:size]).join('.')
+          @pagination[key.to_sym] = size
+        end
+        if number = page[:number]
+          key = (query.chain + [:number]).join('.')
+          @pagination[key.to_sym] = number
+        end
+      end
+
+      def process_filters(filters, query)
+        return unless filters.present?
+        filters.each_pair do |att, config|
+          att = (query.chain + [att]).join('.')
+          @filters[att.to_sym] = config
+        end
+      end
+
+      def process_fields(fields)
+        return unless fields
+        @fields[fields.keys.first.to_sym] = fields.values.join(',')
+      end
+
+      def process_extra_fields(fields)
+        return unless fields
+        @extra_fields[fields.keys.first.to_sym] = fields.values.join(',')
+      end
+
+      def process_sorts(sorts, query)
+        return unless sorts
+
+        if sorts.is_a?(String) # manually assigned
+          @sorts << sorts
+        else
+          sorts.each do |s|
+            sort = (query.chain + [s.keys.first]).join('.')
+            sort = "-#{sort}" if s.values.first == :desc
+            @sorts << sort
+          end
+        end
+      end
+
+      # Do not pass local sideloads to the remote endpoint
+      def trim_sideloads(include_hash)
+        return unless include_hash.present?
+
+        include_hash.each_pair do |assn_name, nested|
+          sideload = @resource.class.sideload(assn_name)
+          if sideload && !sideload.shared_remote?
+            include_hash.delete(assn_name)
+          end
+        end
+        JSONAPI::IncludeDirective.new(include_hash).to_string
+      end
+    end
+  end
+end

data/lib/graphiti/util/remote_serializer.rb

@@ -0,0 +1,53 @@
+module Graphiti
+  module Util
+    class RemoteSerializer
+      def self.for(base, models)
+        new(base).generate(models)
+      end
+
+      def initialize(base)
+        @serializer = ::Class.new(base)
+        @serializer.type { @object._type }
+      end
+
+      def generate(models)
+        models.each do |model|
+          model.to_h.each_pair do |key, value|
+            if key == :_relationships
+              add_relationships(value)
+            else
+              @serializer.attribute(key) if add_attribute?(model, key)
+            end
+          end
+        end
+        post_process(@serializer, models)
+        @serializer
+      end
+
+      private
+
+      def add_relationships(relationship_hash)
+        relationship_hash.each_pair do |name, reldata|
+          @serializer.relationship(name.to_sym)
+        end
+      end
+
+      def add_attribute?(model, name)
+        disallow = [:_type, :id].include?(name)
+        pre_existing = @serializer.attribute_blocks[name]
+        is_relationship = model._relationships.try(:[], name.to_s)
+        !disallow && !pre_existing && !is_relationship
+      end
+
+      def post_process(serializer, models)
+        models.each do |model|
+          model.delete_field(:_relationships)
+          # If this isn't set, Array(resources) will return []
+          # This is important, because jsonapi-serializable makes this call
+          model.instance_variable_set(:@__graphiti_resource, 1)
+          model.instance_variable_set(:@__graphiti_serializer, serializer)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/version.rb

@@ -1,3 +1,3 @@
 module Graphiti
-  VERSION = "1.0.rc.2"
+  VERSION = "1.0.rc.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphiti
 version: !ruby/object:Gem::Version
-  version: 1.0.rc.2
+  version: 1.0.rc.3
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-01-08 00:00:00.000000000 Z
+date: 2019-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jsonapi-serializable
@@ -86,6 +86,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '6'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.15'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -260,6 +274,7 @@ files:
 - lib/graphiti/adapters/active_record/has_one_sideload.rb
 - lib/graphiti/adapters/active_record/inferrence.rb
 - lib/graphiti/adapters/active_record/many_to_many_sideload.rb
+- lib/graphiti/adapters/graphiti_api.rb
 - lib/graphiti/adapters/null.rb
 - lib/graphiti/base.rb
 - lib/graphiti/cli.rb
@@ -286,6 +301,7 @@ files:
 - lib/graphiti/resource/links.rb
 - lib/graphiti/resource/persistence.rb
 - lib/graphiti/resource/polymorphism.rb
+- lib/graphiti/resource/remote.rb
 - lib/graphiti/resource/sideloading.rb
 - lib/graphiti/resource_proxy.rb
 - lib/graphiti/responders.rb
@@ -320,6 +336,8 @@ files:
 - lib/graphiti/util/link.rb
 - lib/graphiti/util/persistence.rb
 - lib/graphiti/util/relationship_payload.rb
+- lib/graphiti/util/remote_params.rb
+- lib/graphiti/util/remote_serializer.rb
 - lib/graphiti/util/serializer_attributes.rb
 - lib/graphiti/util/serializer_relationships.rb
 - lib/graphiti/util/sideload.rb