iknow_view_models 3.1.8 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fc6b7d1f2e4c48c65f3f603d8e322afe7f26d52e08bb418dc746f9c5b6bd6c0
-  data.tar.gz: 39eab5e4ae3423805b3c3d931504d08c623d8fbf602b58e4d978aeb7202aee71
+  metadata.gz: 8031b0e3cf50931cfdc65ee1c530efc4210566f2951ab5d6187f80d75848ac2a
+  data.tar.gz: bad21c087fff5def9362bd93576e0f9f0aeb8ec8ddc4f5ff6eb6849e879168c7
 SHA512:
-  metadata.gz: 13f7e88bc34527984aea0d73518acb2e2fa8e2a6cc4cbb408f325afd39bfedd738be907f0922efcfacebe1802002e8f8d1c86ca9c37fc9a810df767f923d4455
-  data.tar.gz: 71b8b322ce29db0b042c28b40c94820433d96beade6d991c5759a7828a7ce8101fcccc47fea3545538e522355fe949fd5a03493e26b22601c22e8bc31c8b2d92
+  metadata.gz: 17edcc7ab94fa8fa3a9b34e209a3d2feebb1c31fc1d3d619c36d3d9f602312e9ff13c1e0bc0974c2df070084b8b3fa7de3a2f7c74c38a3dbd04976ee166854aa
+  data.tar.gz: e176a0df288c029bea2d083c03492b6a5370e78a4c35164eaadf284b66de9120dfe60eda3dc6bca5e2845b71a865f4996fd17124462d06a70156249fd709a066

data/.circleci/config.yml

@@ -102,15 +102,15 @@ workflows:
   build:
     jobs:
       - test:
-          name: 'ruby 2.6 rails 5.2 pg 11'
+          name: 'ruby 2.6 rails 5.2 pg 12'
           ruby-version: "2.6"
-          pg-version: "11"
+          pg-version: "12"
           gemfile: gemfiles/rails_5_2.gemfile
       - test:
-          name: 'ruby 2.6 rails 6.0 pg 11'
-          ruby-version: "2.6"
-          pg-version: "11"
-          gemfile: gemfiles/rails_6_0_beta.gemfile
+          name: 'ruby 2.7 rails 6.0 pg 12'
+          ruby-version: "2.7"
+          pg-version: "12"
+          gemfile: gemfiles/rails_6_0.gemfile
       - publish:
           filters:
             branches:

data/.rubocop.yml

@@ -0,0 +1,5 @@
+AllCops:
+  TargetRubyVersion: 2.7
+
+inherit_gem:
+  rubocop-iknow: rubocop.yml

data/Appraisals

@@ -3,7 +3,7 @@ appraise "rails-5-2" do
   gem "activesupport", "~> 5.2.0"
 end
 
-appraise "rails-6-0-beta" do
-  gem "activerecord", "~> 6.0.0.beta"
-  gem "activesupport", "~> 6.0.0.beta"
+appraise "rails-6-0" do
+  gem "activerecord", "~> 6.0.0"
+  gem "activesupport", "~> 6.0.0"
 end

data/Gemfile

@@ -3,9 +3,13 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in cerego_view_models.gemspec
 gemspec
 
+# Add our linter rules as a development dependency
+gem 'rubocop'
+gem 'rubocop-iknow'
+
 # Test metadata collection for circleci
 gem 'minitest-ci'
 
 # Override gemspec for development version preferences
-gem 'activerecord',  '~> 5.2.0'
-gem 'activesupport', '~> 5.2.0'
+gem 'activerecord',  '~> 6.0.0'
+gem 'activesupport', '~> 6.0.0'

data/gemfiles/{rails_6_0_beta.gemfile → rails_6_0.gemfile}

@@ -3,7 +3,7 @@
 source "https://rubygems.org"
 
 gem "minitest-ci"
