hyrax 5.0.0.rc1 → 5.0.0.rc3

data/lib/hyrax/transactions/steps/delete_all_file_sets.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Deletes a resource's member FileSets from the persister, returning a `Dry::Monads::Result`
+      # (`Success`|`Failure`).
+      #
+      # @see https://dry-rb.org/gems/dry-monads/1.0/result/
+      class DeleteAllFileSets
+        include Dry::Monads[:result]
+
+        ##
+        # @params [#save] persister
+        def initialize(query_service: Hyrax.query_service, persister: Hyrax.persister, publisher: Hyrax.publisher)
+          @persister = persister
+          @query_service = query_service
+          @publisher = publisher
+        end
+
+        ##
+        # @param [Valkyrie::Resource] resource
+        # @param [::User] the user resposible for the delete action
+        #
+        # @return [Dry::Monads::Result]
+        def call(resource, user: nil)
+          return Failure(:resource_not_persisted) unless resource.persisted?
+
+          @query_service.custom_queries.find_child_file_sets(resource: resource).each do |file_set|
+            return Failure[:failed_to_delete_file_set, file_set] unless
+              Hyrax::Transactions::Container['file_set.destroy']
+              .with_step_args('file_set.remove_from_work' => { user: user },
+                              'file_set.delete' => { user: user })
+              .call(file_set).success?
+          rescue ::Ldp::Gone
+            nil
+          end
+
+          Success(resource)
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/steps/file_metadata_delete.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Deletes a resource from the persister, returning a `Dry::Monads::Result`
+      # (`Success`|`Failure`).
+      #
+      # @see https://dry-rb.org/gems/dry-monads/1.0/result/
+      class FileMetadataDelete
+        include Dry::Monads[:result]
+
+        ##
+        # @params [#save] persister
+        def initialize(persister: Hyrax.persister, storage_adapter: Hyrax.storage_adapter, publisher: Hyrax.publisher)
+          @persister = persister
+          @publisher = publisher
+          @storage_adapter = storage_adapter
+        end
+
+        ##
+        # @param [Hyrax::FileMetadata] FileMetadata resource
+        # @param [::User] the user resposible for the delete action
+        #
+        # @return [Dry::Monads::Result]
+        def call(resource)
+          return Failure(:resource_not_persisted) unless resource.persisted?
+
+          @persister.delete(resource: resource)
+          @publisher.publish('file.metadata.deleted', metadata: resource)
+          Valkyrie::StorageAdapter.delete(id: resource.file_identifier) if resource.file_identifier.present?
+
+          Success(resource)
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/steps/remove_from_membership.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require 'dry/monads'
+
+module Hyrax
+  module Transactions
+    module Steps
+      ##
+      # Removes a collection from its members, returning a `Dry::Monads::Result`
+      # (`Success`|`Failure`).
+      #
+      # @see https://dry-rb.org/gems/dry-monads/1.0/result/
+      class RemoveFromMembership
+        include Dry::Monads[:result]
+
+        ##
+        # @params [#save] persister
+        def initialize(query_service: Hyrax.custom_queries, persister: Hyrax.persister, publisher: Hyrax.publisher)
+          @persister = persister
+          @query_service = query_service
+          @publisher = publisher
+        end
+
+        ##
+        # @param [Valkyrie::Resource] resource
+        # @param [::User] the user resposible for the delete action
+        #
+        # @return [Dry::Monads::Result]
+        def call(collection, user: nil)
+          return Failure(:resource_not_persisted) unless collection.persisted?
+          return Failure(:user_not_present) if user.blank?
+
+          @query_service.find_members_of(collection: collection).each do |member|
+            member.member_of_collection_ids -= [collection.id]
+            @persister.save(resource: member)
+            @publisher.publish('collection.membership.updated', collection: collection, user: user)
+          rescue StandardError
+            nil
+          end
+
+          Success(collection)
+        end
+      end
+    end
+  end
+end

data/lib/hyrax/transactions/steps/save.rb

@@ -40,7 +40,7 @@ module Hyrax
             save_lease_or_embargo(unsaved)
             saved = @persister.save(resource: unsaved)
           rescue StandardError => err
