wor-simple_crud 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dbcb6881c359fa3b5c4ce518871a4f378d92e0698ab7d57dc489315f2f25b80b
-  data.tar.gz: 62cf8cbd6df845cd23a388e9b2a1f8ebfdae784ff91f4e57268688bce0c0bf87
+  metadata.gz: b40c7867a484ffc3807b8dceac29ac1f6cc49ccca6d8a9bb067f93f839703e0c
+  data.tar.gz: 5a72d84147fc1f149695fe0244a11e7f99f2c9b4debb0b99a291e16439b873ac
 SHA512:
-  metadata.gz: 4406326eab40876599274e927df02c9c3470d3f753dcd5f0f150b67a7b3087e2a965ec0fd18ad1e007bada514954f9a665d573d18da98bf7c93aee3ffebc1637
-  data.tar.gz: 1deddc698fb6008531d59e5656675086a309dbc26177b403c023e7743463425626b8e977785f6ef2cbe122d4f251ad697944d1c71f665e498666feecedbae792
+  metadata.gz: 2354c67d6866dd82b70172279fd47a65bced5a950ce4385df97a1d3ab3373724d7f49a2ee7185e9cca3f86f403892e732afeade705c74337d7ae32ed53815632
+  data.tar.gz: 851104267914cd47c8312723af3361a13e5ee5fa2a323f73add55a0a09e04d965492f870c66ffc81f24c5851239afd35485b367633192c80ce8b3d8d90a7753a

data/.rubocop.yml

@@ -1,6 +1,10 @@
 plugins:
   - rubocop-rspec
 
+inherit_mode:
+  merge:
+    - Exclude
+
 AllCops:
   TargetRubyVersion: 3.2
   NewCops: disable
@@ -14,3 +18,14 @@ RSpec/SpecFilePathFormat:
 RSpec/SpecFilePathSuffix:
   Exclude:
     - spec/dummy_controller_spec.rb
