iknow_view_models 3.1.8 → 3.2.0

data/lib/view_model/migratable_view.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'view_model/migration'
+require 'view_model/migrator'
+
+require 'rgl/adjacency'
+require 'rgl/dijkstra'
+
+module ViewModel::MigratableView
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def inherited(base)
+      super
+      base.initialize_as_migratable_view
+    end
+
+    def initialize_as_migratable_view
+      @migrations_lock   = Monitor.new
+      @migration_classes = {}
+      @migration_paths   = {}
+      @realized_migration_paths = true
+    end
+
+    def migration_path(from:, to:)
+      @migrations_lock.synchronize do
+        realize_paths! unless @realized_migration_paths
+
+        migrations = @migration_paths.fetch([from, to]) do
+          raise ViewModel::Migration::NoPathError.new(self, from, to)
+        end
+
+        migrations
+      end
+    end
+
+    private
+
+    # Define a migration on this viewmodel
+    def migrates(from:, to:, &block)
+      @migrations_lock.synchronize do
+        builder = ViewModel::Migration::Builder.new
+        builder.instance_exec(&block)
+        @migration_classes[[from, to]] = builder.build!
+        @realized_migration_paths = false
+      end
+    end
+
+    # Internal: find and record possible paths to the current schema version.
+    def realize_paths!
+      @migration_paths.clear
+
+      graph = RGL::DirectedAdjacencyGraph.new
+
+      # Add edges backwards, as we care about paths from the latest version
+      @migration_classes.each_key do |from, to|
+        graph.add_edge(to, from)
+      end
+
+      paths = graph.dijkstra_shortest_paths(Hash.new { 1 }, self.schema_version)
+
+      paths.each do |target_version, path|
+        next if path.length == 1
+
+        # Store the path forwards rather than backwards
+        path_migration_classes = path.reverse.each_cons(2).map do |from, to|
+          @migration_classes.fetch([from, to])
+        end
+
+        key = [target_version, schema_version]
+
+        @migration_paths[key] = path_migration_classes.map(&:new)
+      end
+
+      @realized_paths = true
+    end
+  end
+end

data/lib/view_model/migration.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class ViewModel::Migration
+  require 'view_model/migration/no_path_error'
+  require 'view_model/migration/one_way_error'
+  require 'view_model/migration/unspecified_version_error'
+
+  def up(view, _references)
+    raise ViewModel::Migration::OneWayError.new(view[ViewModel::TYPE_ATTRIBUTE], :up)
+  end
+
+  def down(view, _references)
+    raise ViewModel::Migration::OneWayError.new(view[ViewModel::TYPE_ATTRIBUTE], :down)
+  end
+
+  # Tiny DSL for defining migration classes
+  class Builder
+    def initialize
+      @up_block = nil
+      @down_block = nil
+    end
+
+    def build!
+      migration = Class.new(ViewModel::Migration)
+      migration.define_method(:up, &@up_block) if @up_block
+      migration.define_method(:down, &@down_block) if @down_block
+      migration
+    end
+
+    private
+
+    def up(&block)
+      check_signature!(block)
+      @up_block = block
+    end
+
+    def down(&block)
+      check_signature!(block)
+      @down_block = block
+    end
+
+    def check_signature!(block)
+      unless block.arity == 2
+        raise RuntimeError.new('Illegal signature for migration method, must be (view, references)')
+      end
+    end
+  end
+end

data/lib/view_model/migration/no_path_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class ViewModel::Migration::NoPathError < ViewModel::AbstractError
+  attr_reader :vm_name, :from, :to
+
+  status 400
+
+  def initialize(viewmodel, from, to)
+    @vm_name = viewmodel.view_name
+    @from = from
+    @to = to
+  end
+
+  def detail
+    "No migration path for #{vm_name} from #{from} to #{to}"
+  end
+
+  def meta
+    {
+      viewmodel: vm_name,
+      from: from,
+      to: to,
+    }
+  end
+end

data/lib/view_model/migration/one_way_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ViewModel::Migration::OneWayError < ViewModel::AbstractError
+  attr_reader :vm_name, :direction
+
+  status 400
+
+  def initialize(vm_name, direction)
+    @vm_name = vm_name
+    @direction = direction
+  end
+
+  def detail
+    "One way migration for #{vm_name} cannot be migrated #{direction}"
+  end
+
+  def meta
+    {
+      viewmodel: vm_name,
+      direction: direction,
+    }
+  end
+end

data/lib/view_model/migration/unspecified_version_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ViewModel::Migration::UnspecifiedVersionError < ViewModel::AbstractError
+  attr_reader :vm_name, :version
+
+  status 400
+
+  def initialize(vm_name, version)
+    @vm_name = vm_name
+    @version = version
+  end
+
+  def detail
+    "Provided view for #{vm_name} at version #{version} does not match request"
+  end
+
+  def meta
+    {
+      viewmodel: vm_name,
+      version: version,
+    }
+  end
+end

