valkyrie 1.1.2 → 1.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2b7dcc5a9a264acb744d602fd069a7c2ff5a1c11
-  data.tar.gz: 82fdcd0161085c15492f9fb5fdd8515ffde5d7e3
+SHA256:
+  metadata.gz: 8a320a108f82f79f88b27eaeb267b7b134499e346dccaae4f93165ff95e47fa5
+  data.tar.gz: bebc13ba65b1e1e2d69fd9a9c9408f8af8ef4484984a6de568db4c90c34eb15f
 SHA512:
-  metadata.gz: ef3b35b27a29849cb2bd00e136d20018067c6852f1f3ead55f92fd202d1030b6ecc073fed84f43b724b9ba52aba193bd28d9b5eece9144ecac1b6edbabdc200c
-  data.tar.gz: '0824a51c53a59ec27205872aa5e29b22ad8bd711ac035bd307d17db1b5b17e1178d159d30229467f87d33b755ee4d6b979719333f287fd6ce74d979d382ed58b'
+  metadata.gz: 8a32748fc47406abdb640ce4191e6271c61a0813cb2774a444ed5c6a45a5a34fd8e599f37afab22ac6c76d71d25bcaee28df6801a3c57add7617b064fc5ed3fb
+  data.tar.gz: b353cc383371599df898f626b6e211294a34f5e351dad0fc0521a11841e79c04da3699c1e867f54e102c09379cba0366fa62e408738c3f7fa0f2637a20d59a14

data/.rubocop.yml

@@ -25,7 +25,7 @@ RSpec/MultipleExpectations:
   Enabled: false
 Rails/TimeZone:
   Enabled: false
-Style/PredicateName:
+Naming/PredicateName:
   Exclude:
     - "lib/valkyrie/resource.rb"
     - "lib/valkyrie/persistence/solr/queries/default_paginator.rb"

data/.rubocop_todo.yml

@@ -1,3 +1,8 @@
 Metrics/ClassLength:
   Exclude:
+    - 'lib/valkyrie/persistence/fedora/persister.rb'
     - 'lib/valkyrie/persistence/postgres/query_service.rb'
