graphiti-activegraph 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 788e448fa1ea2a64247650cb77402a7518ae543789ea8259240fdb60f7469340
+  data.tar.gz: 899272d03b3f1b78fa3567ae6fd02a0bb9386c39544ae8e2ff649c6de022b8ef
+SHA512:
+  metadata.gz: 4c071b303b06a2d8bd78a601b212a2f9ca546be2012fb22f064eb8389232824598d0b8d2366df7e4496d3325360aa5071b8188f703e5ca2b72c7dfd9570163e7
+  data.tar.gz: c4a43e4604cb2f283a79f8bc42e9c43648f9f3ae6af52981bbec3365a1ba9b1f298d3a45ce0842dd09b0e1536d8c5573da3b0f6c3db73f07c2baa282176b1896

data/.gitignore

@@ -0,0 +1,56 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+# .rubocop-https?--*

data/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "zeitwerk"
+
+group :test do
+  gem "pry"
+  gem "appraisal"
+  gem "guard"
+  gem "guard-rspec"
+end

data/graphiti-activegraph.gemspec

@@ -0,0 +1,33 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "graphiti/active_graph/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "graphiti-activegraph"
+  spec.version       = Graphiti::ActiveGraph::VERSION
+  spec.authors       = ["Hardik Joshi"]
+  spec.email         = ["hardikjoshi1991@gmail.com"]
+
+  spec.summary       = "Easily build jsonapi.org-compatible APIs for GraphDB"
+  spec.homepage      = "https://github.com/mrhardikjoshi/graphiti-activegraph"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = "~> 2.3"
+
+  spec.add_dependency "graphiti", "~> 1.2.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.0"
+  spec.add_dependency "activesupport", ">= 4.1"
+  spec.add_dependency "zeitwerk"
+
+  spec.add_development_dependency "faraday", "~> 0.15"
+  spec.add_development_dependency "kaminari", "~> 0.17"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "activemodel", ">= 4.1"
+  spec.add_development_dependency "graphiti_spec_helpers", "1.0.beta.4"
+  spec.add_development_dependency "standard"
+end

data/lib/graphiti-activegraph.rb

@@ -0,0 +1,32 @@
+require 'graphiti'
+require 'zeitwerk'
+
+# Workaround for missing zeitwerk support as of jruby-9.2.13.0
+module Graphiti
+  module ActiveGraph
+    module Scoping
+    end
+    module Adapters
+    end
+    module Util
+    end
+  end
+end
+# End workaround
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect 'version' => 'VERSION'
+loader.ignore(File.expand_path('graphiti-activegraph.rb', __dir__))
+loader.setup
+
+Graphiti::Resource::Persistence.prepend Graphiti::ActiveGraph::Resource::Persistence
+Graphiti::Scoping::Filter.prepend Graphiti::ActiveGraph::Scoping::Filter
+Graphiti::Scoping::Filterable.prepend Graphiti::ActiveGraph::Scoping::Filterable
+Graphiti::Util::SerializerRelationship.prepend Graphiti::ActiveGraph::Util::SerializerRelationship
+Graphiti::Deserializer.prepend Graphiti::ActiveGraph::Deserializer
+Graphiti::Query.prepend Graphiti::ActiveGraph::Query
+Graphiti::Resource.prepend Graphiti::ActiveGraph::ResourceInstanceMethods
+Graphiti::Resource.extend Graphiti::ActiveGraph::Resource
+Graphiti::ResourceProxy.prepend Graphiti::ActiveGraph::ResourceProxy
+Graphiti::Runner.prepend Graphiti::ActiveGraph::Runner
+Graphiti::Scope.prepend Graphiti::ActiveGraph::SideloadResolve

data/lib/graphiti/active_graph/adapters/active_graph.rb

