valkyrie-sequel 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89a976b76238995b845b6b1d5d82cbf3a24afa1e92c795590f8045fa19a9295c
-  data.tar.gz: 63c6b8e510197296ccc2b83428b00d40ab1f974b18f6db05c7dc28c62a955ec9
+  metadata.gz: cd54c1445fecd7ace70e07607d27da780bf9c47d6ac97c8681ab319908e1c36b
+  data.tar.gz: bce2c0e04e1c6aae88d0dfae9bcbb35fc0a4055c2223284526165fb71a34adde
 SHA512:
-  metadata.gz: 71293e3bc4635ba2df250558612088e8dfcb2a7a77cc6923c27c1da7567b09e3c112d462ab0063985084f5a89c32a33ec4fd9aea2ff0120df74ce1583aad67c3
-  data.tar.gz: 9ec49446c6f760ddba814e51154cde6e842d86fc76fbc81bf8b484f3478a2a23e1a27befca96239d41e0a14da561174b4e032902e8809143d861c7c00b4aa121
+  metadata.gz: e7b5a2524a6c10a7b49757ceb360560f2aac259c7376ff0abe51c456eaa8750b4dfdc9185dd692b1041a04bfaa649a047b240427ac4bc5be802fd7de4ebbff05
+  data.tar.gz: 789f2e2931f1c8ea9552124e1119a9582e2c703261782b1f4d242191391f01f5725994c70bb8d4653f5525b60bd8d0d7221177116eacde9862b05aa2e6ecc4a3

data/.circleci/config.yml

@@ -3,9 +3,10 @@ version: 2
 jobs:
   build:
     docker:
-      - image: circleci/ruby:2.4.6-node-browsers
+      - image: circleci/ruby:2.7.2-node-browsers
         environment:
           RAILS_ENV: test
+          BUNDLE_PATH: vendor/bundle
           DB_HOST: localhost
           DB_USERNAME: valkyrie_sequel
           DB_PASSWORD:  ""
@@ -23,7 +24,7 @@ jobs:
         key: valkyrie-sequel-{{ checksum "Gemfile" }}
       - run: gem install bundler -v '~> 2.0'
       # Bundle install dependencies
-      - run: bundle install --path vendor/bundle
+      - run: bundle install
       # Cache Dependencies
       - type: cache-save
         name: Store bundle cache

data/.rubocop.yml

@@ -2,7 +2,6 @@ inherit_gem:
   bixby: bixby_default.yml
 AllCops:
   DisplayCopNames: true
-  TargetRubyVersion: 2.3
   Exclude:
     - 'bin/*'
     - 'db/schema.rb'
@@ -24,3 +23,5 @@ Metrics/ParameterLists:
 RSpec/ExampleLength:
   Exclude:
     - 'spec/valkyrie/sequel/persister_spec.rb'
+Rails/RakeEnvironment:
+  Enabled: false

data/lib/valkyrie/sequel/metadata_adapter.rb

@@ -48,16 +48,16 @@ module Valkyrie::Sequel
 
     private
 
-      def host
-        connection.opts[:host]
-      end
+    def host
+      connection.opts[:host]
+    end
 
-      def port
-        connection.opts[:port]
-      end
+    def port
+      connection.opts[:port]
+    end
 
-      def database
-        connection.opts[:database]
-      end
+    def database
+      connection.opts[:database]
+    end
   end
 end

data/lib/valkyrie/sequel/persister.rb

@@ -121,32 +121,32 @@ module Valkyrie::Sequel
 
     private
 
-      def create_or_update(resource:, attributes:)
-        attributes[:updated_at] = Time.now.utc
-        attributes[:created_at] ||= Time.now.utc
-        return create(resource: resource, attributes: attributes) unless resource.persisted? && !exists?(id: attributes[:id])
-        update(resource: resource, attributes: attributes)
-      end
+    def create_or_update(resource:, attributes:)
+      attributes[:updated_at] = Time.now.utc
+      attributes[:created_at] ||= Time.now.utc
+      return create(resource: resource, attributes: attributes) unless resource.persisted? && !exists?(id: attributes[:id])
+      update(resource: resource, attributes: attributes)
+    end
 