+
+Metrics/MethodLength:
+  Exclude:
+    - 'lib/valkyrie/persistence/fedora/persister.rb'

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+# v1.2.0.RC1 2018-08-09
+
+## Changes since last release
+
+* Support for single values.
+  [Documentation](https://github.com/samvera-labs/valkyrie/wiki/Using-Types#singular-values)
+* Optimistic Locking.
+  [Documentation](https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking)
+* Remove reliance on ActiveFedora for Fedora Storage Adapter.
+* Only load adapters if referenced.
+* Postgres Adapter uses transactions for `save_all`
+* Resources now include `id` attribute by default.
+
+## Special Thanks
+
+This release was made possible by a community sprint undertaken between Penn
+State University Libraries & Princeton University Library. Thanks to the
+following participants who made it happen:
+
+* [awead](https://github.com/awead)
+* [cam156](https://github.com/cam156)
+* [DanCoughlin](https://github.com/DanCoughlin)
+* [escowles](https://github.com/escowles)
+* [hackmastera](https://github.com/hackmastera)
+* [jrgriffiniii](https://github.com/jrgriffiniii)
+* [mtribone](https://github.com/mtribone)
+* [tpendragon](https://github.com/tpendragon)
+
 # v1.1.2 2018-06-08
 
 ## Changes since last release

data/README.md

@@ -5,21 +5,30 @@ Valkyrie is a gem for enabling multiple backends for storage of files and metada
 [![CircleCI](https://circleci.com/gh/samvera-labs/valkyrie.svg?style=svg)](https://circleci.com/gh/samvera-labs/valkyrie)
 [![Coverage Status](https://coveralls.io/repos/github/samvera-labs/valkyrie/badge.svg?branch=master)](https://coveralls.io/github/samvera-labs/valkyrie?branch=master)
 [![Stories in Ready](https://badge.waffle.io/samvera-labs/valkyrie.png?label=ready&title=Ready)](https://waffle.io/samvera-labs/valkyrie)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://rubydoc.info/github/samvera-labs/valkyrie)
 
+## Primary Contacts
+
+### Product Owner
+
+[Carolyn Cole](https://github.com/cam156)
+
+### Technical Lead
+
+[Trey Pendragon](https://github.com/tpendragon)
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-```ruby
-gem 'valkyrie', github: 'samvera-labs/valkyrie'
+```
+gem 'valkyrie'
 ```
 
 And then execute:
 
     $ bundle
 
-
 ## Configuration
 
 Valkyrie is configured in two places: an initializer that registers the persistence options and a YAML
@@ -30,6 +39,7 @@ configuration file that sets which options are used by default in which environm
 Here is a sample initializer that registers a couple adapters and storage adapters, in each case linking an
 instance with a short name that can be used to refer to it in your application:
 
+
 ```
 # frozen_string_literal: true
 require 'valkyrie'
@@ -50,7 +60,7 @@ Rails.application.config.to_prepare do
   )
 
   Valkyrie::StorageAdapter.register(
-    Valkyrie::Storage::Fedora.new(connection: ActiveFedora.fedora.connection),
+    Valkyrie::Storage::Fedora.new(connection: Ldp::Client.new("http://localhost:8988/rest")),
     :fedora
   )
 
@@ -69,7 +79,7 @@ The initializer registers two `Valkyrie::MetadataAdapter` instances for storing
 
 Other adapter options include `Valkyrie::Persistence::BufferedPersister` for buffering in memory before bulk
 updating another persister, `Valkyrie::Persistence::CompositePersister` for storing in more than one adapter
-at once, and `Valkyrie::Persistence::Solr` for storing in Solr.
+at once, `Valkyrie::Persistence::Solr` for storing in Solr, and `Valkyrie::Persistence::Fedora` for storing in Fedora.
 
 The initializer also registers three `Valkyrie::StorageAdapter` instances for storing files:
 * `:disk` which stores files on disk
@@ -101,9 +111,23 @@ For each environment, you must set two values:
 
 The values are the short names used in your initializer.
 
+Further details can be found on the [the Wiki](https://github.com/samvera-labs/valkyrie/wiki/Persistence).
 
 ## Usage
 
+### The Public API
+
+Valkyrie's public API is defined by the shared specs that are used to test each of its core classes.
+This include change sets, resources, persisters, adapters, and queries. When creating your own kinds of
+these kinds of classes, you should use these shared specs to test your classes for conformance to
+Valkyrie's API.
+
+When breaking changes are introduced, necessitating a major version change, the shared specs will reflect
+this. Likewise, non-breaking changes to Valkyrie can be defined as code changes that do not cause any
+errors with the current shared specs.
+
+Using the shared specs in your own models is described in more [detail](https://github.com/samvera-labs/valkyrie/wiki/Shared-Specs).
+
 ### Define a Custom Work
 
 Define a custom work class:
@@ -112,12 +136,13 @@ Define a custom work class:
 # frozen_string_literal: true
 class MyModel < Valkyrie::Resource
   include Valkyrie::Resource::AccessControls
-  attribute :id, Valkyrie::Types::ID.optional  # Optional to allow auto-generation of IDs
   attribute :title, Valkyrie::Types::Set       # Sets are unordered
   attribute :authors, Valkyrie::Types::Array   # Arrays are ordered
 end
 ```
 
+Defining resource attributes is explained in greater detail within the [Wiki](https://github.com/samvera-labs/valkyrie/wiki/Using-Types).
+
 #### Work Types Generator
 
 To create a custom Valkyrie model in your application, you can use the Rails generator.  For example, to
@@ -153,6 +178,10 @@ objects = adapter.query_service.find_all
 Valkyrie.config.metadata_adapter.query_service.find_all_of_model(model: MyModel)
 ```
 
+The usage of `ChangeSets` in writing data are further documented [here](https://github.com/samvera-labs/valkyrie/wiki/ChangeSets-and-Dirty-Tracking).
+
+### Concurrency Support (Optimistic Locking)
+By default, it is assumed that a Valkyrie repository implementation shall use a solution supporting concurrent updates for resources (multiple resources can be updated simultaneously using a Gem such as [Sidekiq](https://github.com/mperham/sidekiq)).  In order to handle the possibility of multiple updates applied to the same resource corrupting data, Valkyrie supports optimistic locking.  For further details, please reference the [overview of optimistic locking for Valkyrie resources](https://github.com/samvera-labs/valkyrie/wiki/Optimistic-Locking).
 
 ## Installing a Development environment
 
@@ -183,7 +212,7 @@ Valkyrie.config.metadata_adapter.query_service.find_all_of_model(model: MyModel)
 
 1. `docker-machine create default`
 1. `docker-machine start default`
-1. `eval "$(docker-machine env)"
+1. `eval "$(docker-machine env)"`
 
 #### Starting the development mode dependencies
 1. Start Solr, Fedora, and PostgreSQL with `rake docker:dev:daemon` (or `rake docker:dev:up` in a separate shell to run them in the foreground)
@@ -204,6 +233,13 @@ Valkyrie.config.metadata_adapter.query_service.find_all_of_model(model: MyModel)
 
 The development and test stacks use fully contained virtual volumes and bind all services to different ports, so they can be running at the same time without issue.
 
+## Get Help
+
+If you have any questions regarding Valkyrie you can send a message to [the
+Samvera community tech list](mailto:samvera-tech@googlegroups.com) or the `#valkyrie`
+channel in the [Samvera community Slack
+team](https://wiki.duraspace.org/pages/viewpage.action?pageId=87460391#Getintouch!-Slack).
+
 ## License
 
 Valkyrie is available under [the Apache 2.0 license](../LICENSE).

data/db/migrate/20180802220739_add_optimistic_locking_to_orm_resources.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+class AddOptimisticLockingToOrmResources < ActiveRecord::Migration[5.1]
+  def change
+    add_column :orm_resources, :lock_version, :integer
+  end
+end

data/lib/generators/valkyrie/templates/resource.rb.erb

@@ -2,7 +2,6 @@
 # Generated with `rails generate valkyrie:model <%= class_name %>`
 class <%= class_name %> < Valkyrie::Resource
   include Valkyrie::Resource::AccessControls
-  attribute :id, Valkyrie::Types::ID.optional
 <%- attributes.each do |att| -%>
   attribute :<%= att.name %>, Valkyrie::Types::<%= (att.type == :array) ? 'Array' : 'Set' %>
 <%- end -%>

data/lib/valkyrie/change_set.rb

@@ -24,12 +24,15 @@ module Valkyrie
     property :append_id, virtual: true
 
     # Set ID of record this one should be appended to.
+    # We use append_id to add a member/child onto an existing list of members.
     # @param append_id [Valkyrie::ID]
     def append_id=(append_id)
       super(Valkyrie::ID.new(append_id))
     end
 
     # Returns whether or not a given field has multiple values.
+    # Multiple values are useful for fields like creator, author, title, etc.
+    # where there may be more than one value for a field that is stored and returned in the UI
     # @param field_name [Symbol]
     # @return [Boolean]
     def multiple?(field_name)
@@ -37,6 +40,7 @@ module Valkyrie
     end
 
     # Returns whether or not a given field is required.
+    # Useful for distinguishing required fields in a form and for validation
     # @param field_name [Symbol]
     # @return [Boolean]
     def required?(field_name)

data/lib/valkyrie/id.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 module Valkyrie
   # A simple ID class to keep IDs distinguished from strings
+  # In order for an object to be queryable via joins, it needs
+  # to be added as a reference via a Valkyrie::ID rather than just a string ID.
   class ID
     attr_reader :id
     delegate :empty?, to: :id
@@ -19,8 +21,11 @@ module Valkyrie
     end
     alias == eql?
 
+    # @deprecated Please use {.uri_for} instead
     def to_uri
       return RDF::Literal.new(id.to_s, datatype: RDF::URI("http://example.com/valkyrie_id")) if id.to_s.include?("://")
+      warn "[DEPRECATION] `to_uri` is deprecated and will be removed in the next major release. " \
+           "Called from #{Gem.location_of_caller.join(':')}"
       ::RDF::URI(ActiveFedora::Base.id_to_uri(id))
     end
 

data/lib/valkyrie/metadata_adapter.rb

@@ -8,6 +8,7 @@ module Valkyrie
     self.adapters = {}
     class << self
       # Register an adapter by a short name.
+      # Registering an adapter by a short name makes the adapter easier to find and reference.
       # @param adapter [#persister,#query_service] Adapter to register.
       # @param short_name [Symbol] Name to register it under.
       def register(adapter, short_name)

data/lib/valkyrie/persistence/composite_persister.rb

@@ -19,7 +19,15 @@ module Valkyrie::Persistence
 
     # (see Valkyrie::Persistence::Memory::Persister#save)
     def save(resource:)
-      persisters.inject(resource) { |m, persister| persister.save(resource: m) }
+      # Assume the first persister is the canonical data store; that's the optlock we want
+      first, *rest = *persisters
+      cached_resource = first.save(resource: resource)
+      # Don't pass opt lock tokens to other persisters
+      internal_resource = cached_resource.dup
+      internal_resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", []) if internal_resource.optimistic_locking_enabled?
+      rest.inject(internal_resource) { |m, persister| persister.save(resource: m) }
+      # return the one with the desired opt lock token
+      cached_resource
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save_all)
@@ -27,6 +35,9 @@ module Valkyrie::Persistence
       resources.map do |resource|
         save(resource: resource)
       end
+    rescue Valkyrie::Persistence::StaleObjectError
+      # clear out any IDs returned to reduce potential confusion
+      raise Valkyrie::Persistence::StaleObjectError
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#delete)

data/lib/valkyrie/persistence/fedora/list_node.rb

@@ -18,7 +18,7 @@ module Valkyrie::Persistence::Fedora
     end
 
     # Returns the next proxy or a tail sentinel.
-    # @return [ActiveFedora::Orders::ListNode]
+    # @return [RDF::URI]
     def next
       @next ||=
         if next_uri
@@ -31,13 +31,13 @@ module Valkyrie::Persistence::Fedora
     end
 
     # Returns the previous proxy or a head sentinel.
-    # @return [ActiveFedora::Orders::ListNode]
+    # @return [RDF::URI]
     def prev
       @prev ||= node_cache.fetch(prev_uri) if prev_uri
     end
 
     # Graph representation of node.
-    # @return [ActiveFedora::Orders::ListNode::Resource]
+    # @return [Valkyrie::Persistence::Fedora::ListNode::Resource]
     def to_graph
       return RDF::Graph.new if target_id.blank?
       g = Resource.new(rdf_subject)

data/lib/valkyrie/persistence/fedora/metadata_adapter.rb

@@ -24,6 +24,10 @@ module Valkyrie::Persistence::Fedora
       Valkyrie::Persistence::Fedora::Persister.new(adapter: self)
     end
 
+    def id
+      @id ||= Valkyrie::ID.new(Digest::MD5.hexdigest(connection_prefix))
+    end
+
     def resource_factory
       Valkyrie::Persistence::Fedora::Persister::ResourceFactory.new(adapter: self)
     end

data/lib/valkyrie/persistence/fedora/permissive_schema.rb

@@ -63,6 +63,11 @@ module Valkyrie::Persistence::Fedora
       uri_for(:valkyrie_time)
     end
 
+    # @return [RDF::URI]
+    def self.optimistic_lock_token
+      uri_for(:optimistic_lock_token)
+    end
+
     # Cast the property to a URI in the namespace
     # @param property [Symbol]
     # @return [RDF::URI]

data/lib/valkyrie/persistence/fedora/persister/alternate_identifier.rb

@@ -4,7 +4,6 @@ require 'valkyrie/types'
 
 module Valkyrie::Persistence::Fedora
   class AlternateIdentifier < ::Valkyrie::Resource
-    attribute :id, ::Valkyrie::Types::ID.optional
     attribute :references, ::Valkyrie::Types::ID.optional
   end
 end

data/lib/valkyrie/persistence/fedora/persister/model_converter.rb

@@ -22,6 +22,8 @@ module Valkyrie::Persistence::Fedora
         graph_resource
       end
 
+      # Filter resource properties to remove properties that should not be persisted to Fedora.
+      # * new_record is a virtual property for marking unsaved objects
       def properties
         resource_attributes.keys - [:new_record]
       end

data/lib/valkyrie/persistence/fedora/persister/orm_converter.rb

@@ -11,7 +11,7 @@ module Valkyrie::Persistence::Fedora
       end
 
       def convert
-        Valkyrie::Types::Anything[attributes]
+        populate_native_lock(Valkyrie::Types::Anything[attributes])
       end
 
       def attributes
@@ -20,6 +20,17 @@ module Valkyrie::Persistence::Fedora
                          .merge(id: id, new_record: false)
       end
 
+      # Get Fedora's lastModified value from the LDP response
+      def populate_native_lock(resource)
+        return resource unless resource.respond_to?(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK)
+        lastmod = object.response_graph.first_object([nil, RDF::URI("http://fedora.info/definitions/v4/repository#lastModified"), nil])
+        return resource unless lastmod
+
+        token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: "native-#{adapter.id}", token: DateTime.parse(lastmod.to_s).httpdate)
+        resource.send(Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK) << token
+        resource
+      end
+
       def id
         id_property.present? ? Valkyrie::ID.new(id_property) : adapter.uri_to_id(object.subject_uri)
       end
@@ -237,6 +248,18 @@ module Valkyrie::Persistence::Fedora
           end
         end
 
+        class ValkyrieOptimisticLockToken < ::Valkyrie::ValueMapper
+          FedoraValue.register(self)
+          def self.handles?(value)
+            value.statement.object.is_a?(RDF::Literal) && value.statement.object.datatype == PermissiveSchema.optimistic_lock_token
+          end
+
+          def result
+            value.statement.object = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: value.adapter.id, token: value.statement.object.to_s)
+            calling_mapper.for(Property.new(statement: value.statement, scope: value.scope, adapter: value.adapter)).result
+          end
+        end
+
         class InternalURI < ::Valkyrie::ValueMapper
           FedoraValue.register(self)
           def self.handles?(value)
@@ -295,10 +318,17 @@ module Valkyrie::Persistence::Fedora
             @property = property
           end
 
+          # Apply as a single value by default, if there are multiple then
+          # create an array. Done to support single values - if the resource is
+          # a Set or Array then it'll cast the single value back to an array
+          # appropriately.
           def apply_to(hsh)
             return if blacklist?(key)
-            hsh[key.to_sym] ||= []
-            hsh[key.to_sym] += cast_array(values)
+            hsh[key.to_sym] = if hsh.key?(key.to_sym)
+                                Array.wrap(hsh[key.to_sym]) + cast_array(values)
+                              else
+                                values
+                              end
           end
 
           def key

data/lib/valkyrie/persistence/fedora/persister.rb

@@ -6,6 +6,8 @@ module Valkyrie::Persistence::Fedora
     require 'valkyrie/persistence/fedora/persister/alternate_identifier'
     attr_reader :adapter
     delegate :connection, :base_path, :resource_factory, to: :adapter
+
+    # @note (see Valkyrie::Persistence::Memory::Persister#initialize)
     def initialize(adapter:)
       @adapter = adapter
     end
@@ -13,21 +15,26 @@ module Valkyrie::Persistence::Fedora
     # (see Valkyrie::Persistence::Memory::Persister#save)
     def save(resource:)
       initialize_repository
-      resource.created_at ||= Time.current
-      resource.updated_at ||= Time.current
-      ensure_multiple_values!(resource)
-      orm = resource_factory.from_resource(resource: resource)
-      alternate_resources = find_or_create_alternate_ids(resource)
-
-      if !orm.new? || resource.id
-        cleanup_alternate_resources(resource) if alternate_resources
-        orm.update { |req| req.headers["Prefer"] = "handling=lenient; received=\"minimal\"" }
+      internal_resource = resource.dup
+      internal_resource.created_at ||= Time.current
+      internal_resource.updated_at ||= Time.current
+      validate_lock_token(internal_resource)
+      native_lock = native_lock_token(internal_resource)
+      generate_lock_token(internal_resource)
+      orm = resource_factory.from_resource(resource: internal_resource)
+      alternate_resources = find_or_create_alternate_ids(internal_resource)
+
+      if !orm.new? || internal_resource.id
+        cleanup_alternate_resources(internal_resource) if alternate_resources
+        orm.update { |req| update_request_headers(req, native_lock) }
       else
         orm.create
       end
       persisted_resource = resource_factory.to_resource(object: orm)
 
       alternate_resources ? save_reference_to_resource(persisted_resource, alternate_resources) : persisted_resource
+    rescue Ldp::PreconditionFailed
+      raise Valkyrie::Persistence::StaleObjectError, internal_resource.id.to_s
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#save_all)
@@ -35,6 +42,9 @@ module Valkyrie::Persistence::Fedora
       resources.map do |resource|
         save(resource: resource)
       end
+    rescue Valkyrie::Persistence::StaleObjectError
+      # blank out the message / id
+      raise Valkyrie::Persistence::StaleObjectError
     end
 
     # (see Valkyrie::Persistence::Memory::Persister#delete)
@@ -70,13 +80,6 @@ module Valkyrie::Persistence::Fedora
 
     private
 
-      def ensure_multiple_values!(resource)
-        bad_keys = resource.attributes.except(:internal_resource, :created_at, :updated_at, :new_record, :id, :references).select do |_k, v|
-          !v.nil? && !v.is_a?(Array)
-        end
-        raise ::Valkyrie::Persistence::UnsupportedDatatype, "#{resource}: #{bad_keys.keys} have non-array values, which can not be persisted by Valkyrie. Cast to arrays." unless bad_keys.keys.empty?
-      end
-
       def find_or_create_alternate_ids(resource)
         return nil unless resource.try(:alternate_ids)
 
@@ -107,5 +110,43 @@ module Valkyrie::Persistence::Fedora
 
         resource
       end
+
+      # @note Fedora's last modified response is not granular enough to produce an effective lock token
+      #   therefore, we use the same implementation as the memory adapter. This could fail to lock a
+      #   resource if Fedora updated this resource between the time it was saved and Valkyrie created
+      #   the token.
+      def generate_lock_token(resource)
+        return unless resource.optimistic_locking_enabled?
+        token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
+        resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", token)
+      end
+
+      def validate_lock_token(resource)
+        return unless resource.optimistic_locking_enabled?
+        return if resource.id.blank?
+
+        current_lock_token = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id == adapter.id }
+        return if current_lock_token.blank?
+
+        retrieved_lock_tokens = adapter.query_service.find_by(id: resource.id)[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+        retrieved_lock_token = retrieved_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
+        return if retrieved_lock_token.blank?
+
+        raise Valkyrie::Persistence::StaleObjectError, resource.id.to_s unless current_lock_token == retrieved_lock_token
+      end
+
+      # Retrieve the lock token that holds Fedora's system-managed last-modified date
+      def native_lock_token(resource)
+        return unless resource.optimistic_locking_enabled?
+        resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].find { |lock_token| lock_token.adapter_id == "native-#{adapter.id}" }
+      end
+
+      # Set Fedora request headers:
+      # * `Prefer: handling=lenient; received="minimal"` allows us to avoid sending all server-managed triples
+      # * `If-Unmodified-Since` triggers Fedora's server-side optimistic locking
+      def update_request_headers(request, lock_token)
+        request.headers["Prefer"] = "handling=lenient; received=\"minimal\""
+        request.headers["If-Unmodified-Since"] = lock_token.token if lock_token
+      end
   end
 end

data/lib/valkyrie/persistence/fedora/query_service.rb

@@ -4,6 +4,8 @@ module Valkyrie::Persistence::Fedora
   class QueryService
     attr_reader :adapter
     delegate :connection, :resource_factory, to: :adapter
+
+    # @note (see Valkyrie::Persistence::Memory::QueryService#initialize)
     def initialize(adapter:)
       @adapter = adapter
     end

data/lib/valkyrie/persistence/fedora.rb

@@ -3,6 +3,8 @@
 module Valkyrie::Persistence
   # Implements the DataMapper Pattern to store metadata into Fedora
   module Fedora
+    require 'active_triples'
+    require 'active_fedora'
     require 'valkyrie/persistence/fedora/permissive_schema'
     require 'valkyrie/persistence/fedora/metadata_adapter'
     require 'valkyrie/persistence/fedora/persister'

data/lib/valkyrie/persistence/memory/metadata_adapter.rb

@@ -23,5 +23,9 @@ module Valkyrie::Persistence::Memory
     def cache
       @cache ||= {}
     end
+
+    def id
+      @id ||= Valkyrie::ID.new(Digest::MD5.hexdigest(self.class.to_s))
+    end
   end
 end

data/lib/valkyrie/persistence/memory/persister.rb

@@ -6,8 +6,10 @@ module Valkyrie::Persistence::Memory
   class Persister
     attr_reader :adapter
     delegate :cache, to: :adapter
+
     # @param adapter [Valkyrie::Persistence::Memory::MetadataAdapter] The memory adapter which
     #   holds the cache for this persister.
+    # @note Many persister methods are part of Valkyrie's public API, but instantiation itself is not
     def initialize(adapter)
       @adapter = adapter
     end
@@ -16,13 +18,18 @@ module Valkyrie::Persistence::Memory
     # @return [Valkyrie::Resource] The resource with an `#id` value generated by the
     #   persistence backend.
     def save(resource:)
-      resource = generate_id(resource) if resource.id.blank?
-      resource.created_at ||= Time.current
-      resource.updated_at = Time.current
-      resource.new_record = false
-      normalize_dates!(resource)
-      ensure_multiple_values!(resource)
-      cache[resource.id] = resource
+      raise Valkyrie::Persistence::StaleObjectError, resource.id unless valid_lock?(resource)
+
+      # duplicate the resource so we are not creating side effects on the caller's resource
+      internal_resource = resource.dup
+
+      internal_resource = generate_id(internal_resource) if internal_resource.id.blank?
+      internal_resource.created_at ||= Time.current
+      internal_resource.updated_at = Time.current
+      internal_resource.new_record = false
+      generate_lock_token(internal_resource)
+      normalize_dates!(internal_resource)
+      cache[internal_resource.id] = internal_resource
     end
 
     # @param resources [Array<Valkyrie::Resource>] List of resources to save.
@@ -32,6 +39,9 @@ module Valkyrie::Persistence::Memory
       resources.map do |resource|
         save(resource: resource)
       end
+    rescue Valkyrie::Persistence::StaleObjectError
+      # Re-raising with no error message to prevent confusion
+      raise Valkyrie::Persistence::StaleObjectError
     end
 
     # @param resource [Valkyrie::Resource] The resource to delete from the persistence
@@ -51,13 +61,6 @@ module Valkyrie::Persistence::Memory
         resource.new(id: SecureRandom.uuid)
       end
 
-      def ensure_multiple_values!(resource)
-        bad_keys = resource.attributes.except(:internal_resource, :created_at, :updated_at, :new_record, :id).select do |_k, v|
-          !v.nil? && !v.is_a?(Array)
-        end
-        raise ::Valkyrie::Persistence::UnsupportedDatatype, "#{resource}: #{bad_keys.keys} have non-array values, which can not be persisted by Valkyrie. Cast to arrays." unless bad_keys.keys.empty?
-      end
-
       def normalize_dates!(resource)
         resource.attributes.each { |k, v| resource.send("#{k}=", normalize_date_values(v)) }
       end
@@ -72,5 +75,25 @@ module Valkyrie::Persistence::Memory
         return value.to_datetime.utc if value.is_a?(Time)
         value
       end
+
+      def generate_lock_token(resource)
+        return unless resource.optimistic_locking_enabled?
+        token = Valkyrie::Persistence::OptimisticLockToken.new(adapter_id: adapter.id, token: Time.now.to_r)
+        resource.send("#{Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK}=", token)
+      end
+
+      def valid_lock?(resource)
+        return true unless resource.optimistic_locking_enabled?
+
+        cached_resource = cache[resource.id]
+        return true if cached_resource.blank?
+
+        resource_lock_tokens = resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK]
+        resource_value = resource_lock_tokens.find { |lock_token| lock_token.adapter_id == adapter.id }
+        return true if resource_value.blank?
+
+        cached_value = cached_resource[Valkyrie::Persistence::Attributes::OPTIMISTIC_LOCK].first
+        cached_value == resource_value
+      end
   end
 end