valkyrie 2.1.0 → 3.0.0.pre.beta.1

data/lib/valkyrie/persistence/postgres/orm_converter.rb

@@ -21,65 +21,65 @@ module Valkyrie::Persistence::Postgres
 
     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
+      )
+    end
 
-      # Construct the optimistic lock token using the adapter and lock version for the Resource
-      # @return [Valkyrie::Persistence::OptimisticLockToken]
-      def lock_token
-        return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
-        @lock_token ||=
-          Valkyrie::Persistence::OptimisticLockToken.new(
-            adapter_id: resource_factory.adapter_id,
-            token: orm_object.lock_version
-          )
-      end
+    # Construct the optimistic lock token using the adapter and lock version for the Resource
+    # @return [Valkyrie::Persistence::OptimisticLockToken]
+    def lock_token
+      return lock_token_warning unless orm_object.class.column_names.include?("lock_version")
+      @lock_token ||=
+        Valkyrie::Persistence::OptimisticLockToken.new(
+          adapter_id: resource_factory.adapter_id,
+          token: orm_object.lock_version
+        )
+    end
 
-      # Issue a migration warning for previous releases of Valkyrie which did not support optimistic locking
-      def lock_token_warning
-        return nil unless resource_klass.optimistic_locking_enabled?
-        warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
-             "optimistic locking enabled, but the necessary migrations have not been run. \n" \
-             "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
-             "to enable this feature for Postgres."
-        nil
-      end
+    # Issue a migration warning for previous releases of Valkyrie which did not support optimistic locking
+    def lock_token_warning
+      return nil unless resource_klass.optimistic_locking_enabled?
+      warn "[MIGRATION REQUIRED] You have loaded a resource from the Postgres adapter with " \
+           "optimistic locking enabled, but the necessary migrations have not been run. \n" \
+           "Please run `bin/rails valkyrie_engine:install:migrations && bin/rails db:migrate` " \
+           "to enable this feature for Postgres."
+      nil
+    end
 
-      # Retrieve the Class used to construct the Valkyrie Resource
-      # @return [Class]
-      def resource_klass
-        Valkyrie.config.resource_class_resolver.call(internal_resource)
-      end
+    # Retrieve the Class used to construct the Valkyrie Resource
+    # @return [Class]
+    def resource_klass
+      Valkyrie.config.resource_class_resolver.call(internal_resource)
+    end
 
-      # Access the String for the Valkyrie Resource type within the attributes
-      # @return [String]
-      def internal_resource
-        attributes[:internal_resource]
-      end
+    # Access the String for the Valkyrie Resource type within the attributes
+    # @return [String]
+    def internal_resource
+      attributes[:internal_resource]
+    end
 
-      # @return [Hash] Valkyrie-style hash of attributes.
-      def attributes
-        @attributes ||= orm_object.attributes.merge(rdf_metadata).symbolize_keys
-      end
+    # @return [Hash] Valkyrie-style hash of attributes.
+    def attributes
+      @attributes ||= orm_object.attributes.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 ||= RDFMetadata.new(orm_object.metadata).result
-      end
+    # Generate a Hash derived from Valkyrie Resource metadata encoded in the RDF
+    # @return [Hash]
+    def rdf_metadata
+      @rdf_metadata ||= RDFMetadata.new(orm_object.metadata).result
+    end
 
-      # Responsible for converting `metadata` JSON-B field in
-      # {Valkyrie::Persistence::Postgres::ORM::Resource} into an acceptable hash
-      # for {Valkyrie::Resource}
-      class RDFMetadata < ::Valkyrie::Persistence::Shared::JSONValueMapper
-      end
+    # Responsible for converting `metadata` JSON-B field in
+    # {Valkyrie::Persistence::Postgres::ORM::Resource} into an acceptable hash
+    # for {Valkyrie::Resource}
+    class RDFMetadata < ::Valkyrie::Persistence::Shared::JSONValueMapper
+    end
   end
 end

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

@@ -17,9 +17,12 @@ module Valkyrie::Persistence::Postgres
     # @return [Valkyrie::Resource] the persisted/updated resource
     # @raise [Valkyrie::Persistence::StaleObjectError] raised if the resource
     #   was modified in the database between been read into memory and persisted
-    def save(resource:)
+    def save(resource:, external_resource: false)
       orm_object = resource_factory.from_resource(resource: resource)
       orm_object.transaction do
+        if !external_resource && resource.persisted? && !orm_object.persisted?
+          raise Valkyrie::Persistence::ObjectNotFoundError, "The object #{resource.id} is previously persisted but not found at save time."
+        end
         orm_object.save!
         if resource.id && resource.id.to_s != orm_object.id
           raise Valkyrie::Persistence::UnsupportedDatatype,

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

@@ -251,46 +251,46 @@ module Valkyrie::Persistence::Postgres
 
     private
 
-      def find_ordered_references_by(resource:, property:, model: nil)
-        if model
-          run_query(find_ordered_references_with_type_query, property, resource.id.to_s, model)
-        else
-          run_query(find_ordered_references_query, property, 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, resource.id.to_s, model)
+      else
+        run_query(find_ordered_references_query, property, 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, resource.id.to_s, model)
-        else
-          run_query(find_references_query, property, resource.id.to_s)
-        end
+    def find_unordered_references_by(resource:, property:, model: nil)
+      if model
+        run_query(find_references_with_type_query, property, resource.id.to_s, model)
+      else
+        run_query(find_references_query, property, resource.id.to_s)
       end
+    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
 
-      # 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 ||= orm_class.columns_hash["id"].type
-      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 ||= orm_class.columns_hash["id"].type
+    end
 
-      def ordered_property?(resource:, property:)
-        resource.ordered_attribute?(property)
-      end
+    def ordered_property?(resource:, property:)
+      resource.ordered_attribute?(property)
+    end
   end
 end

data/lib/valkyrie/persistence/shared/json_value_mapper.rb

@@ -152,7 +152,7 @@ module Valkyrie::Persistence::Shared
       # Generates a Time object in the UTC from the datestamp string value
       # @return [Time]
       def result
-        DateTime.iso8601(value).utc
+        DateTime.iso8601(value).new_offset(0)
       end
     end
   end

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

@@ -27,18 +27,30 @@ module Valkyrie::Persistence::Solr
   #     )
   #   )
   class MetadataAdapter
-    attr_reader :connection, :resource_indexer
+    attr_reader :connection, :resource_indexer, :write_only
     # @param connection [RSolr::Client] The RSolr connection to index to.
     # @param resource_indexer [Class, #to_solr] An indexer which is able to
     #   receive a `resource` argument and then has an instance method `#to_solr`
-    def initialize(connection:, resource_indexer: NullIndexer)
+    # @param write_only [Boolean] If true act as a write only adapter.
+    # @param soft_commit [Boolean] If false, don't soft commit.
+    def initialize(connection:, resource_indexer: NullIndexer, write_only: false, soft_commit: true)
       @connection = connection
       @resource_indexer = resource_indexer
+      @write_only = write_only
+      @soft_commit = soft_commit
     end
 
     # @return [Valkyrie::Persistence::Solr::Persister] The solr persister.
     def persister
-      Valkyrie::Persistence::Solr::Persister.new(adapter: self)
+      @persister ||= Valkyrie::Persistence::Solr::Persister.new(adapter: self)
+    end
+
+    def write_only?
+      write_only
+    end
+
+    def soft_commit?
+      @soft_commit
     end
 
     # @return [Valkyrie::Persistence::Solr::QueryService] The solr query