graphiti-activegraph 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0928b60dbd846d64a29c21e84023b471b619e437261e1d8b77f840e5c633dd81'
-  data.tar.gz: 69afd454fcf50c4ffa50930de69bea8d182c5e32681c9be2c9c33b676719f102
+  metadata.gz: c387f138fe40ab7a304c5d587a0281258e2bf4e8304d7e0f0967295adeeef6d7
+  data.tar.gz: 6154b76796fef327e488b722d1075b05f448be9fd499e4b8525e58b3544399d0
 SHA512:
-  metadata.gz: b6675d6ee443f716836b6ce3680597d2ee9abcb5ff5999ba8cd452d03128d3794a5f0bc663d311d99401f4549887f77347be86d0fc84430c5b5b3e869b0bcf10
-  data.tar.gz: 1f972ef62c9bf15ba0b0881206cb09bcb5986a8cd2f28875d703e3d372d61ce89e19cf12f049b6609416ead6d52704185f5791554e5967631d90327ef610e52a
+  metadata.gz: 16cf1d53448e132be9dd3c45dc755f933f434114dc13d7414b3670becaf97c4696ba0c57e3f10075f984b60516d1286d3ccee01bad8baa4bc2bad1143ea1d1f4
+  data.tar.gz: 69a336f08b80474be83a0d0111e74a7cfbed451e5dc3ca2dba41318e3212c0e10565f799be327fdc9a26eed111b7ef1a7a46d90f24e85151a4f0d1e719b909d9

data/CHANGELOG.md

@@ -7,6 +7,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.0] - 2025-05-2
+
+### Added
+
+- **Deep sideloading**: introduced Include scoping class to support deep sideloading using single query (e.g. include='author.posts')
+- **Deep sorting**: added SortNormalizer to support sorting by deep sideloaded resource's attribute (e.g. sort='author.posts.title')
+- **Links control**: Control the links(pagination and resource) in response via request query params (pagination_links=true|false, links=true|false)
+
 ## [1.0.0] - 2025-03-18
 
 ### Added

data/README.md