-      def create(resource:, attributes:)
-        attributes[:lock_version] = 0 if resource.optimistic_locking_enabled? && resources.columns.include?(:lock_version)
-        Array(resources.returning.insert(attributes)).first
-      end
+    def create(resource:, attributes:)
+      attributes[:lock_version] = 0 if resource.optimistic_locking_enabled? && resources.columns.include?(:lock_version)
+      Array(resources.returning.insert(attributes)).first
+    end
 
-      def update(resource:, attributes:)
-        relation = resources.where(id: attributes[:id])
-        if resource.optimistic_locking_enabled?
-          relation = relation.where(Sequel.function(:coalesce, :lock_version, 0) => attributes[:lock_version] || 0)
-          attributes[:lock_version] = (Sequel.function(:coalesce, :lock_version, 0) + 1)
-        end
-        attributes.delete(:lock_version) if attributes[:lock_version].nil?
-        output = relation.returning.update(attributes)
-        raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." if output.blank? && resource.optimistic_locking_enabled?
-        Array(output).first
+    def update(resource:, attributes:)
+      relation = resources.where(id: attributes[:id])
+      if resource.optimistic_locking_enabled?
+        relation = relation.where(Sequel.function(:coalesce, :lock_version, 0) => attributes[:lock_version] || 0)
+        attributes[:lock_version] = (Sequel.function(:coalesce, :lock_version, 0) + 1)
       end
+      attributes.delete(:lock_version) if attributes[:lock_version].nil?
+      output = relation.returning.update(attributes)
+      raise Valkyrie::Persistence::StaleObjectError, "The object #{resource.id} has been updated by another process." if output.blank? && resource.optimistic_locking_enabled?
+      Array(output).first
+    end
 
-      def exists?(id:)
-        resources.select(1).first(id: id).nil?
-      end
+    def exists?(id:)
+      resources.select(1).first(id: id).nil?
+    end
   end
 end

data/lib/valkyrie/sequel/query_service.rb

@@ -1,7 +1,11 @@
 # frozen_string_literal: true
 module Valkyrie::Sequel
   class QueryService
+    # ACCEPTABLE_UUID is deprecated and unused.
+    # which IDs are acceptable is now decided by the database.
     ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}.freeze
+    DEFAULT_ID_TYPE = :uuid
+
     attr_reader :adapter
     delegate :resources, :resource_factory, :connection, to: :adapter
     def initialize(adapter:)
@@ -14,14 +18,27 @@ module Valkyrie::Sequel
       end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def find_by(id:)
       id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
       validate_id(id)
-      raise Valkyrie::Persistence::ObjectNotFoundError unless ACCEPTABLE_UUID.match?(id.to_s)
-      attributes = resources.first(id: id.to_s)
+      attributes = nil
+      # Create a nested transaction so it can rollback to a non-essential
+      # savepoint if the query fails, not wrecking upstream transactions.
+      connection.transaction(savepoint: true) do
+        attributes = resources.first(id: id.to_s)
+      end
       raise Valkyrie::Persistence::ObjectNotFoundError unless attributes
       resource_factory.to_resource(object: attributes)
+    rescue Sequel::DatabaseError => err
+      case err.cause
+      when PG::InvalidTextRepresentation
+        raise Valkyrie::Persistence::ObjectNotFoundError
+      else
+        raise err
+      end
     end
+    # rubocop:enable Metrics/MethodLength
 
     def find_all_of_model(model:)
       resources.where(internal_resource: model.to_s).map do |attributes|
@@ -42,11 +59,8 @@ module Valkyrie::Sequel
         validate_id(id)
         id.to_s
       end
-      ids = ids.select do |id|
-        ACCEPTABLE_UUID.match?(id)
-      end
 
