sanger-jsonapi-resources 0.1.0 → 0.2.0

data/lib/jsonapi/routing_ext.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionDispatch
   module Routing
     class Mapper
@@ -18,7 +20,13 @@ module ActionDispatch
 
         def jsonapi_resource(*resources, &_block)
           @resource_type = resources.first
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
+
+          res._routed = true
+
+          unless res.singleton?
+            warn "Singleton routes created for non singleton resource #{res}. Links may not be generated correctly."
+          end
 
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
@@ -33,8 +41,8 @@ module ActionDispatch
           end
 
           if res._immutable
-            options[:except] << :create  unless options[:except].include?(:create)  || options[:except].include?('create')
-            options[:except] << :update  unless options[:except].include?(:update)  || options[:except].include?('update')
+            options[:except] << :create unless options[:except].include?(:create) || options[:except].include?('create')
+            options[:except] << :update unless options[:except].include?(:update) || options[:except].include?('update')
             options[:except] << :destroy unless options[:except].include?(:destroy) || options[:except].include?('destroy')
           end
 
@@ -64,7 +72,7 @@ module ActionDispatch
         end
 
         def jsonapi_relationships(options = {})
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
           res._relationships.each do |relationship_name, relationship|
             if relationship.is_a?(JSONAPI::Relationship::ToMany)
               jsonapi_links(relationship_name, options)
@@ -78,7 +86,13 @@ module ActionDispatch
 
         def jsonapi_resources(*resources, &_block)
           @resource_type = resources.first
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(@resource_type))
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(@resource_type))
+
+          res._routed = true
+
+          if res.singleton?
+            warn "Singleton resource #{res} should use `jsonapi_resource` instead."
+          end
 
           options = resources.extract_options!.dup
           options[:controller] ||= @resource_type
@@ -102,8 +116,8 @@ module ActionDispatch
           end
 
           if res._immutable
-            options[:except] << :create  unless options[:except].include?(:create)  || options[:except].include?('create')
-            options[:except] << :update  unless options[:except].include?(:update)  || options[:except].include?('update')
+            options[:except] << :create unless options[:except].include?(:create) || options[:except].include?('create')
+            options[:except] << :update unless options[:except].include?(:update) || options[:except].include?('update')
             options[:except] << :destroy unless options[:except].include?(:destroy) || options[:except].include?('destroy')
           end
 
@@ -147,25 +161,26 @@ module ActionDispatch
           formatted_relationship_name = format_route(link_type)
           options = links.extract_options!.dup
 
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options[:controller] ||= res._type.to_s
 
           methods = links_methods(options)
 
           if methods.include?(:show)
             match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
             if methods.include?(:update)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
@@ -175,69 +190,77 @@ module ActionDispatch
           formatted_relationship_name = format_route(link_type)
           options = links.extract_options!.dup
 
-          res = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          res = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options[:controller] ||= res._type.to_s
 
           methods = links_methods(options)
 
           if methods.include?(:show)
             match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                  action: 'show_relationship', relationship: link_type.to_s, via: [:get]
+                  action: 'show_relationship', relationship: link_type.to_s, via: [:get],
+                  as: "relationships/#{link_type}"
           end
 
           if res.mutable?
             if methods.include?(:create)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
+                    action: 'create_relationship', relationship: link_type.to_s, via: [:post]
             end
 
             if methods.include?(:update)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
+                    action: 'update_relationship', relationship: link_type.to_s, via: [:put, :patch]
             end
 
             if methods.include?(:destroy)
               match "relationships/#{formatted_relationship_name}", controller: options[:controller],
-                                                                          action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
+                    action: 'destroy_relationship', relationship: link_type.to_s, via: [:delete]
             end
           end
         end
 
         def jsonapi_related_resource(*relationship)
-          source = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          source = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options = relationship.extract_options!.dup
 
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
 
           if relationship.polymorphic?
             options[:controller] ||= relationship.class_name.underscore.pluralize
           else
-            related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore.pluralize))
+            related_resource = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(relationship.class_name.underscore.pluralize))
             options[:controller] ||= related_resource._type.to_s
           end
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resource', via: [:get]
+          match formatted_relationship_name, controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'show_related_resource', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         def jsonapi_related_resources(*relationship)
-          source = JSONAPI::Resource.resource_for(resource_type_with_module_prefix)
+          source = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix)
           options = relationship.extract_options!.dup
 
           relationship_name = relationship.first
           relationship = source._relationships[relationship_name]
 