+
+# Context class names are self-documenting; comments would be noise.
+Style/Documentation:
+  Exclude:
+    - lib/simple_crud/*_context.rb
+
+# The destroy failure spec must stub find_record on the instance to intercept
+# both default (klass.find) and custom-finder (lambda) lookup paths.
+RSpec/AnyInstance:
+  Exclude:
+    - lib/spec/shared_examples/simple_crud_for_destroy.rb

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 ## Change log
 
+### V0.6.0
+
+Serializer support:
+* Blueprinter: `serializer:` now accepts a [Blueprinter](https://github.com/blueprinter/blueprinter) blueprint on every action, which simple_crud renders with `render_as_hash(record, options)`, as well as an ActiveModelSerializers serializer. The shared examples' default `serializer_class` uses `"#{Model}Blueprint"` when no `"#{Model}Serializer"` constant exists, and `have_been_serialized_with` reads Blueprinter fields.
+* `serializer_options:` on every action: a lambda that runs through `instance_exec`. simple_crud forwards its result to the serializer (`render_as_hash(record, options)` for Blueprinter, `new(record, options)` for AMS). Arity 0 runs with no arguments; arity ≥ 1 gets the record. On `:index` it runs once with no record, so arity-1 lambdas get `nil`. Paginated Blueprinter indexes need wor-paginate ≥ 0.5.
+
+New options:
+* `status:` on `:create`/`:update`/`:destroy` overrides the success status (`:created`/`:ok`/`:ok` by default). `status: :no_content` returns an empty body.
+* `after_persist:` on `:create`/`:update`/`:destroy`: a `(record, saved)` lambda that runs after the write and before rendering. Use it for side effects like cache invalidation. It still runs when you pass a render block.
+
+Behavior changes:
+* `create`/`update` responses now honor `serializer:`. Before, they returned the raw record. AMS apps that never passed `serializer:` see no change.
+* Cached `:show` now honors `serializer:`. Before, it returned `record.as_json`.
+* Unpaginated `:index` now serializes through the same path as the other actions, so Blueprinter works there. Before, it passed `each_serializer` to `render`.
+
+Fixes:
+* `finder:` lambdas now run through `instance_exec` on the controller, so `current_user` and other controller methods are available, matching the README.
+* `:index` resolves a private `current_user` method.
+* Shared examples no longer inject `params[:format]`, which collided with model attributes named `format`.
+* Shared-example `owner_foreign_key` honors custom `foreign_key:` declarations.
+* The base `index` example compares ids with `match_array`; create/update/destroy examples honor a custom `status:`.
+
+### V0.5.0
+
+New options:
+* `cache: { key:, ttl: }` on `simple_crud_for :show` and `:index` — skips the DB on cache hits. On a miss: find/query, authorize, run block, cache, render. `key` is a lambda receiving `params` or a plain string; both default when omitted (`"#{model}:#{action}:v1:#{request.fullpath}"` and 300 s). Block must return the payload hash, not call `render`. `@record`/`@records` is set before the block, so shared examples work unchanged. Controllers get a default `fetch_cached(key, ttl, &block)` backed by `Rails.cache`; override to use a different store.
+* `expire_simple_crud_cache(action, path: request.fullpath)` on controllers — deletes the default cache key for an action without constructing it by hand. Only works for the default key format; custom `key:` lambdas must be deleted directly.
+
 ### V0.4.0
 
 Breaking:

data/Gemfile

@@ -17,6 +17,7 @@ group :development, :test do
   gem 'action_policy', '~> 0.7.6', require: false
   gem 'active_model_serializers', '~> 0.10.16'
   gem 'appraisal', '~> 2.5'
+  gem 'blueprinter', '~> 1.3'
   gem 'byebug', '~> 13.0'
   gem 'cancancan', '~> 3.6', require: false
   gem 'database_cleaner-active_record', '~> 2.2', require: 'database_cleaner/active_record'
@@ -24,6 +25,9 @@ group :development, :test do
   gem 'devise-jwt', '~> 0.13'
   gem 'factory_bot_rails', '~> 6.5'
   gem 'faker', '~> 3.8'
+  # json 3 dropped the `quirks_mode` keyword that ActionController::TestCase
+  # (and thus rails-controller-testing) still passes on Rails <= 8.0.
+  gem 'json', '< 3'
   gem 'kaminari', '~> 1.2', require: false
   gem 'overcommit', '~> 0.72'
   gem 'pagy', '~> 43.0', require: false
@@ -39,5 +43,5 @@ group :development, :test do
   # required range differs across supported versions.
   gem 'webmock', '~> 3.26'
   gem 'will_paginate', '~> 4.0', require: false
-  gem 'wor-paginate', '~> 0.4'
+  gem 'wor-paginate', '~> 0.5'
 end

data/README.md

@@ -18,6 +18,7 @@ SimpleCrud
         - [Serializer](#serializer)
         - [HTML](#html)
         - [Finder](#finder)
+        - [Cache](#cache)
       - [Controller-level defaults](#controller-level-defaults)
       - [Shared examples](#shared-examples)
   - [Contributing](#contributing)
@@ -102,7 +103,10 @@ simple_crud_for :index, paginate: false, authorize: false, serializer: CustomSer
 - Authorize: whether it should check authorization via the configured authorization adapter (Pundit by default)
 - Authenticate: whether the generated action calls `authenticate_user!`. `true` (default) or `false`
 - Authenticate_headers: whether shared examples set auth headers and run the unauthorized test. Defaults to `authenticate:`. Set independently when a base-controller `before_action` handles auth and the lambda should skip `authenticate_user!`
-- Serializer: specify a particular serializer you should use
+- Serializer: specify a particular serializer you should use. Accepts an ActiveModelSerializers serializer or a Blueprinter blueprint (see [Serializer](#serializer))
+- Serializer_options: a `Proc`/`lambda` that runs with the controller as `self`. Its result goes to the serializer: `render_as_hash(record, options)` for Blueprinter, `new(record, options)` for ActiveModelSerializers. Arity 0 runs without arguments; arity ≥ 1 receives the record. On `:index` it runs once with no record
+- Status: only valid for `:create`, `:update` and `:destroy`. Overrides the success status (`:created`, `:ok` and `:ok` by default). `status: :no_content` responds with an empty body
+- After_persist: only valid for `:create`, `:update` and `:destroy`. A `Proc`/`lambda` `->(record, saved) { ... }` that runs with the controller as `self`, after the write and before rendering. Use it for side effects like cache invalidation. It still runs when you pass a render block
 - Html: renders the action's ERB template instead of JSON (valid for `:index`, `:show`, `:new`, `:edit`, `:create`, `:update` and `:destroy`). Only meaningful in controllers that render templates
 - Scope: only valid for `:index`. A `Proc`/`lambda` taking `current_user` (plus the controller's `params` if it takes a second argument) that returns the relation to list, overriding the default `policy_scope`. The user is resolved via `SimpleCrud::Config.user_method` (`:current_user` by default; set it to e.g. `:current_admin`)
 - Finder: only valid for `:show`, `:update`, `:destroy` and `:edit`. A `Proc`/`lambda` (invoked with the controller's params) or a `Symbol` naming a class method on the model, used to look up the record instead of `klass.find(params[:id])`.
@@ -268,12 +272,22 @@ simple_crud_defaults authenticate: false, authenticate_headers: true
 ```
 
 #### Serializer
-The name of the serializer, by default, is the name of the model followed by Serializer, as is the standard for [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers). It's possible to just pass a custom serializer class though. As for the serializer itself, it's a standard serializer, with the gotcha that you need to include `:id` for the SimpleCrud examples to work.
+`serializer:` picks the serializer for JSON responses on every action. Pass either an [ActiveModelSerializers](https://github.com/rails-api/active_model_serializers) serializer class, which simple_crud builds per record with `serializer.new(record, serializer_options)`, or a [Blueprinter](https://github.com/blueprinter/blueprinter) blueprint class, which it renders with `blueprint.render_as_hash(record, serializer_options)`.
+
+Without `serializer:`, the response uses the record's `as_json`. The shared examples expect an `:id` attribute. Paginated `:index` with Blueprinter needs wor-paginate ≥ 0.5.
 
 ```ruby
 class AuthorSerializer < ActiveModel::Serializer
-  attributes :email, :first_name, :last_name, :institution, :role, :id
+  attributes :email, :first_name, :last_name, :id
+end
+
+class AuthorBlueprint < Blueprinter::Base
+  identifier :id
+  fields :email, :first_name, :last_name
 end
+
+simple_crud_for :show, serializer: AuthorBlueprint
+simple_crud_for :index, serializer: AuthorBlueprint, serializer_options: -> { { current_user: current_user } }
 ```
 
 #### HTML
@@ -343,6 +357,58 @@ simple_crud_for :destroy, finder: ->(params) { current_user.models.find(params[:
 
 When omitted it defaults to `klass.find(params[:id])`, and `not_found` is still returned whenever the finder finds no record.
 
+#### Cache
+Pass `cache: { key:, ttl: }` on `:show` or `:index` to skip the DB on cache hits.
+
+`key` is a lambda receiving `params`, or a plain string. Both `key` and `ttl` are optional — defaults are `"#{model}:#{action}:v1:#{request.fullpath}"` and 300 seconds. With `cache:` the block must return the payload hash, not call `render`. `@record`/`@records` is set before the block, so shared examples work unchanged.
+
+Controllers get a default `fetch_cached(key, ttl, &block)` backed by `Rails.cache`. Override to use a different store:
+
+```ruby
+# Override with a direct Redis connection
+def fetch_cached(key, ttl)
+  cached = redis.get(key)
+  return JSON.parse(cached, symbolize_names: true) if cached
+
+  result = yield
+  redis.setex(key, ttl, result.to_json)
+  result
+end
+
+# All options explicit
+simple_crud_for :show,
+                finder: ->(p) { Article.includes(:author).find(p[:id]) },
+                cache: { key: ->(p) { "article:v1:#{p[:id]}" }, ttl: 900 } do |article|
+  article_payload(article)
+end
+
+# All defaults — key and TTL inferred from model name and params
+simple_crud_for :index, paginate: false, cache: {} do |articles|
+  articles.map { |a| article_summary(a) }
+end
+```
+
+Invalidate on write. For the default key format, `expire_simple_crud_cache(action)` deletes it without constructing it by hand:
+
+```ruby
+expire_simple_crud_cache(:show)
+expire_simple_crud_cache(:index)
+```
+
+For a custom `key:` lambda, delete the key yourself:
+
+```ruby
+def update
+  article = current_user.articles.find(params[:id])
+  if article.update(article_params)
+    redis.del("article:v1:#{article.id}")
+    render json: article_payload(article)
+  else
+    render json: { errors: article.errors.full_messages }, status: :unprocessable_entity
+  end
+end
+```
+
 ### Shared examples
 While optional, using the included shared examples saves you from writing the standard test cases for the methods. You can even use them if you didn't use `simple_crud_for`, as a set of basic tests. To include them, add `require 'simple_crud/rspec'` to your `rails_helper.rb` **after** `require "rspec/rails"`, then add the lines you need to your `*_spec.rb` files:
 ```ruby

data/lib/simple_crud/action_context.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class ActionContext
+    DEFAULT_CACHE_TTL = 300
+
+    attr_reader :controller, :klass, :parameters, :block
+
+    def self.cache_key_for(model, action, path)
+      "#{model.model_name.singular}:#{action}:v1:#{path}"
+    end
+
+    def initialize(controller, klass, parameters, &block)
+      @controller = controller
+      @klass      = klass
+      @parameters = parameters
+      @block      = block
+    end
+
+    def call
+      controller.authenticate_user! if parameters[:authenticate]
+      run
+    end
+
+    private
+
+    def run
+      raise NotImplementedError, "#{self.class} must implement run"
+    end
+
+    def action_name
+      raise NotImplementedError, "#{self.class} must implement action_name to support caching"
+    end
+
+    def maybe_authorize(object)
+      return unless parameters[:authorize]
+
+      SimpleCrud::Config.authorization_adapter.authorize(controller, object)
+    end
+
+    def find_record
+      record = lookup_record
+      raise ActiveRecord::RecordNotFound, "couldn't find #{klass}" if record.nil?
+      unless record.is_a?(ActiveRecord::Base)
+        raise ActiveRecord::RecordNotFound, "#{klass} finder must return a single record"
+      end
+
+      record
+    end
+
+    def lookup_record
+      finder = parameters[:finder]
+      return find_by_id if finder.nil?
+      return klass.send(finder, controller.params) unless finder.respond_to?(:call)
+
+      controller.instance_exec(controller.params, &finder)
+    end
+
+    def find_by_id
+      klass.find(controller.params[:id])
+    end
+
+    def build_record
+      parameters[:build] ? controller.instance_exec(&parameters[:build]) : klass.new
+    end
+
+    def permitted_params
+      controller.send("#{klass.model_name.singular}_params")
+    end
+
+    def serialize_opts(key)
+      opts = { key => parameters[:serializer] }.compact
+      options = serializer_options
+      opts[:serializer_options] = options if options.present?
+      opts
+    end
+
+    def serializer_options(record = nil)
+      callable = parameters[:serializer_options]
+      return {} unless callable
+
+      callable.arity.zero? ? controller.instance_exec(&callable) : controller.instance_exec(record, &callable)
+    end
+
+    def render_record(record, template)
+      return render_html_record(record, template) if parameters[:html] || block
+
+      render_json_record(record)
+    end
+
+    def render_html_record(record, template)
+      controller.instance_variable_set(:@record, record)
+      block ? controller.instance_exec(record, &block) : controller.render(template)
+    end
+
+    def render_json_record(record)
+      serializer = parameters[:serializer]
+      controller.render json: SimpleCrud::Serializer.render(serializer, record, serializer_options(record))
+    end
+
+    def render_cached(cache_opts, &fetch_block)
+      key    = resolve_cache_key(cache_opts)
+      ttl    = cache_opts[:ttl] || DEFAULT_CACHE_TTL
+      result = controller.send(:fetch_cached, key, ttl, &fetch_block)
+      controller.render json: result
+    end
+
+    def resolve_cache_key(cache_opts)
+      k = cache_opts[:key]
+      return default_cache_key if k.nil?
+
+      k.respond_to?(:call) ? controller.instance_exec(controller.params, &k) : k
+    end
+
+    def default_cache_key
+      self.class.cache_key_for(klass, action_name, controller.request.fullpath)
+    end
+  end
+end

data/lib/simple_crud/action_lambdas.rb

@@ -3,78 +3,10 @@
 module SimpleCrud
   # Builds the lambda installed as each action declared with simple_crud_for.
   module ActionLambdas
-    def crud_lambda_for_show(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-
-        options = {}.merge(serializer: parameters[:serializer]).compact
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        SimpleCrudController.render_show(self, requested, options, parameters, &block)
-      end
-    end
-
-    def crud_lambda_for_new(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        record = SimpleCrudController.build_record(self, klass, parameters)
-        SimpleCrudController.maybe_authorize(self, record, parameters)
-        SimpleCrudController.render_new(self, record, parameters, &block)
-      end
-    end
-
-    # The find-instead-of-build twin of :new.
-    def crud_lambda_for_edit(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        SimpleCrudController.render_edit(self, requested, parameters, &block)
-      end
-    end
-
-    def crud_lambda_for_index(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        SimpleCrudController.maybe_authorize(self, klass, parameters)
-        options = {}.merge(each_serializer: parameters[:serializer]).compact
-        SimpleCrudController.render_index(self, klass, options, parameters, &block)
-      end
-    end
-
-    def crud_lambda_for_create(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-        record = SimpleCrudController.build_record(self, klass, parameters)
-        record.assign_attributes(permitted_params)
-        SimpleCrudController.maybe_authorize(self, record, parameters)
-        persist = ->(bang:) { bang ? record.save! : record.save }
-        options = { status: :created, failure_template: :new }
-        SimpleCrudController.save_and_render(self, record, parameters, options, persist, &block)
-      end
-    end
-
-    def crud_lambda_for_update(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        permitted_params = send("#{self.class.simple_crud_controller_model.to_s.underscore}_params")
-        persist = ->(bang:) { bang ? requested.update!(permitted_params) : requested.update(permitted_params) }
-        options = { status: :ok, failure_template: :edit }
-        SimpleCrudController.save_and_render(self, requested, parameters, options, persist, &block)
-      end
-    end
-
-    def crud_lambda_for_destroy(klass, parameters = {}, &block)
-      lambda do
-        authenticate_user! if parameters[:authenticate]
-        requested = SimpleCrudController.find_record(klass, self, parameters)
-        SimpleCrudController.maybe_authorize(self, requested, parameters)
-        options = { status: :ok, failure_template: :show, redirect: parameters[:redirect] || klass }
-        persist = ->(bang:) { bang ? requested.destroy! : requested.destroy }
-        SimpleCrudController.persist_and_render(self, requested, parameters, options, persist, &block)
+    %i[show new edit index create update destroy].each do |action|
+      ctx_class = SimpleCrud.const_get(:"#{action.to_s.capitalize}Context")
+      define_method(:"crud_lambda_for_#{action}") do |klass, parameters = {}, &block|
+        -> { ctx_class.new(self, klass, parameters, &block).call }
       end
     end
   end

data/lib/simple_crud/cache_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  # Default fetch_cached included into controllers that extend SimpleCrudController.
+  # Override in the controller to use a different store.
+  module CacheHelpers
+    def fetch_cached(key, ttl, &block)
+      Rails.cache.fetch(key, expires_in: ttl, &block)
+    end
+
+    def expire_simple_crud_cache(action, path: request.fullpath)
+      Rails.cache.delete(
+        SimpleCrud::ActionContext.cache_key_for(self.class.simple_crud_controller_model, action, path)
+      )
+    end
+  end
+end

data/lib/simple_crud/create_context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class CreateContext < PersistenceContext
+    private
+
+    def run
+      attrs  = permitted_params
+      record = build_record
+      record.assign_attributes(attrs)
+      maybe_authorize(record)
+      persist = ->(bang:) { bang ? record.save! : record.save }
+      options = { status: parameters[:status] || :created, failure_template: :new,
+                  redirect: parameters[:redirect] || record }
+      persist_and_render(record, options, persist)
+    end
+  end
+end

data/lib/simple_crud/destroy_context.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class DestroyContext < PersistenceContext
+    private
+
+    def run
+      record = find_record
+      maybe_authorize(record)
+      persist = ->(bang:) { bang ? record.destroy! : record.destroy }
+      options = { status: parameters[:status] || :ok, failure_template: :show,
+                  redirect: parameters[:redirect] || klass }
+      persist_and_render(record, options, persist)
+    end
+  end
+end

data/lib/simple_crud/edit_context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class EditContext < ActionContext
+    private
+
+    def run
+      record = find_record
+      maybe_authorize(record)
+      render_record(record, :edit)
+    end
+  end
+end

data/lib/simple_crud/index_context.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class IndexContext < ActionContext
+    private
+
+    def action_name = :index
+
+    def run
+      maybe_authorize(klass)
+      cache_opts = parameters[:cache]
+      cache_opts ? render_cached(cache_opts) { payload } : render_index
+    end
+
+    def payload
+      opts     = serialize_opts(:each_serializer)
+      relation = index_relation
+      records  = index_records(relation, opts)
+      controller.instance_variable_set(:@records, records)
+      block ? controller.instance_exec(records, &block) : serialize_records(records)
+    end
+
+    def serialize_records(records)
+      serializer = parameters[:serializer]
+      return records.as_json if serializer.nil?
+
+      records.map { |record| SimpleCrud::Serializer.render(serializer, record, serializer_options) }
+    end
+
+    def render_index
+      relation = index_relation
+      opts     = serialize_opts(:each_serializer)
+      if parameters[:html] || block
+        render_records(relation, opts)
+      elsif parameters[:paginate]
+        SimpleCrud::Config.pagination_adapter.paginate(controller, relation, opts)
+      else
+        controller.render json: serialize_records(relation)
+      end
+    end
+
+    def render_records(relation, opts)
+      records = index_records(relation, opts)
+      controller.instance_variable_set(:@records, records)
+      block ? controller.instance_exec(records, &block) : controller.render(:index)
+    end
+
+    def index_relation
+      if parameters[:scope]
+        call_scope
+      elsif parameters[:authorize]
+        SimpleCrud::Config.authorization_adapter.policy_scope(controller, klass)
+      else
+        klass.all
+      end
+    end
+
+    def call_scope
+      user_method = SimpleCrud::Config.user_method
+      user = controller.respond_to?(user_method, true) ? controller.send(user_method) : nil
+      scope = parameters[:scope]
+      scope.arity == 1 ? scope.call(user) : scope.call(user, controller.params)
+    end
+
+    def index_records(relation, opts)
+      return relation unless parameters[:paginate]
+
+      SimpleCrud::Config.pagination_adapter.paginated_records(controller, relation, opts)
+    end
+  end
+end

data/lib/simple_crud/new_context.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class NewContext < ActionContext
+    private
+
+    def run
+      record = build_record
+      maybe_authorize(record)
+      render_record(record, :new)
+    end
+  end
+end

data/lib/simple_crud/pagination/wor_paginate_adapter.rb

@@ -10,7 +10,13 @@ module SimpleCrud
       include Adapter
 
       def paginate(controller, relation, options)
-        controller.send(:render_paginated, relation, options)
+        serializer = options[:each_serializer]
+        return controller.send(:render_paginated, relation, options) if serializer.nil?
+
+        serializer_options = options[:serializer_options] || {}
+        controller.send(:render_paginated, relation, options) do |record|
+          SimpleCrud::Serializer.render(serializer, record, serializer_options)
+        end
       end
 
       def paginated_records(controller, relation, options)

data/lib/simple_crud/persistence_context.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class PersistenceContext < ActionContext
+    private
+
+    def persist_and_render(record, options, persist)
+      saved = parameters[:raise_on_invalid] ? persist.call(bang: true) : persist.call(bang: false)
+      run_after_persist(record, saved)
+      return render_persisted(record, saved, options) unless block || parameters[:html]
+
+      controller.instance_variable_set(:@record, record)
+      block ? controller.instance_exec(record, saved, &block) : render_html_redirect(record, saved, options)
+    end
+
+    def run_after_persist(record, saved)
+      hook = parameters[:after_persist]
+      controller.instance_exec(record, saved, &hook) if hook
+    end
+
+    def render_html_redirect(record, saved, options)
+      if saved
+        controller.redirect_to(redirect_target(record, options[:redirect]))
+      else
+        controller.render(options[:failure_template])
+      end
+    end
+
+    def redirect_target(record, target)
+      target.is_a?(Proc) ? controller.instance_exec(record, &target) : target
+    end
+
+    def render_persisted(record, saved, options)
+      return render_success(record, options[:status]) if saved
+
+      controller.render json: { errors: record.errors.full_messages }, status: 422
+    end
+
+    def render_success(record, status)
+      return controller.head(status) if status == :no_content
+
+      controller.render json: payload(record), status: status
+    end
+
+    def payload(record)
+      SimpleCrud::Serializer.render(parameters[:serializer], record, serializer_options(record))
+    end
+  end
+end

data/lib/simple_crud/rspec/config.rb

@@ -51,7 +51,12 @@ module SimpleCrud
         unauthenticated_status: :unauthorized,
         assert_html_template: true,
         policy_class: ->(klass) { "#{klass}Policy".constantize },
-        serializer_class: ->(model) { "#{model.class}_serializer".classify.constantize },
+        serializer_class: lambda { |model|
+          klass = model.class
+          next "#{klass}Serializer".constantize if Kernel.const_defined?("#{klass}Serializer")
+
+          "#{klass}Blueprint".constantize
+        },
         created_record_check: nil
       }.freeze
 

data/lib/simple_crud/rspec/helpers/authentication.rb

@@ -19,7 +19,8 @@ module SimpleCrud
         end
 
         def owner_foreign_key
-          :"#{owner_association}_id"
+          reflection = model_class_object.reflect_on_association(owner_association)
+          reflection ? reflection.foreign_key : :"#{owner_association}_id"
         end
 
         # The owner association attributed to current_user, if the model has one.

data/lib/simple_crud/rspec/helpers/controller_options.rb

@@ -10,8 +10,8 @@ module SimpleCrud
           described_class.instance_variable_get(:@simple_crud_metadata)[method][option]
         end
 
-        %i[paginate authorize authenticate serializer html finder scope build raise_on_invalid block
-           authenticate_headers].each do |option|
+        %i[paginate authorize authenticate serializer serializer_options status after_persist html finder
+           scope build raise_on_invalid block authenticate_headers].each do |option|
           define_method("check_#{option}") { |method| get_option(method, option) }
         end