-      resources.where(id: ids).map do |attributes|
+      resources.where(Sequel.lit('(id::varchar) IN ?', ids)).map do |attributes|
         resource_factory.to_resource(object: attributes)
       end
     end
@@ -111,149 +125,149 @@ module Valkyrie::Sequel
 
     private
 
-      # Generate the SQL query for retrieving member resources in PostgreSQL using a
-      #   resource ID as an argument.
-      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
-      # @note this uses a CROSS JOIN for all combinations of member IDs with the
-      #   IDs of their parents
-      # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
-      # This also uses JSON functions in order to retrieve JSON property values
-      # @see https://www.postgresql.org/docs/current/static/functions-json.html
-      # @return [String]
-      def find_members_query
-        <<-SQL
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   resource ID as an argument.
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # @note this uses a CROSS JOIN for all combinations of member IDs with the
+    #   IDs of their parents
+    # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+    # This also uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
+    def find_members_query
+      <<-SQL
           SELECT member.* FROM orm_resources a,
           jsonb_array_elements(a.metadata->'member_ids') WITH ORDINALITY AS b(member, member_pos)
           JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
           ORDER BY b.member_pos
         SQL
-      end
+    end
 
-      # Generate the SQL query for retrieving member resources in PostgreSQL using a
-      #   resource ID and resource type as arguments.
-      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
-      # @note this uses a CROSS JOIN for all combinations of member IDs with the
-      #   IDs of their parents
-      # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
-      # This also uses JSON functions in order to retrieve JSON property values
-      # @see https://www.postgresql.org/docs/current/static/functions-json.html
-      # @return [String]
-      def find_members_with_type_query
-        <<-SQL
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   resource ID and resource type as arguments.
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # @note this uses a CROSS JOIN for all combinations of member IDs with the
+    #   IDs of their parents
+    # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+    # This also uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
+    def find_members_with_type_query
+      <<-SQL
           SELECT member.* FROM orm_resources a,
           jsonb_array_elements(a.metadata->'member_ids') WITH ORDINALITY AS b(member, member_pos)
           JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
           AND member.internal_resource = ?
           ORDER BY b.member_pos
         SQL
-      end
+    end
 
-      # Generate the SQL query for retrieving member resources in PostgreSQL using a
-      #   JSON object literal as an argument (e. g. { "alternate_ids": [{"id": "d6e88f80-41b3-4dbf-a2a0-cd79e20f6d10"}] }).
-      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
-      # This uses JSON functions in order to retrieve JSON property values
-      # @see https://www.postgresql.org/docs/current/static/functions-json.html
-      # @return [String]
-      def find_inverse_references_query
-        <<-SQL
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   JSON object literal as an argument (e. g. { "alternate_ids": [{"id": "d6e88f80-41b3-4dbf-a2a0-cd79e20f6d10"}] }).
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # This uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
+    def find_inverse_references_query
+      <<-SQL
           SELECT * FROM orm_resources WHERE
           metadata @> ?
         SQL
-      end
+    end
 
-      def find_inverse_references_with_model_query
-        <<-SQL
+    def find_inverse_references_with_model_query
+      <<-SQL
           SELECT * FROM orm_resources WHERE
           metadata @> ?
           AND internal_resource = ?
         SQL
-      end
+    end
 
-      # Generate the SQL query for retrieving member resources in PostgreSQL using a
-      #   JSON object literal and resource ID as arguments.
-      # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
-      # @note this uses a CROSS JOIN for all combinations of member IDs with the
-      #   IDs of their parents
-      # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
-      # This also uses JSON functions in order to retrieve JSON property values
-      # @see https://www.postgresql.org/docs/current/static/functions-json.html
-      # @return [String]
-      def find_references_query
-        <<-SQL
+    # Generate the SQL query for retrieving member resources in PostgreSQL using a
+    #   JSON object literal and resource ID as arguments.
+    # @see https://guides.rubyonrails.org/active_record_querying.html#array-conditions
+    # @note this uses a CROSS JOIN for all combinations of member IDs with the
+    #   IDs of their parents
+    # @see https://www.postgresql.org/docs/current/static/queries-table-expressions.html#QUERIES-FROM
+    # This also uses JSON functions in order to retrieve JSON property values
+    # @see https://www.postgresql.org/docs/current/static/functions-json.html
+    # @return [String]
+    def find_references_query
+      <<-SQL
           SELECT DISTINCT member.* FROM orm_resources a,
           jsonb_array_elements(a.metadata->?) AS b(member)
           JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
         SQL