-            return Failure(["Failed save on #{change_set}\n\t#{err.message}", change_set.resource])
+            return Failure.new(["Failed save on #{change_set}\n\t#{err.message}", change_set.resource], err.backtrace.first)
           end
 
           # if we have a permission manager, it's acting as a local cache of another resource.
@@ -58,6 +58,7 @@ module Hyrax
         private
 
         def valid_future_date?(item, attribute)
+          return true if item.fields[attribute].blank?
           raise StandardError, "#{item.model} must use a future date" if item.fields[attribute] < Time.zone.now
         end
 

data/lib/hyrax/transactions/steps/set_user_as_creator.rb

@@ -23,7 +23,7 @@ module Hyrax
 
           Success(change_set)
         rescue NoMethodError => err
-          Failure([err.message, change_set])
+          Failure.new([err.message, change_set], err.backtrace.first)
         end
 
         ##

data/lib/hyrax/transactions/steps/update_work_members.rb

@@ -29,6 +29,8 @@ module Hyrax
           obj.member_ids -= destroys.map { |id| Valkyrie::ID.new(id) }
 
           save_resource(obj, user)
+          Hyrax.publisher.publish('object.membership.updated', object: obj, user: user)
+
           Success(obj)
         end
 

data/lib/hyrax/transactions/work_destroy.rb

@@ -8,8 +8,9 @@ module Hyrax
     #
     # @since 3.0.0
     class WorkDestroy < Transaction
-      DEFAULT_STEPS = ['work_resource.delete',
-                       'work_resource.delete_acl'].freeze
+      DEFAULT_STEPS = ['work_resource.delete_all_file_sets',
+                       'work_resource.delete_acl',
+                       'work_resource.delete'].freeze
 
       ##
       # @see Hyrax::Transactions::Transaction

data/lib/hyrax/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Hyrax
-  VERSION = '5.0.0.rc1'
+  VERSION = '5.0.0.rc3'
 end

data/lib/hyrax.rb

@@ -41,6 +41,7 @@ module Hyrax
     autoload :Configuration
     autoload :ControlledVocabularies
     autoload :EventStore
+    autoload :Forms
     autoload :RedisEventStore
     autoload :ResourceSync
     autoload :Zotero

data/lib/tasks/collection_type_global_id.rake

@@ -7,13 +7,18 @@ namespace :hyrax do
 
       count = 0
 
-      Collection.all.each do |collection|
-        next if collection.collection_type_gid == collection.collection_type.to_global_id.to_s
+      Hyrax.query_service.find_all_of_model(model: Hyrax::PcdmCollection).each do |collection|
+        type = Hyrax::CollectionType.find_by_gid(collection.collection_type_gid)
+        next if collection.collection_type_gid == type.to_global_id.to_s
 
-        collection.public_send(:collection_type_gid=, collection.collection_type.to_global_id, force: true)
+        # Awful hack to allow converted AF collections to force update collection_type_gid
+        Thread.current[:force_collection_type_gid] = true
+        collection.collection_type_gid = type.to_global_id
 
-        collection.save &&
+        Hyrax.persister.save(resource: collection) &&
           count += 1
+      ensure
+        Thread.current[:force_collection_type_gid] = false
       end
 
       puts "Updated #{count} collections."

data/lib/tasks/embargo_lease.rake

@@ -8,6 +8,7 @@ namespace :hyrax do
 
       Hyrax.query_service.find_many_by_ids(ids: ids).each do |resource|
         Hyrax::EmbargoManager.release_embargo_for(resource: resource) &&
+          Hyrax.persister.save(resource: resource.embargo) &&
           Hyrax::AccessControlList(resource).save
       end
     end
@@ -20,6 +21,7 @@ namespace :hyrax do
 
       Hyrax.query_service.find_many_by_ids(ids: ids).each do |resource|
         Hyrax::LeaseManager.release_lease_for(resource: resource) &&
+          Hyrax.persister.save(resource: resource.lease) &&
           Hyrax::AccessControlList(resource).save
       end
     end

data/lib/valkyrie/indexing/solr/indexing_adapter.rb