@@ -4,7 +4,7 @@
 
 An adapter to make Graphiti work with the ActiveGraph(former Neo4jrb) OGM. This gem allows you to easily build [jsonapi.org](https://jsonapi.org) compatible APIs for GraphDB using [Graphiti](https://www.graphiti.dev) and [ActiveGraph](https://github.com/neo4jrb/activegraph). 
 
-### Installation
+## Installation
 Add this line to your application's `Gemfile`:
 ```ruby
 gem 'graphiti-activegraph'
@@ -20,7 +20,6 @@ Or install it yourself as:
 gem install graphiti-activegraph
 ```
 
-
 ## Usage
 While defining a Resource class, inherit it from `Graphiti::ActiveGraph::Resource`
 ```ruby
@@ -34,28 +33,42 @@ class RelationshipBackedResource < Graphiti::ActiveGraph::Resource
 end
 ```
 
-### Documentation
-##### **Key Differences from Graphiti**
-- **Efficient Sideloading:**
+## Documentation
+### Key Differences from Graphiti
+#### Efficient Sideloading:
 Unlike Graphiti, which executes multiple queries for sideloading, graphiti-activegraph leverages `with_ordered_associations` from ActiveGraph to fetch sideloaded data in a single query, improving performance.
 
-- **Sideposting Behavior:**
+#### Sideposting Behavior:
 graphiti-activegraph allows assigning and unassigning relationships via sideposting but does not support modifying a resource’s attributes through sideposting.
 
-- **Thread Context Handling:**
+#### Thread Context Handling:
 Graphiti stores context using `Thread.current[]`, which does not persist across different fibers within the same thread. In graphiti-activegraph, when running on MRI (non-JRuby environments), the gem uses `thread_variable_get` and `thread_variable_set`. Ensuring the context remains consistent across different fibers in the same thread.
 
-##### **New Features in graphiti-activegraph**
-###### Rendering Preloaded Objects Without Extra Queries
+### New Features in graphiti-activegraph
+#### Rendering Preloaded Objects Without Extra Queries
 graphiti-activegraph introduces two new methods on the Graphiti resource class:
 `with_preloaded_obj(record, params)` – Renders a single preloaded ActiveGraph object without querying the database.
 `all_with_preloaded(records, params)` – Renders multiple preloaded ActiveGraph objects without additional queries.
 **Note:** These methods assume that the provided records are final and will not apply Graphiti’s filtering, sorting, or scoping logic.
 
-### Contributing
+#### Efficient Deep Sorting
+Graphiti does not natively support deep sorting (i.e., sorting based on attributes of associated resources), `graphiti-activegraph` adds this feature by allowing you to chain associations using dot (.) notation.
+For example, to sort Post records based on their Author's Country's name, you can use following query string:
+```
+sort=author.country.name&include=author.country
+```
+Here, `Author` and `Country` are associated resources, and `name` is an attribute on `Country`. The posts will be sorted by the country's name. You can chain any number of associations in this way to achieve deep sorting.
+Note: The `include` parameter must be present and include the full association path (`author.country`) for the sorting to work correctly.
+
+#### Response Payload Links control
+Control the links in response payload via request query params:
+- `pagination_links=true|false` — toggle top-level pagination links
+- `links=true|false` — toggle links inside each resource object
+
+## Contributing
 Bug reports and pull requests are welcome on GitHub at https://github.com/mrhardikjoshi/graphiti-activegraph. This project is intended to be a safe, welcoming space for collaboration.
 
-### Release
+## Release
 1. Make sure version file is updated/incremented in master branch
 2. git checkout master
 3. git pull origin master
@@ -64,5 +77,5 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/mrhard
 6. gem build graphiti-activegraph.gemspec
 7. gem push graphiti-activegraph-1.2.3.gem
 
-### License
+## License
 The gem is available as open-source under the terms of the MIT License.

data/graphiti-activegraph.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'graphiti', '>= 1.6.4'
   spec.add_dependency 'activegraph', '>= 12.0.0.beta.5'
+  spec.add_dependency 'parslet', '>= 2.0.0'
+  spec.add_dependency 'activegraph-extensions', '>= 0.1.0'
 
   spec.add_development_dependency 'graphiti_spec_helpers', '>= 1.0.0'
   spec.add_development_dependency 'standard'

data/lib/graphiti/active_graph/jsonapi_ext/include_directive.rb

@@ -0,0 +1,66 @@
+module Graphiti::ActiveGraph::JsonapiExt
+  class IncludeDirective < JSONAPI::IncludeDirective
+    attr_accessor :length, :retain_rel_limit
+
+    def initialize(include_args, options = {})
+      include_hash = JSONAPI::IncludeDirective::Parser.parse_include_args(include_args)
+      @retain_rel_limit = options.delete(:retain_rel_limit)
+      @hash = formulate_hash(include_hash, options)
+      @options = options
+    end
+
+    def keys
+      super.select(&method(:key?))
+    end
+
+    alias get []
+
+    def key?(key)
+      super && get(key).valid_length?
+    end
+
+    def [](key)
+      super&.descend(key) || {}
+    end
+
+    def descend(key)
+      length && length != '' ? dup.tap { |dup| dup.add_self_reference(key, length.to_i - 1) } : self
+    end
+
+    def valid_length?
+      length.nil? || length == '' || length.to_i.positive?
+    end
+
+    def to_hash
+      @hash.each_with_object({}) do |(key, value), hash|
+        key = "#{key}*#{value.length}".to_sym if value.length
+        hash[key] = value.to_hash unless value == self
+      end
+    end
+
+    def add_self_reference(key, length)
+      @hash = @hash.merge(key => self)
+      self.length = length
+    end
+
+    private
+
+    def formulate_hash(include_hash, options)
+      include_hash.each_with_object({}) do |(key, value), hash|
+        rel_name, rel_length = extract_rel_meta(key)
+
+        hash[rel_name] = self.class.new(value, options_with_retain_rel_limit(options)).tap do |directive|
+          directive.add_self_reference(rel_name, rel_length) if key.to_s.match?(/.+\*(\d*)\z/)
+        end
+      end
+    end
+
+    def extract_rel_meta(key)
+      Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(key).split_rel_length(retain_rel_limit)
+    end
+
+    def options_with_retain_rel_limit(options)
+      options.merge(retain_rel_limit:)
+    end
+  end
+end

data/lib/graphiti/active_graph/query.rb

@@ -36,12 +36,39 @@ module Graphiti::ActiveGraph
       []
     end
 
+    def include_directive
+      @include_directive ||= Graphiti::ActiveGraph::JsonapiExt::IncludeDirective.new(@include_param, retain_rel_limit: true)
+    end
+
     def parse_sort_criteria_hash(hash)
       hash.map { |key, value| [key.to_s.split('.').map(&:to_sym), value] }.to_h
     end
 
+    def links?
+      [:json, :xml, 'json', 'xml'].exclude?(params[:format]) && show_resource_links?
+    end
+
+    def pagination_links?
+      action != :find && show_pagination_links?
+    end
+
     private
 
+    def show_pagination_links?
+      return @show_pagination_links unless @show_pagination_links.nil?
+      @show_pagination_links = read_link_params(:pagination_links)
+    end
+
+    def show_resource_links?
+      return @show_resource_links unless @show_resource_links.nil?
+
+      @show_resource_links = read_link_params(:links)
+    end
+
+    def read_link_params(name)
+      ActiveModel::Type::Boolean.new.cast(params[name]) != false
+    end
+
     def sort_criteria(sort)
       sort.split(',').map(&method(:sort_hash)).map(&method(:parse_sort_criteria_hash))
     end

data/lib/graphiti/active_graph/scope.rb

@@ -14,6 +14,7 @@ module Graphiti
       end
 
       def append_scopings(opts)
+        add_scoping(:include, Scoping::Include, opts)
         add_scoping(:association_eagerload, Scoping::AssociationEagerLoad, opts)
       end
 

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

@@ -1,6 +1,5 @@
 module Graphiti::ActiveGraph
   module Scoping
-    # Handles sideloading via scoping instead of sideloading query as in original jsonapi_suite
     class AssociationEagerLoad < Graphiti::Scoping::Base
       def custom_scope
         nil

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

@@ -0,0 +1,43 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    # Handles sideloading via scoping instead of sideloading query as in original jsonapi_suite
+    # This avoids extra queries for fetching sideload
+    class Include < Graphiti::Scoping::Base
+      include Internal::SortingAliases
+
+      def custom_scope
+        nil
+      end
+
+      def apply_standard_scope
+        return scope if normalized_includes.empty?
+        self.scope = resource.handle_includes(scope, normalized_includes, normalized_sorts,
+                                              with_vars: with_vars_for_sort, paginate: paginate?)
+      end
+
+      private
+
+      attr_accessor :scope
+
+      def query
+        @opts[:query_obj]
+      end
+
+      def paginate?
+        Graphiti::Scoping::Paginate.new(@resource, @query_hash, scope, @opts).apply?
+      end
+
+      def normalized_sorts
+        Internal::SortNormalizer.new(scope).normalize(normalized_includes, query.sorts, query.deep_sort)
+      end
+
+      def include_normalizer
+        Internal::IncludeNormalizer
+      end
+
+      def normalized_includes
+        @normalized_includes ||= include_normalizer.new(resource.class, scope, query_hash[:fields]).normalize(query.include_hash)
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/include_normalizer.rb

@@ -0,0 +1,82 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      class IncludeNormalizer
+        include SparseFieldsEagerloading
+
+        def initialize(resource_class, scope, fields)
+          @scope = scope
+          @resource_class = resource_class
+          @fields = fields
+        end
+
+        def normalize(include_hash)
+          normalize_includes(@scope, include_hash, @resource_class)
+        end
+
+        private
+
+        def normalize_includes(scope, include_hash, resource_class)
+          includes_array = include_hash.map do |key, value|
+            normalize_include(scope, key, value, resource_class)
+          end
+          add_relationships_from_sparse_fields(scope, includes_array)
+          deep_merge_hashes(includes_array.compact).to_h
+        end
+
+        def deep_merge_hashes(includes_array)
+          includes_array.each_with_object({}) do |(key, value), mapping|
+            mapping[key] = mapping[key] ? mapping[key].deep_merge(value) : value
+          end.to_a
+        end
+
+        def normalize_include(scope, key, value, resource_class)
+          rel_name = rel_name_sym(key)
+
+          if scope.associations.key?(rel_name)
+            [key, normalize_includes(scope.send(rel_name), value, find_resource_class(resource_class, rel_name, scope))]
+          elsif (custom_eagerload = resource_class&.custom_eagerload(rel_name))
+            handle_custom_eagerload(scope, custom_eagerload)
+          else
+            include_for_rel(scope, rel_name, value, resource_class)
+          end
+        end
+
+        def handle_custom_eagerload(_scope, custom_eagerload)
+          JSONAPI::IncludeDirective.new(custom_eagerload).to_hash
+        end
+
+        def include_for_rel(scope, key, value, resource_class)
+          return unless association = PathDescriptor.association_for_relationship(scope.associations, rel_name: key.to_s)
+
+          limit_part = Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(value.keys.first).rel_limit
+          association_name = "#{limit_part}#{association.first}".to_sym
+          normalize_include(scope, association_name, next_non_rel_value(value), resource_class_by_rel(resource_class, association, key, scope))
+        end
+
+        def find_resource_class(resource_class, rel_name, scope)
+          target_class_name = scope.associations[rel_name]&.target_class&.model_name
+
+          resource_class&.sideload_resource_class(rel_name) ||
+            resource_class&.sideload_resource_class(target_class_name&.singular&.to_sym)
+        end
+
+        def resource_class_by_rel(resource_class, association, key, scope)
+          # in case of rel resource, for finding custom_eagerload defination
+          # if current resourceClass defination has direct association defined with opposite node of relResource
+          #   then use current resourceClass, (giving direct resourceClass more preference than relResourceClass)
+          # else use relResourceClass
+          find_resource_class(resource_class, association.first, scope) ? resource_class : resource_class&.sideload_resource_class(rel_name_sym(key))
+        end
+
+        def rel_name_sym(key)
+          Graphiti::ActiveGraph::Util::Transformers::RelationParam.new(key).rel_name_sym
+        end
+
+        def next_non_rel_value(value)
+          value.values.first || {}
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/path_descriptor.rb

@@ -0,0 +1,94 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      # Determine valid paths specified in filter and sort API params and normalize them for neo4j
+      class PathDescriptor
+        attr_reader :scope, :path, :attribute, :rel
+        delegate :relationship_class, to: :rel, allow_nil: true
+
+        def initialize(scope, rel)
+          self.scope = scope
+          self.path = []
+          self.attribute = :id
+          self.rel = rel
+          @has_next = true
+        end
+
+        def next?
+          @has_next
+        end
+
+        def increment(key)
+          raise Exception, 'no continuation on path possible' unless next?
+          if rel
+            increment_from_cache(key)
+          else
+            increment_from_scope(key)
+          end
+        end
+
+        def declared_property
+          (relationship_class || scope).attributes[attribute]
+        end
+
+        def self.parse(scope, path, rel = nil)
+          path_desc = new(scope, rel)
+          path_desc.increment(path.shift) while path_desc.next? && path.present?
+          path_desc if path.empty?
+        end
+
+        def self.association_for_relationship(associations, key)
+          key_class_name = key[:rel_name].classify
+          key_assoc_name = key[:rel_name].gsub('_rel', '')
+          assocs = associations.find_all { |_, value| value.relationship_class_name == key_class_name || value.name.to_s == key_assoc_name }
+          assocs.size == 1 ? assocs.first : nil
+        end
+
+        def path_relationships
+          path.map { |elm| elm[:rel_name].to_sym }
+        end
+
+        private
+
+        attr_writer :scope, :path, :attribute, :rel
+
+        def increment_from_cache(key)
+          rel_name = key[:rel_name]
+          if rel.target_class_names.map(&:demodulize).map(&:downcase).include?(rel_name)
+            self.rel = nil
+          else
+            final_attribute(rel_name)
+          end
+        end
+
+        def increment_from_scope(key)
+          associations = scope.associations
+          if associations.key?(key[:rel_name].to_sym)
+            advance(key)
+          else
+            increment_from_rel(self.class.association_for_relationship(associations, key), key)
+          end
+        end
+
+        def increment_from_rel(entry, key)
+          if entry
+            advance(rel_name: entry.first.to_s)
+            self.rel = entry.last
+          else
+            final_attribute(key[:rel_name])
+          end
+        end
+
+        def advance(key)
+          path << key
+          self.scope = scope.send(key[:rel_name], rel_length: key[:rel_length])
+        end
+
+        def final_attribute(key)
+          self.attribute = key
+          @has_next = false
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/sort_normalizer.rb

@@ -0,0 +1,54 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      class SortNormalizer
+        attr_reader :scope
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def normalize(includes_hash, sorts, deep_sorts)
+          normalized_deep_sort = normalize_deep_sort(includes_hash, deep_sorts || [])
+          normalized_base_sort = normalize_base_sort(sorts)
+          normalized_deep_sort.merge(normalized_base_sort)
+        end
+
+        def normalize_base_sort(sorts)
+          sorts.present? ? { '' => sorts.map { |sort| "#{sort.keys.first} #{sort.values.first}" } } : {}
+        end
+
+        def normalize_deep_sort(includes_hash, sorts)
+          sorts
+            .map { |sort| sort(includes_hash, sort) }
+            .compact
+            .group_by(&:first)
+            .map { |key, value| combined_order_spec(key, value) }
+            .to_h
+        end
+
+        private
+
+        def combined_order_spec(key, value)
+          [key.join('.'), value.map(&:last)]
+        end
+
+        def sort(includes_hash, sort)
+          path = sort.keys.first.map { |key| { rel_name: key.to_s } }
+          return nil unless (descriptor = PathDescriptor.parse(scope, path))
+
+          sort_spec(descriptor, sort.values.first) if valid_sort?(includes_hash.deep_dup, descriptor.path_relationships)
+        end
+
+        def valid_sort?(hash, rels)
+          rels.empty? || rels.all? { |rel| hash = hash[rel] || hash[:"#{rel.to_s + '*'}"] }
+        end
+
+        def sort_spec(descriptor, direction)
+          sort_attr = [descriptor.attribute, direction].join(' ')
+          [descriptor.path_relationships, descriptor.rel.present? ? { rel: sort_attr } : sort_attr]
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/sorting_aliases.rb

@@ -0,0 +1,25 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      # Carrying forward valriables from neo4j procedure call to sort with include
+      module SortingAliases
+        def with_vars_for_sort
+          [] unless add_extra_vars_to_query?
+          (deep_sort_keys + sort_keys) & resource.extra_attributes.keys
+        end
+
+        def add_extra_vars_to_query?
+          resource.extra_attributes.present? && (query.sorts.present? || query.deep_sort.present?)
+        end
+
+        def deep_sort_keys
+          (query.deep_sort || []).collect { |sort| sort.keys.first.first }
+        end
+
+        def sort_keys
+          query.sorts.collect(&:keys).flatten
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/scoping/internal/sparse_fields_eagerloading.rb

@@ -0,0 +1,28 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    module Internal
+      module SparseFieldsEagerloading
+        private
+
+        def add_relationships_from_sparse_fields(scope, includes_array)
+          return if @fields.blank?
+
+          related_fields(scope.model).each { |field_name| includes_array << process_field(field_name, scope) }
+        end
+
+        def process_field(field_name, _scope)
+          field_name
+        end
+
+        def resource_name_of(model)
+          model.model_name.plural.to_sym
+        end
+
+        def related_fields(model)
+          attr_and_rel_fields = @fields[resource_name_of(model)] || []
+          attr_and_rel_fields.select { |field_name| model.associations[field_name] }
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/util/parsers/rel_chain.rb

@@ -0,0 +1,27 @@
+module Graphiti::ActiveGraph
+  module Util
+    module Parsers
+      class RelChain < Parslet::Parser
+        VAR_CHAR = 'a-z_'
+
+        rule(:asterisk) { str('*') }
+        rule(:range) { str('..') }
+        rule(:dot) { str('.') }
+        rule(:none) { str('') }
+        rule(:number) { match('[\d]').repeat(1) }
+        rule(:number?) { number | none }
+        rule(:identifier) { match("[#{VAR_CHAR}]") >> match("[#{VAR_CHAR}0-9]").repeat(0) }
+        rule(:identifier?) { identifier | none }
+        rule(:rel_name) { identifier?.as(:rel_name) }
+        rule(:length) { asterisk.as(:ast) >> number?.maybe.as(:min) >> range.as(:range).maybe >> number?.maybe.as(:max) }
+        rule(:rel) { rel_name >> length.maybe }
+
+        rule(:rel_chain) { rel >> (dot >> rel).repeat(0) }
+        root(:rel_chain)
+
+        rule(:limit) { number?.as(:limit_digit) >> asterisk.as(:limit_ast) }
+        rule(:rel_param_rule) { limit.maybe.as(:limit_part) >> rel_name >> length.maybe.as(:length_part) }
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/util/transformers/relation_param.rb

@@ -0,0 +1,56 @@
+module Graphiti::ActiveGraph
+  module Util
+    module Transformers
+      class RelationParam
+        attr_reader :map
+
+        def initialize(relation_param_str)
+          @map = Graphiti::ActiveGraph::Util::Parsers::RelChain.new.rel_param_rule.parse(relation_param_str.to_s)
+        end
+
+        def split_rel_length(retain_rel_limit)
+          rel_name_part = if retain_rel_limit
+                            (rel_limit || '') + rel_name
+                          else
+                            rel_name_sym
+                          end
+          [rel_name_part.to_sym, rel_length_number]
+        end
+
+        def rel_name_n_length
+          "#{rel_name}#{rel_length}"
+        end
+
+        def rel_limit(limit_part = nil)
+          join(limit_part || map[:limit_part])
+        end
+
+        def rel_limit_number
+          rel_limit(map[:limit_part]&.except(:limit_ast))
+        end
+
+        def rel_name
+          map[:rel_name].to_s
+        end
+
+        def rel_name_sym
+          rel_name.to_sym
+        end
+
+        def rel_length(length_part = nil)
+          join(length_part || map[:length_part])
+        end
+
+        def rel_length_number
+          rel_length(map[:length_part]&.except(:ast))
+        end
+
+        private
+
+        def join(hash)
+          hash&.values&.map(&:to_s)&.join
+        end
+      end
+    end
+  end
+end

data/lib/graphiti/active_graph/version.rb

@@ -1,5 +1,5 @@
 module Graphiti
   module ActiveGraph
-    VERSION = '1.0.0'
+    VERSION = '1.1.0'
   end
 end

data/lib/graphiti/sidepost_configuration.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Graphiti
   module SidepostConfiguration
     extend ActiveSupport::Concern

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphiti-activegraph
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Hardik Joshi
 bindir: exe
 cert_chain: []
-date: 2025-03-21 00:00:00.000000000 Z
+date: 2025-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphiti
@@ -37,6 +37,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 12.0.0.beta.5
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: activegraph-extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: graphiti_spec_helpers
   requirement: !ruby/object:Gem::Requirement
@@ -166,6 +194,7 @@ files:
 - lib/graphiti/active_graph/extensions/resources/payload_combinable.rb
 - lib/graphiti/active_graph/extensions/resources/preloadable.rb
 - lib/graphiti/active_graph/extensions/resources/rel.rb
+- lib/graphiti/active_graph/jsonapi_ext/include_directive.rb
 - lib/graphiti/active_graph/jsonapi_ext/serializable/resource_ext.rb
 - lib/graphiti/active_graph/query.rb
 - lib/graphiti/active_graph/request_validators/validator.rb
@@ -178,10 +207,18 @@ files:
 - lib/graphiti/active_graph/scoping/association_eager_load.rb
 - lib/graphiti/active_graph/scoping/filter.rb
 - lib/graphiti/active_graph/scoping/filterable.rb
+- lib/graphiti/active_graph/scoping/include.rb
+- lib/graphiti/active_graph/scoping/internal/include_normalizer.rb
+- lib/graphiti/active_graph/scoping/internal/path_descriptor.rb
+- lib/graphiti/active_graph/scoping/internal/sort_normalizer.rb
+- lib/graphiti/active_graph/scoping/internal/sorting_aliases.rb
+- lib/graphiti/active_graph/scoping/internal/sparse_fields_eagerloading.rb
 - lib/graphiti/active_graph/sideload_resolve.rb
+- lib/graphiti/active_graph/util/parsers/rel_chain.rb
 - lib/graphiti/active_graph/util/relationship_payload.rb
 - lib/graphiti/active_graph/util/serializer_attribute.rb
 - lib/graphiti/active_graph/util/serializer_relationship.rb
+- lib/graphiti/active_graph/util/transformers/relation_param.rb
 - lib/graphiti/active_graph/version.rb
 - lib/graphiti/sidepost_configuration.rb
 homepage: https://github.com/mrhardikjoshi/graphiti-activegraph