wor-simple_crud 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e280efd8ead44768d16e0ba663e25a40d6972b53e253281d1c7eac0735421b64
-  data.tar.gz: 78625a2a759ca5fda1e7d41e421db92ed721f2e2c343524f0580cd810d32ac7a
+  metadata.gz: b5b50548416811b034a75f72c96d4e94c41cdb9883d7112cdf720ad3febaeb11
+  data.tar.gz: 99ae1562bae38c2fa8ff1d697859f8643e2b818aaeb66f2e14220171fa9f28dc
 SHA512:
-  metadata.gz: 406a83cc98deaa7fa3ba5f7ccb9a12486a903b6aef81bddd0a5f4f9c595ffa64e7414cb8a718d4a4fe96f987fcefaf34a8b201cbe16aab4db2721eea0bd19397
-  data.tar.gz: 7177530ba1a01fcf526c406a14f3bf64bfcf895ce5675f4acca5f24f28c57db90859ddab43866d314f70e723cfebda24bc5930d64ac66a01d29bc6246792c04a
+  metadata.gz: ef7dd6acb64f882534e9951a9adf2d8deab27f2264451cb1dee2613c78e4842e38d10a638a2ed9ec623984d0d571aee558e2a3626f7bf8f016eca65dc3174ae3
+  data.tar.gz: 43a9b8fb46febb90d101814a33d48049ba0a5c2df3a3b14568c5423816ebd55325966fabe8673320ef3ed89b1a7bfe0ac10f4940c16b0e412649b100dd08e051

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,26 @@
 ## Change log
 
+### 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:
+* Blocks given to `simple_crud_for` no longer imply `html: true`. HTML controllers with render blocks must pass `html: true` explicitly.
+
+New options:
+* `authenticate_headers:` controls whether shared examples set auth headers and run the unauthorized test, independent of `authenticate:`. Defaults to `authenticate:`. Set `authenticate: false, authenticate_headers: true` when a base-controller `before_action` handles auth so the lambda skips the call but tests still cover the auth path.
+* `simple_crud_defaults(options)` sets option defaults at the controller level. Subclasses inherit. Per-action options override. Precedence: gem defaults < controller defaults < per-action options.
+
+Fixes:
+* Use `RSpec.shared_examples` instead of the top-level alias, which is unavailable with `config.disable_monkey_patching!`.
+* Auto-require `SimpleCrud::Authorization::Adapter` on `require 'simple_crud'`.
+* Remove `cattr_accessor :params, :permitted` (thread-unsafe, never read by the gem). Remove the `set_params` boilerplate from host controllers.
+* Raise a clear error when `owner_association` names an attribute the model doesn't have, instead of a bare `NoMethodError` from FactoryBot.
+
 ### V0.3.1
 
 Shared examples configuration:

data/README.md