@@ -9,7 +9,7 @@ module Valkyrie
         ##
         # @!attribute [r] connection
         #   @return [RSolr::Client]
-        attr_reader :connection
+        attr_accessor :connection
 
         ##
         # @param connection [RSolr::Client] The RSolr connection to index to.
@@ -37,6 +37,10 @@ module Valkyrie
           connection.commit
         end
 
+        def reset!
+          self.connection = default_connection
+        end
+
         private
 
         def persist(resources)
@@ -66,9 +70,14 @@ module Valkyrie
             return {}
           end
 
-          { 'host' => bl_index.host,
+          {
+            'host' => bl_index.host,
+            'user' => bl_index.user,
+            'password' => bl_index.password,
+            'scheme' => bl_index.scheme,
             'port' => bl_index.port,
-            'core' => 'hyrax-valkyrie' }
+            'core' => bl_index.path.split("/")[2] || 'hyrax-valkyrie'
+          }.compact
         end
 
         def connection_url
@@ -78,10 +87,17 @@ module Valkyrie
                      {}
                    end
 
-          # if any configuration is missing, derive it from Blacklight
+          # Given how we're building blacklight_based_config, there won't be a URL.  So let's avoid
+          # that whole logic path.
+          return config['url'] if config['url'].present?
+
+          # Derive any missing configuration from Blacklight.
           config = blacklight_based_config.with_indifferent_access.merge(config)
 
-          "http://#{config['host']}:#{config['port']}/solr/#{config['core']}"
+          url = "#{config.fetch('scheme', 'http')}://"
+          url = "#{url}#{config['user']}:#{config['password']}@" if config.key?('user') && config.key?('password')
+
+          "#{url}#{config['host']}:#{config['port']}/solr/#{config['core']}"
         end
 
         def default_connection
@@ -89,7 +105,7 @@ module Valkyrie
         end
 
         def resource_indexer
-          Hyrax::ValkyrieIndexer
+          Hyrax::Indexers::ResourceIndexer
         end
       end
     end

data/lib/wings/active_fedora_converter/default_work.rb

@@ -77,11 +77,10 @@ module Wings
     # default work class builder
     def self.DefaultWork(resource_class) # rubocop:disable Naming/MethodName
       class_cache[resource_class] ||= Class.new(DefaultWork) do
-        self.valkyrie_class = resource_class
-
+        self.valkyrie_class = resource_class.respond_to?(:valkyrie_class) ? resource_class.valkyrie_class : resource_class
         # skip reserved attributes, we assume we don't need to translate valkyrie internals
-        schema = resource_class.schema.reject do |key|
-          resource_class.reserved_attributes.include?(key.name)
+        schema = valkyrie_class.schema.reject do |key|
+          valkyrie_class.reserved_attributes.include?(key.name)
         end
 
         Wings::ActiveFedoraConverter.apply_properties(self, schema)
@@ -142,7 +141,7 @@ module Wings
       end
 
       def indexing_service
-        Hyrax::ValkyrieIndexer.for(resource: valkyrie_resource)
+        Hyrax::Indexers::ResourceIndexer.for(resource: valkyrie_resource)
       end
 
       def to_global_id

data/lib/wings/active_fedora_converter/file_metadata_node.rb

@@ -36,7 +36,7 @@ module Wings
     end
 
     def indexing_service
-      Hyrax::ValkyrieIndexer.for(resource: valkyrie_resource)
+      Hyrax::Indexers::ResourceIndexer.for(resource: valkyrie_resource)
     end
 
     def to_solr

data/lib/wings/active_fedora_converter.rb

@@ -170,6 +170,7 @@ module Wings
 
     # for files, add attributes to metadata_node, plus some other work
     def add_file_attributes(af_object)
+      add_file_uri(af_object)
       converted_attrs = normal_attributes
       pcdm_use = converted_attrs.delete(:pcdm_use)
       af_object.metadata_node.attributes = converted_attrs
@@ -180,6 +181,11 @@ module Wings
       af_object.mime_type = resource.mime_type
     end
 
