valkyrie-sequel 2.0.1 → 3.0.0.pre.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a74b8f8a7ba365deb8fcda493a2289a579580018ba4d9251684a9bcc02d3665
-  data.tar.gz: 70774d437ef4fdc8e75566ca4c1942bbc66f247eee19b49a3017cea3097b66af
+  metadata.gz: b6d42b77cece523b4eeacf7f4853bc20e0fac7f5b8df24e742ae4ef1e6b7df12
+  data.tar.gz: 6edac9cf3f494640dfe74e062dd3760d9f0386d8d3b60dcf2ea7f01190e3fc3d
 SHA512:
-  metadata.gz: dad38881c3959f86f9febc7fe1a1ea5e62fea9310af9715c27da3087cfe4af6ebfed20ab9e48de6b99e775901f818aeca5beb2e3fd215b3a7adf81cb87ceff1e
-  data.tar.gz: 160c5f59b084e3594995d492773d16734daaaa98141b9340f4859914a7710fa3426d3f5b38e97efd56b19f527ac618210280e96de2f8521b6afca55de352d05d
+  metadata.gz: 53f9dc78cec19cb0eaac3e7001eaf2f8d2cf8c29e3ec10795fa0f1b69162ba34d8a237582c9f7345022fc0d82d422eac490be84eb8596f39941b2dffad2af812
+  data.tar.gz: 51faaaad25361de2f20885dafa49307a56bb75bd91a2a907607ae4228bef125764acf7d6ef162a34c2fbc50270ff3a6e5a5b1922074c33030a0415a2b4e97d87

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

@@ -8,9 +8,9 @@ module Valkyrie::Sequel
       @adapter = adapter
     end
 
-    def save(resource:)
+    def save(resource:, external_resource: false)
       object_attributes = resource_factory.from_resource(resource: resource)
-      output = create_or_update(resource: resource, attributes: object_attributes)
+      output = create_or_update(resource: resource, attributes: object_attributes, external_resource: external_resource)
       resource_factory.to_resource(object: output)
     end
 
@@ -121,32 +121,39 @@ 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])
+    def create_or_update(resource:, attributes:, external_resource:)
+      attributes[:updated_at] = Time.now.utc
+      attributes[:created_at] ||= Time.now.utc
+      if exists?(id: attributes[:id])
         update(resource: resource, attributes: attributes)
+      else
+        if !external_resource && resource.persisted?
+          # This resource has been deleted in the meantime, error.
+          raise Valkyrie::Persistence::ObjectNotFoundError, "The object #{resource.id} is previously persisted but not found at save time." unless exists?(id: attributes[:id])
+        end
+        create(resource: resource, attributes: attributes)
       end
+    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|
@@ -29,37 +46,45 @@ module Valkyrie::Sequel
       end
     end
 
+    # Count all records for a specific resource type
+    # @param [Class] model
+    # @return integer
+    def count_all_of_model(model:)
+      resources.where(internal_resource: model.to_s).count
+    end
+
     def find_many_by_ids(ids:)
       ids = ids.map do |id|
         id = Valkyrie::ID.new(id.to_s) if id.is_a?(String)
         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
 
-    def find_references_by(resource:, property:)
+    def find_references_by(resource:, property:, model: nil)
       return [] if resource.id.blank? || resource[property].blank?
       # only return ordered if needed to avoid performance penalties
       if ordered_property?(resource: resource, property: property)
-        run_query(find_ordered_references_query, property.to_s, resource.id.to_s)
+        find_ordered_references_by(resource: resource, property: property, model: model)
       else
-        run_query(find_references_query, property.to_s, resource.id.to_s)
+        find_unordered_references_by(resource: resource, property: property, model: model)
       end
     end
 
-    def find_inverse_references_by(resource: nil, id: nil, property:)
+    def find_inverse_references_by(resource: nil, id: nil, model: nil, property:)
       raise ArgumentError, "Provide resource or id" unless resource || id
       ensure_persisted(resource) if resource
       id ||= resource.id
       internal_array = { property => [id: id.to_s] }
-      run_query(find_inverse_references_query, internal_array.to_json)
+      if model
+        run_query(find_inverse_references_with_model_query, internal_array.to_json, model.to_s)
+      else
+        run_query(find_inverse_references_query, internal_array.to_json)
+      end
     end
 
     # Find and a record using a Valkyrie ID for an alternate ID, and construct
@@ -100,106 +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
+          SELECT * FROM orm_resources WHERE
+          metadata @> ?
+          AND internal_resource = ?
+        SQL
+    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
+          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
 
-      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
 
-      # 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
+    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
 
-      # 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
+    # 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 a resource has been persisted
-      # @param [Object] resource
-      # @raise [ArgumentError]
-      def ensure_persisted(resource)
-        raise ArgumentError, 'resource is not saved' unless resource.persisted?
+    # 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
+
+    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
+    end
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
+    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.0.1"
+    VERSION = "3.0.0-beta.1"
   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 "valkyrie", '~> 2.0.0'
-  spec.add_dependency "oj"
+  spec.add_dependency "sequel", "~> 5.0"
+  spec.add_dependency "sequel_pg", "~> 1.0"
+  spec.add_dependency "valkyrie", ">= 3.0.0-beta.1"
+  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,71 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie-sequel
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0.pre.beta.1
 platform: ruby
 authors:
 - Trey Pendragon
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-02-04 00:00:00.000000000 Z
+date: 2021-10-26 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
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0.pre.beta.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0.pre.beta.1
 - !ruby/object:Gem::Dependency
   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'
+        version: '2'
   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'
-  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
@@ -222,12 +208,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Valkyrie::MetadataAdapter for Postgres using Sequel.
 test_files: []