iknow_view_models 2.8.4

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'view_model/after_transaction_runner'
+
+# Concern providing caching configuration and lookup on viewmodels.
+module ViewModel::ActiveRecord::Cache::CacheableView
+  extend ActiveSupport::Concern
+
+  # Callback handler to participate in ActiveRecord::ConnectionAdapters::
+  # Transaction callbacks: invalidates a given cache member after the current
+  # transaction commits.
+  CacheClearer = Struct.new(:cache, :id) do
+    include ViewModel::AfterTransactionRunner
+
+    def after_transaction
+      cache.delete(id)
+    end
+
+    def connection
+      cache.viewmodel_class.model_class.connection
+    end
+  end
+
+  class_methods do
+    def create_viewmodel_cache!(**opts)
+      @viewmodel_cache = ViewModel::ActiveRecord::Cache.new(self, **opts)
+    end
+
+    def viewmodel_cache
+      @viewmodel_cache
+    end
+
+    def serialize_from_cache(views, 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_views.first unless plural
+      return json_views, json_refs
+    end
+  end
+
+  # Clear the cache if the view or its owned children were changed during
+  # deserialization
+  def after_deserialize(deserialize_context:, changes:)
+    super if defined?(super)
+
+    if !changes.new? && changes.changed_tree?
+      CacheClearer.new(self.class.viewmodel_cache, id).add_to_transaction
+    end
+  end
+end

data/lib/view_model/active_record/cloner.rb

@@ -0,0 +1,113 @@
+# Simple visitor for cloning models through the tree structure defined by
+# ViewModel::ActiveRecord. Owned associations will be followed and cloned, while
+# shared associations will be copied directly. Attributes (including association
+# foreign keys not covered by ViewModel `association`s) will be copied from the
+# original.
+#
+# To customize, subclasses may define methods `visit_x_view(node, new_model)`
+# for each type they wish to affect. These callbacks may update attributes of
+# the new model, and additionally can call `ignore!` or
+# `ignore_association!(name)` to prune the current model or the target of the
+# named association from the cloned tree.
+class ViewModel::ActiveRecord::Cloner
+  def clone(node)
+    reset_state!
+
+    new_model = node.model.dup
+
+    pre_visit(node, new_model)
+    return nil if ignored?
+
+    if node.class.name
+      class_name      = node.class.name.underscore.gsub('/', '__')
+      visit     = :"visit_#{class_name}"
+      end_visit = :"end_visit_#{class_name}"
+    end
+
+    if visit && respond_to?(visit, true)
+      self.send(visit, node, new_model)
+      return nil if ignored?
+    end
+
+    # visit the underlying viewmodel for each association, ignoring any
+    # customization
+    node.class._members.each do |name, association_data|
+      next unless association_data.is_a?(ViewModel::ActiveRecord::AssociationData)
+
+      reflection = association_data.direct_reflection
+
+      if association_ignored?(name)
+        new_associated = nil
+      else
+        # Load the record associated with the old model
+        associated = node.model.public_send(reflection.name)
+
+        if associated.nil?
+          new_associated = nil
+        elsif association_data.shared? && !association_data.through?
+          # simply attach the associated target to the new model
+          new_associated = associated
+        else
+          # Otherwise descend into the child, and attach the result
+          vm_class =
+            case
+            when association_data.through?
+              # descend into the synthetic join table viewmodel
+              association_data.direct_viewmodel
+            when association_data.collection?
+              association_data.viewmodel_class
+            else
+              association_data.viewmodel_class_for_model!(associated.class)
+            end
+
+          new_associated =
+            if ViewModel::Utils.array_like?(associated)
+              associated.map { |m| clone(vm_class.new(m)) }.compact
+            else
+              clone(vm_class.new(associated))
+            end
+        end
+      end
+
+      new_association = new_model.association(reflection.name)
+      new_association.writer(new_associated)
+    end
+
+    if end_visit && respond_to?(end_visit, true)
+      self.send(end_visit, node, new_model)
+    end
+
+    post_visit(node, new_model)
+
+    new_model
+  end
+
+  def pre_visit(node, new_model)
+  end
+
+  def post_visit(node, new_model)
+  end
+
+  private
+
+  def reset_state!
+    @ignored = false
+    @ignored_associations = Set.new
+  end
+
+  def ignore!
+    @ignored = true
+  end
+
+  def ignore_association!(name)
+    @ignored_associations.add(name.to_s)
+  end
+
+  def ignored?
+    @ignored
+  end
+
+  def association_ignored?(name)
+    @ignored_associations.include?(name.to_s)
+  end
+end

data/lib/view_model/active_record/collection_nested_controller.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'view_model/active_record/nested_controller_base'
+
+# Controller mixin for accessing a root ViewModel which can be accessed in a
+# collection by a parent model. Enabled by calling `nested_in :parent, as:
+# :children` on the viewmodel controller
+
+# Contributes the following routes:
+# PUT    /parents/:parent_id/children            #append  -- deserialize (possibly existing) children and append to collection
+# POST   /parents/:parent_id/children            #replace -- deserialize (possibly existing) children, replacing existing collection
+# GET    /parents/:parent_id/children            #index_associated -- list collection
+# DELETE /parents/:parent_id/children/:child_id  #disassociate -- delete relationship between parent/child (possibly garbage-collecting child)
+# DELETE /parents/:parent_id/children            #disassociate_all -- delete relationship from parent to all children
+
+## Inherits the following routes to manipulate children directly:
+# POST   /children      #create -- create or update without parent
+# GET    /children      #index  -- list all child models regardless of parent
+# GET    /children/:id  #show
+# DELETE /children/:id  #destroy
+module ViewModel::ActiveRecord::CollectionNestedController
+  extend ActiveSupport::Concern
+  include ViewModel::ActiveRecord::NestedControllerBase
+
+  def index_associated(scope: nil, serialize_context: new_serialize_context)
+    show_association(scope: scope, serialize_context: serialize_context)
+  end
+
+  # Deserialize items of the associated type and associate them with the owner,
+  # replacing previously associated items.
+  def replace(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+    write_association(serialize_context: serialize_context, deserialize_context: deserialize_context)
+  end
+
+  def disassociate_all(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+    destroy_association(true, serialize_context: serialize_context, deserialize_context: deserialize_context)
+  end
+
+  # Deserialize items of the associated type and append them to the owner's
+  # collection.
+  def append(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+    assoc_view = nil
+    pre_rendered = owner_viewmodel.transaction do
+      update_hash, refs = parse_viewmodel_updates
+
+      before = parse_relative_position(:before)
+      after  = parse_relative_position(:after)
+
+      if before && after
+        raise ViewModel::DeserializationError::InvalidSyntax.new("Can not provide both `before` and `after` anchors for a collection append")
+      end
+
+      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, serialize_context: serialize_context)
+
+      assoc_view = owner_view.append_associated(association_name,
+                                                update_hash,
+                                                references: refs,
+                                                before:     before,
+                                                after:      after,
+                                                deserialize_context: deserialize_context)
+      ViewModel::Callbacks.wrap_serialize(owner_view, context: serialize_context) do
+        child_context = owner_view.context_for_child(association_name, context: serialize_context)
+        ViewModel.preload_for_serialization(assoc_view, serialize_context: child_context)
+        prerender_viewmodel(assoc_view, serialize_context: child_context)
+      end
+    end
+    render_json_string(pre_rendered)
+    assoc_view
+  end
+
+  def disassociate(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+    owner_viewmodel.transaction do
+      owner_view = owner_viewmodel.find(owner_viewmodel_id, eager_include: false, serialize_context: serialize_context)
+      owner_view.delete_associated(association_name, viewmodel_id, type: viewmodel_class, deserialize_context: deserialize_context)
+      render_viewmodel(nil)
+    end
+  end
+
+  private
+
+  def parse_relative_position(name)
+    id = parse_uuid_param(name, default: nil)
+
+    if id
+      if association_data.polymorphic?
+        type_name = parse_param("#{name}_type")
+        type = association_data.viewmodel_class_for_name(type_name)
+        if type.nil?
+          raise ViewModel::DeserializationError::InvalidAssociationType.new(association_data.association_name.to_s, type_name)
+        end
+      else
+        type = owner_viewmodel.viewmodel_class
+      end
+
+      ViewModel::Reference.new(type, id)
+    else
+      nil
+    end
+  end
+end

data/lib/view_model/active_record/controller.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'view_model/active_record/controller_base'
+require 'view_model/active_record/collection_nested_controller'
+require 'view_model/active_record/singular_nested_controller'
+
+# Controller for accessing an ViewModel::ActiveRecord
+# Provides for the following routes:
+# POST   /models      #create -- create or update one or more models
+# GET    /models      #index
+# GET    /models/:id  #show
+# DELETE /models/:id  #destroy
+
+module ViewModel::ActiveRecord::Controller
+  extend ActiveSupport::Concern
+  include ViewModel::ActiveRecord::ControllerBase
+  include ViewModel::ActiveRecord::CollectionNestedController
+  include ViewModel::ActiveRecord::SingularNestedController
+
+  def show(scope: nil, viewmodel_class: self.viewmodel_class, serialize_context: new_serialize_context(viewmodel_class: viewmodel_class))
+    view = nil
+    pre_rendered = viewmodel_class.transaction do
+      view = viewmodel_class.find(viewmodel_id, scope: scope, serialize_context: serialize_context)
+      view = yield(view) if block_given?
+      prerender_viewmodel(view, serialize_context: serialize_context)
+    end
+    render_json_string(pre_rendered)
+    view
+  end
+
+  def index(scope: nil, viewmodel_class: self.viewmodel_class, serialize_context: new_serialize_context(viewmodel_class: viewmodel_class))
+    views = nil
+    pre_rendered = viewmodel_class.transaction do
+      views = viewmodel_class.load(scope: scope, serialize_context: serialize_context)
+      views = yield(views) if block_given?
+      prerender_viewmodel(views, serialize_context: serialize_context)
+    end
+    render_json_string(pre_rendered)
+    views
+  end
+
+  def create(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+    update_hash, refs = parse_viewmodel_updates
+
+    view = nil
+    pre_rendered = viewmodel_class.transaction do
+      view = viewmodel_class.deserialize_from_view(update_hash, references: refs, deserialize_context: deserialize_context)
+
+      serialize_context.add_includes(deserialize_context.updated_associations)
+
+      view = yield(view) if block_given?
+
+      ViewModel.preload_for_serialization(view, serialize_context: serialize_context)
+      prerender_viewmodel(view, serialize_context: serialize_context)
+    end
+    render_json_string(pre_rendered)
+    view
+  end
+
+  def destroy(serialize_context: new_serialize_context, deserialize_context: new_deserialize_context)
+    viewmodel_class.transaction do
+      view = viewmodel_class.find(viewmodel_id, eager_include: false, serialize_context: serialize_context)
+      view.destroy!(deserialize_context: deserialize_context)
+    end
+    render_viewmodel(nil)
+  end
+
+  included do
+    etag { self.viewmodel_class.deep_schema_version }
+  end
+
+  private
+
+  def viewmodel_id
+    parse_param(:id)
+  end
+end

data/lib/view_model/active_record/controller_base.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'iknow_params'
+
+module ViewModel::ActiveRecord::ControllerBase
+  extend ActiveSupport::Concern
+  include IknowParams::Parser
+  include ViewModel::Controller
+
+  protected
+
+  # Override (pre)render_viewmodel to use the default serialization context from this controller.
+  def render_viewmodel(viewmodel, serialize_context: new_serialize_context, **args)
+    super(viewmodel, serialize_context: serialize_context, **args)
+  end
+
+  def prerender_viewmodel(viewmodel, serialize_context: new_serialize_context, **args)
+    super(viewmodel, serialize_context: serialize_context, **args)
+  end
+
+  def new_deserialize_context(viewmodel_class: self.viewmodel_class, access_control: self.access_control.new, **args)
+    viewmodel_class.new_deserialize_context(access_control: access_control, **args)
+  end
+
+  def new_serialize_context(viewmodel_class: self.viewmodel_class, access_control: self.access_control.new, **args)
+    viewmodel_class.new_serialize_context(access_control: access_control, **args)
+  end
+
+  class_methods do
+    def viewmodel_class
+      unless instance_variable_defined?(:@viewmodel_class)
+        # try to autodetect the viewmodel based on our name
+        if (match = /(.*)Controller$/.match(self.name))
+          self.viewmodel_name = match[1].singularize
+        else
+          raise ArgumentError.new("Could not auto-determine ViewModel from Controller name '#{self.name}'") if match.nil?
+        end
+      end
+      @viewmodel_class
+    end
+
+    def access_control
+      unless instance_variable_defined?(:@access_control)
+        raise ArgumentError.new("AccessControl instance not set for Controller '#{self.name}'")
+      end
+      @access_control
+    end
+
+    def model_class
+      viewmodel_class.model_class
+    end
+
+    protected
+
+    def viewmodel_name=(name)
+      self.viewmodel_class = ViewModel::Registry.for_view_name(name)
+    end
+
+    def viewmodel_class=(type)
+      if instance_variable_defined?(:@viewmodel_class)
+        raise ArgumentError.new("ViewModel class for Controller '#{self.name}' already set")
+      end
+
+      unless type < ViewModel
+        raise ArgumentError.new("'#{type.inspect}' is not a valid ViewModel")
+      end
+      @viewmodel_class = type
+    end
+
+    def access_control=(access_control)
+      if instance_variable_defined?(:@access_control)
+        raise ArgumentError.new("AccessControl class for Controller '#{self.name}' already set")
+      end
+
+      unless access_control.is_a?(Class) && access_control < ViewModel::AccessControl
+        raise ArgumentError.new("'#{access_control.inspect}' is not a valid AccessControl")
+      end
+      @access_control = access_control
+    end
+  end
+
+  def viewmodel_class
+    self.class.viewmodel_class
+  end
+
+  def model_class
+    self.class.model_class
+  end
+
+  def access_control
+    self.class.access_control
+  end
+end
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      module Resources
+        def arvm_resources(resource_name, options = {}, &block)
+          except             = options.delete(:except) { [] }
+          add_shallow_routes = options.delete(:add_shallow_routes) { true }
+
+          nested = shallow_nesting_depth > 0
+
+          only_routes = []
+          only_routes += [:create] unless nested
+          only_routes += [:show, :destroy] if add_shallow_routes
+          only_routes -= except
+
+          resources resource_name, shallow: true, only: only_routes, **options do
+            instance_eval(&block) if block_given?
+
+            if nested
+              # Nested controllers also get :append and :disassociate, and alias a top level create.
+              collection do
+                name_route = { as: '' } # Only one route may take the name
+                get('',    action: :index_associated, **name_route.extract!(:as)) unless except.include?(:index)
+                put('',    action: :append,           **name_route.extract!(:as)) unless except.include?(:append)
+                post('',   action: :replace,          **name_route.extract!(:as)) unless except.include?(:replace)
+                delete('', action: :disassociate_all, **name_route.extract!(:as)) unless except.include?(:disassociate_all)
+              end
+
+              scope shallow: false do
+                member do
+                  delete '', action: :disassociate, as: '' unless except.include?(:disassociate)
+                end
+              end
+
+              # Add top level `create` route to manipulate existing viewmodels
+              # without providing parent context
+              shallow_scope do
+                collection do
+                  name_route = { as: '' } # Only one route may take the name
+                  post('', action: :create, **name_route.extract!(:as)) unless except.include?(:create) || !add_shallow_routes
+                  get('',  action: :index,  **name_route.extract!(:as)) unless except.include?(:index)  || !add_shallow_routes
+                end
+              end
+            else
+              collection do
+                get('', action: :index, as: '') unless except.include?(:index)
+              end
+            end
+          end
+        end
+
+        def arvm_resource(resource_name, options = {}, &block)
+          except             = options.delete(:except) { [] }
+          add_shallow_routes = options.delete(:add_shallow_routes) { true }
+
+          only_routes = []
+          is_shallow = false
+          resource resource_name, shallow: true, only: only_routes, **options do
+            is_shallow = shallow_nesting_depth > 1
+            instance_eval(&block) if block_given?
+
+            name_route = { as: '' } # Only one route may take the name
+
+            if is_shallow
+              post('',   action: :create_associated,  **name_route.extract!(:as)) unless except.include?(:create)
+              get('',    action: :show_associated,    **name_route.extract!(:as)) unless except.include?(:show)
+              delete('', action: :destroy_associated, **name_route.extract!(:as)) unless except.include?(:destroy)
+            else
+              post('',   action: :create,  **name_route.extract!(:as)) unless except.include?(:create)
+              get('',    action: :show,    **name_route.extract!(:as)) unless except.include?(:show)
+              delete('', action: :destroy, **name_route.extract!(:as)) unless except.include?(:destroy)
+            end
+          end
+
+          # singularly nested resources provide collection accessors at the top level
+          if is_shallow && add_shallow_routes
+            resources resource_name.to_s.pluralize, shallow: true, only: [:show, :destroy] - except do
+              shallow_scope do
+                collection do
+                  name_route = { as: '' } # Only one route may take the name
+                  post('', action: :create, **name_route.extract!(:as)) unless except.include?(:create)
+                  get('',  action: :index,  **name_route.extract!(:as)) unless except.include?(:index)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end