+    def add_file_uri(af_object)
+      file_uri = Hyrax.storage_adapter.fedora_identifier(id: resource.file_identifier)
+      af_object.uri = file_uri.to_s if af_object.uri.to_s.blank? && file_uri.to_s.present?
+    end
+
     def perform_lease_conversion(af_object:, resource:)
       # TODO(#6134): af_object.lease.class has the same name as resource.lease.class; however, each class has a different object_id
       # so a type mismatch happens. the code below coerces the one object into the other

data/lib/wings/attribute_transformer.rb

@@ -15,29 +15,36 @@ module Wings
       end
     end
 
-    def self.run(obj) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-      attrs = obj.reflections.each_with_object({}) do |(key, reflection), mem|
+    def self.run(obj) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+      attrs = obj.reflections.each_with_object({}) do |(key, reflection), mem| # rubocop:disable Metrics/BlockLength
         case reflection
-        when ActiveFedora::Reflection::HasManyReflection,
-             ActiveFedora::Reflection::HasAndBelongsToManyReflection,
-             ActiveFedora::Reflection::IndirectlyContainsReflection
-          mem[:"#{key.to_s.singularize}_ids"] =
-            obj.association(key).ids_reader
-        when ActiveFedora::Reflection::DirectlyContainsReflection
-          mem[:"#{key.to_s.singularize}_ids"] =
-            Array(obj.public_send(reflection.name)).map(&:id)
-        when ActiveFedora::Reflection::FilterReflection,
-             ActiveFedora::Reflection::OrdersReflection,
-             ActiveFedora::Reflection::HasSubresourceReflection,
-             ActiveFedora::Reflection::BelongsToReflection,
-             ActiveFedora::Reflection::BasicContainsReflection
+        when ActiveFedora::Reflection::BelongsToReflection, # uses foreign_key SingularRDFPropertyReflection
+             ActiveFedora::Reflection::BasicContainsReflection, # ???
+             ActiveFedora::Reflection::FilterReflection, # rely on :extending_from
+             ActiveFedora::Reflection::HasAndBelongsToManyReflection, # uses foreign_key RDFPropertyReflection
+             ActiveFedora::Reflection::HasManyReflection, # captured by inverse relation
+             ActiveFedora::Reflection::HasSubresourceReflection, # ???
           :noop
+        when ActiveFedora::Reflection::OrdersReflection
+          mem[:"#{reflection.options[:unordered_reflection].name.to_s.singularize}_ids"] ||= []
+          mem[:"#{reflection.options[:unordered_reflection].name.to_s.singularize}_ids"] +=
+            obj.association(reflection.name).target_ids_reader
         when ActiveFedora::Reflection::DirectlyContainsOneReflection
           mem[:"#{key.to_s.singularize}_id"] =
             obj.public_send(reflection.name)&.id
+        when ActiveFedora::Reflection::IndirectlyContainsReflection
+          mem[:"#{key.to_s.singularize}_ids"] ||= []
+          mem[:"#{key.to_s.singularize}_ids"] +=
+            obj.association(key).ids_reader
+        when ActiveFedora::Reflection::DirectlyContainsReflection
+          mem[:"#{key.to_s.singularize}_ids"] ||= []
+          mem[:"#{key.to_s.singularize}_ids"] +=
+            Array(obj.public_send(reflection.name)).map(&:id)
+        when ActiveFedora::Reflection::RDFPropertyReflection
+          mem[reflection.name.to_sym] =
+            obj.public_send(reflection.name.to_sym)
         else
-          mem[reflection.foreign_key.to_sym] =
-            obj.public_send(reflection.foreign_key.to_sym)
+          raise NotImplementedError, "Expected a known ActiveFedora::Reflection, but got #{reflection}"
         end
       end
 

data/lib/wings/model_registry.rb

@@ -24,6 +24,10 @@ module Wings
       instance.register(*args)
     end
 
+    def self.unregister(*args)
+      instance.unregister(*args)
+    end
+
     def self.lookup(*args)
       instance.lookup(*args)
     end
@@ -40,6 +44,10 @@ module Wings
       @map[valkyrie.name] = active_fedora.name
     end
 
+    def unregister(valkyrie)
+      @map.delete(valkyrie.name)
+    end
+
     def lookup(valkyrie)
       valkyrie = valkyrie._canonical_valkyrie_model if
         valkyrie.respond_to?(:_canonical_valkyrie_model)