-      end
+    end
 
-      def find_references_with_type_query
-        <<-SQL
+    def find_references_with_type_query
+      <<-SQL
           SELECT DISTINCT member.* FROM orm_resources a,
           jsonb_array_elements(a.metadata->?) AS b(member)
           JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
           AND member.internal_resource = ?
         SQL
-      end
+    end
 
-      def find_ordered_references_query
-        <<-SQL
+    def find_ordered_references_query
+      <<-SQL
           SELECT member.* FROM orm_resources a,
           jsonb_array_elements(a.metadata->?) WITH ORDINALITY AS b(member, member_pos)
           JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
           ORDER BY b.member_pos
         SQL
-      end
+    end
 
-      def find_ordered_references_with_type_query
-        <<-SQL
+    def find_ordered_references_with_type_query
+      <<-SQL
           SELECT member.* FROM orm_resources a,
           jsonb_array_elements(a.metadata->?) WITH ORDINALITY AS b(member, member_pos)
           JOIN orm_resources member ON (b.member->>'id')::#{id_type} = member.id WHERE a.id = ?
           AND member.internal_resource = ?
           ORDER BY b.member_pos
         SQL
-      end
+    end
 
-      # Accesses the data type in PostgreSQL used for the primary key
-      # (For example, a UUID)
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaCache.html#method-i-columns_hash
-      # @return [Symbol]
-      def id_type
-        @id_type ||= :uuid
-      end
+    # Accesses the data type in PostgreSQL used for the primary key
+    # (For example, a UUID)
+    # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaCache.html#method-i-columns_hash
+    # @return [Symbol]
+    def id_type
+      @id_type ||= DEFAULT_ID_TYPE
+    end
 
-      # Determines whether or not an Object is a Valkyrie ID
-      # @param [Object] id
-      # @raise [ArgumentError]
-      def validate_id(id)
-        raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
-      end
+    # Determines whether or not an Object is a Valkyrie ID
+    # @param [Object] id
+    # @raise [ArgumentError]
+    def validate_id(id)
+      raise ArgumentError, 'id must be a Valkyrie::ID' unless id.is_a? Valkyrie::ID
+    end
 
-      # Determines whether or not a resource has been persisted
-      # @param [Object] resource
-      # @raise [ArgumentError]
-      def ensure_persisted(resource)
-        raise ArgumentError, 'resource is not saved' unless resource.persisted?
-      end
+    # Determines whether or not a resource has been persisted
+    # @param [Object] resource
+    # @raise [ArgumentError]
+    def ensure_persisted(resource)
+      raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    end
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      end
+    def ordered_property?(resource:, property:)
+      resource.ordered_attribute?(property)
+    end
 
-      def find_ordered_references_by(resource:, property:, model: nil)
-        if model
-          run_query(find_ordered_references_with_type_query, property.to_s, resource.id.to_s, model.to_s)
-        else
-          run_query(find_ordered_references_query, property.to_s, resource.id.to_s)
-        end
+    def find_ordered_references_by(resource:, property:, model: nil)
+      if model
+        run_query(find_ordered_references_with_type_query, property.to_s, resource.id.to_s, model.to_s)
+      else
+        run_query(find_ordered_references_query, property.to_s, resource.id.to_s)
       end
+    end
 
