wor-simple_crud 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5b50548416811b034a75f72c96d4e94c41cdb9883d7112cdf720ad3febaeb11
-  data.tar.gz: 99ae1562bae38c2fa8ff1d697859f8643e2b818aaeb66f2e14220171fa9f28dc
+  metadata.gz: b40c7867a484ffc3807b8dceac29ac1f6cc49ccca6d8a9bb067f93f839703e0c
+  data.tar.gz: 5a72d84147fc1f149695fe0244a11e7f99f2c9b4debb0b99a291e16439b873ac
 SHA512:
-  metadata.gz: ef7dd6acb64f882534e9951a9adf2d8deab27f2264451cb1dee2613c78e4842e38d10a638a2ed9ec623984d0d571aee558e2a3626f7bf8f016eca65dc3174ae3
-  data.tar.gz: 43a9b8fb46febb90d101814a33d48049ba0a5c2df3a3b14568c5423816ebd55325966fabe8673320ef3ed89b1a7bfe0ac10f4940c16b0e412649b100dd08e051
+  metadata.gz: 2354c67d6866dd82b70172279fd47a65bced5a950ce4385df97a1d3ab3373724d7f49a2ee7185e9cca3f86f403892e732afeade705c74337d7ae32ed53815632
+  data.tar.gz: 851104267914cd47c8312723af3361a13e5ee5fa2a323f73add55a0a09e04d965492f870c66ffc81f24c5851239afd35485b367633192c80ce8b3d8d90a7753a

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 ## 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:

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