data/lib/wings/model_transformer.rb

@@ -83,8 +83,25 @@ module Wings
       # otherwise, we can just rely on the `access_control_ids`.
       return unless resource.respond_to?(:permission_manager)
 
-      resource.permission_manager.acl.permissions =
-        pcdm_object.access_control.valkyrie_resource.permissions
+      # When the pcdm_object has an access_control (see above) but there's no access_control_id, we
+      # need to rely on the computed access_control object.  Why?  There are tests that fail.
+      acl = if pcdm_object.access_control_id.nil?
+              pcdm_object.access_control.valkyrie_resource
+            else
+              begin
+                # Given that we have an access_control AND an access_control_id, we want to ensure
+                # that we fetch the access_control from persistence.  Why?  Because when we update
+                # an ACL and are using those adapters, we will write the ACL to the Valkyrie adapter
+                # without writing the work to the Valkyrie adapter.  This might be a failing, but
+                # migrations in place are hard.
+                acl_id = pcdm_object.access_control_id
+                acl_id = ::Valkyrie::ID.new(acl_id) unless acl_id.is_a?(::Valkyrie::ID)
+                Hyrax.query_service.find_by(id: acl_id)
+              rescue ::Valkyrie::Persistence::ObjectNotFoundError
+                pcdm_object.access_control.valkyrie_resource
+              end
+            end
+      resource.permission_manager.acl.permissions = acl.permissions
     end
 
     ##
@@ -150,17 +167,9 @@ module Wings
       { :id => pcdm_object.id,
         :created_at => pcdm_object.try(:create_date),
         :updated_at => pcdm_object.try(:modified_date),
-        :member_ids => member_ids,
         ::Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token }
     end
 
-    # Prefer ordered members, but if ordered members don't exist, use non-ordered members.
-    def member_ids
-      ordered_member_ids = pcdm_object.try(:ordered_member_ids)
-      return ordered_member_ids if ordered_member_ids.present?
-      pcdm_object.try(:member_ids)
-    end
-
     def lock_token
       result = []
       result << ::Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: 'wings-fedora-etag', token: pcdm_object.etag) unless pcdm_object.new_record?

data/lib/wings/orm_converter.rb

@@ -40,6 +40,10 @@ module Wings
             _canonical_valkyrie_model&.name
           end
 
+          def to_rdf_representation
+            name
+          end
+
           ##
           # @return [String]
           def to_s
@@ -78,29 +82,34 @@ module Wings
         end
 
         # add reflection associations
-        ldp_reflections = (klass.try(:reflections) || []).select do |_key, reflection|
+        (klass.try(:reflections) || []).each do |reflection_key, reflection|
           case reflection
-          when ActiveFedora::Reflection::FilterReflection,
-               ActiveFedora::Reflection::OrdersReflection,
-               ActiveFedora::Reflection::BasicContainsReflection,
-               ActiveFedora::Reflection::HasSubresourceReflection
-            false
-          else
-            true
-          end
-        end
-
-        ldp_reflections.each do |reflection_key, reflection|
-          if reflection.collection?
-            type           = ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+          when ActiveFedora::Reflection::BelongsToReflection, # uses foreign_key SingularRDFPropertyReflection
+               ActiveFedora::Reflection::BasicContainsReflection, # ???
+               ActiveFedora::Reflection::FilterReflection, # rely on :extending_from
+               ActiveFedora::Reflection::HasAndBelongsToManyReflection, # uses foreign_key RDFPropertyReflection
+               ActiveFedora::Reflection::HasManyReflection, # captured by inverse relation
+               ActiveFedora::Reflection::HasSubresourceReflection, # ???
+               ActiveFedora::Reflection::OrdersReflection # map to :unordered_association in Wings::AttributeTransformer (but retain order)
+            next
+          when ActiveFedora::Reflection::DirectlyContainsOneReflection
+            attribute_name = (reflection_key.to_s.singularize + '_id').to_sym
+            type = ::Valkyrie::Types::ID.optional
+          when ActiveFedora::Reflection::DirectlyContainsReflection,
+               ActiveFedora::Reflection::IndirectlyContainsReflection
             attribute_name = (reflection_key.to_s.singularize + '_ids').to_sym