+          relationship._routed = true
+
           formatted_relationship_name = format_route(relationship.name)
-          related_resource = JSONAPI::Resource.resource_for(resource_type_with_module_prefix(relationship.class_name.underscore))
+          related_resource = JSONAPI::Resource.resource_klass_for(resource_type_with_module_prefix(relationship.class_name.underscore))
           options[:controller] ||= related_resource._type.to_s
 
-          match "#{formatted_relationship_name}", controller: options[:controller],
-                                                  relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
-                                                  action: 'get_related_resources', via: [:get]
+          match formatted_relationship_name,
+                controller: options[:controller],
+                relationship: relationship.name, source: resource_type_with_module_prefix(source._type),
+                action: 'index_related_resources', via: [:get],
+                as: "related/#{relationship_name}"
         end
 
         protected
@@ -250,6 +273,7 @@ module ActionDispatch
           @scope = @scope.parent
         end
         # :nocov:
+
         private
 
         def resource_type_with_module_prefix(resource = nil)

data/lib/jsonapi-resources.rb

@@ -1,10 +1,21 @@
+# frozen_string_literal: true
+
+require 'jsonapi/resources/railtie'
 require 'jsonapi/naive_cache'
 require 'jsonapi/compiled_json'
+require 'jsonapi/basic_resource'
+require 'jsonapi/active_relation_resource'
 require 'jsonapi/resource'
-require 'jsonapi/cached_resource_fragment'
+require 'jsonapi/cached_response_fragment'
 require 'jsonapi/response_document'
 require 'jsonapi/acts_as_resource_controller'
-require 'jsonapi/resource_controller'
+if Rails::VERSION::MAJOR >= 6
+  ActiveSupport.on_load(:action_controller_base) do
+    require 'jsonapi/resource_controller'
+  end
+else
+  require 'jsonapi/resource_controller'
+end
 require 'jsonapi/resource_controller_metal'
 require 'jsonapi/resources/version'
 require 'jsonapi/configuration'
@@ -16,12 +27,19 @@ require 'jsonapi/resource_serializer'
 require 'jsonapi/exceptions'
 require 'jsonapi/error'
 require 'jsonapi/error_codes'
-require 'jsonapi/request_parser'
-require 'jsonapi/operation_dispatcher'
+require 'jsonapi/request'
 require 'jsonapi/processor'
 require 'jsonapi/relationship'
 require 'jsonapi/include_directives'
+require 'jsonapi/operation'
 require 'jsonapi/operation_result'
-require 'jsonapi/operation_results'
 require 'jsonapi/callbacks'
 require 'jsonapi/link_builder'
+require 'jsonapi/active_relation/adapters/join_left_active_record_adapter'
+require 'jsonapi/active_relation/join_manager'
+require 'jsonapi/resource_identity'
+require 'jsonapi/resource_fragment'
+require 'jsonapi/resource_tree'
+require 'jsonapi/resource_set'
+require 'jsonapi/path'
+require 'jsonapi/path_segment'

data/lib/sanger-jsonapi-resources.rb

@@ -0,0 +1,7 @@
+# As we are packaging 'sanger-jsonapi-resources' as a separate gem, RubyGems expects
+# the main file to be 'lib/sanger-jsonapi-resources.rb' to match the gem name.
+# Without this file, requiring the gem or Rails autoloading would fail, even if the internal code is unchanged.
+# This file exists to ensure compatibility with RubyGems and Bundler.
+# The easiest solution is to use this wrapper file, which simply requires the original 'jsonapi-resources' code,
+# so all internal references and modules remain unchanged and compatible.
+require_relative 'jsonapi-resources'

data/lib/tasks/check_upgrade.rake