-      def find_unordered_references_by(resource:, property:, model: nil)
-        if model
-          run_query(find_references_with_type_query, property.to_s, resource.id.to_s, model.to_s)
-        else
-          run_query(find_references_query, property.to_s, resource.id.to_s)
-        end
+    def find_unordered_references_by(resource:, property:, model: nil)
+      if model
+        run_query(find_references_with_type_query, property.to_s, resource.id.to_s, model.to_s)
+      else
+        run_query(find_references_query, property.to_s, resource.id.to_s)
       end
+    end
   end
 end

data/lib/valkyrie/sequel/resource_factory/orm_converter.rb

@@ -13,48 +13,48 @@ module Valkyrie::Sequel
 
     private
 
-      # Construct a new Valkyrie Resource using the attributes retrieved from the database
-      # @return [Valkyrie::Resource]
-      def resource
-        resource_klass.new(
-          attributes.merge(
-            new_record: false,
-            Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
-          )
+    # Construct a new Valkyrie Resource using the attributes retrieved from the database
+    # @return [Valkyrie::Resource]
+    def resource
+      resource_klass.new(
+        attributes.merge(
+          new_record: false,
+          Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK => lock_token
         )
-      end
-
-      # Construct the optimistic lock token using the adapter and lock version for the Resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      def lock_token
-        return nil unless object[:lock_version].present?
-        @lock_token ||=
-          Valkyrie::Persistence::OptimisticLockToken.new(
-            adapter_id: resource_factory.adapter_id,
-            token: object[:lock_version]
-          )
-      end
-
-      # Retrieve the Class used to construct the Valkyrie Resource
-      # @return [Class]
-      def resource_klass
-        internal_resource.constantize
-      end
-
-      # Access the String for the Valkyrie Resource type within the attributes
-      # @return [String]
-      def internal_resource
-        attributes[:internal_resource]
-      end
-
-      def attributes
-        @attributes ||= object.except(:metadata).merge(rdf_metadata).symbolize_keys
-      end
-
-      # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
-      # @return [Hash]
-      def rdf_metadata
-        @rdf_metadata ||= Valkyrie::Persistence::Shared::JSONValueMapper.new(object[:metadata]).result
-      end
+      )
+    end
+
+    # Construct the optimistic lock token using the adapter and lock version for the Resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    def lock_token
+      return nil if object[:lock_version].blank?
+      @lock_token ||=
+        Valkyrie::Persistence::OptimisticLockToken.new(
+          adapter_id: resource_factory.adapter_id,
+          token: object[:lock_version]
+        )
+    end
+
+    # Retrieve the Class used to construct the Valkyrie Resource
+    # @return [Class]
+    def resource_klass
+      internal_resource.constantize
+    end
+
+    # Access the String for the Valkyrie Resource type within the attributes
+    # @return [String]
+    def internal_resource
+      attributes[:internal_resource]
+    end
+
+    def attributes
+      @attributes ||= object.except(:metadata).merge(rdf_metadata).symbolize_keys
+    end
+
+    # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
+    # @return [Hash]
+    def rdf_metadata
+      @rdf_metadata ||= Valkyrie::Persistence::Shared::JSONValueMapper.new(object[:metadata]).result
+    end
   end
 end

data/lib/valkyrie/sequel/resource_factory/resource_converter.rb

@@ -8,7 +8,7 @@ module Valkyrie::Sequel
       :internal_resource
     ].freeze
 