@@ -103,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])`.
@@ -269,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

data/lib/simple_crud/action_context.rb

@@ -50,10 +50,14 @@ module SimpleCrud
 
     def lookup_record
       finder = parameters[:finder]
-      return klass.find(controller.params[:id]) if finder.nil?
+      return find_by_id if finder.nil?
       return klass.send(finder, controller.params) unless finder.respond_to?(:call)
 
-      finder.call(controller.params)
+      controller.instance_exec(controller.params, &finder)
+    end
+
+    def find_by_id
+      klass.find(controller.params[:id])
     end
 
     def build_record
@@ -65,16 +69,33 @@ module SimpleCrud
     end
 
     def serialize_opts(key)
-      { key => parameters[:serializer] }.compact
+      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)
-      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
+      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)

data/lib/simple_crud/create_context.rb

@@ -10,7 +10,8 @@ module SimpleCrud
       record.assign_attributes(attrs)
       maybe_authorize(record)
       persist = ->(bang:) { bang ? record.save! : record.save }
-      options = { status: :created, failure_template: :new, redirect: parameters[:redirect] || record }
+      options = { status: parameters[:status] || :created, failure_template: :new,
+                  redirect: parameters[:redirect] || record }
       persist_and_render(record, options, persist)
     end
   end

data/lib/simple_crud/destroy_context.rb

@@ -8,7 +8,8 @@ module SimpleCrud
       record = find_record
       maybe_authorize(record)
       persist = ->(bang:) { bang ? record.destroy! : record.destroy }
-      options = { status: :ok, failure_template: :show, redirect: parameters[:redirect] || klass }
+      options = { status: parameters[:status] || :ok, failure_template: :show,
+                  redirect: parameters[:redirect] || klass }
       persist_and_render(record, options, persist)
     end
   end

data/lib/simple_crud/index_context.rb

@@ -17,7 +17,14 @@ module SimpleCrud
       relation = index_relation
       records  = index_records(relation, opts)
       controller.instance_variable_set(:@records, records)
-      block ? controller.instance_exec(records, &block) : records.as_json
+      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
@@ -28,7 +35,7 @@ module SimpleCrud
       elsif parameters[:paginate]
         SimpleCrud::Config.pagination_adapter.paginate(controller, relation, opts)
       else
-        controller.render({ json: relation }.merge(opts))
+        controller.render json: serialize_records(relation)
       end
     end
 
@@ -50,7 +57,7 @@ module SimpleCrud
 
     def call_scope
       user_method = SimpleCrud::Config.user_method
-      user = controller.respond_to?(user_method) ? controller.public_send(user_method) : nil
+      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

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

@@ -6,12 +6,18 @@ module SimpleCrud
 
     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]))
@@ -25,9 +31,19 @@ module SimpleCrud
     end
 
     def render_persisted(record, saved, options)
-      return controller.render(json: record, status: options[:status]) if saved
+      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
 

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

@@ -11,8 +11,11 @@ module SimpleCrud
           Rack::Utils::SYMBOL_TO_STATUS_CODE.invert[422]
         end
 
-        def request_format(action)
-          check_html(action) ? :html : :json
+        # Rails copies the controller-test `format:` kwarg into params, which
+        # collides with a model attribute named `format`. Only HTML requests
+        # need it, so leave params untouched for JSON.
+        def format_param(action)
+          check_html(action) ? :html : nil
         end
 
         # Extra params (e.g. a parent slug) added to every request, for nested

data/lib/simple_crud/serializer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SimpleCrud
+  # Renders a record with the app's serializer stack.
+  #
+  # Blueprinter blueprints respond to `render_as_hash` and receive the
+  # render options, so a blueprint can read `url_builder:` (or any other
+  # option) from them. For anything else, simple_crud assumes an
+  # ActiveModelSerializers-style serializer and calls `new(record, options)`.
+  # A `nil` serializer renders `record.as_json`.
+  module Serializer
+    def self.render(serializer, record, options = {})
+      return record.as_json if serializer.nil?
+      return serializer.render_as_hash(record, options) if serializer.respond_to?(:render_as_hash)
+
+      serializer.new(record, options).as_json
+    end
+  end
+end

data/lib/simple_crud/show_context.rb

@@ -21,7 +21,9 @@ module SimpleCrud
       record = find_record
       maybe_authorize(record)
       controller.instance_variable_set(:@record, record)
-      block ? controller.instance_exec(record, &block) : record.as_json
+      return controller.instance_exec(record, &block) if block
+
+      SimpleCrud::Serializer.render(parameters[:serializer], record, serializer_options(record))
     end
   end
 end

data/lib/simple_crud/simple_crud_controller.rb

@@ -2,6 +2,7 @@
 
 require 'active_support/all'
 require_relative 'config'
+require_relative 'serializer'
 require_relative 'cache_helpers'
 require_relative 'action_context'
 require_relative 'persistence_context'
@@ -63,7 +64,8 @@ module SimpleCrudController
   def parameters_with_defaults(parameters)
     defaults = {
       authorize: true, paginate: true, authenticate: true, authenticate_headers: nil,
-      serializer: nil, html: false, finder: nil, scope: nil, build: nil, raise_on_invalid: false
+      serializer: nil, serializer_options: nil, status: nil, after_persist: nil, html: false,
+      finder: nil, scope: nil, build: nil, raise_on_invalid: false
     }
     defaults.merge(simple_crud_inherited_defaults).each do |key, value|
       parameters[key] = value unless parameters.key?(key)

data/lib/simple_crud/update_context.rb

@@ -9,7 +9,8 @@ module SimpleCrud
       maybe_authorize(record)
       attrs   = permitted_params
       persist = ->(bang:) { bang ? record.update!(attrs) : record.update(attrs) }
-      options = { status: :ok, failure_template: :edit, redirect: parameters[:redirect] || record }
+      options = { status: parameters[:status] || :ok, failure_template: :edit,
+                  redirect: parameters[:redirect] || record }
       persist_and_render(record, options, persist)
     end
   end

data/lib/simple_crud/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleCrud
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/spec/matchers/have_been_serialized_with.rb

@@ -4,12 +4,29 @@ RSpec::Matchers.define :have_been_serialized_with do |serializer|
   # TODO: Add support for optional relations `has_many :zarasa, if: zarasa2`
   # TODO: Support multilevel serialization
   match do |json_response|
+    attributes  = serializer_attributes(serializer)
+    reflections = serializer_reflections(serializer)
+
     [json_response].flatten.all? do |json_response_item|
-      all_attributes_included?(serializer._attributes, json_response_item) &&
-        all_attributes_included?(serializer._reflections.keys, json_response_item)
+      all_attributes_included?(attributes, json_response_item) &&
+        all_attributes_included?(reflections, json_response_item)
     end
   end
 
+  # Blueprinter blueprints expose their fields through the view collection;
+  # ActiveModelSerializers expose `._attributes` / `._reflections`.
+  def serializer_attributes(serializer)
+    return serializer._attributes unless serializer.respond_to?(:view_collection)
+
+    serializer.view_collection.fields_for(:default).map(&:name)
+  end
+
+  def serializer_reflections(serializer)
+    return serializer._reflections.keys unless serializer.respond_to?(:view_collection)
+
+    []
+  end
+
   failure_message do |json_response|
     "expected attributes of #{serializer} serializer to be included in #{json_response}"
   end

data/lib/spec/shared_examples/simple_crud_for_create.rb

@@ -4,7 +4,7 @@ RSpec.shared_examples 'simple crud for create' do
   describe 'POST #create' do
     context 'without authenticated user' do
       subject!(:req) do
-        post :create, params: with_route_params(body_params(params_for(model_class))), format: request_format(:create)
+        post :create, params: with_route_params(body_params(params_for(model_class))), format: format_param(:create)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:create)
@@ -16,7 +16,7 @@ RSpec.shared_examples 'simple crud for create' do
 
         before do
           make_policies_fail(:create)
-          post :create, params: with_route_params(body_params(model_params)), format: request_format(:create)
+          post :create, params: with_route_params(body_params(model_params)), format: format_param(:create)
         end
 
         it 'fails with forbidden' do
@@ -30,7 +30,7 @@ RSpec.shared_examples 'simple crud for create' do
       let(:create_params) { model_params.merge(owner_params) }
 
       before do
-        post :create, params: with_route_params(body_params(create_params)), format: request_format(:create)
+        post :create, params: with_route_params(body_params(create_params)), format: format_param(:create)
       end
 
       if check_html(:create)
@@ -38,8 +38,8 @@ RSpec.shared_examples 'simple crud for create' do
           expect(response).to have_http_status(:found)
         end
       else
-        it 'response with 201 status code' do
-          expect(response).to have_http_status(:created)
+        it 'response with the configured status code' do
+          expect(response).to have_http_status(check_status(:create) || :created)
         end
 
         it 'creates an article with valid attributes' do
@@ -58,7 +58,7 @@ RSpec.shared_examples 'simple crud for create' do
         include_context 'with authenticated user' if check_authenticate(:create)
 
         before do
-          post :create, params: with_route_params(body_params(owner_params)), format: request_format(:create)
+          post :create, params: with_route_params(body_params(owner_params)), format: format_param(:create)
         end
 
         unless check_block(:create)

data/lib/spec/shared_examples/simple_crud_for_create_with_block.rb

@@ -7,7 +7,7 @@ RSpec.shared_examples 'simple crud for create with block' do
       let(:create_params) { model_params.merge(owner_params) }
 
       before do
-        post :create, params: with_route_params(body_params(create_params)), format: request_format(:create)
+        post :create, params: with_route_params(body_params(create_params)), format: format_param(:create)
       end
 
       it 'passes the saved record to the block' do
@@ -24,7 +24,7 @@ RSpec.shared_examples 'simple crud for create with block' do
         include_context 'with authenticated user' if check_authenticate(:create)
 
         before do
-          post :create, params: with_route_params(body_params(owner_params)), format: request_format(:create)
+          post :create, params: with_route_params(body_params(owner_params)), format: format_param(:create)
         end
 
         it 'does not create a model' do

data/lib/spec/shared_examples/simple_crud_for_create_with_build.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for create with build' do
     include_context 'with authenticated user' if check_authenticate(:create)
 
     before do
-      post :create, params: with_route_params(body_params(params_for(model_class))), format: request_format(:create)
+      post :create, params: with_route_params(body_params(params_for(model_class))), format: format_param(:create)
     end
 
     it 'creates the record owned by the current user' do

data/lib/spec/shared_examples/simple_crud_for_destroy.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for destroy' do
     context 'without authenticated user' do
       subject!(:req) do
         delete :destroy, params: with_route_params(record_param(:destroy, nil, not_found: true)),
-                         format: request_format(:destroy)
+                         format: format_param(:destroy)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:destroy)
@@ -17,7 +17,7 @@ RSpec.shared_examples 'simple crud for destroy' do
 
         before do
           make_policies_fail(:destroy)
-          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
         end
 
         it 'fails with forbidden' do
@@ -31,7 +31,7 @@ RSpec.shared_examples 'simple crud for destroy' do
 
       before do
         model
-        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
       end
 
       if check_html(:destroy)
@@ -40,8 +40,8 @@ RSpec.shared_examples 'simple crud for destroy' do
           expect(model_class_object.exists?(model.id)).to be false
         end
       else
-        it 'response with 200 status code' do
-          expect(response).to have_http_status(:ok)
+        it 'response with the configured status code' do
+          expect(response).to have_http_status(check_status(:destroy) || :ok)
         end
       end
     end
@@ -53,7 +53,7 @@ RSpec.shared_examples 'simple crud for destroy' do
         model
         allow(model).to receive(:destroy).and_return(false)
         allow_any_instance_of(SimpleCrud::DestroyContext).to receive(:find_record).and_return(model)
-        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+        delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
       end
 
       it 'keeps the record' do
@@ -77,7 +77,7 @@ RSpec.shared_examples 'simple crud for destroy' do
       before do
         model
         delete :destroy, params: with_route_params(record_param(:destroy, nil, not_found: true)),
-                         format: request_format(:destroy)
+                         format: format_param(:destroy)
       end
 
       it 'responds with not found status' do
@@ -92,7 +92,7 @@ RSpec.shared_examples 'simple crud for destroy' do
         before do
           model
           make_policies_fail(:destroy)
-          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: request_format(:destroy)
+          delete :destroy, params: with_route_params(record_param(:destroy, model)), format: format_param(:destroy)
         end
 
         it 'responds with forbidden status' do

data/lib/spec/shared_examples/simple_crud_for_destroy_with_block.rb

@@ -7,7 +7,7 @@ RSpec.shared_examples 'simple crud for destroy with block' do
     let!(:record) { model }
 
     before do
-      delete :destroy, params: with_route_params(record_param(:destroy, record)), format: request_format(:destroy)
+      delete :destroy, params: with_route_params(record_param(:destroy, record)), format: format_param(:destroy)
     end
 
     it 'passes the destroyed record to the block' do

data/lib/spec/shared_examples/simple_crud_for_destroy_with_finder.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for destroy with finder' do
       before do
         model
         delete :destroy, params: with_route_params(finder_key => model.public_send(finder_key)),
-                         format: request_format(:destroy)
+                         format: format_param(:destroy)
       end
 
       it 'destroys the model' do
@@ -24,8 +24,8 @@ RSpec.shared_examples 'simple crud for destroy with finder' do
           expect(response).to have_http_status(:found)
         end
       else
-        it 'responds with ok status' do
-          expect(response).to have_http_status(:ok)
+        it 'responds with the configured status code' do
+          expect(response).to have_http_status(check_status(:destroy) || :ok)
         end
       end
     end

data/lib/spec/shared_examples/simple_crud_for_edit.rb

@@ -2,7 +2,7 @@
 
 RSpec.shared_examples 'simple crud for edit' do
   describe 'GET #edit' do
-    subject(:edit_request) { get :edit, params: with_route_params(edit_params), format: request_format(:edit) }
+    subject(:edit_request) { get :edit, params: with_route_params(edit_params), format: format_param(:edit) }
 
     before do
       model
@@ -10,7 +10,7 @@ RSpec.shared_examples 'simple crud for edit' do
 
     context 'without authenticated user' do
       subject!(:req) do
-        get :edit, params: with_route_params(record_param(:edit, model)), format: request_format(:edit)
+        get :edit, params: with_route_params(record_param(:edit, model)), format: format_param(:edit)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:edit)

data/lib/spec/shared_examples/simple_crud_for_index.rb

@@ -14,7 +14,7 @@ RSpec.shared_examples 'simple crud for index' do
 
       before do
         make_policies_succeed(:index) if check_authorize(:index)
-        get :index, params: with_route_params({}), format: request_format(:index)
+        get :index, params: with_route_params({}), format: format_param(:index)
       end
 
       if check_html(:index)
@@ -25,7 +25,7 @@ RSpec.shared_examples 'simple crud for index' do
         end
 
         it 'renders the correct paginated models' do
-          expect(response_body['page'].map { |a| a['id'] }).to eq(model_class_object.all.map(&:id))
+          expect(response_body['page'].map { |a| a['id'] }).to match_array(model_class_object.all.map(&:id))
         end
       else
         it 'renders unpaginated models correctly serialized' do
@@ -33,7 +33,7 @@ RSpec.shared_examples 'simple crud for index' do
         end
 
         it 'renders the correct unpaginated models' do
-          expect(response_body.map { |a| a['id'] }).to eq(model_class_object.all.map(&:id))
+          expect(response_body.map { |a| a['id'] }).to match_array(model_class_object.all.map(&:id))
         end
       end
     end

data/lib/spec/shared_examples/simple_crud_for_index_with_block.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for index with block' do
 
     before do
       created_models
-      get :index, params: with_route_params({}), format: request_format(:index)
+      get :index, params: with_route_params({}), format: format_param(:index)
     end
 
     if check_html(:index)

data/lib/spec/shared_examples/simple_crud_for_index_with_scope.rb

@@ -13,7 +13,7 @@ RSpec.shared_examples 'simple crud for index with scope' do
       make_policies_succeed(:index) if check_authorize(:index)
       my_models
       other_models
-      get :index, params: with_route_params(request_params), format: request_format(:index)
+      get :index, params: with_route_params(request_params), format: format_param(:index)
     end
 
     if check_html(:index)

data/lib/spec/shared_examples/simple_crud_for_new.rb

@@ -10,7 +10,7 @@ RSpec.shared_examples 'simple crud for new' do
 
       before do
         make_policies_succeed(:new) if check_authorize(:new)
-        get :new, params: with_route_params({}), format: request_format(:new)
+        get :new, params: with_route_params({}), format: format_param(:new)
       end
 
       it 'responds with ok status' do

data/lib/spec/shared_examples/simple_crud_for_new_with_block.rb

@@ -6,7 +6,7 @@ RSpec.shared_examples 'simple crud for new with block' do
 
     before do
       make_policies_succeed(:new) if check_authorize(:new)
-      get :new, params: with_route_params({}), format: request_format(:new)
+      get :new, params: with_route_params({}), format: format_param(:new)
     end
 
     if check_html(:new)

data/lib/spec/shared_examples/simple_crud_for_new_with_build.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for new with build' do
     include_context 'with authenticated user' if check_authenticate(:new)
 
     before do
-      get :new, params: with_route_params({}), format: request_format(:new)
+      get :new, params: with_route_params({}), format: format_param(:new)
     end
 
     it 'builds the record owned by the current user', :aggregate_failures do

data/lib/spec/shared_examples/simple_crud_for_show.rb

@@ -2,14 +2,14 @@
 
 RSpec.shared_examples 'simple crud for show' do
   describe 'GET #show' do
-    subject(:show_request) { get :show, params: with_route_params(show_params), format: request_format(:show) }
+    subject(:show_request) { get :show, params: with_route_params(show_params), format: format_param(:show) }
 
     before do
       model
     end
 
     context 'without authenticated user' do
-      subject!(:req) { get :show, params: with_route_params(record_param(:show, model)), format: request_format(:show) }
+      subject!(:req) { get :show, params: with_route_params(record_param(:show, model)), format: format_param(:show) }
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:show)
     end

data/lib/spec/shared_examples/simple_crud_for_show_with_block.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for show with block' do
 
     before do
       make_policies_succeed(:show) if check_authorize(:show)
-      get :show, params: with_route_params(record_param(:show, record)), format: request_format(:show)
+      get :show, params: with_route_params(record_param(:show, record)), format: format_param(:show)
     end
 
     if check_html(:show)

data/lib/spec/shared_examples/simple_crud_for_show_with_finder.rb

@@ -8,7 +8,7 @@ RSpec.shared_examples 'simple crud for show with finder' do
       before do
         model
         get :show, params: with_route_params(finder_key => model.public_send(finder_key)),
-                   format: request_format(:show)
+                   format: format_param(:show)
       end
 
       if check_block(:show)

data/lib/spec/shared_examples/simple_crud_for_update.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples 'simple crud for update' do
     context 'without authenticated user' do
       subject!(:req) do
         update_params = body_params(params_for(model_class)).merge(record_param(:update, model))
-        put :update, params: with_route_params(update_params), format: request_format(:update)
+        put :update, params: with_route_params(update_params), format: format_param(:update)
       end
 
       include_examples 'unauthorized when not logged in' if check_authenticate(:update)
@@ -18,7 +18,7 @@ RSpec.shared_examples 'simple crud for update' do
         before do
           make_policies_fail(:update)
           put :update, params: with_route_params(body_params(model_params).merge(record_param(:update, model))),
-                       format: request_format(:update)
+                       format: format_param(:update)
         end
 
         it 'fails with forbidden' do
@@ -34,7 +34,7 @@ RSpec.shared_examples 'simple crud for update' do
 
       before do
         model
-        put :update, params: with_route_params(update_params), format: request_format(:update)
+        put :update, params: with_route_params(update_params), format: format_param(:update)
       end
 
       if check_html(:update)
@@ -42,8 +42,8 @@ RSpec.shared_examples 'simple crud for update' do
           expect(response).to have_http_status(:found)
         end
       else
-        it 'response with 200 status code' do
-          expect(response).to have_http_status(:ok)
+        it 'response with the configured status code' do
+          expect(response).to have_http_status(check_status(:update) || :ok)
         end
 
         it 'updates an model' do
@@ -66,7 +66,7 @@ RSpec.shared_examples 'simple crud for update' do
 
       before do
         put :update, params: with_route_params(record_param(:update, nil, not_found: true)),
-                     format: request_format(:update)
+                     format: format_param(:update)
       end
 
       it 'response with 404 status code' do
@@ -86,7 +86,7 @@ RSpec.shared_examples 'simple crud for update' do
           model
           put :update, params: with_route_params(body_params({ required_attribute => nil }.merge(owner_params))
                                                          .merge(record_param(:update, model))),
-                       format: request_format(:update)
+                       format: format_param(:update)
         end
 
         unless check_block(:update)

data/lib/spec/shared_examples/simple_crud_for_update_with_finder.rb

@@ -12,7 +12,7 @@ RSpec.shared_examples 'simple crud for update with finder' do
 
       before do
         model
-        put :update, params: update_params, format: request_format(:update)
+        put :update, params: update_params, format: format_param(:update)
       end
 
       it 'updates the model' do

data/lib/spec/shared_examples/simple_crud_not_found_with_finder.rb

@@ -4,7 +4,7 @@ RSpec.shared_examples 'simple crud not found with finder' do |http_method, actio
   context 'when the model does not exist' do
     before do
       send(http_method, action, params: with_route_params(finder_key => "nonexistent-#{finder_key}"),
-                                format: request_format(action))
+                                format: format_param(action))
     end
 
     it 'responds with not found status' do

data/spec/blueprint/dummy_models_controller_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Blueprint::DummyModelsController, type: :controller do
+  let(:serializer) { DummyModelBlueprint }
+
+  include_examples 'simple crud for index'
+  include_examples 'simple crud for show'
+  include_examples 'simple crud for create'
+  include_examples 'simple crud for update'
+  include_examples 'simple crud for destroy'
+
+  describe 'GET #show' do
+    include_context 'with authenticated user'
+
+    let!(:record) { create(:dummy_model, user: current_user) }
+
+    it 'passes serializer_options to the blueprint' do
+      get :show, params: { id: record.id }
+
+      expect(response.parsed_body['url']).to eq(dummy_model_url(record))
+    end
+  end
+end

data/spec/blueprint_unpaginated/dummy_models_controller_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe BlueprintUnpaginated::DummyModelsController, type: :controller do
+  let(:serializer) { DummyModelBlueprint }
+
+  include_examples 'simple crud for index'
+end

data/spec/dummy/app/blueprints/dummy_model_blueprint.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class DummyModelBlueprint < Blueprinter::Base
+  identifier :id
+  fields :name, :something, :user_id
+
+  field :url do |record, options|
+    options[:url_builder]&.dummy_model_url(record)
+  end
+end

data/spec/dummy/app/controllers/blueprint/dummy_models_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Blueprint
+  class DummyModelsController < ApplicationController
+    include Wor::Paginate
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    def dummy_model_params
+      params.permit(:name, :something, :user_id, :slug)
+    end
+
+    SERIALIZER_OPTIONS = -> { { url_builder: self } }
+
+    simple_crud_for :index, serializer: DummyModelBlueprint
+    simple_crud_for :show, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+    simple_crud_for :create, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+    simple_crud_for :update, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+    simple_crud_for :destroy, serializer: DummyModelBlueprint, serializer_options: SERIALIZER_OPTIONS
+  end
+end

data/spec/dummy/app/controllers/blueprint_unpaginated/dummy_models_controller.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module BlueprintUnpaginated
+  class DummyModelsController < ApplicationController
+    include Pundit::Authorization
+    extend SimpleCrudController
+
+    simple_crud_for :index, paginate: false, serializer: DummyModelBlueprint
+  end
+end

data/spec/dummy/config/routes.rb

@@ -120,6 +120,14 @@ Rails.application.routes.draw do
     resources :dummy_models, only: :create
   end
 
+  namespace :blueprint do
+    resources :dummy_models
+  end
+
+  namespace :blueprint_unpaginated do
+    resources :dummy_models, only: :index
+  end
+
   namespace :nested_route do
     resources :classrooms, only: [], param: :slug do
       resources :dummy_models, param: :slug, only: %i[show create destroy]

data/spec/dummy_model_blueprint_spec.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe DummyModelBlueprint do
+  let(:dummy_model) { DummyModel.new(id: 3, name: 'widget', something: 'thing', user_id: 7) }
+  let(:full_response) { described_class.render_as_hash(dummy_model) }
+
+  it 'matches a response including all blueprint attributes' do
+    expect(full_response).to have_been_serialized_with(described_class)
+  end
+
+  it 'does not match a response missing blueprint attributes' do
+    expect({ 'id' => dummy_model.id }).not_to have_been_serialized_with(described_class)
+  end
+end

data/spec/simple_crud/action_context_spec.rb

@@ -19,4 +19,23 @@ describe SimpleCrud::ActionContext do
       expect(key).to eq('dummy_model:show:v1:/dummy_models/1')
     end
   end
+
+  describe '#serializer_options' do
+    let(:record) { DummyModel.new(name: 'widget') }
+
+    it 'returns an empty hash when no callable is configured' do
+      ctx = described_class.new(double, DummyModel, {})
+      expect(ctx.send(:serializer_options, record)).to eq({})
+    end
+
+    it 'calls a zero-arity callable without the record' do
+      ctx = described_class.new(double, DummyModel, { serializer_options: -> { { prefix: :none } } })
+      expect(ctx.send(:serializer_options, record)).to eq(prefix: :none)
+    end
+
+    it 'calls an arity-one callable with the record' do
+      ctx = described_class.new(double, DummyModel, { serializer_options: ->(record) { { name: record.name } } })
+      expect(ctx.send(:serializer_options, record)).to eq(name: 'widget')
+    end
+  end
 end

data/spec/simple_crud/rspec_config_spec.rb

@@ -58,6 +58,19 @@ describe SimpleCrud::RSpec do
       SimpleCrud::RSpec.configure { |c| c.required_attribute = original }
       expect(config.required_attribute).to eq(:name)
     end
+
+    describe 'the default serializer_class' do
+      it 'prefers the AMS serializer when the constant exists' do
+        expect(config.serializer_class.call(DummyModel.new)).to eq(DummyModelSerializer)
+      end
+
+      it 'falls back to the Blueprint when there is no AMS serializer' do
+        allow(Kernel).to receive(:const_defined?).and_call_original
+        allow(Kernel).to receive(:const_defined?).with('DummyModelSerializer').and_return(false)
+
+        expect(config.serializer_class.call(DummyModel.new)).to eq(DummyModelBlueprint)
+      end
+    end
   end
 
   describe SimpleCrud::RSpec::Helpers do

data/spec/simple_crud/serializer_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe SimpleCrud::Serializer do
+  let(:record) { DummyModel.new(id: 1, name: 'widget', something: 'thing', user_id: 9) }
+
+  describe '.render' do
+    it 'falls back to the record as_json when there is no serializer' do
+      expect(described_class.render(nil, record)).to eq(record.as_json)
+    end
+
+    it 'renders through a Blueprinter blueprint with the given options' do
+      result = described_class.render(DummyModelBlueprint, record, { url_builder: nil })
+
+      expect(result).to include(id: record.id, name: record.name, something: record.something, user_id: record.user_id)
+    end
+
+    it 'instantiates an AMS-style serializer with the given options', :aggregate_failures do
+      allow(DummyModelSerializer).to receive(:new).and_call_original
+
+      result = described_class.render(DummyModelSerializer, record, { root: false })
+
+      expect(DummyModelSerializer).to have_received(:new).with(record, { root: false })
+      expect(result).to include(id: record.id, something: record.something)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: wor-simple_crud
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - icoluccio
 bindir: bin
 cert_chain: []
-date: 2026-09-01 00:00:00.000000000 Z
+date: 2026-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -76,6 +76,7 @@ files:
 - lib/simple_crud/rspec/helpers/policies.rb
 - lib/simple_crud/rspec/helpers/requests.rb
 - lib/simple_crud/rspec/helpers/settings.rb
+- lib/simple_crud/serializer.rb
 - lib/simple_crud/show_context.rb
 - lib/simple_crud/simple_crud_controller.rb
 - lib/simple_crud/update_context.rb
@@ -116,11 +117,14 @@ files:
 - spec/block_new/dummy_models_controller_spec.rb
 - spec/block_redirect/dummy_models_controller_spec.rb
 - spec/block_show/dummy_models_controller_spec.rb
+- spec/blueprint/dummy_models_controller_spec.rb
+- spec/blueprint_unpaginated/dummy_models_controller_spec.rb
 - spec/built/dummy_models_controller_spec.rb
 - spec/cached/dummy_models_controller_spec.rb
 - spec/cached_defaults/dummy_models_controller_spec.rb
 - spec/dummy/Rakefile
 - spec/dummy/app/assets/config/manifest.js
+- spec/dummy/app/blueprints/dummy_model_blueprint.rb
 - spec/dummy/app/controllers/application_controller.rb
 - spec/dummy/app/controllers/block/dummy_models_controller.rb
 - spec/dummy/app/controllers/block_create/dummy_models_controller.rb
@@ -131,6 +135,8 @@ files:
 - spec/dummy/app/controllers/block_new/dummy_models_controller.rb
 - spec/dummy/app/controllers/block_redirect/dummy_models_controller.rb
 - spec/dummy/app/controllers/block_show/dummy_models_controller.rb
+- spec/dummy/app/controllers/blueprint/dummy_models_controller.rb
+- spec/dummy/app/controllers/blueprint_unpaginated/dummy_models_controller.rb
 - spec/dummy/app/controllers/built/dummy_models_controller.rb
 - spec/dummy/app/controllers/cached/dummy_models_controller.rb
 - spec/dummy/app/controllers/cached_defaults/dummy_models_controller.rb
@@ -206,6 +212,7 @@ files:
 - spec/dummy/spec/factories/dummy_models.rb
 - spec/dummy/spec/factories/users.rb
 - spec/dummy_controller_spec.rb
+- spec/dummy_model_blueprint_spec.rb
 - spec/dummy_model_policy_spec.rb
 - spec/dummy_model_serializer_spec.rb
 - spec/finder/dummy_models_controller_spec.rb
@@ -231,6 +238,7 @@ files:
 - spec/simple_crud/index_context_spec.rb
 - spec/simple_crud/pagination/adapters_spec.rb
 - spec/simple_crud/rspec_config_spec.rb
+- spec/simple_crud/serializer_spec.rb
 - spec/simple_crud/show_context_spec.rb
 - spec/simple_crud_configuration_spec.rb
 - spec/simple_crud_controller_spec.rb
@@ -258,7 +266,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Simplified CRUD endpoints for Rails API controllers
 test_files: []