@@ -0,0 +1,52 @@
+require 'rake'
+require 'jsonapi-resources'
+
+namespace :jsonapi do
+  namespace :resources do
+    desc 'Checks application for orphaned overrides'
+    task :check_upgrade => :environment do
+      Rails.application.eager_load!
+
+      resource_klasses = ObjectSpace.each_object(Class).select { |klass| klass < JSONAPI::Resource}
+
+      puts "Checking #{resource_klasses.count} resources"
+
+      issues_found = 0
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:find_records) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `find_records`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `find_records` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:records_for) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `records_for`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `records_for` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      klasses_with_deprecated = resource_klasses.select { |klass| klass.methods.include?(:apply_includes) }
+      unless klasses_with_deprecated.empty?
+        puts "  Found the following resources the still implement `apply_includes`:"
+        klasses_with_deprecated.each { |klass| puts "    #{klass}"}
+        puts "  The `apply_includes` method is no longer called by JR. Please review and ensure your functionality is ported over."
+
+        issues_found = issues_found + klasses_with_deprecated.length
+      end
+
+      if issues_found > 0
+        puts "Finished inspection. #{issues_found} issues found that may impact upgrading. Please address these issues. "
+      else
+        puts "Finished inspection with no issues found. Note this is only a cursory check for method overrides that will no \n" \
+             "longer be called by JSONAPI::Resources. This check in no way assures your code will continue to function as \n" \
+             "it did before the upgrade. Please do adequate testing before using in production."
+      end
+    end
+  end
+end

metadata

@@ -1,30 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: sanger-jsonapi-resources
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
-- Dan Gebhardt
-- Larry Gebhardt
+- PSD Team - Wellcome Trust Sanger Institute
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-11 00:00:00.000000000 Z
+date: 2025-06-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.17'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -43,16 +42,22 @@ dependencies:
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.10'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 5.10.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.10'
+    - - "!="
+      - !ruby/object:Gem::Version
+        version: 5.10.2
 - !ruby/object:Gem::Dependency
   name: minitest-spec-rails
   requirement: !ruby/object:Gem::Requirement
@@ -109,34 +114,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  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: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '5.1'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -151,26 +170,32 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A resource-centric approach to implementing the controllers, routes,
-  and serializers needed to support the JSON API spec.
+description: Forked from jsonapi-resources. A resource-centric approach to implementing
+  the controllers, routes, and serializers needed to support the JSON API spec.
 email:
-- dan@cerebris.com
-- larry@cerebris.com
+- psd@sanger.ac.uk
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE.txt
 - README.md
+- lib/bug_report_templates/rails_5_latest.rb
+- lib/bug_report_templates/rails_5_master.rb
 - lib/generators/jsonapi/USAGE
 - lib/generators/jsonapi/controller_generator.rb
 - lib/generators/jsonapi/resource_generator.rb
 - lib/generators/jsonapi/templates/jsonapi_controller.rb
 - lib/generators/jsonapi/templates/jsonapi_resource.rb
 - lib/jsonapi-resources.rb
+- lib/jsonapi/active_relation/adapters/join_left_active_record_adapter.rb
+- lib/jsonapi/active_relation/join_manager.rb
+- lib/jsonapi/active_relation_resource.rb
 - lib/jsonapi/acts_as_resource_controller.rb
-- lib/jsonapi/cached_resource_fragment.rb
+- lib/jsonapi/basic_resource.rb
+- lib/jsonapi/cached_response_fragment.rb
 - lib/jsonapi/callbacks.rb
+- lib/jsonapi/compatibility_helper.rb
 - lib/jsonapi/compiled_json.rb
 - lib/jsonapi/configuration.rb
 - lib/jsonapi/error.rb
@@ -182,22 +207,28 @@ files:
 - lib/jsonapi/mime_types.rb
 - lib/jsonapi/naive_cache.rb
 - lib/jsonapi/operation.rb
-- lib/jsonapi/operation_dispatcher.rb
 - lib/jsonapi/operation_result.rb
-- lib/jsonapi/operation_results.rb
 - lib/jsonapi/paginator.rb
+- lib/jsonapi/path.rb
+- lib/jsonapi/path_segment.rb
 - lib/jsonapi/processor.rb
 - lib/jsonapi/relationship.rb
-- lib/jsonapi/relationship_builder.rb
-- lib/jsonapi/request_parser.rb
+- lib/jsonapi/request.rb
 - lib/jsonapi/resource.rb
 - lib/jsonapi/resource_controller.rb
 - lib/jsonapi/resource_controller_metal.rb
+- lib/jsonapi/resource_fragment.rb
+- lib/jsonapi/resource_identity.rb
 - lib/jsonapi/resource_serializer.rb
+- lib/jsonapi/resource_set.rb
+- lib/jsonapi/resource_tree.rb
+- lib/jsonapi/resources/railtie.rb
 - lib/jsonapi/resources/version.rb
 - lib/jsonapi/response_document.rb
 - lib/jsonapi/routing_ext.rb
-homepage: https://github.com/cerebris/jsonapi-resources
+- lib/sanger-jsonapi-resources.rb
+- lib/tasks/check_upgrade.rake
+homepage: https://github.com/sanger/jsonapi-resources
 licenses:
 - MIT
 metadata: {}