@@ -0,0 +1,169 @@
+module Graphiti::ActiveGraph
+  module Adapters
+    class ActiveGraph < ::Graphiti::Adapters::Abstract
+      def self.sideloading_classes
+        {
+          has_many: Graphiti::ActiveGraph::Adapters::ActiveGraph::HasManySideload,
+          has_one: Graphiti::ActiveGraph::Adapters::ActiveGraph::HasOneSideload
+        }
+      end
+
+      def base_scope(model)
+        model.all
+      end
+
+      def assign_attributes(model_instance, attributes)
+        model_instance.before_assign_resource_attr if model_instance.respond_to?(:before_assign_resource_attr)
+
+        attributes.each_pair do |k, v|
+          model_instance.send(:"#{k}=", v) if model_instance.respond_to?(:"#{k}=")
+        end
+      end
+
+      def paginate(scope, current_page, per_page)
+        scope.skip((current_page - 1) * per_page).limit(per_page)
+      end
+
+      def transaction(_model_class)
+        ::ActiveGraph::Base.transaction do
+          yield
+        end
+      end
+
+      def order(scope, attribute, direction, extra_field = false)
+        if extra_field
+          scope.query.order("#{attribute} #{direction}").proxy_as(scope.model, scope.identity)
+        else
+          scope.order(attribute => direction)
+        end
+      end
+
+      def count(scope, _attr)
+        scope.skip(0).limit(nil).count
+      end
+
+      def save(model_instance)
+        model_instance.save
+        model_instance
+      end
+
+      def destroy(model_instance)
+        model_instance.destroy
+        model_instance
+      end
+
+      def resolve(scope)
+        scope.to_a
+      end
+
+      # def associate_all(parent, children, association_name, association_type)
+      #   if association_type == :has_many
+      #     if !parent.send(:"#{association_name}").present?
+      #       parent.send(:"#{association_name}=", children)
+      #     else
+      #       parent.send(:"#{association_name}") << children
+      #     end
+      #   else
+      #     parent.send(:"#{association_name}=", children)
+      #   end
+      # end
+
+      def process_belongs_to(persistence, attributes)
+        []
+      end
+
+      def process_has_many(persistence, caller_model)
+        []
+      end
+
+      def persistence_attributes(persistence, attributes)
+        rel_attrs = {}
+        @persistence = persistence
+
+        del_empty_rels(rel_attrs) unless resource.relation_resource?
+        attributes_for_has_one(rel_attrs)
+        attributes_for_has_many(rel_attrs)
+
+        attributes.merge rel_attrs
+      end
+
+      def associate(parent, child, association_name, type)
+      end
+
+      def disassociate(parent, child, association_name, type)
+        parent.send(:"#{association_name}=", nil)
+      end
+
+      def clear_active_connections!
+      end
+
+      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
+      alias filter_uuid_eq filter_eq
+      alias filter_enum_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
+      alias filter_uuid_not_eq filter_not_eq
+      alias filter_enum_not_eq filter_not_eq
+
+      private
+
+      def del_empty_rels(rel_attrs)
+        relationships = @persistence.instance_variable_get(:@relationships)
+        relationships.each do |rel_name, rel_data|
+          rel_attrs[rel_name] = nil if rel_data.blank?
+        end
+      end
+
+      def attributes_for_has_one(rel_attrs)
+        @persistence.iterate(only: [:has_one]) do |x|
+          process_relationship_attrs(x, rel_attrs, false)
+        end
+      end
+
+      def attributes_for_has_many(rel_attrs)
+        @persistence.iterate(only: [:has_many]) do |x|
+          process_relationship_attrs(x, rel_attrs, true)
+        end
+      end
+
+      def process_relationship_attrs(x, rel_attrs, assign_multiple)
+        x[:object] = x[:resource]
+          .persist_with_relationships(x[:meta], x[:attributes], x[:relationships], self, x[:foreign_key])
+
+        resource = @persistence.instance_variable_get(:@resource)
+        meta = @persistence.instance_variable_get(:@meta)
+        # Relationship start/end nodes cannot be changed once persisted
+        unless meta[:method] == :update && resource.relation_resource?
+          if assign_multiple
+            rel_attrs[x[:foreign_key]] ||= []
+            rel_attrs[x[:foreign_key]] << resource_association_value(x)
+          else
+            rel_attrs[x[:foreign_key]] = resource_association_value(x)
+          end
+        end
+      end
+
+      def resource_association_value(rel_map)
+        if [:destroy, :disassociate].include?(rel_map[:meta][:method]) || rel_map[:attributes].blank?
+          nil
+        else
+          rel_map[:object]
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/adapters/active_graph/has_many_sideload.rb