-    BLACKLIST_TERMS = [
+    DISALLOWED_TERMS = [
       :new_record
     ].freeze
 
@@ -23,53 +23,52 @@ module Valkyrie::Sequel
     def convert!
       output = database_hash
       output[:id] = resource.id.to_s if resource.id
-      output.delete(:id) unless !output[:id] || QueryService::ACCEPTABLE_UUID.match?(output[:id].to_s)
       process_lock_token(output)
       output
     end
 
     private
 
-      # Retrieves the optimistic lock token from the Valkyrie attribute value and
-      #   sets it to the lock_version on ORM resource
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
-      # @param [ORM::Resource] orm_object
-      def process_lock_token(orm_object)
-        return unless resource.respond_to?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
-        postgres_token = (resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK] || []).find do |token|
-          token.adapter_id == resource_factory.adapter_id
-        end
-        return unless postgres_token
-        orm_object[:lock_version] = postgres_token.token
-      end
-
-      def database_hash
-        resource_hash.select do |k, _v|
-          PRIMARY_TERMS.include?(k)
-        end.compact.merge(
-          metadata: ::Sequel.pg_json(metadata_hash)
-        )
+    # Retrieves the optimistic lock token from the Valkyrie attribute value and
+    #   sets it to the lock_version on ORM resource
+    # @see https://api.rubyonrails.org/classes/ActiveRecord/Locking/Optimistic.html
+    # @param [ORM::Resource] orm_object
+    def process_lock_token(orm_object)
+      return unless resource.respond_to?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
+      postgres_token = (resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK] || []).find do |token|
+        token.adapter_id == resource_factory.adapter_id
       end
+      return unless postgres_token
+      orm_object[:lock_version] = postgres_token.token
+    end
 
-      def resource_hash
-        @resource_hash ||= resource.__attributes__
-      end
+    def database_hash
+      resource_hash.select do |k, _v|
+        PRIMARY_TERMS.include?(k)
+      end.compact.merge(
+        metadata: ::Sequel.pg_json(metadata_hash)
+      )
+    end
 
-      # Convert attributes to all be arrays to better enable querying and
-      # "changing of minds" later on.
-      # @return [Hash]
-      def metadata_hash
-        Hash[
-          selected_resource_attributes.compact.map do |k, v|
-            [k, Array.wrap(v)]
-          end
-        ]
-      end
+    def resource_hash
+      @resource_hash ||= resource.__attributes__
+    end
 
-      def selected_resource_attributes
-        resource_hash.select do |k, _v|
-          !PRIMARY_TERMS.include?(k) && !BLACKLIST_TERMS.include?(k)
+    # Convert attributes to all be arrays to better enable querying and
+    # "changing of minds" later on.
+    # @return [Hash]
+    def metadata_hash
+      Hash[
+        selected_resource_attributes.compact.map do |k, v|
+          [k, Array.wrap(v)]
         end
+      ]
+    end
+
+    def selected_resource_attributes
+      resource_hash.select do |k, _v|
+        !PRIMARY_TERMS.include?(k) && !DISALLOWED_TERMS.include?(k)
       end
+    end
   end
 end

data/lib/valkyrie/sequel/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Valkyrie
   module Sequel
-    VERSION = "2.1.0"
+    VERSION = "2.2.0"
   end
 end

data/valkyrie-sequel.gemspec

@@ -20,16 +20,15 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "sequel"
-  spec.add_dependency "sequel_pg"
+  spec.add_dependency "sequel", "~> 5.0"
+  spec.add_dependency "sequel_pg", "~> 1.0"
   spec.add_dependency "valkyrie", '~> 2.1.0'
-  spec.add_dependency "oj"
+  spec.add_dependency "oj", "~> 3.0"
   spec.add_development_dependency "bundler", "~> 2.0"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "bixby"
   spec.add_development_dependency "pry-byebug"
-  spec.add_development_dependency "database_cleaner"
-  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "database_cleaner", "< 2"
   spec.add_development_dependency "simplecov"
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie-sequel
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Trey Pendragon
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-03-10 00:00:00.000000000 Z
+date: 2021-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
   name: sequel_pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: valkyrie
   requirement: !ruby/object:Gem::Requirement
@@ -56,16 +56,16 @@ dependencies:
   name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -140,30 +140,16 @@ dependencies:
   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: coveralls
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -211,7 +197,7 @@ files:
 homepage: https://github.com/samvera-labs/valkyrie-sequel
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -226,8 +212,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Valkyrie::MetadataAdapter for Postgres using Sequel.
 test_files: []