valkyrie 3.0.2 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76da3433a725bab465d01c70034a9b528de21b67e4e2b2b4e81672749b9f8742
-  data.tar.gz: 1379068c2f9c376ff085e1ac401a4b4f02ed86abbe5713f76b17e046d0fdfe56
+  metadata.gz: e6705b30a79e047e4892d78b3f60a2fb71a9acc4b4687272a7e169e216177a81
+  data.tar.gz: c4cbe96c86968b611d1932f505cb020c1071e6fa0938f11b25f4e78c3c7b840b
 SHA512:
-  metadata.gz: 31b910d396d7cb48ab10785818e01e5855de5f5001b2c5a3d7474663133b96a1c2d5ee222a911f169244c61daa23b16fe95cc215575756812da63d2cbae54989
-  data.tar.gz: be55227d51bf77a2f13382cde82d5008e7e0fe5612353c096450b5204632f5f0291412abecd8853571b1183b18aad30fae246ff5b3e70439be46498c1850ef36
+  metadata.gz: 80cc406ed49c5256d4744c83eaf0e849722d28b151a6f47b5dfdb9c69871a82253f9b3c2b8331f92b6a253792b1c982f5bfcd9c198cd631f84613e50c57c4d5f
+  data.tar.gz: b7b397512adac100586c392be50ecc9690562d7282078b2e627dc558aa37f096472543130c11eedf60dd4a4a5c091e6496d86064009583c85d110cb2aed2e151

data/.circleci/config.yml

@@ -28,7 +28,7 @@ jobs:
         environment:
           CATALINA_OPTS: "-Djava.awt.headless=true -Dfile.encoding=UTF-8 -server -Xms512m -Xmx1024m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:PermSize=256m -XX:MaxPermSize=256m -XX:+DisableExplicitGC"
           JAVA_OPTIONS: "-Djetty.http.port=8998 -Dfcrepo.dynamic.jms.port=61618 -Dfcrepo.dynamic.stomp.port=61614"
-      - image: fcrepo/fcrepo:6.0.0
+      - image: fcrepo/fcrepo:6.4.0
         environment:
           CATALINA_OPTS: "-Djava.awt.headless=true -Dfile.encoding=UTF-8 -server -Xms512m -Xmx1024m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:PermSize=256m -XX:MaxPermSize=256m -XX:+DisableExplicitGC -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true"
           JAVA_OPTS: "-Djetty.http.port=8978 -Dfcrepo.dynamic.jms.port=61619 -Dfcrepo.dynamic.stomp.port=61615 -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true"

data/.lando.yml

@@ -24,19 +24,26 @@ services:
       - fedora4:/data
       ports:
       - 8988:8080
-    portforward: true
+    environment:
+      CATALINA_OPTS: "-Djava.awt.headless=true -Dfile.encoding=UTF-8 -server -Xms512m -Xmx1024m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:PermSize=256m -XX:MaxPermSize=256m -XX:+DisableExplicitGC"
+    portforward: 8988
   valkyrie_fedora_5:
     type: compose
     app_mount: false
     volumes:
       fedora5:
     services:
-      image: samvera/fcrepo4:5.1.0
-      command: /fedora-entrypoint.sh
+      image: fcrepo/fcrepo:5.1.1-multiplatform
+      command:
+        - "catalina.sh"
+        - "run"
       volumes:
       - fedora5:/data
       ports:
       - 8998:8080
+      environment:
+        CATALINA_OPTS: "-Djava.awt.headless=true -Dfile.encoding=UTF-8 -server -Xms512m -Xmx1024m -XX:NewSize=256m -XX:MaxNewSize=256m -XX:PermSize=256m -XX:MaxPermSize=256m -XX:+DisableExplicitGC -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true"
+        JAVA_OPTS: "-Dfcrepo.dynamic.jms.port=61620 -Dfcrepo.dynamic.stomp.port=61617 -Dorg.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH=true"
     portforward: true
   valkyrie_fedora_6:
     type: compose