@@ -0,0 +1,15 @@
+class Graphiti::ActiveGraph::Adapters::ActiveGraph::HasManySideload < Graphiti::Sideload::HasMany
+  include Graphiti::ActiveGraph::Adapters::ActiveGraph::Sideload
+
+  def default_base_scope
+    resource_class.model.all
+  end
+
+  def infer_foreign_key
+    association_name.to_sym
+  end
+
+  def default_value_when_empty
+    []
+  end
+end

data/lib/graphiti/active_graph/adapters/active_graph/has_one_sideload.rb

@@ -0,0 +1,15 @@
+class Graphiti::ActiveGraph::Adapters::ActiveGraph::HasOneSideload < Graphiti::Sideload::HasOne
+  include Graphiti::ActiveGraph::Adapters::ActiveGraph::Sideload
+
+  def default_base_scope
+    resource_class.model.all
+  end
+
+  def infer_foreign_key
+    association_name.to_sym
+  end
+
+  def default_value_when_empty
+    nil
+  end
+end

data/lib/graphiti/active_graph/adapters/active_graph/sideload.rb

@@ -0,0 +1,68 @@
+module Graphiti::ActiveGraph::Adapters::ActiveGraph::Sideload
+  def self.included(base)
+    base.class_eval do
+      class_attribute :sideload_scope
+    end
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def sideload_scope(&blk)
+      self.sideload_scope = blk
+    end
+  end
+
+  # def base_scope
+  #   if @base_scope
+  #     @base_scope.respond_to?(:call) ? @base_scope.call : @base_scope
+  #   else
+  #     resource.base_scope
+  #   end
+  # end
+
+  # def load(parents, query, graph_parent)
+  #   params, opts, proxy = nil, nil, nil
+
+  #   with_error_handling Errors::SideloadParamsError do
+  #     params = load_params(parents, query)
+  #     params_proc&.call(params, parents, context)
+  #     return [] if blank_query?(params)
+  #     opts = load_options(parents, query)
+  #     opts[:sideload] = self
+  #     opts[:parent] = graph_parent
+  #   end
+
+  #   with_error_handling(Errors::SideloadQueryBuildingError) do
+  #     proxy = resource.class._all(params, opts, base_scope)
+  #     pre_load_proc&.call(proxy, parents)
+  #   end
+
+  #   proxy.to_a
+  # end
+
+  # def load(parents, _, _)
+  #   child_arr = []
+  #   @child_map = resource_with_parent_assoc(parents).each_with_object({}) do |arr, hash|
+  #     child_obj = arr.first
+  #     parent_uuid = arr.last
+  #     hash[parent_uuid] ||= []
+  #     hash[parent_uuid] << child_obj
+  #     child_arr << child_obj
+  #   end
+
+  #   fire_assign(parents, child_arr)
+  #   child_arr
+  # end
+
+  # def resource_with_parent_assoc(parents)
+  #   parent_ids = parents.pluck(:id)
+  #   proxy = parent_resource_class.model.as(:p).where(id: parent_ids)
+  #   scope = self.class.sideload_scope
+
+  #   if scope.present?
+  #     scope.call(proxy)
+  #   else
+  #     proxy.send(association_name, :children)
+  #   end.query.pluck(:children, p: :neo_id)
+  # end
+end

data/lib/graphiti/active_graph/deserializer.rb