-gem "activerecord", "~> 6.0.0.beta"
-gem "activesupport", "~> 6.0.0.beta"
+gem "activerecord", "~> 6.0.0"
+gem "activesupport", "~> 6.0.0"
 
 gemspec path: "../"

data/iknow_view_models.gemspec

@@ -36,13 +36,14 @@ Gem::Specification.new do |spec|
   spec.add_dependency "lazily"
   spec.add_dependency "renum"
   spec.add_dependency "oj"
+  spec.add_dependency "rgl"
 
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "byebug"
   spec.add_development_dependency "method_source"
   spec.add_development_dependency "minitest-hooks"
-  spec.add_development_dependency "pg", '~> 0.18' # As of 5.1.4, Rails runtime check excludes pg 1.x, see #31669
+  spec.add_development_dependency "pg"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec-expectations"

data/lib/iknow_view_models/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module IknowViewModels
-  VERSION = '3.1.8'
+  VERSION = '3.2.0'
 end

data/lib/view_model.rb

@@ -12,7 +12,12 @@ class ViewModel
   VERSION_ATTRIBUTE   = "_version"
   NEW_ATTRIBUTE       = "_new"
 
-  Metadata = Struct.new(:id, :view_name, :schema_version, :new) do
+  # Migrations leave a metadata attribute _migrated on any views that they
+  # alter. This attribute is accessible as metadata when deserializing migrated
+  # input, and is included in the output serialization sent to clients.
+  MIGRATED_ATTRIBUTE  = "_migrated"
+
+  Metadata = Struct.new(:id, :view_name, :schema_version, :new, :migrated) do
     alias :new? :new
   end
 
@@ -99,8 +104,9 @@ class ViewModel
       type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)
       schema_version = hash.delete(ViewModel::VERSION_ATTRIBUTE)
       new            = hash.delete(ViewModel::NEW_ATTRIBUTE) { false }
+      migrated       = hash.delete(ViewModel::MIGRATED_ATTRIBUTE) { false }
 
-      Metadata.new(id, type_name, schema_version, new)
+      Metadata.new(id, type_name, schema_version, new, migrated)
     end
 
     def extract_reference_only_metadata(hash)
@@ -108,7 +114,7 @@ class ViewModel
       id             = hash.delete(ViewModel::ID_ATTRIBUTE)
       type_name      = hash.delete(ViewModel::TYPE_ATTRIBUTE)
 
-      Metadata.new(id, type_name, nil, false)
+      Metadata.new(id, type_name, nil, false, false)
     end
 
     def extract_reference_metadata(hash)
@@ -234,6 +240,11 @@ class ViewModel
       schema_version == self.schema_version
     end
 