data/lib/view_model/migrator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+class ViewModel
+  class Migrator
+    class << self
+      def migrated_deep_schema_version(viewmodel_class, required_versions, include_referenced: true)
+        deep_schema_version = viewmodel_class.deep_schema_version(include_referenced: include_referenced)
+
+        if required_versions.present?
+          deep_schema_version = deep_schema_version.dup
+
+          required_versions.each do |required_vm_class, required_version|
+            name = required_vm_class.view_name
+            if deep_schema_version.has_key?(name)
+              deep_schema_version[name] = required_version
+            end
+          end
+        end
+
+        deep_schema_version
+      end
+    end
+
+    def initialize(required_versions)
+      @paths = required_versions.each_with_object({}) do |(viewmodel_class, required_version), h|
+        if required_version != viewmodel_class.schema_version
+          path = viewmodel_class.migration_path(from: required_version, to: viewmodel_class.schema_version)
+          h[viewmodel_class.view_name] = path
+        end
+      end
+
+      @versions = required_versions.each_with_object({}) do |(viewmodel_class, required_version), h|
+        h[viewmodel_class.view_name] = [required_version, viewmodel_class.schema_version]
+      end
+    end
+
+    def migrate!(node, references:)
+      case node
+      when Hash
+        if (type = node[ViewModel::TYPE_ATTRIBUTE])
+          version = node[ViewModel::VERSION_ATTRIBUTE]
+
+          if migrate_viewmodel!(type, version, node, references)
+            node[ViewModel::MIGRATED_ATTRIBUTE] = true
+          end
+        end
+
+        node.each_value do |child|
+          migrate!(child, references: references)
+        end
+      when Array
+        node.each { |child| migrate!(child, references: references) }
+      end
+    end
+
+    private
+
+    def migrate_viewmodel!(_view_name, _version, _view_hash, _references)
+      raise RuntimeError.new('abstract method')
+    end
+  end
+
+  class UpMigrator < Migrator
+    private
+
+    def migrate_viewmodel!(view_name, source_version, view_hash, references)
+      path = @paths[view_name]
+      return false unless path
+
+      # We assume that an unspecified source version is the same as the required
+      # version.
+      required_version, current_version = @versions[view_name]
+
+      unless source_version.nil? || source_version == required_version
+        raise ViewModel::Migration::UnspecifiedVersionError.new(view_name, source_version)
+      end
+
+      path.each do |migration|
+        migration.up(view_hash, references)
+      end
+
+      view_hash[ViewModel::VERSION_ATTRIBUTE] = current_version
+
+      true
+    end
+  end
+
+  # down migrations find a reverse path from the current schema version to the
+  # specific version requested by the client.
+  class DownMigrator < Migrator
+    private
+
+    def migrate_viewmodel!(view_name, _, view_hash, references)
+      path = @paths[view_name]
+      return false unless path
+
+      required_version, _current_version = @versions[view_name]
+
+      path.reverse_each do |migration|
+        migration.down(view_hash, references)
+      end
+
+      view_hash[ViewModel::VERSION_ATTRIBUTE] = required_version
+
+      true
+    end
+  end
+end

data/lib/view_model/record.rb

@@ -10,6 +10,9 @@ class ViewModel::Record < ViewModel
   attr_accessor :model
 
   require 'view_model/record/attribute_data'
+  require 'view_model/migratable_view'
+
+  include ViewModel::MigratableView
 
   class << self
     attr_reader :_members
@@ -207,7 +210,7 @@ class ViewModel::Record < ViewModel
   end
 
   def serialize_view(json, serialize_context: self.class.new_serialize_context)
-    json.set!(ViewModel::ID_ATTRIBUTE, model.id) if model.respond_to?(:id)
+    json.set!(ViewModel::ID_ATTRIBUTE, self.id) if stable_id?
     json.set!(ViewModel::TYPE_ATTRIBUTE, self.view_name)
     json.set!(ViewModel::VERSION_ATTRIBUTE, self.class.schema_version)
 

data/lib/view_model/test_helpers/arvm_builder.rb

@@ -4,7 +4,8 @@ class ViewModel::TestHelpers::ARVMBuilder
   # Building an ARVM requires three blocks, to define schema, model and
   # viewmodel. Support providing these either in an spec argument or as a
   # dsl-style builder.
-  Spec = Struct.new(:schema, :model, :viewmodel) do
+  Spec = Struct.new(:schema, :model, :viewmodel)
+  class Spec
     def initialize(schema:, model:, viewmodel:)
       super(schema, model, viewmodel)
     end

data/nix/dependencies.nix