@@ -0,0 +1,132 @@
+module Graphiti::ActiveGraph
+  module Deserializer
+    class Conflict < StandardError
+      attr_reader :key, :path_value, :body_value
+
+      def initialize(key, path_value, body_value)
+        @key = key
+        @path_value = path_value
+        @body_value = body_value
+      end
+
+      def message
+        "Path parameter #{key} with value '#{path_value}' conflicts with payload value '#{body_value}'"
+      end
+    end
+
+    def initialize(payload, env=nil, model=nil, parent_map=nil)
+      super(payload)
+
+      if data.blank? && env && JsonApiNonParsableMiddleware.parsable_content?(env)
+        raise ArgumentError, "JSON API payload must contain the 'data' key"
+      end
+
+      @params = payload
+      @model = model
+      @parent_map = parent_map || {}
+      @env = env
+    end
+
+    def process_relationships(relationship_hash)
+      {}.tap do |hash|
+        relationship_hash.each_pair do |name, relationship_payload|
+          name = name.to_sym
+          data_payload = relationship_payload[:data]
+          hash[name] = data_payload.nil? ? process_nil_relationship(name) : process_relationship(relationship_payload[:data])
+        end
+      end
+    end
+
+    # change empty relationship as `disassociate` hash so they will be removed
+    def process_nil_relationship(name)
+      attributes = {}
+      method_name = :disassociate
+
+      {
+        meta: {
+          jsonapi_type: name.to_sym,
+          method: method_name
+        },
+        attributes: attributes,
+        relationships: {}
+      }
+    end
+
+    def meta(action: nil)
+      results = super
+      return results if action.present? || @env.nil?
+
+      action = case @env['REQUEST_METHOD']
+               when 'POST' then :create
+               when 'PUT', 'PATCH' then :update
+               when 'DELETE' then :destroy
+               end
+
+      results[:method] = action
+      results
+    end
+
+    def add_path_id_to_relationships!(params)
+      return params if path_relationships_updated?
+      detect_conflict(:id, @params[:id], attributes[:id])
+      path_map.each do |rel_name, path_value|
+        body_value = relationships.dig(rel_name, :attributes, :id)
+        if body_value
+          detect_conflict(rel_name, path_value.to_i, body_value&.to_i)
+        else
+          update_params(params, rel_name, path_value)
+          update_realationships(rel_name, path_value)
+        end
+      end
+      path_relationships_updated!
+      params
+    end
+
+    def path_relationships_updated!
+      @path_relationships_updated = true
+    end
+
+    def path_relationships_updated?
+      @path_relationships_updated.present?
+    end
+
+    def update_params(params, rel_name, path_value)
+      params[:data] ||= {}
+      params[:data][:relationships] ||= {}
+      params[:data][:relationships][rel_name] = {
+        data: {
+          type: rel_name.to_s,
+          id: path_value.to_i
+        }
+      }
+    end
+
+    def update_realationships(rel_name, path_value)
+      relationships[rel_name] = { meta: {}, attributes: { id: path_value.to_i } }
+    end
+
+    def path_map
+      map = @params.select { |key, _| key =~ /_id$/ }.permit!.to_h
+      map = filter_keys(map) { |key| key.gsub(/_id$/, '').to_sym }
+      map = filter_keys(map) { |key| @parent_map[key] || key }
+      map = filter_keys_presence(map) if @model < ActiveGraph::Node
+      map
+    end
+
+    def filter_keys_presence(map)
+      filter_keys(map) { |key| presence(key) || presence(key.to_s.pluralize.to_sym) }
+    end
+
+    def filter_keys(map)
+      map.map { |key, v| [yield(key), v] }.select(&:first).to_h
+    end
+
+    def presence(key)
+      key if @model.associations.include?(key)
+    end
+
+    def detect_conflict(key, path_value, body_value)
+      raise Conflict.new(key, path_value, body_value) if body_value && body_value != path_value
+    end
+  end
+end

data/lib/graphiti/active_graph/query.rb