+    def schema_hash(schema_versions)
+      version_string = schema_versions.to_a.sort.join(',')
+      Base64.urlsafe_encode64(Digest::MD5.digest(version_string))
+    end
+
     def preload_for_serialization(viewmodels, serialize_context: new_serialize_context, include_referenced: true, lock: nil)
       Array.wrap(viewmodels).group_by(&:class).each do |type, views|
         DeepPreloader.preload(views.map(&:model),

data/lib/view_model/active_record.rb

@@ -245,7 +245,7 @@ class ViewModel::ActiveRecord < ViewModel::Record
         begin
           dependent_viewmodels(include_referenced: include_referenced).each_with_object({}) do |view, h|
             h[view.view_name] = view.schema_version
-          end
+          end.freeze
         end
     end
 

data/lib/view_model/active_record/cache.rb

@@ -5,6 +5,7 @@ require 'iknow_cache'
 # Cache for ViewModels that wrap ActiveRecord models.
 class ViewModel::ActiveRecord::Cache
   require 'view_model/active_record/cache/cacheable_view'
+  require 'view_model/migrator'
 
   class UncacheableViewModelError < RuntimeError; end
 
@@ -13,13 +14,20 @@ class ViewModel::ActiveRecord::Cache
   # If cache_group: is specified, it must be a group of a single key: `:id`
   def initialize(viewmodel_class, cache_group: nil)
     @viewmodel_class = viewmodel_class
-    @cache_group = cache_group || create_default_cache_group # requires @viewmodel_class
+
+    @cache_group = cache_group || create_default_cache_group
+    @migrated_cache_group = @cache_group.register_child_group(:migrated, :version)
+
+    # /viewname/:id/viewname-currentversion
     @cache = @cache_group.register_cache(cache_name)
+
+    # /viewname/:id/migrated/:oldversion/viewname-currentversion
+    @migrated_cache = @migrated_cache_group.register_cache(cache_name)
   end
 
   def delete(*ids)
     ids.each do |id|
-      @cache_group.delete_all(key_for(id))
+      @cache_group.delete_all(@cache.key.new(id))
     end
   end
 
@@ -27,14 +35,14 @@ class ViewModel::ActiveRecord::Cache
     @cache_group.invalidate_cache_group
   end
 
-  def fetch_by_viewmodel(viewmodels, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
+  def fetch_by_viewmodel(viewmodels, migration_versions: {}, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
     ids = viewmodels.map(&:id)
-    fetch(ids, initial_viewmodels: viewmodels, locked: false, serialize_context: serialize_context)
+    fetch(ids, initial_viewmodels: viewmodels, migration_versions: migration_versions, locked: locked, serialize_context: serialize_context)
   end
 
-  def fetch(ids, initial_viewmodels: nil, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
+  def fetch(ids, initial_viewmodels: nil, migration_versions: {}, locked: false, serialize_context: @viewmodel_class.new_serialize_context)
     data_serializations = Array.new(ids.size)
-    worker = CacheWorker.new(serialize_context: serialize_context)
+    worker = CacheWorker.new(migration_versions: migration_versions, serialize_context: serialize_context)
 
     # If initial root viewmodels were provided, visit them to ensure that they
     # are visible. Other than this, no traversal callbacks are performed, as a
@@ -98,12 +106,14 @@ class ViewModel::ActiveRecord::Cache
     SENTINEL = Object.new
     WorklistEntry = Struct.new(:ref_name, :viewmodel)
 
-    attr_reader :serialize_context, :resolved_references
+    attr_reader :migration_versions, :serialize_context, :resolved_references
 
-    def initialize(serialize_context:)
-      @worklist            = {}
-      @resolved_references = {}
-      @serialize_context   = serialize_context
+    def initialize(migration_versions:, serialize_context:)
+      @worklist                = {}
+      @resolved_references     = {}
+      @migration_versions      = migration_versions
+      @migrated_cache_versions = {}
+      @serialize_context       = serialize_context
     end
 
     def resolve_references!
@@ -141,11 +151,15 @@ class ViewModel::ActiveRecord::Cache
       end
     end
 
+    def migrated_cache_version(viewmodel_cache)
+      @migrated_cache_versions[viewmodel_cache] ||= viewmodel_cache.migrated_cache_version(migration_versions)
+    end
+
     # Loads the specified entities from the cache and returns a hash of
     # {id=>serialized_view}. Any references encountered are added to the
     # worklist.
     def load_from_cache(viewmodel_cache, ids)
-      cached_serializations = viewmodel_cache.load(ids, serialize_context: serialize_context)
+      cached_serializations = viewmodel_cache.load(ids, migrated_cache_version(viewmodel_cache), serialize_context: serialize_context)
 
       cached_serializations.each_with_object({}) do |(id, cached_serialization), result|
         add_refs_to_worklist(cached_serialization[:ref_cache])
@@ -159,17 +173,54 @@ class ViewModel::ActiveRecord::Cache
     # added to the worklist.
     def serialize_and_cache(viewmodels)
       viewmodels.each_with_object({}) do |viewmodel, result|
-        data_serialization = Jbuilder.encode do |json|
+        builder = Jbuilder.new do |json|
           ViewModel.serialize(viewmodel, json, serialize_context: serialize_context)
         end
 
         referenced_viewmodels = serialize_context.extract_referenced_views!
+
+        if migration_versions.present?
+          migrator = ViewModel::DownMigrator.new(migration_versions)
+
+          # This migration isn't given the chance to inspect/alter the contents
+          # of referenced views, only their presence: it's strictly less
+          # powerful than migrations on a fully serialized tree, as the only
+          # possible action on a referenced child is to delete it. The effect of
+          # this is that for sufficiently complex migrations where a parent view
+          # must introduce children or alter the contents of its referenced
+          # children, we may have to avoid caching while the migration is in
+          # use.
+          dummy_references = referenced_viewmodels.transform_values do |ref_vm|
+            {
+              ViewModel::TYPE_ATTRIBUTE    => ref_vm.class.view_name,
+              ViewModel::VERSION_ATTRIBUTE => ref_vm.class.schema_version,
+              ViewModel::ID_ATTRIBUTE      => ref_vm.id,
+            }.freeze
+          end
+
+          migrator.migrate!(builder.attributes!, references: dummy_references)
+
+          # Removed dummy references can be removed from referenced_viewmodels.
+          referenced_viewmodels.keep_if { |k, _| dummy_references.has_key?(k) }
+
+          # Introduced dummy references cannot be handled.
+          if dummy_references.keys != referenced_viewmodels.keys
+            version = migration_versions[viewmodel.class]
+            raise ViewModel::Error.new(
+                    status: 500,
+                    detail: "Down-migration for cacheable view #{viewmodel.class} to v#{version} must not introduce new shared references")
+          end
+        end
+
+        data_serialization = builder.target!
+
         add_viewmodels_to_worklist(referenced_viewmodels)
 
         if viewmodel.class < CacheableView
           cacheable_references = referenced_viewmodels.transform_values { |vm| cacheable_reference(vm) }
-          viewmodel.class.viewmodel_cache.store(viewmodel.id, data_serialization, cacheable_references,
-                                                serialize_context: serialize_context)
+          target_cache = viewmodel.class.viewmodel_cache
+          target_cache.store(viewmodel.id, migrated_cache_version(target_cache), data_serialization, cacheable_references,
+                             serialize_context: serialize_context)
         end
 
         result[viewmodel.id] = data_serialization
@@ -225,8 +276,20 @@ class ViewModel::ActiveRecord::Cache
     end
   end
 
-  def key_for(id)
-    cache.key.new(id)
+  def cache_for(migration_version)
+    if migration_version
+      @migrated_cache
+    else
+      @cache
+    end
+  end
+
+  def key_for(id, migration_version)
+    if migration_version
+      @migrated_cache.key.new(id, migration_version)
+    else
+      @cache.key.new(id)
+    end
   end
 
   def id_for(key)
@@ -234,32 +297,47 @@ class ViewModel::ActiveRecord::Cache
   end
 
   # Save the provided serialization and reference data in the cache
-  def store(id, data_serialization, ref_cache, serialize_context:)
-    cache.write(key_for(id), { data: data_serialization, ref_cache: ref_cache })
+  def store(id, migration_version, data_serialization, ref_cache, serialize_context:)
+    key = key_for(id, migration_version)
+    cache_for(migration_version).write(key, { data: data_serialization, ref_cache: ref_cache })
   end
 
-  def load(ids, serialize_context:)
-    keys = ids.map { |id| key_for(id) }
-    results = cache.read_multi(keys)
+  def load(ids, migration_version, serialize_context:)
+    keys = ids.map { |id| key_for(id, migration_version) }
+    results = cache_for(migration_version).read_multi(keys)
     results.transform_keys! { |key| id_for(key) }
   end
 
-  private
+  def cache_version
+    @cache_version ||=
+      begin
+        versions = @viewmodel_class.deep_schema_version(include_referenced: false)
+        ViewModel.schema_hash(versions)
+      end
+  end
 
-  attr_reader :cache
+  def migrated_cache_version(migration_versions)
+    versions = ViewModel::Migrator.migrated_deep_schema_version(viewmodel_class, migration_versions, include_referenced: false)
+    version_hash = ViewModel.schema_hash(versions)
+
+    if version_hash == cache_version
+      # no migrations affect this view
+      nil
+    else
+      version_hash
+    end
+  end
+
+  private
 
   def create_default_cache_group
     IknowCache.register_group(@viewmodel_class.name, :id)
   end
 
-  # Statically version the terminal cache based on the deep schema versions of
-  # the constituent viewmodels, so that viewmodel changes force invalidation.
+  # Statically version the cache name based on the (current) deep schema
+  # versions of the constituent viewmodels, so that viewmodel changes force
+  # invalidation.
   def cache_name
-    "#{@viewmodel_class.name}_#{cache_version}"
-  end
-
-  def cache_version
-    version_string = @viewmodel_class.deep_schema_version(include_referenced: false).to_a.sort.join(',')
-    Base64.urlsafe_encode64(Digest::MD5.digest(version_string))
+    "vmcache_#{cache_version}"
   end
 end

data/lib/view_model/active_record/cache/cacheable_view.rb

@@ -40,10 +40,10 @@ module ViewModel::ActiveRecord::Cache::CacheableView
       @viewmodel_cache
     end
 
-    def serialize_from_cache(views, serialize_context:)
+    def serialize_from_cache(views, migration_versions: {}, locked: false, serialize_context:)
       plural = views.is_a?(Array)
       views = Array.wrap(views)
-      json_views, json_refs = viewmodel_cache.fetch_by_viewmodel(views, serialize_context: serialize_context)
+      json_views, json_refs = viewmodel_cache.fetch_by_viewmodel(views, locked: locked, migration_versions: migration_versions, serialize_context: serialize_context)
       json_views = json_views.first unless plural
       return json_views, json_refs
     end

data/lib/view_model/active_record/controller.rb

@@ -62,7 +62,29 @@ module ViewModel::ActiveRecord::Controller
   end
 
   included do
-    etag { self.viewmodel_class.deep_schema_version }
+    etag { migrated_deep_schema_version }
+  end
+
+  def parse_viewmodel_updates
+    super.tap do |update_hash, refs|
+      if migration_versions.present?
+        migrator = ViewModel::UpMigrator.new(migration_versions)
+        migrator.migrate!([update_hash, refs], references: refs)
+      end
+    end
+  end
+
+  def prerender_viewmodel(*)
+    super do |jbuilder|
+      yield(jbuilder) if block_given?
+
+      # migrate the resulting structure before it's serialized to a json string
+      if migration_versions.present?
+        tree = jbuilder.attributes!
+        migrator = ViewModel::DownMigrator.new(migration_versions)
+        migrator.migrate!(tree, references: tree['references'])
+      end
+    end
   end
 
   private
@@ -70,4 +92,34 @@ module ViewModel::ActiveRecord::Controller
   def viewmodel_id
     parse_param(:id)
   end
+
+  def migration_versions
+    @migration_versions ||=
+      begin
+        versions = parse_param(
+          :versions,
+          default: {},
+          with: IknowParams::Serializer::HashOf.new(
+            IknowParams::Serializer::String, IknowParams::Serializer::Integer))
+
+        migration_versions = {}
+
+        versions.each do |view_name, required_version|
+          viewmodel_class = ViewModel::Registry.for_view_name(view_name)
+
+          if viewmodel_class.schema_version != required_version
+            migration_versions[viewmodel_class] = required_version
+          end
+        rescue ViewModel::DeserializationError::UnknownView
+          # Ignore requests to migrate types that no longer exist
+          next
+        end
+
+        migration_versions.freeze
+      end
+  end
+
+  def migrated_deep_schema_version
+    ViewModel::Migrator.migrated_deep_schema_version(viewmodel_class, migration_versions, include_referenced: true)
+  end
 end