@@ -44,7 +51,7 @@ services:
     volumes:
       fedora6:
     services:
-      image: fcrepo/fcrepo:6.0.0
+      image: fcrepo/fcrepo:6.4.0
       command:
         - "catalina.sh"
         - "run"

data/.rubocop_todo.yml

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

data/CHANGELOG.md

@@ -1,3 +1,32 @@
+# v3.1.0 2023-09-15
+
+## Changes since last release
+
+* Add storage adapter versioning. ([tpendragon](https://github.com/tpendragon))
+    - Special thanks to [marrus-sh](https://github.com/marrus-sh) and
+        [no-reply](https://github.com/no-reply) for their work testing and
+        finding a good interface for using versions in an application.
+
+Additional thanks to the following for code review and issue reports leading to
+this release:
+
+* [dlpierce](https://github.com/dlpierce)
+* [hackartisan](https://github.com/hackartisan)
+* [marrus-sh](https://github.com/marrus-sh)
+* [no-reply](https://github.com/no-reply)
+
+# v3.0.3 2023-05-15
+
+## Changes since last release
+
+* Avoid `delegate` in ChangeSet. ([dlpierce](https://github.com/dlpierce))
+
+Additional thanks to the following for code review and issue reports leading to
+this release:
+
+* [ShanaLMoore](https://github.com/ShanaLMoore)
+* [jeremyf](https://github.com/jeremyf)
+
 # v3.0.2 2023-04-10
 
 ## Changes since last release

data/lib/valkyrie/change_set.rb

@@ -77,9 +77,11 @@ module Valkyrie
       send(key) if respond_to?(key)
     end
 
-    delegate :attributes, to: :resource
-
-    delegate :internal_resource, :created_at, :updated_at, :model_name, :optimistic_locking_enabled?, to: :resource
+    [:internal_resource, :created_at, :updated_at, :model_name, :optimistic_locking_enabled?, :attributes].each do |method_name|
+      define_method(method_name) do |*args|
+        resource.public_send(method_name, *args)
+      end
+    end
 
     # Prepopulates all fields with defaults defined in the changeset. This is an
     # override of Reform::Form's method to allow for single-valued fields to

data/lib/valkyrie/specs/shared_specs/storage_adapter.rb

@@ -16,6 +16,11 @@ RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
   it { is_expected.to respond_to(:find_by).with_keywords(:id) }
   it { is_expected.to respond_to(:delete).with_keywords(:id) }
   it { is_expected.to respond_to(:upload).with_keywords(:file, :resource, :original_filename) }
+  it { is_expected.to respond_to(:supports?) }
+
+  it "returns false for non-existing features" do
+    expect(storage_adapter.supports?(:bad_feature_not_real_dont_implement)).to eq false
+  end
 
   it "can upload a file which is just an IO" do
     io_file = Tempfile.new('temp_io')
@@ -50,7 +55,7 @@ RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
   end
 
   it "can upload, validate, re-fetch, and delete a file" do
-    resource = Valkyrie::Specs::CustomResource.new(id: "test")
+    resource = Valkyrie::Specs::CustomResource.new(id: "test#{SecureRandom.uuid}")
     sha1 = Digest::SHA1.file(file).to_s
     size = file.size
     expect(uploaded_file = storage_adapter.upload(file: file, original_filename: 'foo.jpg', resource: resource, fake_upload_argument: true)).to be_kind_of Valkyrie::StorageAdapter::File
@@ -77,4 +82,64 @@ RSpec.shared_examples 'a Valkyrie::StorageAdapter' do
     expect { storage_adapter.find_by(id: uploaded_file.id) }.to raise_error Valkyrie::StorageAdapter::FileNotFound
     expect { storage_adapter.find_by(id: Valkyrie::ID.new("noexist")) }.to raise_error Valkyrie::StorageAdapter::FileNotFound
   end
+
+  it "can upload and find new versions" do
+    pending "Versioning not supported" unless storage_adapter.supports?(:versions)
+    resource = Valkyrie::Specs::CustomResource.new(id: "test#{SecureRandom.uuid}")
+    uploaded_file = storage_adapter.upload(file: file, original_filename: 'foo.jpg', resource: resource, fake_upload_argument: true)
+    expect(uploaded_file.version_id).not_to be_blank
+
+    f = Tempfile.new
+    f.puts "Test File"
+    f.rewind
+
+    # upload_version
+    new_version = storage_adapter.upload_version(id: uploaded_file.id, file: f)
+    expect(uploaded_file.id).to eq new_version.id
+    expect(uploaded_file.version_id).not_to eq new_version.version_id
+
+    # find_versions
+    # Two versions of the same file have the same id, but different version_ids,
+    # use case: I want to store metadata about a file when it's uploaded as a
+    #   version and refer to it consistently.
+    versions = storage_adapter.find_versions(id: new_version.id)
+    expect(versions.length).to eq 2
+    expect(versions.first.id).to eq new_version.id
+    expect(versions.first.version_id).to eq new_version.version_id
+
+    expect(versions.last.id).to eq uploaded_file.id
+    expect(versions.last.version_id).to eq uploaded_file.version_id
+
+    expect(versions.first.size).not_to eq versions.last.size
+
+    expect(storage_adapter.find_by(id: uploaded_file.version_id).version_id).to eq uploaded_file.version_id
+
+    # Deleting a version should leave the current versions
+    if storage_adapter.supports?(:version_deletion)
+      storage_adapter.delete(id: uploaded_file.version_id)
+      expect(storage_adapter.find_versions(id: uploaded_file.id).length).to eq 1
+      expect { storage_adapter.find_by(id: uploaded_file.version_id) }.to raise_error Valkyrie::StorageAdapter::FileNotFound
+    end
+    current_length = storage_adapter.find_versions(id: new_version.id).length
+
+    # Restoring a previous version is just pumping its file into upload_version
+    newest_version = storage_adapter.upload_version(file: new_version, id: new_version.id)
+    expect(newest_version.version_id).not_to eq new_version.id
+    expect(storage_adapter.find_by(id: newest_version.id).version_id).to eq newest_version.version_id
+
+    # I can restore a version twice
+    newest_version = storage_adapter.upload_version(file: new_version, id: new_version.id)
+    expect(newest_version.version_id).not_to eq new_version.id
+    expect(storage_adapter.find_by(id: newest_version.id).version_id).to eq newest_version.version_id
+    expect(storage_adapter.find_versions(id: newest_version.id).length).to eq current_length + 2
+
+    # NOTE: We originally wanted deleting the current record to push it into the
+    # versions history, but FCRepo 4/5/6 doesn't work that way, so we changed to
+    # instead make deleting delete everything.
+    storage_adapter.delete(id: new_version.id)
+    expect { storage_adapter.find_by(id: new_version.id) }.to raise_error Valkyrie::StorageAdapter::FileNotFound
+    expect(storage_adapter.find_versions(id: new_version.id).length).to eq 0
+  ensure
+    f&.close
+  end
 end

data/lib/valkyrie/storage/disk.rb

@@ -27,6 +27,12 @@ module Valkyrie::Storage
       id.to_s.start_with?("disk://#{base_path}")
     end
 
+    # @param feature [Symbol] Feature to test for.
+    # @return [Boolean] true if the adapter supports the given feature
+    def supports?(_feature)
+      false
+    end
+
     def file_path(id)
       id.to_s.gsub(/^disk:\/\//, '')
     end

data/lib/valkyrie/storage/fedora.rb

@@ -19,12 +19,21 @@ module Valkyrie::Storage
       id.to_s.start_with?(PROTOCOL)
     end
 
+    # @param feature [Symbol] Feature to test for.
+    # @return [Boolean] true if the adapter supports the given feature
+    def supports?(feature)
+      return true if feature == :versions
+      # Fedora 6 auto versions and you can't delete versions.
+      return true if feature == :version_deletion && fedora_version != 6
+      false
+    end
+
     # Return the file associated with the given identifier
     # @param id [Valkyrie::ID]
     # @return [Valkyrie::StorageAdapter::StreamFile]
     # @raise Valkyrie::StorageAdapter::FileNotFound if nothing is found
     def find_by(id:)
-      Valkyrie::StorageAdapter::StreamFile.new(id: id, io: response(id: id))
+      perform_find(id: id)
     end
 
     # @param file [IO]
@@ -37,24 +46,123 @@ module Valkyrie::Storage
     def upload(file:, original_filename:, resource:, content_type: "application/octet-stream", # rubocop:disable Metrics/ParameterLists
                resource_uri_transformer: default_resource_uri_transformer, **_extra_arguments)
       identifier = resource_uri_transformer.call(resource, base_url) + '/original'
+      upload_file(fedora_uri: identifier, io: file, content_type: content_type, original_filename: original_filename)
+      # Fedora 6 auto versions, so check to see if there's a version for this
+      # initial upload. If not, then mint one (fedora 4/5)
+      version_id = current_version_id(id: valkyrie_identifier(uri: identifier)) || mint_version(identifier, latest_version(identifier))
+      perform_find(id: Valkyrie::ID.new(identifier.to_s.sub(/^.+\/\//, PROTOCOL)), version_id: version_id)
+    end
+
+    # @param id [Valkyrie::ID] ID of the Valkyrie::StorageAdapter::StreamFile to
+    #   version.
+    # @param file [IO]
+    def upload_version(id:, file:)
+      uri = fedora_identifier(id: id)
+      # Fedora 6 has auto versioning, so have to sleep if it's too soon after last
+      # upload.
+      if fedora_version == 6 && current_version_id(id: id).to_s.split("/").last == Time.current.utc.strftime("%Y%m%d%H%M%S")
+        sleep(0.5)
+        return upload_version(id: id, file: file)
+      end
+      upload_file(fedora_uri: uri, io: file)
+      version_id = mint_version(uri, latest_version(uri))
+      perform_find(id: Valkyrie::ID.new(uri.to_s.sub(/^.+\/\//, PROTOCOL)), version_id: version_id)
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Array<Valkyrie::StorageAdapter::StreamFile>]
+    def find_versions(id:)
+      uri = fedora_identifier(id: id)
+      version_list = version_list(uri)
+      version_list.map do |version|
+        id = valkyrie_identifier(uri: version["@id"])
+        perform_find(id: id, version_id: id)
+      end
+    end
+
+    # Delete the file in Fedora associated with the given identifier.
+    # @param id [Valkyrie::ID]
+    def delete(id:)
+      connection.http.delete(fedora_identifier(id: id))
+    end
+
+    def version_list(fedora_uri)
+      version_list = connection.http.get do |request|
+        request.url "#{fedora_uri}/fcr:versions"
+        request.headers["Accept"] = "application/ld+json"
+      end
+      return [] unless version_list.success?
+      version_graph = JSON.parse(version_list.body)&.first
+      if fedora_version == 4
+        version_graph&.fetch("http://fedora.info/definitions/v4/repository#hasVersion", [])
+      else
+        # Fedora 5/6 use Memento.
+        version_graph&.fetch("http://www.w3.org/ns/ldp#contains", [])&.sort_by { |x| x["@id"] }&.reverse
+      end
+    end
+
+    def upload_file(fedora_uri:, io:, content_type: "application/octet-stream", original_filename: "default")
       sha1 = [5, 6].include?(fedora_version) ? "sha" : "sha1"
       connection.http.put do |request|
-        request.url identifier
+        request.url fedora_uri
         request.headers['Content-Type'] = content_type
-        request.headers['Content-Length'] = file.length.to_s
+        request.headers['Content-Length'] = io.length.to_s if io.respond_to?(:length)
         request.headers['Content-Disposition'] = "attachment; filename=\"#{original_filename}\""
-        request.headers['digest'] = "#{sha1}=#{Digest::SHA1.file(file)}"
+        request.headers['digest'] = "#{sha1}=#{Digest::SHA1.file(io)}" if io.respond_to?(:to_str)
         request.headers['link'] = "<http://www.w3.org/ns/ldp#NonRDFSource>; rel=\"type\""
-        io = Faraday::UploadIO.new(file, content_type, original_filename)
+        io = Faraday::UploadIO.new(io, content_type, original_filename)
         request.body = io
       end
-      find_by(id: Valkyrie::ID.new(identifier.to_s.sub(/^.+\/\//, PROTOCOL)))
     end
 
-    # Delete the file in Fedora associated with the given identifier.
-    # @param id [Valkyrie::ID]
-    def delete(id:)
-      connection.http.delete(fedora_identifier(id: id))
+    # Returns a new version identifier to mint. Defaults to version1, but will
+    # increment to version2 etc if one found. Only for Fedora 4.
+    def latest_version(identifier)
+      # Only version 4 needs a version ID, 5/6 both mint using timestamps.
+      return :not_applicable if fedora_version != 4
+      version_list = version_list(identifier)
+      return "version1" if version_list.blank?
+      last_version = version_list.first["@id"]
+      last_version_number = last_version.split("/").last.gsub("version", "").to_i
+      "version#{last_version_number + 1}"
+    end
+
+    # @param [Valkyrie::ID] id A storage ID that's not a version, to get the
+    #   version ID of.
+    def current_version_id(id:)
+      version_list = version_list(fedora_identifier(id: id))
+      return nil if version_list.blank?
+      valkyrie_identifier(uri: version_list.first["@id"])
+    end
+
+    def perform_find(id:, version_id: nil)
+      current_id = Valkyrie::ID.new(id.to_s.split("/fcr:versions").first)
+      version_id ||= id if id != current_id
+      # No version got passed and we're asking for a current_id, gotta get the
+      # version ID
+      return perform_find(id: current_id, version_id: (current_version_id(id: id) || :empty)) if version_id.nil?
+      Valkyrie::StorageAdapter::StreamFile.new(id: current_id, io: response(id: id), version_id: version_id)
+    end
+
+    # @param identifier [String] Fedora URI to mint a version for.
+    # @return [Valkyrie::ID] version_id of the minted version.
+    # Versions are created AFTER content is uploaded, except for Fedora 6 which
+    #   auto versions.
+    def mint_version(identifier, version_name = "version1")
+      response = connection.http.post do |request|
+        request.url "#{identifier}/fcr:versions"
+        request.headers['Slug'] = version_name if fedora_version == 4
+      end
+      # If there's a deletion marker, don't return anything. (Fedora 4)
+      return nil if response.status == 410
+      # This is awful, but versioning is locked to per-second increments,
+      # returns a 409 in Fedora 5 if there's a conflict.
+      if response.status == 409
+        sleep(0.5)
+        return mint_version(identifier, version_name)
+      end
+      raise "Version unable to be created" unless response.status == 201
+      valkyrie_identifier(uri: response.headers["location"].gsub("/fcr:metadata", ""))
     end
 
     class IOProxy
@@ -81,6 +189,11 @@ module Valkyrie::Storage
       RDF::URI(identifier)
     end
 
+    def valkyrie_identifier(uri:)
+      id = uri.to_s.sub("http://", PROTOCOL)
+      Valkyrie::ID.new(id)
+    end
+
     private
 
     # @return [IOProxy]

data/lib/valkyrie/storage/memory.rb

@@ -17,7 +17,32 @@ module Valkyrie::Storage
     # @return [Valkyrie::StorageAdapter::StreamFile]
     def upload(file:, original_filename:, resource: nil, **_extra_arguments)
       identifier = Valkyrie::ID.new("memory://#{resource.id}")
-      cache[identifier] = Valkyrie::StorageAdapter::StreamFile.new(id: identifier, io: file)
+      version_id = Valkyrie::ID.new("#{identifier}##{SecureRandom.uuid}")
+      cache[identifier] ||= {}
+      cache[identifier][:current] = Valkyrie::StorageAdapter::StreamFile.new(id: identifier, io: file, version_id: version_id)
+    end
+
+    # @param file [IO]
+    # @param original_filename [String]
+    # @param previous_version_id [Valkyrie::ID]
+    # @param _extra_arguments [Hash] additional arguments which may be passed to
+    #   other adapters.
+    # @return [Valkyrie::StorageAdapter::StreamFile]
+    def upload_version(id:, file:)
+      # Get previous file and add a UUID to the end of it.
+      new_file = Valkyrie::StorageAdapter::StreamFile.new(id: id, io: file, version_id: Valkyrie::ID.new("#{id}##{SecureRandom.uuid}"))
+      current_file = cache[id][:current]
+      cache[id][:current] = new_file
+      cache[id][:versions] ||= []
+      cache[id][:versions].prepend(current_file) if current_file
+      new_file
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Array<Valkyrie::StorageAdapter::StreamFile>]
+    def find_versions(id:)
+      return [] if cache[id].nil?
+      [cache[id][:current] || nil].compact + cache[id].fetch(:versions, [])
     end
 
     # Return the file associated with the given identifier
@@ -25,8 +50,18 @@ module Valkyrie::Storage
     # @return [Valkyrie::StorageAdapter::StreamFile]
     # @raise Valkyrie::StorageAdapter::FileNotFound if nothing is found
     def find_by(id:)
-      raise Valkyrie::StorageAdapter::FileNotFound unless cache[id]
-      cache[id]
+      no_version_id, _version = id_and_version(id)
+      raise Valkyrie::StorageAdapter::FileNotFound unless cache[no_version_id]
+      version =
+        if id == no_version_id
+          cache[id][:current]
+        else
+          find_versions(id: no_version_id).find do |file|
+            file.version_id == id
+          end
+        end
+      raise Valkyrie::StorageAdapter::FileNotFound unless version
+      version
     end
 
     # @param id [Valkyrie::ID]
@@ -35,10 +70,35 @@ module Valkyrie::Storage
       id.to_s.start_with?("memory://")
     end
 
+    # @param feature [Symbol] Feature to test for.
+    # @return [Boolean] true if the adapter supports the given feature
+    def supports?(feature)
+      case feature
+      when :versions
+        true
+      when :version_deletion
+        true
+      else
+        false
+      end
+    end
+
+    def id_and_version(id)
+      id, version = id.to_s.split("#")
+      [Valkyrie::ID.new(id), version]
+    end
+
     # Delete the file on disk associated with the given identifier.
     # @param id [Valkyrie::ID]
     def delete(id:)
-      cache.delete(id)
+      base_id, version = id_and_version(id)
+      if version && cache[base_id][:current]&.version_id != id
+        cache[base_id][:versions].reject! do |file|
+          file.version_id == id
+        end
+      else
+        cache.delete(base_id)
+      end
       nil
     end
   end

data/lib/valkyrie/storage/versioned_disk.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+module Valkyrie::Storage
+  # The VersionedDisk adapter implements versioned storage on disk by storing
+  # the timestamp of the file's creation as part of the file name
+  # (v-timestamp-filename.jpg). If the
+  # current file is deleted it creates a DeletionMarker, which is an empty file
+  # with "deletionmarker" in the name of the file.
+  class VersionedDisk
+    attr_reader :base_path, :path_generator, :file_mover
+    def initialize(base_path:, path_generator: ::Valkyrie::Storage::Disk::BucketedStorage, file_mover: FileUtils.method(:cp))
+      @base_path = Pathname.new(base_path.to_s)
+      @path_generator = path_generator.new(base_path: base_path)
+      @file_mover = file_mover
+    end
+
+    # @param file [IO]
+    # @param original_filename [String]
+    # @param resource [Valkyrie::Resource]
+    # @param _extra_arguments [Hash] additional arguments which may be passed to other adapters
+    # @return [Valkyrie::StorageAdapter::File]
+    def upload(file:, original_filename:, resource: nil, paused: false, **extra_arguments)
+      version_timestamp = current_timestamp
+      new_path = path_generator.generate(resource: resource, file: file, original_filename: "v-#{version_timestamp}-#{original_filename}")
+      # If we've gone faster than milliseconds here, pause a millisecond and
+      # re-call. Probably only an issue for test suites.
+      return sleep(0.001) && upload(file: file, original_filename: original_filename, resource: resource, paused: true, **extra_arguments) if !paused && File.exist?(new_path)
+      FileUtils.mkdir_p(new_path.parent)
+      file_mover.call(file.try(:path) || file.try(:disk_path), new_path)
+      find_by(id: Valkyrie::ID.new("versiondisk://#{new_path}"))
+    end
+
+    def current_timestamp
+      Time.now.strftime("%s%L")
+    end
+
+    # @param id [Valkyrie::ID] ID of the Valkyrie::StorageAdapter::File to
+    #   version.
+    # @param file [IO]
+    # @param paused [Boolean] set to true when upload_version had to pause for a
+    #   millisecond to get a later timestamp. Internal only - do not set.
+    def upload_version(id:, file:, paused: false)
+      version_timestamp = current_timestamp
+      # Get the existing version_id so we can calculate the next path from it.
+      current_version_id = version_id(id)
+      current_version_id = current_version_id.version_files[1] if current_version_id.deletion_marker?
+      existing_path = current_version_id.file_path
+      new_path = Pathname.new(existing_path.gsub(current_version_id.version, version_timestamp.to_s))
+      # If we've gone faster than milliseconds here, pause a millisecond and
+      # re-call.
+      return sleep(0.001) && upload_version(id: id, file: file, paused: true) if !paused && File.exist?(new_path)
+      FileUtils.mkdir_p(new_path.parent)
+      file_mover.call(file.try(:path) || file.try(:disk_path), new_path)
+      find_by(id: Valkyrie::ID.new("versiondisk://#{new_path}"))
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Boolean] true if this adapter can handle this type of identifer
+    def handles?(id:)
+      id.to_s.start_with?("versiondisk://#{base_path}")
+    end
+
+    # @param feature [Symbol] Feature to test for.
+    # @return [Boolean] true if the adapter supports the given feature
+    def supports?(feature)
+      return true if feature == :versions || feature == :version_deletion
+      false
+    end
+
+    # Return the file associated with the given identifier
+    # @param id [Valkyrie::ID]
+    # @return [Valkyrie::StorageAdapter::File]
+    # @raise Valkyrie::StorageAdapter::FileNotFound if nothing is found
+    def find_by(id:)
+      version_id = version_id(id)
+      raise Valkyrie::StorageAdapter::FileNotFound if version_id.nil? || version_id&.deletion_marker?
+      Valkyrie::StorageAdapter::File.new(id: version_id.current_reference_id.id, io: ::Valkyrie::Storage::Disk::LazyFile.open(version_id.file_path, 'rb'), version_id: version_id.id)
+    rescue Errno::ENOENT
+      raise Valkyrie::StorageAdapter::FileNotFound
+    end
+
+    # Delete the file on disk associated with the given identifier.
+    # @param id [Valkyrie::ID]
+    def delete(id:)
+      id = version_id(id).resolve_current
+      if id.current?
+        id.version_files.each do |version_id|
+          FileUtils.rm_rf(version_id.file_path)
+        end
+      elsif File.exist?(id.file_path)
+        FileUtils.rm_rf(id.file_path)
+      end
+    end
+
+    # @param id [Valkyrie::ID]
+    # @return [Array<Valkyrie::StorageAdapter::File>]
+    def find_versions(id:)
+      version_files(id: id).select { |x| !x.to_s.include?("deletionmarker") }.map do |file|
+        find_by(id: Valkyrie::ID.new("versiondisk://#{file}"))
+      end
+    end
+
+    def version_files(id:)
+      root = Pathname.new(file_path(id))
+      id = VersionId.new(id)
+      root.parent.children.select { |file| file.basename.to_s.end_with?(id.filename) }.sort.reverse
+    end
+
+    def file_path(version_id)
+      version_id.to_s.gsub(/^versiondisk:\/\//, '')
+    end
+
+    # @return VersionId A VersionId value that's resolved a current reference,
+    #   so we can access the `version_id` and current reference.
+    def version_id(id)
+      id = VersionId.new(id)
+      return id unless id.versioned?
+      id.resolve_current
+    end
+
+    # A small value class that holds a version id and methods for knowing things about it.
+    # Examples of version ids in this adapter:
+    #   * "versiondisk://te/st/test/v-current-filename.jpg" (never actually saved this way on disk, just used as a reference)
+    #   * "versiondisk://te/st/test/v-1694195675462560794-filename.jpg" (this timestamped form would be saved on disk)
+    #   * "versiondisk://te/st/test/v-1694195675462560794-deletionmarker-filename.jpg" (this file is saved on disk but empty)
+    class VersionId
+      attr_reader :id
+      def initialize(id)
+        @id = id
+      end
+
+      def current_reference_id
+        self.class.new(Valkyrie::ID.new(string_id.gsub(version, "current")))
+      end
+
+      # @return [VersionID] the version_id for the current file
+      def resolve_current
+        return self unless reference?
+        version_files.first
+      end
+
+      def file_path
+        @file_path ||= string_id.gsub(/^versiondisk:\/\//, '')
+      end
+
+      def version_files
+        root = Pathname.new(file_path)
+        root.parent.children.select { |file| file.basename.to_s.end_with?(filename) }.sort.reverse.map do |file|
+          VersionId.new(Valkyrie::ID.new("versiondisk://#{file}"))
+        end
+      end
+
+      def deletion_marker?
+        string_id.include?("deletionmarker")
+      end
+
+      def current?
+        version_files.first.id == id
+      end
+
+      # @return [Boolean] Whether this id is referential (e.g. "current") or absolute (e.g. a timestamp)
+      def reference?
+        version == "current"
+      end
+
+      def versioned?
+        string_id.include?("v-")
+      end
+
+      def version
+        string_id.split("v-").last.split("-", 2).first
+      end
+
+      def filename
+        string_id.split("v-").last.split("-", 2).last.gsub("deletionmarker-", "")
+      end
+
+      def string_id
+        id.to_s
+      end
+    end
+  end
+end

data/lib/valkyrie/storage.rb

@@ -31,6 +31,7 @@ module Valkyrie
   # @see lib/valkyrie/specs/shared_specs/storage_adapter.rb
   module Storage
     require 'valkyrie/storage/disk'
+    require 'valkyrie/storage/versioned_disk'
     require 'valkyrie/storage/fedora'
     require 'valkyrie/storage/memory'
   end

data/lib/valkyrie/storage_adapter.rb

@@ -67,6 +67,7 @@ module Valkyrie
     class File < Dry::Struct
       attribute :id, Valkyrie::Types::Any
       attribute :io, Valkyrie::Types::Any
+      attribute :version_id, Valkyrie::Types::Any.optional.default(nil)
       delegate :size, :read, :rewind, :close, to: :io
       def stream
         io

data/lib/valkyrie/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Valkyrie
-  VERSION = "3.0.2"
+  VERSION = "3.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valkyrie
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.1.0
 platform: ruby
 authors:
 - Trey Pendragon
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-10 00:00:00.000000000 Z
+date: 2023-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-struct
@@ -535,6 +535,7 @@ files:
 - lib/valkyrie/storage/disk.rb
 - lib/valkyrie/storage/fedora.rb
 - lib/valkyrie/storage/memory.rb
+- lib/valkyrie/storage/versioned_disk.rb
 - lib/valkyrie/storage_adapter.rb
 - lib/valkyrie/types.rb
 - lib/valkyrie/value_mapper.rb