@@ -0,0 +1,54 @@
+module Graphiti::ActiveGraph
+  module Query
+    attr_reader :deep_sort
+
+    def filters
+      @filters ||= begin
+        {}.tap do |hash|
+          (@params[:filter] || {}).each_pair do |name, value|
+            name = name.to_sym
+
+            if legacy_nested?(name)
+              value.keys.each do |key|
+                filter_name = key.to_sym
+                filter_value = value[key]
+
+                if @resource.get_attr!(filter_name, :filterable, request: true)
+                  hash[filter_name] = filter_value
+                end
+              end
+            elsif nested?(name)
+              name = name.to_s.split(".").last.to_sym
+              validate!(name, :filterable)
+              hash[name] = value
+            else
+              hash[name] = value
+            end
+          end
+        end
+      end
+    end
+
+    def sorts
+      return super unless (sort = params[:sort]) && sort.include?('.')
+
+      @deep_sort = sort_criteria(sort)
+      []
+    end
+
+    def parse_sort_criteria_hash(hash)
+      hash.map { |key, value| [key.to_s.split('.').map(&:to_sym), value] }.to_h
+    end
+
+    private
+
+    def sort_criteria(sort)
+      sort.split(',').map(&method(:sort_hash)).map(&method(:parse_sort_criteria_hash))
+    end
+
+    def update_include_hash(authorized_include_param)
+      @include_hash = authorized_include_param
+      @sideloads = nil
+    end
+  end
+end

data/lib/graphiti/active_graph/resource.rb

@@ -0,0 +1,72 @@
+module Graphiti
+  module ActiveGraph
+    module Resource
+      def relation_resource?
+        config[:relation_resource] || false
+      end
+
+      def relationship_resource=(value)
+        config[:relation_resource] = value
+      end
+
+      def with_preloaded_obj(obj, params)
+        id = params[:data].try(:[], :id) || params.delete(:id)
+        params[:filter] ||= {}
+        params[:filter][:id] = id if id
+
+        validate!(params)
+        runner = ::Graphiti::Runner.new(self, params)
+        runner.proxy(nil, single: true, raise_on_missing: false, preloaded: obj, bypass_required_filters: true)
+      end
+
+      def all_with_preloaded(obj_arr, params)
+        validate!(params)
+
+        runner = ::Graphiti::Runner.new(self, params)
+        runner.proxy(nil, raise_on_missing: false, preloaded: obj_arr)
+      end
+    end
+
+    module ResourceInstanceMethods
+      def relation_resource?
+        self.class.relation_resource?
+      end
+
+      def before_resolve(scope, query)
+        if query.params[:group_by].present?
+          scope.collect { |gp| query.params[:group_class].new(name: gp['name']) }
+        else
+          scope
+        end
+        # scope.with_associations(sideload_name_arr(query))
+      end
+
+      def sideload_name_arr(query)
+        query.sideloads.keys.map(&:to_sym)
+      end
+
+      def typecast(name, value, flag)
+        att = get_attr!(name, flag, request: true)
+
+        # in case of attribute is not declared on resource
+        # do not throw error, return original value without typecast
+        return value unless att
+
+        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
+          flag = :write if flag == :writable
+          flag = :params if [:sortable, :filterable].include?(flag)
+          type[flag][value]
+        rescue => e
+          raise Errors::TypecastFailed.new(self, name, value, e, type_name)
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/resource/persistence.rb

@@ -0,0 +1,25 @@
+module Graphiti::ActiveGraph
+  module Resource
+    module Persistence
+      def update(update_params, meta = nil)
+        model_instance = nil
+        id = update_params[:id]
+        update_params = update_params.except(:id)
+
+        run_callbacks :persistence, :update, update_params, meta do
+          run_callbacks :attributes, :update, update_params, meta do |params|
+            model_instance = id ? model.find(id) : self.class._find(id: id).data
+            call_with_meta(:assign_attributes, model_instance, params, meta)
+            model_instance
+          end
+
+          run_callbacks :save, :update, model_instance, meta do
+            model_instance = call_with_meta(:save, model_instance, meta)
+          end
+        end
+
+        model_instance
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/resource_proxy.rb