@@ -18,6 +18,8 @@ SimpleCrud
         - [Serializer](#serializer)
         - [HTML](#html)
         - [Finder](#finder)
+        - [Cache](#cache)
+      - [Controller-level defaults](#controller-level-defaults)
       - [Shared examples](#shared-examples)
   - [Contributing](#contributing)
   - [Releases](#releases)
@@ -68,12 +70,6 @@ Before SimpleCrud can be used, some boilerplate is needed. Add the following to
 include Pundit::Authorization
 include Wor::Paginate
 extend SimpleCrudController
-
-before_action :set_params
-
-def set_params
-  SimpleCrudController.params = params
-end
 ```
 
 (Skip `include Pundit::Authorization` / `include Wor::Paginate` if you're using a different adapter, or `authorize: false` / `paginate: false` everywhere.)
@@ -105,7 +101,8 @@ simple_crud_for :index, paginate: false, authorize: false, serializer: CustomSer
 
 - Paginate: whether it should paginate or not. `true` paginates via the configured pagination adapter (wor-paginate by default), `false` doesn't paginate
 - Authorize: whether it should check authorization via the configured authorization adapter (Pundit by default)
-- Authenticate: whether it should use Devise to check for a current_user
+- 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
 - 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`)
@@ -114,6 +111,22 @@ simple_crud_for :index, paginate: false, authorize: false, serializer: CustomSer
 - Raise_on_invalid: only valid for `:create` and `:update`. Keeps the strict `create!`/`update!` semantics (raising on invalid input) instead of returning `422` with the validation errors
 - Redirect: only valid for HTML-mode `:create`, `:update` and `:destroy`. A `Proc`/`lambda` (called with the record) or a literal path used as the success redirect target. Defaults to the record (`:create`/`:update`) or the model's collection path (`:destroy`)
 
+#### Controller-level defaults
+
+`simple_crud_defaults` sets option defaults for every `simple_crud_for` in the controller. Subclasses inherit; per-action options override.
+
+```ruby
+class Api::BaseController < ActionController::API
+  extend SimpleCrudController
+  simple_crud_defaults authorize: false, authenticate: false, authenticate_headers: true
+end
+
+class Api::PostsController < Api::BaseController
+  simple_crud_for :show                    # inherits defaults
+  simple_crud_for :create, authorize: true # overrides for this action only
+end
+```
+
 You'll need a few things so they work correctly:
 
 ### Options
@@ -247,7 +260,13 @@ end
 ```
 
 #### Authenticate
-SimpleCrud will assume a current_user method. Future versions will support a custom model. Defining a current_user method in ApplicationController should work if you're using a different model, as of now.
+`authenticate: true` (default) calls `authenticate_user!` inside the generated action. `authenticate: false` skips it.
+
+If your base controller already runs `before_action :authenticate_user!`, set `authenticate: false` to avoid a double call and `authenticate_headers: true` so shared examples still cover the auth path:
+
+```ruby
+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.
@@ -279,16 +298,22 @@ simple_crud_for :update, html: true
 simple_crud_for :destroy, html: true
 ```
 
-Or pass a block that renders explicitly, overriding the auto-render. The block receives the records for `:index`, the record for `:show`/`:new`, or the record plus a saved flag for `:create`/`:update`/`:destroy`. Passing a block also implies `html: true` for the shared examples (so a server-rendered block is asserted as HTML); if your block renders JSON instead, pass `html: false` explicitly:
+Or pass a block that renders explicitly, overriding the auto-render. The block receives the records for `:index`, the record for `:show`/`:new`, or the record plus a saved flag for `:create`/`:update`/`:destroy`. Blocks do not change the `html:` default; pass it explicitly so the shared examples know which request format to use:
 
 ```ruby
-simple_crud_for :index do |records|
+# Server-rendered block: pass html: true so shared examples send HTML requests
+simple_crud_for :index, html: true do |records|
   render :index, locals: { models: records }
 end
 
-simple_crud_for :create do |record, saved|
+simple_crud_for :create, html: true do |record, saved|
   saved ? redirect_to(record) : render(:new, locals: { model: record })
 end
+
+# API block: html: false is the default
+simple_crud_for :show, html: false do |record|
+  render json: record.as_json(only: %i[id name])
+end
 ```
 
 #### Build
@@ -319,8 +344,60 @@ 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, just add `require 'simple_crud/rspec'` to your `rails_helper.rb` file and add the lines you need to your `*_spec.rb` files:
+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
 require 'rails_helper'
 

data/lib/simple_crud/action_context.rb

@@ -0,0 +1,98 @@
+# 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 klass.find(controller.params[:id]) if finder.nil?
+      return klass.send(finder, controller.params) unless finder.respond_to?(:call)
+
+      finder.call(controller.params)
+    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)
+      { key => parameters[:serializer] }.compact
+    end
+
+    def render_record(record, template)
+      if parameters[:html] || block
+        controller.instance_variable_set(:@record, record)
+        block ? controller.instance_exec(record, &block) : controller.render(template)
+      else
+        controller.render({ json: record }.merge(serialize_opts(:serializer)))
+      end
+    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,17 @@
+# 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: :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,15 @@
+# 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: :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,64 @@
+# 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) : records.as_json
+    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: relation }.merge(opts))
+      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) ? controller.public_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/persistence_context.rb

@@ -0,0 +1,33 @@
+# 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)
+      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 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 controller.render(json: record, status: options[:status]) if saved
+
+      controller.render json: { errors: record.errors.full_messages }, status: 422
+    end
+  end
+end

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

@@ -10,9 +10,14 @@ 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].each do |option|
+        %i[paginate authorize authenticate serializer html finder scope build raise_on_invalid block
+           authenticate_headers].each do |option|
           define_method("check_#{option}") { |method| get_option(method, option) }
         end
+
+        def check_authenticate(method)
+          check_authenticate_headers(method)
+        end
       end
     end
   end

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

@@ -15,7 +15,22 @@ module SimpleCrud
         end
 
         def model
-          @model ||= create_record(model_class, model_attributes)
+          @model ||= begin
+            validate_owner_association!
+            create_record(model_class, model_attributes)
+          end
+        end
+
+        def validate_owner_association!
+          assoc = owner_association
+          return unless assoc
+
+          klass = model_class_object
+          return if klass.method_defined?("#{assoc}=") || klass.column_names.include?(assoc.to_s)
+
+          raise "simple_crud: owner_association is :#{assoc} but #{klass} has no #{assoc}= setter. " \
+                'Set `simple_crud: { owner_association: nil }` in your describe block or ' \
+                'override model_attributes directly.'
         end
 
         def model_attributes

data/lib/simple_crud/show_context.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  class ShowContext < ActionContext
+    private
+
+    def action_name = :show
+
+    def run
+      cache_opts = parameters[:cache]
+      if cache_opts
+        render_cached(cache_opts) { payload }
+      else
+        record = find_record
+        maybe_authorize(record)
+        render_record(record, :show)
+      end
+    end
+
+    def payload
+      record = find_record
+      maybe_authorize(record)
+      controller.instance_variable_set(:@record, record)
+      block ? controller.instance_exec(record, &block) : record.as_json
+    end
+  end
+end