@@ -209,7 +240,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.1'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/jsonapi/cached_resource_fragment.rb

@@ -1,127 +0,0 @@
-module JSONAPI
-  class CachedResourceFragment
-    def self.fetch_fragments(resource_klass, serializer, context, cache_ids)
-      serializer_config_key = serializer.config_key(resource_klass).gsub("/", "_")
-      context_json = resource_klass.attribute_caching_context(context).to_json
-      context_b64 = JSONAPI.configuration.resource_cache_digest_function.call(context_json)
-      context_key = "ATTR-CTX-#{context_b64.gsub("/", "_")}"
-
-      results = self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-
-      miss_ids = results.select{|k,v| v.nil? }.keys
-      unless miss_ids.empty?
-        find_filters = {resource_klass._primary_key => miss_ids.uniq}
-        find_options = {context: context}
-        resource_klass.find(find_filters, find_options).each do |resource|
-          (id, cr) = write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
-          results[id] = cr
-        end
-      end
-
-      if JSONAPI.configuration.resource_cache_usage_report_function
-        JSONAPI.configuration.resource_cache_usage_report_function.call(
-          resource_klass.name,
-          cache_ids.size - miss_ids.size,
-          miss_ids.size
-        )
-      end
-
-      return results
-    end
-
-    attr_reader :resource_klass, :id, :type, :context, :fetchable_fields, :relationships,
-                :links_json, :attributes_json, :meta_json,
-                :preloaded_fragments
-
-    def initialize(resource_klass, id, type, context, fetchable_fields, relationships,
-                   links_json, attributes_json, meta_json)
-      @resource_klass = resource_klass
-      @id = id
-      @type = type
-      @context = context
-      @fetchable_fields = Set.new(fetchable_fields)
-
-      # Relationships left uncompiled because we'll often want to insert included ids on retrieval
-      @relationships = relationships
-
-      @links_json = CompiledJson.of(links_json)
-      @attributes_json = CompiledJson.of(attributes_json)
-      @meta_json = CompiledJson.of(meta_json)
-
-      # A hash of hashes
-      @preloaded_fragments ||= Hash.new
-    end
-
-    def to_cache_value
-      {
-        id: id,
-        type: type,
-        fetchable: fetchable_fields,
-        rels: relationships,
-        links: links_json.try(:to_s),
-        attrs: attributes_json.try(:to_s),
-        meta: meta_json.try(:to_s)
-      }
-    end
-
-    def to_real_resource
-      rs = Resource.resource_for(self.type).find_by_keys([self.id], {context: self.context})
-      return rs.try(:first)
-    end
-
-    private
-
-    def self.lookup(resource_klass, serializer_config_key, context, context_key, cache_ids)
-      type = resource_klass._type
-
-      keys = cache_ids.map do |(id, cache_key)|
-        [type, id, cache_key, serializer_config_key, context_key]
-      end
-
-      hits = JSONAPI.configuration.resource_cache.read_multi(*keys).reject{|_,v| v.nil? }
-      return keys.each_with_object({}) do |key, hash|
-        (_, id, _, _) = key
-        if hits.has_key?(key)
-          hash[id] = self.from_cache_value(resource_klass, context, hits[key])
-        else
-          hash[id] = nil
-        end
-      end
-    end
-
-    def self.from_cache_value(resource_klass, context, h)
-      new(
-        resource_klass,
-        h.fetch(:id),
-        h.fetch(:type),
-        context,
-        h.fetch(:fetchable),
-        h.fetch(:rels, nil),
-        h.fetch(:links, nil),
-        h.fetch(:attrs, nil),
-        h.fetch(:meta, nil)
-      )
-    end
-
-    def self.write(resource_klass, resource, serializer, serializer_config_key, context, context_key)
-      (id, cache_key) = resource.cache_id
-      json = serializer.object_hash(resource) # No inclusions passed to object_hash
-      cr = self.new(
-        resource_klass,
-        json['id'],
-        json['type'],
-        context,
-        resource.fetchable_fields,
-        json['relationships'],
-        json['links'],
-        json['attributes'],
-        json['meta']
-      )
-
-      key = [resource_klass._type, id, cache_key, serializer_config_key, context_key]
-      JSONAPI.configuration.resource_cache.write(key, cr.to_cache_value)
-      return [id, cr]
-    end
-
-  end
-end