@@ -0,0 +1,5 @@
+{pkgs}:
+{
+  ruby = pkgs.ruby_2_7;
+  postgresql = pkgs.postgresql_12;
+}

data/nix/gem/generate.rb

@@ -7,6 +7,7 @@
 # This workaround is from https://github.com/manveru/bundix/issues/10#issuecomment-405879379
 
 require 'shellwords'
+require 'uri'
 
 def sh(*args)
   warn args.shelljoin
@@ -20,7 +21,7 @@ require 'bundler'
 
 lockfile = Bundler::LockfileParser.new(File.read('Gemfile.lock'))
 gems = lockfile.specs.select { |spec| spec.source.is_a?(Bundler::Source::Rubygems) }
-sources = [URI('https://rubygems.org/')] | gems.map(&:source).flat_map(&:remotes)
+sources = gems.map(&:source).flat_map(&:remotes).uniq
 
 FileUtils.mkdir_p 'nix/gem'
 Dir.chdir 'nix/gem' do

data/shell.nix

@@ -1,10 +1,15 @@
-with import <nixpkgs> {};
+{ pkgs ? import <nixpkgs> {} }:
 
+with pkgs;
+
+let
+  dependencies = import ./nix/dependencies.nix { inherit pkgs; };
+in
 (bundlerEnv {
   name = "iknow-view-models-shell";
   gemdir = ./nix/gem;
 
-  gemConfig = (defaultGemConfig.override { postgresql = postgresql_11; });
+  gemConfig = (defaultGemConfig.override { inherit (dependencies) postgresql; });
 
-  ruby = ruby_2_6;
+  inherit (dependencies) ruby;
 }).env

data/test/helpers/controller_test_helpers.rb

@@ -79,11 +79,25 @@ module ControllerTestModels
       end
       define_viewmodel do
         root!
+        self.schema_version = 2
+
         attributes   :name
         associations :label, :target
         association  :children
         association  :poly, viewmodels: [:PolyOne, :PolyTwo]
         association  :category, external: true
+
+        migrates from: 1, to: 2 do
+          up do |view, _refs|
+            if view.has_key?('old_name')
+              view['name'] = view.delete('old_name')
+            end
+          end
+
+          down do |view, refs|
+            view['old_name'] = view.delete('name')
+          end
+        end
       end
     end
 

data/test/helpers/viewmodel_spec_helpers.rb

@@ -120,8 +120,8 @@ module ViewModelSpecHelpers
     def model_attributes
       f = subject_association_features
       super.merge(schema:    ->(t) { t.references :child, foreign_key: true },
-                  model:     ->(m) { belongs_to :child, inverse_of: :model, dependent: :destroy },
-                  viewmodel: ->(v) { association :child, **f })
+                  model:     ->(_m) { belongs_to :child, inverse_of: :model, dependent: :destroy },
+                  viewmodel: ->(_v) { association :child, **f })
     end
 
     def child_attributes
@@ -139,6 +139,71 @@ module ViewModelSpecHelpers
     end
   end
 
+  module ParentAndBelongsToChildWithMigration
+    extend ActiveSupport::Concern
+    include ViewModelSpecHelpers::ParentAndBelongsToChild
+    def model_attributes
+      super.merge(
+        schema: ->(t) { t.integer :new_field, default: 1, null: false },
+        viewmodel: ->(_v) {
+          self.schema_version = 4
+
+          attribute :new_field
+
+          # add: old_field (one-way)
+          migrates from: 1, to: 2 do
+            down do |view, _refs|
+              view.delete('old_field')
+            end
+          end
+
+          # rename: old_field -> mid_field
+          migrates from: 2, to: 3 do
+            up do |view, _refs|
+              if view.has_key?('old_field')
+                view['mid_field'] = view.delete('old_field') + 1
+              end
+            end
+
+            down do |view, _refs|
+              view['old_field'] = view.delete('mid_field') - 1
+            end
+          end
+
+          # rename: mid_field -> new_field
+          migrates from: 3, to: 4 do
+            up do |view, _refs|
+              if view.has_key?('mid_field')
+                view['new_field'] = view.delete('mid_field') + 1
+              end
+            end
+
+            down do |view, _refs|
+              view['mid_field'] = view.delete('new_field') - 1
+            end
+          end
+        })
+    end
+
+    def child_attributes
+      super.merge(
+        viewmodel: ->(_v) {
+          self.schema_version = 3
+
+          # delete: former_field
+          migrates from: 2, to: 3 do
+            up do |view, _refs|
+              view.delete('former_field')
+            end
+
+            down do |view, _refs|
+              view['former_field'] = 'reconstructed'
+            end
+          end
+        })
+    end
+  end
+
   module ParentAndSharedBelongsToChild
     extend ActiveSupport::Concern
     include ViewModelSpecHelpers::ParentAndBelongsToChild