@@ -0,0 +1,84 @@
+module Graphiti::ActiveGraph
+  module ResourceProxy
+    include Graphiti::ActiveGraph::SideloadResolve
+    attr_reader :preloaded
+
+    def initialize(resource, scope, query,
+      payload: nil,
+      single: false,
+      raise_on_missing: false,
+      preloaded: false)
+      @resource = resource
+      @scope = scope
+      @query = query
+      @payload = payload
+      @single = single
+      @raise_on_missing = raise_on_missing
+      @preloaded = preloaded
+    end
+
+    def data
+      return @data if @data
+
+      return super unless @preloaded
+
+      resolve_sideloads(@preloaded)
+      @single ? data_for_preloaded_record : data_for_preloaded_records
+    end
+
+    def data_for_preloaded_record
+      @preloaded = @preloaded.is_a?(Array) ? @preloaded[0] : @preloaded
+      @resource.decorate_record(@preloaded)
+      @data = @preloaded
+    end
+
+    def data_for_preloaded_records
+      @preloaded.each do |r|
+        @resource.decorate_record(r)
+      end
+      @data = @preloaded
+    end
+
+    def stats
+      @stats ||= if @query.hash[:stats] && !resource.relation_resource?
+        payload = ::Graphiti::Stats::Payload.new @resource,
+          @query,
+          @scope.unpaginated_object,
+          data
+        payload.generate
+      else
+        {}
+      end
+    end
+
+    def save(action: :create)
+      # TODO: remove this. Only used for persisting many-to-many with AR
+      # (see activerecord adapter)
+      original = Graphiti.context[:namespace]
+      begin
+        Graphiti.context[:namespace] = action
+        ::Graphiti::RequestValidator.new(@resource, @payload.params).validate!
+        validator = persist {
+          @resource.persist_with_relationships \
+            @payload.meta(action: action),
+            @payload.attributes,
+            @payload.relationships
+        }
+      ensure
+        Graphiti.context[:namespace] = original
+      end
+      @data, success = validator.to_a
+
+      if success && !resource.relation_resource?
+        # If the context namespace is `update` or `create`, certain
+        # adapters will cause N+1 validation calls, so lets explicitly
+        # switch to a lookup context.
+        Graphiti.with_context(Graphiti.context[:object], :show) do
+          @scope.resolve_sideloads([@data])
+        end
+      end
+
+      success
+    end
+  end
+end

data/lib/graphiti/active_graph/runner.rb

@@ -0,0 +1,38 @@
+module Graphiti::ActiveGraph
+  module Runner
+    def initialize(resource_class, params, query = nil, action = nil)
+      @resource_class = resource_class
+      @params = params
+      @query = query
+      @action = action
+
+      validator = ::Graphiti::RequestValidator.new(jsonapi_resource, params)
+
+      validator.validate! unless params[:skip_render_val]
+
+      @deserialized_payload = validator.deserialized_payload
+    end
+
+    def proxy(base = nil, opts = {})
+      base ||= jsonapi_resource.base_scope
+      scope_opts = opts.slice :sideload_parent_length,
+        :default_paginate,
+        :after_resolve,
+        :sideload,
+        :parent,
+        :params
+      scope = jsonapi_scope(base, scope_opts) unless jsonapi_resource.relation_resource?
+      preloaded = opts[:preloaded] || (jsonapi_resource.relation_resource? && jsonapi_resource.base_scope)
+      options = { payload: deserialized_payload,
+        single: opts[:single],
+        raise_on_missing: opts[:raise_on_missing],
+        preloaded: preloaded
+      }
+      ::Graphiti::ResourceProxy.new jsonapi_resource,
+        scope,
+        query,
+        options
+    end
+  end
+end
+

data/lib/graphiti/active_graph/scoping/filter.rb

@@ -0,0 +1,38 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Filter
+      def each_filter
+        filter_param.each_pair do |param_name, param_value|
+          filter = find_filter!(param_name)
+
+          normalize_param(filter, param_value).each do |operator, value|
+            operator = operator.to_s.gsub("!", "not_").to_sym
+
+            # dynamic filters errors for validating and typecasting value below
+            # so they are skipped here without validation or typecast
+            filter_map = filter.values[0]
+            if filter_map[:dynamic_filter]
+              yield filter, operator, value
+              next
+            end
+            validate_operator(filter, operator)
+
+            type = ::Graphiti::Types[filter_map[:type]]
+            unless type[:canonical_name] == :hash || !value.is_a?(String)
+              value = parse_string_value(filter_map, value)
+            end
+
+            check_deny_empty_filters!(resource, filter, value)
+            value = parse_string_null(filter_map, value)
+            validate_singular(resource, filter, value)
+            value = coerce_types(filter_map, param_name.to_sym, value)
+            validate_allowlist(resource, filter, value)
+            validate_denylist(resource, filter, value)
+            value = value[0] if filter_map[:single]
+            yield filter, operator, value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/filterable.rb