+            type = ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
+          when ActiveFedora::Reflection::SingularRDFPropertyReflection
+            attribute_name = reflection.name.to_sym
+            type = ::Valkyrie::Types::ID.optional
+          when ActiveFedora::Reflection::RDFPropertyReflection
+            attribute_name = reflection.name.to_sym
+            type = ::Valkyrie::Types::Set.of(::Valkyrie::Types::ID)
           else
-            type           = ::Valkyrie::Types::ID.optional
-            attribute_name = (reflection_key.to_s.singularize + '_id').to_sym
+            raise NotImplementedError, "Expected a known ActiveFedora::Reflection, but got #{reflection}"
           end
 
-          next if fields.include?(attribute_name)
-          attribute attribute_name, type
+          attribute(attribute_name, type)
         end
 
         def internal_resource

data/lib/wings/services/custom_queries/find_ids_by_model.rb

@@ -29,7 +29,7 @@ module Wings
         model_name = ModelRegistry.lookup(model).model_name
 
         solr_query = "_query_:\"{!raw f=has_model_ssim}#{model_name}\""
-        solr_response = ActiveFedora::SolrService.get(solr_query, fl: 'id', rows: @query_rows)['response']
+        solr_response = Hyrax::SolrService.get(solr_query, fl: 'id', rows: @query_rows)['response']
 
         loop do
           response_docs = solr_response['docs']
@@ -38,7 +38,7 @@ module Wings
           response_docs.each { |doc| yield doc['id'] }
 
           break if (solr_response['start'] + solr_response['docs'].count) >= solr_response['numFound']
-          solr_response = ActiveFedora::SolrService.get(solr_query, fl: 'id', rows: @query_rows, start: solr_response['start'] + @query_rows)['response']
+          solr_response = Hyrax::SolrService.get(solr_query, fl: 'id', rows: @query_rows, start: solr_response['start'] + @query_rows)['response']
         end
       end
     end

data/lib/wings/setup.rb

@@ -98,12 +98,12 @@ end
 Valkyrie::MetadataAdapter.register(
   Wings::Valkyrie::MetadataAdapter.new, :wings_adapter
 )
-Valkyrie.config.metadata_adapter = :wings_adapter
+Valkyrie.config.metadata_adapter = :wings_adapter unless Hyrax.config.disable_wings
 
 Valkyrie::StorageAdapter.register(
   Wings::Valkyrie::Storage.new, :active_fedora
 )
-Valkyrie.config.storage_adapter = :active_fedora
+Valkyrie.config.storage_adapter = :active_fedora unless Hyrax.config.disable_wings
 
 # TODO: Custom query registration is not Wings specific.  These custom_queries need to be registered for other adapters too.
 #       A refactor is needed to add the default implementations to hyrax.rb and only handle the wings specific overrides here.

data/lib/wings/valkyrie/query_service.rb

@@ -23,7 +23,7 @@ module Wings
       def count_all_of_model(model:)
         ActiveFedora::Base
           .where(has_model_ssim: [model_class_for(model).to_rdf_representation,
-                                  model.new.internal_resource.to_s])
+                                  model.to_rdf_representation])
           .count
       end
 
@@ -63,6 +63,9 @@ module Wings
       #
       # @param model [Class]
       # @return [Array<Valkyrie::Resource>]
+      #
+      # @note Due to implementation details, .find_all_of_model and .count_all_of_model may not
+      #       return the same number of results.  Is that a bug?  Probably.
       def find_all_of_model(model:)
         model_class_for(model).all.map do |obj|
           resource_factory.to_resource(object: obj)
@@ -139,7 +142,7 @@ module Wings
         return find_many_by_ids(ids: Array(resource.send(property))) unless model
 
         results = resource.public_send(property).map do |reference|
-          resource_factory.to_resource(object: ::ActiveFedora::Base.find(reference))
+          resource_factory.to_resource(object: ::ActiveFedora::Base.find(reference.to_s))
         end
 
         results.select { |r| r.class.name == model.name }