graphiti-activegraph 0.2.0 → 1.1.0

data/lib/graphiti/active_graph/scope.rb

@@ -0,0 +1,28 @@
+module Graphiti
+  module ActiveGraph
+    class Scope < Graphiti::Scope
+      def non_applicable_for_unpaginated
+        %i[association_eagerload]
+      end
+
+      def apply_scoping(scope, opts)
+        opts[:query_obj] = @query
+        super
+
+        append_scopings(opts) unless @resource.remote?
+        @object
+      end
+
+      def append_scopings(opts)
+        add_scoping(:include, Scoping::Include, opts)
+        add_scoping(:association_eagerload, Scoping::AssociationEagerLoad, opts)
+      end
+
+      def add_scoping(key, scoping_class, opts, _ = {})
+        @object = scoping_class.new(@resource, @query.hash, @object, opts).apply
+        return if non_applicable_for_unpaginated.include?(key)
+        @unpaginated_object = scoping_class.new(@resource, @query.hash, @unpaginated_object, opts.merge(unpaginated_query: true)).apply
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Graphiti::ActiveGraph
+  module Scoping
+    class AssociationEagerLoad < Graphiti::Scoping::Base
+      def custom_scope
+        nil
+      end
+
+      def apply_standard_scope
+        return @scope unless eagerload_associations?
+        if (ids = @scope.collect(&:id)).present?
+          @opts[:query_obj].include_hash.each_key do |key|
+            eagerload_association(key, ids)
+          end
+        end
+        @scope
+      end
+
+      def eagerload_associations?
+        @opts[:query_obj].include_hash.present? && @resource.model.include?(ActiveGraph::Node) &&
+          @resource.model.associations_to_eagerload.present?
+      end
+
+      def eagerload_association(key, ids)
+        return unless @resource.model.eagerload_association?(key)
+        nodes = @resource.model.association_nodes(key, ids, @resource.context.send(:association_filter_params))
+        @scope.each { |node| node.send("#{key}=", nodes[node.id] || nil_or_empty(key)) }
+      end
+
+      def nil_or_empty(key)
+        @resource.class.config[:sideloads][key].type == :has_one ? nil : []
+      end
+    end
+  end
+end

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 = '0.2.0'
+    VERSION = '1.1.0'
   end
 end

data/lib/graphiti/sidepost_configuration.rb

@@ -1,8 +1,7 @@
-# frozen_string_literal: true
-
 module Graphiti
   module SidepostConfiguration
     extend ActiveSupport::Concern
+
     included do
       attr_accessor :allow_sidepost
     end

data/lib/graphiti-activegraph.rb

@@ -20,21 +20,23 @@ loader.ignore(File.expand_path('graphiti-activegraph.rb', __dir__))
 loader.setup
 
 Graphiti::Scoping::Filterable.prepend Graphiti::ActiveGraph::Scoping::Filterable
-Graphiti::Resource::Persistence.prepend Graphiti::ActiveGraph::Resource::Persistence
-Graphiti::Resource::Interface::ClassMethods.prepend Graphiti::ActiveGraph::Resource::Interface::ClassMethods
+Graphiti::Resource::Persistence.prepend Graphiti::ActiveGraph::Resources::Persistence
+Graphiti::Resource::Interface::ClassMethods.prepend Graphiti::ActiveGraph::Resources::Interface::ClassMethods
 require 'graphiti'
 Graphiti::Scoping::Filter.prepend Graphiti::ActiveGraph::Scoping::Filter
 Graphiti::Util::SerializerRelationship.prepend Graphiti::ActiveGraph::Util::SerializerRelationship
 Graphiti::Util::SerializerAttribute.prepend Graphiti::ActiveGraph::Util::SerializerAttribute
 Graphiti::Util::RelationshipPayload.prepend Graphiti::ActiveGraph::Util::RelationshipPayload
 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
 Graphiti::Configuration.include Graphiti::SidepostConfiguration
 Graphiti::RequestValidators::Validator.prepend Graphiti::ActiveGraph::RequestValidators::Validator
 
+unless RUBY_PLATFORM == 'java'
+  Graphiti.prepend Graphiti::ActiveGraph::Extensions::Context
+end
+
 # JSONAPI extensions
 JSONAPI::Serializable::Resource.prepend Graphiti::ActiveGraph::JsonapiExt::Serializable::ResourceExt

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphiti-activegraph
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Hardik Joshi
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-01-27 00:00:00.000000000 Z
+date: 2025-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphiti
@@ -38,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
@@ -80,6 +107,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffaker
+  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: factory_bot_rails
+  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
@@ -108,7 +163,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.9.0
-description: 
 email:
 - hardikjoshi1991@gmail.com
 executables: []
@@ -119,8 +173,10 @@ files:
 - ".gitignore"
 - ".rspec"
 - CHANGELOG.md
+- CHANGELOG_PRE_1.0.0.md
 - Gemfile
 - LICENSE.txt
+- README.md
 - graphiti-activegraph.gemspec
 - lib/graphiti-activegraph.rb
 - lib/graphiti/active_graph/adapters/active_graph.rb
@@ -131,29 +187,44 @@ files:
 - lib/graphiti/active_graph/adapters/active_graph/sideload.rb
 - lib/graphiti/active_graph/concerns/path_relationships.rb
 - lib/graphiti/active_graph/deserializer.rb
+- lib/graphiti/active_graph/extensions/context.rb
 - lib/graphiti/active_graph/extensions/grouping/params.rb
 - lib/graphiti/active_graph/extensions/query_params.rb
+- lib/graphiti/active_graph/extensions/resources/authorizationable.rb
+- 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
 - lib/graphiti/active_graph/resource.rb
-- lib/graphiti/active_graph/resource/interface.rb
-- lib/graphiti/active_graph/resource/persistence.rb
 - lib/graphiti/active_graph/resource_proxy.rb
+- lib/graphiti/active_graph/resources/interface.rb
+- lib/graphiti/active_graph/resources/persistence.rb
 - lib/graphiti/active_graph/runner.rb
+- lib/graphiti/active_graph/scope.rb
+- 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
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -168,8 +239,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Easily build jsonapi.org-compatible APIs for GraphDB
 test_files: []