@@ -0,0 +1,12 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Filterable
+      def find_filter!(name)
+        val = resource.filters[name] || {
+          operators: {}, type: :string, single: false, dynamic_filter: true
+        }
+        {name => val}
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/sideload_resolve.rb

@@ -0,0 +1,23 @@
+module Graphiti::ActiveGraph
+  module SideloadResolve
+    def resolve_sideloads(parents)
+      @query.sideloads.each_pair do |name, q|
+        sideload = @resource.class.sideload(name)
+        next if sideload.nil? || sideload.shared_remote?
+
+        if sideload.assign_each_proc
+          Array.wrap(parents).each do |parent|
+            children = sideload.assign_each_proc.call(parent) || sideload.default_value_when_empty
+
+            # currently there is no possible way to assign association on activegraph without triggering save
+            # https://github.com/neo4jrb/activegraph/issues/1445
+            # as a workaround we are using instance variable here to store and retrive associations
+            # once above issue is fixed use that fix to assign the association here
+            # and also remove 1) this code and 2) SerializerRelationship#data_proc
+            parent.instance_variable_set("@graphiti_render_#{name}", { data: children })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/util/serializer_relationship.rb

@@ -0,0 +1,29 @@
+module Graphiti::ActiveGraph
+  module Util
+    module SerializerRelationship
+      def data_proc
+        sideload_ref = @sideload
+        ->(_) {
+          # use custom assigned sideload if it is specified via "assign_each_proc"
+          # otherwise retrieve sideload using normal getter on parent object
+          custom_assigned_sideload = @object.instance_variable_get("@graphiti_render_#{sideload_ref.association_name}")
+          records = if custom_assigned_sideload.blank?
+                      @object.public_send(sideload_ref.association_name)
+                    else
+                      custom_assigned_sideload[:data]
+                    end
+
+          if records
+            if records.respond_to?(:to_ary)
+              records.each { |r| sideload_ref.resource.decorate_record(r) }
+            else
+              sideload_ref.resource.decorate_record(records)
+            end
+
+            records
+          end
+        }
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/version.rb

@@ -0,0 +1,5 @@
+module Graphiti
+  module ActiveGraph
+    VERSION = '0.1.2'
+  end
+end

metadata

@@ -0,0 +1,217 @@
+--- !ruby/object:Gem::Specification
+name: graphiti-activegraph
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Hardik Joshi
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphiti
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: kaminari
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: graphiti_spec_helpers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.beta.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.beta.4
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- hardikjoshi1991@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- graphiti-activegraph.gemspec
+- lib/graphiti-activegraph.rb
+- lib/graphiti/active_graph/adapters/active_graph.rb
+- lib/graphiti/active_graph/adapters/active_graph/has_many_sideload.rb
+- lib/graphiti/active_graph/adapters/active_graph/has_one_sideload.rb
+- lib/graphiti/active_graph/adapters/active_graph/sideload.rb
+- lib/graphiti/active_graph/deserializer.rb
+- lib/graphiti/active_graph/query.rb
+- lib/graphiti/active_graph/resource.rb
+- lib/graphiti/active_graph/resource/persistence.rb
+- lib/graphiti/active_graph/resource_proxy.rb
+- lib/graphiti/active_graph/runner.rb
+- lib/graphiti/active_graph/scoping/filter.rb
+- lib/graphiti/active_graph/scoping/filterable.rb
+- lib/graphiti/active_graph/sideload_resolve.rb
+- lib/graphiti/active_graph/util/serializer_relationship.rb
+- lib/graphiti/active_graph/version.rb
+homepage: https://github.com/mrhardikjoshi/graphiti-activegraph
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Easily build jsonapi.org-compatible APIs for GraphDB
+test_files: []