rest_framework 0.8.15 → 0.8.17

data/docs/index.md

@@ -0,0 +1,133 @@
+---
+---
+
+# Rails REST Framework
+
+[![Gem Version](https://badge.fury.io/rb/rest_framework.svg)](https://badge.fury.io/rb/rest_framework)
+[![Pipeline](https://github.com/gregschmit/rails-rest-framework/actions/workflows/pipeline.yml/badge.svg)](https://github.com/gregschmit/rails-rest-framework/actions/workflows/pipeline.yml)
+[![Coverage](https://coveralls.io/repos/github/gregschmit/rails-rest-framework/badge.svg?branch=master)](https://coveralls.io/github/gregschmit/rails-rest-framework?branch=master)
+[![Maintainability](https://api.codeclimate.com/v1/badges/ba5df7706cb544d78555/maintainability)](https://codeclimate.com/github/gregschmit/rails-rest-framework/maintainability)
+
+A framework for DRY RESTful APIs in Ruby on Rails.
+
+**The Problem**: Building controllers for APIs usually involves writing a lot of redundant CRUD
+logic, and routing them can be obnoxious. Building and maintaining features like ordering,
+filtering, and pagination can be tedious.
+
+**The Solution**: This framework implements browsable API responses, CRUD actions for your models,
+and features like ordering/filtering/pagination, so you can focus on building awesome APIs.
+
+Website/Guide: [rails-rest-framework.com](https://rails-rest-framework.com)
+
+Demo: [demo.rails-rest-framework.com](https://demo.rails-rest-framework.com)
+
+Source: [github.com/gregschmit/rails-rest-framework](https://github.com/gregschmit/rails-rest-framework)
+
+YARD Docs: [rubydoc.info/gems/rest_framework](https://rubydoc.info/gems/rest_framework)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rest_framework'
+```
+
+And then execute:
+
+```shell
+$ bundle install
+```
+
+Or install it yourself with:
+
+```shell
+$ gem install rest_framework
+```
+
+## Quick Usage Tutorial
+
+### Controller Mixins
+
+To transform a controller into a RESTful controller, you can either include `BaseControllerMixin`,
+`ReadOnlyModelControllerMixin`, or `ModelControllerMixin`. `BaseControllerMixin` provides a `root`
+action and a simple interface for routing arbitrary additional actions:
+
+```ruby
+class ApiController < ApplicationController
+  include RESTFramework::BaseControllerMixin
+  self.extra_actions = {test: [:get]}
+
+  def test
+    render api_response({message: "Test successful!"})
+  end
+end
+```
+
+`ModelControllerMixin` assists with providing the standard model CRUD for your controller.
+
+```ruby
+class Api::MoviesController < ApiController
+  include RESTFramework::ModelControllerMixin
+
+  self.recordset = Movie.where(enabled: true)
+end
+```
+
+`ReadOnlyModelControllerMixin` only enables list/show actions, but since we're naming this
+controller in a way that doesn't make the model obvious, we can set that explicitly:
+
+```ruby
+class Api::ReadOnlyMoviesController < ApiController
+  include RESTFramework::ReadOnlyModelControllerMixin
+
+  self.model = Movie
+end
+```
+
+Note that you can also override the `get_recordset` instance method to override the API behavior
+dynamically per-request.
+
+### Routing
+
+You can use Rails' `resource`/`resources` routers to route your API, however if you want
+`extra_actions` / `extra_member_actions` to be routed automatically, then you can use `rest_route`
+for non-resourceful controllers, or `rest_resource` / `rest_resources` resourceful routers. You can
+also use `rest_root` to route the root of your API:
+
+```ruby
+Rails.application.routes.draw do
+  rest_root :api  # will find `api_controller` and route the `root` action to '/api'
+  namespace :api do
+    rest_resources :movies
+    rest_resources :users
+  end
+end
+```
+
+Or if you want the API root to be routed to `Api::RootController#root`:
+
+```ruby
+Rails.application.routes.draw do
+  namespace :api do
+    rest_root  # will route `Api::RootController#root` to '/' in this namespace ('/api')
+    rest_resources :movies
+    rest_resources :users
+  end
+end
+```
+
+## Development/Testing
+
+After you clone the repository, cd'ing into the directory should create a new gemset if you are
+using RVM. Then run `bundle install` to install the appropriate gems.
+
+To run the test suite:
+
+```shell
+$ rails test
+```
+
+The top-level `bin/rails` proxies all Rails commands to the test project, so you can operate it via
+the usual commands. Ensure you run `rails db:setup` before running `rails server` or
+`rails console`.

data/lib/rest_framework/controller_mixins/base.rb

@@ -8,8 +8,16 @@ require_relative "../utils"
 module RESTFramework::BaseControllerMixin
   RRF_BASE_CONTROLLER_CONFIG = {
     filter_pk_from_request_body: true,
-    exclude_body_fields: [
-      :created_at, :created_by, :created_by_id, :updated_at, :updated_by, :updated_by_id
+    exclude_body_fields: %w[
+      created_at
+      created_by
+      created_by_id
+      updated_at
+      updated_by
+      updated_by_id
+      _method
+      utf8
+      authenticity_token
     ].freeze,
     extra_actions: nil,
     extra_member_actions: nil,
@@ -323,7 +331,6 @@ module RESTFramework::BaseControllerMixin
             @json_payload = payload.to_json if self.class.serialize_to_json
             @xml_payload = payload.to_xml if self.class.serialize_to_xml
           end
-          @template_logo_text ||= "Rails REST Framework"
           @title ||= self.class.get_title
           @description ||= self.class.description
           @route_props, @route_groups = RESTFramework::Utils.get_routes(

data/lib/rest_framework/controller_mixins/models.rb

@@ -3,6 +3,15 @@ require_relative "../filters"
 
 # This module provides the core functionality for controllers based on models.
 module RESTFramework::BaseModelControllerMixin
+  BASE64_REGEX = /data:(.*);base64,(.*)/
+  BASE64_TRANSLATE = ->(field, value) {
+    _, content_type, payload = value.match(BASE64_REGEX).to_a
+    return {
+      io: StringIO.new(Base64.decode64(payload)),
+      content_type: content_type,
+      filename: "image_#{field}#{Rack::Mime::MIME_TYPES.invert[content_type]}",
+    }
+  }
   include RESTFramework::BaseControllerMixin
 
   RRF_BASE_MODEL_CONTROLLER_CONFIG = {
@@ -89,20 +98,18 @@ module RESTFramework::BaseModelControllerMixin
       return self.get_model.human_attribute_name(s, default: super)
     end
 
-    # Get the available fields. Returning `nil` indicates that anything should be accepted. If
-    # `fallback` is true, then we should fallback to this controller's model columns, or an empty
-    # array. This should always return an array of strings, no symbols, and possibly `nil` (only if
-    # `fallback` is false).
-    def get_fields(input_fields: nil, fallback: true)
-      input_fields ||= self.fields if fallback
+    # Get the available fields. Fallback to this controller's model columns, or an empty array. This
+    # should always return an array of strings.
+    def get_fields(input_fields: nil)
+      input_fields ||= self.fields
 
       # If fields is a hash, then parse it.
       if input_fields.is_a?(Hash)
         return RESTFramework::Utils.parse_fields_hash(
           input_fields, self.get_model, exclude_associations: self.exclude_associations
         )
-      elsif !input_fields && fallback
-        # Otherwise, if fields is nil and fallback is true, then fallback to columns.
+      elsif !input_fields
+        # Otherwise, if fields is nil, then fallback to columns.
         model = self.get_model
         return model ? RESTFramework::Utils.fields_for(
           model, exclude_associations: self.exclude_associations
@@ -148,7 +155,9 @@ module RESTFramework::BaseModelControllerMixin
     end
 
     # Get metadata about the resource's fields.
-    def get_fields_metadata
+    def fields_metadata
+      return @_fields_metadata if @_fields_metadata
+
       # Get metadata sources.
       model = self.get_model
       fields = self.get_fields.map(&:to_s)
@@ -156,8 +165,14 @@ module RESTFramework::BaseModelControllerMixin
       column_defaults = model.column_defaults
       reflections = model.reflections
       attributes = model._default_attributes
-
-      return fields.map { |f|
+      readonly_attributes = model.readonly_attributes
+      exclude_body_fields = self.exclude_body_fields.map(&:to_s)
+      rich_text_association_names = model.reflect_on_all_associations(:has_one)
+        .collect(&:name)
+        .select { |n| n.to_s.start_with?("rich_text_") }
+      attachment_reflections = model.attachment_reflections
+
+      return @_fields_metadata = fields.map { |f|
         # Initialize metadata to make the order consistent.
         metadata = {
           type: nil,
@@ -173,6 +188,11 @@ module RESTFramework::BaseModelControllerMixin
           metadata[:primary_key] = true
         end
 
+        # Determine if the field is a read-only attribute.
+        if metadata[:primary_key] || f.in?(readonly_attributes) || f.in?(exclude_body_fields)
+          metadata[:read_only] = true
+        end
+
         # Determine `type`, `required`, `label`, and `kind` based on schema.
         if column = columns[f]
           metadata[:kind] = "column"
@@ -249,9 +269,22 @@ module RESTFramework::BaseModelControllerMixin
           }.compact
         end
 
+        # Determine if this is an ActionText "rich text".
+        if :"rich_text_#{f}".in?(rich_text_association_names)
+          metadata[:kind] = "rich_text"
+        end
+
+        # Determine if this is an ActiveStorage attachment.
+        if ref = attachment_reflections[f]
+          metadata[:kind] = "attachment"
+          metadata[:attachment] = {
+            macro: ref.macro,
+          }
+        end
+
         # Determine if this is just a method.
-        if model.method_defined?(f)
-          metadata[:kind] ||= "method"
+        if !metadata[:kind] && model.method_defined?(f)
+          metadata[:kind] = "method"
         end
 
         # Collect validator options into a hash on their type, while also updating `required` based
@@ -290,7 +323,8 @@ module RESTFramework::BaseModelControllerMixin
     def get_options_metadata
       return super.merge(
         {
-          fields: self.get_fields_metadata,
+          primary_key: self.get_model.primary_key,
+          fields: self.fields_metadata,
           callbacks: self._process_action_callbacks.as_json,
         },
       )
@@ -377,9 +411,9 @@ module RESTFramework::BaseModelControllerMixin
   end
 
   # Get a list of fields, taking into account the current action.
-  def get_fields(fallback: false)
+  def get_fields
     fields = self._get_specific_action_config(:action_fields, :fields)
-    return self.class.get_fields(input_fields: fields, fallback: fallback)
+    return self.class.get_fields(input_fields: fields)
   end
 
   # Pass fields to get dynamic metadata based on which fields are available.
@@ -387,14 +421,12 @@ module RESTFramework::BaseModelControllerMixin
     return self.class.get_options_metadata
   end
 
-  # Get a list of find_by fields for the current action. Do not fallback to columns in case the user
-  # wants to find by virtual columns.
+  # Get a list of find_by fields for the current action.
   def get_find_by_fields
-    return self.class.find_by_fields || self.get_fields
+    return self.class.find_by_fields
   end
 
-  # Get a list of parameters allowed for the current action. By default we do not fallback to
-  # columns so arbitrary fields can be submitted if no fields are defined.
+  # Get a list of parameters allowed for the current action.
   def get_allowed_parameters
     return @_get_allowed_parameters if defined?(@_get_allowed_parameters)
 
@@ -403,35 +435,54 @@ module RESTFramework::BaseModelControllerMixin
       :allowed_parameters,
     )
     return @_get_allowed_parameters if @_get_allowed_parameters
-    return @_get_allowed_parameters = nil unless fields = self.get_fields
 
     # For fields, automatically add `_id`/`_ids` and `_attributes` variations for associations.
-    id_variations = []
-    variations = {}
-    @_get_allowed_parameters = fields.map { |f|
+    variations = []
+    hash_variations = {}
+    reflections = self.class.get_model.reflections
+    @_get_allowed_parameters = self.get_fields.map { |f|
       f = f.to_s
-      next f unless ref = self.class.get_model.reflections[f]
+
+      # ActiveStorage Integration: `has_one_attached`.
+      if reflections.key?("#{f}_attachment")
+        next f
+      end
+
+      # ActiveStorage Integration: `has_many_attached`.
+      if reflections.key?("#{f}_attachments")
+        hash_variations[f] = []
+        next nil
+      end
+
+      # ActionText Integration.
+      if reflections.key?("rich_test_#{f}")
+        next f
+      end
+
+      # Return field if it's not an association.
+      next f unless ref = reflections[f]
 
       if self.class.permit_id_assignment
         if ref.collection?
-          variations["#{f.singularize}_ids"] = []
+          hash_variations["#{f.singularize}_ids"] = []
         elsif ref.belongs_to?
-          id_variations << "#{f}_id"
+          variations << "#{f}_id"
         end
       end
 
       if self.class.permit_nested_attributes_assignment
         if self.class.allow_all_nested_attributes
-          variations["#{f}_attributes"] = {}
+          hash_variations["#{f}_attributes"] = {}
         else
-          variations["#{f}_attributes"] = self.class.get_field_config(f)[:sub_fields]
+          hash_variations["#{f}_attributes"] = self.class.get_field_config(f)[:sub_fields]
         end
       end
 
-      next f
-    }.flatten
-    @_get_allowed_parameters += id_variations
-    @_get_allowed_parameters << variations
+      # Associations are not allowed to be submitted in their bare form.
+      next nil
+    }.compact
+    @_get_allowed_parameters += variations
+    @_get_allowed_parameters << hash_variations
     return @_get_allowed_parameters
   end
 
@@ -454,14 +505,8 @@ module RESTFramework::BaseModelControllerMixin
   def get_body_params(data: nil)
     data ||= request.request_parameters
 
-    # Filter the request body and map to strings. Return all params if we cannot resolve a list of
-    # allowed parameters or fields.
-    body_params = if allowed_parameters = self.get_allowed_parameters
-      data = ActionController::Parameters.new(data)
-      data.permit(*allowed_parameters)
-    else
-      data
-    end
+    # Filter the request body with strong params.
+    body_params = ActionController::Parameters.new(data).permit(*self.get_allowed_parameters)
 
     # Filter primary key if configured.
     if self.class.filter_pk_from_request_body
@@ -471,6 +516,27 @@ module RESTFramework::BaseModelControllerMixin
     # Filter fields in `exclude_body_fields`.
     (self.class.exclude_body_fields || []).each { |f| body_params.delete(f) }
 
+    # ActiveStorage Integration: Translate base64 encoded attachments to upload objects.
+    #
+    # rubocop:disable Layout/LineLength
+    #
+    # Good example base64 image:
+    #   data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABgAAAAYCAYAAADgdz34AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAApgAAAKYB3X3/OAAAABl0RVh0U29mdHdhcmUAd3d3Lmlua3NjYXBlLm9yZ5vuPBoAAANCSURBVEiJtZZPbBtFFMZ/M7ubXdtdb1xSFyeilBapySVU8h8OoFaooFSqiihIVIpQBKci6KEg9Q6H9kovIHoCIVQJJCKE1ENFjnAgcaSGC6rEnxBwA04Tx43t2FnvDAfjkNibxgHxnWb2e/u992bee7tCa00YFsffekFY+nUzFtjW0LrvjRXrCDIAaPLlW0nHL0SsZtVoaF98mLrx3pdhOqLtYPHChahZcYYO7KvPFxvRl5XPp1sN3adWiD1ZAqD6XYK1b/dvE5IWryTt2udLFedwc1+9kLp+vbbpoDh+6TklxBeAi9TL0taeWpdmZzQDry0AcO+jQ12RyohqqoYoo8RDwJrU+qXkjWtfi8Xxt58BdQuwQs9qC/afLwCw8tnQbqYAPsgxE1S6F3EAIXux2oQFKm0ihMsOF71dHYx+f3NND68ghCu1YIoePPQN1pGRABkJ6Bus96CutRZMydTl+TvuiRW1m3n0eDl0vRPcEysqdXn+jsQPsrHMquGeXEaY4Yk4wxWcY5V/9scqOMOVUFthatyTy8QyqwZ+kDURKoMWxNKr2EeqVKcTNOajqKoBgOE28U4tdQl5p5bwCw7BWquaZSzAPlwjlithJtp3pTImSqQRrb2Z8PHGigD4RZuNX6JYj6wj7O4TFLbCO/Mn/m8R+h6rYSUb3ekokRY6f/YukArN979jcW+V/S8g0eT/N3VN3kTqWbQ428m9/8k0P/1aIhF36PccEl6EhOcAUCrXKZXXWS3XKd2vc/TRBG9O5ELC17MmWubD2nKhUKZa26Ba2+D3P+4/MNCFwg59oWVeYhkzgN/JDR8deKBoD7Y+ljEjGZ0sosXVTvbc6RHirr2reNy1OXd6pJsQ+gqjk8VWFYmHrwBzW/n+uMPFiRwHB2I7ih8ciHFxIkd/3Omk5tCDV1t+2nNu5sxxpDFNx+huNhVT3/zMDz8usXC3ddaHBj1GHj/As08fwTS7Kt1HBTmyN29vdwAw+/wbwLVOJ3uAD1wi/dUH7Qei66PfyuRj4Ik9is+hglfbkbfR3cnZm7chlUWLdwmprtCohX4HUtlOcQjLYCu+fzGJH2QRKvP3UNz8bWk1qMxjGTOMThZ3kvgLI5AzFfo379UAAAAASUVORK5CYII=
+    #
+    # rubocop:enable Layout/LineLength
+    self.class.get_model.attachment_reflections.keys.each do |k|
+      next unless (body_params[k].is_a?(String) && body_params[k].match?(BASE64_REGEX)) ||
+        (body_params[k].is_a?(Array) && body_params[k].all? { |v|
+          v.is_a?(String) && v.match?(BASE64_REGEX)
+        })
+
+      if body_params[k].is_a?(Array)
+        body_params[k] = body_params[k].map { |v| BASE64_TRANSLATE.call(k, v) }
+      else
+        body_params[k] = BASE64_TRANSLATE.call(k, body_params[k])
+      end
+    end
+
     return body_params
   end
   alias_method :get_create_params, :get_body_params
@@ -492,8 +558,18 @@ module RESTFramework::BaseModelControllerMixin
 
   # Get the recordset but with any associations included to avoid N+1 queries.
   def get_recordset_with_includes
-    reflections = self.class.get_model.reflections.keys
-    associations = self.get_fields(fallback: true).select { |f| f.in?(reflections) }
+    reflections = self.class.get_model.reflections
+    associations = self.get_fields.map { |f|
+      if reflections.key?(f)
+        f.to_sym
+      elsif reflections.key?("rich_text_#{f}")
+        :"rich_text_#{f}"
+      elsif reflections.key?("#{f}_attachment")
+        :"#{f}_attachment"
+      elsif reflections.key?("#{f}_attachments")
+        :"#{f}_attachments"
+      end
+    }.compact
 
     if associations.any?
       return self.get_recordset.includes(associations)

data/lib/rest_framework/filters.rb

@@ -11,11 +11,10 @@ end
 # A simple filtering backend that supports filtering a recordset based on fields defined on the
 # controller class.
 class RESTFramework::ModelFilter < RESTFramework::BaseFilter
-  # Get a list of filterset fields for the current action. Fallback to columns because we don't want
-  # to try filtering by any query parameter because that could clash with other query parameters.
+  # Get a list of filterset fields for the current action.
   def _get_fields
     # Always return a list of strings; `@controller.get_fields` already does this.
-    return @controller.class.filterset_fields&.map(&:to_s) || @controller.get_fields(fallback: true)
+    return @controller.class.filterset_fields&.map(&:to_s) || @controller.get_fields
   end
 
   # Filter params for keys allowed by the current action's filterset_fields/fields config.
@@ -64,8 +63,7 @@ end
 
 # A filter backend which handles ordering of the recordset.
 class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
-  # Get a list of ordering fields for the current action. Do not fallback to columns in case the
-  # user wants to order by a virtual column.
+  # Get a list of ordering fields for the current action.
   def _get_fields
     return @controller.class.ordering_fields&.map(&:to_s) || @controller.get_fields
   end
@@ -88,7 +86,8 @@ class RESTFramework::ModelOrderingFilter < RESTFramework::BaseFilter
           column = field
           direction = :asc
         end
-        next unless !fields || column.in?(fields)
+
+        next if !column.in?(fields) && column.split(".").first.in?(fields)
 
         ordering[column] = direction
       end
@@ -113,15 +112,14 @@ end
 
 # Multi-field text searching on models.
 class RESTFramework::ModelSearchFilter < RESTFramework::BaseFilter
-  # Get a list of search fields for the current action. Fallback to columns but only grab a few
-  # common string-like columns by default.
+  # Get a list of search fields for the current action.
   def _get_fields
     if search_fields = @controller.class.search_fields
       return search_fields&.map(&:to_s)
     end
 
     columns = @controller.class.get_model.column_names
-    return @controller.get_fields(fallback: true).select { |f|
+    return @controller.get_fields.select { |f|
       f.in?(RESTFramework.config.search_columns) && f.in?(columns)
     }
   end

data/lib/rest_framework/serializers.rb

@@ -219,13 +219,18 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     includes = {}
     methods = []
     serializer_methods = {}
+
+    column_names = @model.column_names
+    reflections = @model.reflections
+    attachment_reflections = @model.attachment_reflections
+
     fields.each do |f|
       field_config = @controller.class.get_field_config(f)
       next if field_config[:write_only]
 
-      if f.in?(@model.column_names)
+      if f.in?(column_names)
         columns << f
-      elsif ref = @model.reflections[f]
+      elsif ref = reflections[f]
         sub_columns = []
         sub_methods = []
         field_config[:sub_fields].each do |sf|
@@ -242,9 +247,8 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
           # If we need to limit the number of serialized association records, then dynamically add a
           # serializer method to do so.
           if limit = self._get_associations_limit
-            method_name = "__rrf_limit_method_#{f}"
-            serializer_methods[method_name] = f
-            self.define_singleton_method(method_name) do |record|
+            serializer_methods[f] = f
+            self.define_singleton_method(f) do |record|
               next record.send(f).limit(limit).as_json(**sub_config)
             end
           else
@@ -253,8 +257,8 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
 
           # If we need to include the association count, then add it here.
           if @controller.class.native_serializer_include_associations_count
-            method_name = "__rrf_count_method_#{f}"
-            serializer_methods[method_name] = "#{f}.count"
+            method_name = "#{f}.count"
+            serializer_methods[method_name] = method_name
             self.define_singleton_method(method_name) do |record|
               next record.send(f).count
             end
@@ -262,6 +266,24 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
         else
           includes[f] = sub_config
         end
+      elsif ref = reflections["rich_text_#{f}"]
+        # ActionText Integration: Define rich text serializer method.
+        serializer_methods[f] = f
+        self.define_singleton_method(f) do |record|
+          next record.send(f).to_s
+        end
+      elsif ref = attachment_reflections[f]
+        # ActiveStorage Integration: Define attachment serializer method.
+        serializer_methods[f] = f
+        if ref.macro == :has_one_attached
+          self.define_singleton_method(f) do |record|
+            next record.send(f).attachment&.url
+          end
+        else
+          self.define_singleton_method(f) do |record|
+            next record.send(f).map(&:url)
+          end
+        end
       elsif @model.method_defined?(f)
         methods << f
       end
@@ -272,9 +294,10 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     }
   end
 
-  # Get the raw serializer config. Use `deep_dup` on any class mutables (array, hash, etc) to avoid
-  # mutating class state.
-  def _get_raw_serializer_config
+  # Get the raw serializer config, prior to any adjustments from the request.
+  #
+  # Use `deep_dup` on any class mutables (array, hash, etc) to avoid mutating class state.
+  def get_raw_serializer_config
     # Return a locally defined serializer config if one is defined.
     if local_config = self.get_local_native_serializer_config
       return local_config.deep_dup
@@ -286,7 +309,7 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
     end
 
     # If the config wasn't determined, build a serializer config from controller fields.
-    if @model && fields = @controller&.get_fields(fallback: true)
+    if @model && fields = @controller&.get_fields
       return self._get_controller_serializer_config(fields.deep_dup)
     end
 
@@ -296,7 +319,7 @@ class RESTFramework::NativeSerializer < RESTFramework::BaseSerializer
 
   # Get a configuration passable to `serializable_hash` for the object, filtered if required.
   def get_serializer_config
-    return filter_from_request(self._get_raw_serializer_config)
+    return filter_from_request(self.get_raw_serializer_config)
   end
 
   # Serialize a single record and merge results of `serializer_methods`.

data/lib/rest_framework/utils.rb

@@ -180,7 +180,12 @@ module RESTFramework::Utils
     return model.column_names.reject { |c|
       c.in?(foreign_keys)
     } + model.reflections.map { |association, ref|
-      # Exclude certain associations (by default, active storage and action text associations).
+      # Ignore associations for which we have custom integrations.
+      if ref.class_name.in?(%w(ActiveStorage::Attachment ActiveStorage::Blob ActionText::RichText))
+        next nil
+      end
+
+      # Exclude user-specified associations.
       if ref.class_name.in?(RESTFramework.config.exclude_association_classes)
         next nil
       end
@@ -192,7 +197,11 @@ module RESTFramework::Utils
       end
 
       next association
-    }.compact
+    }.compact + model.reflect_on_all_associations(:has_one).collect(&:name).select { |n|
+      n.to_s.start_with?("rich_text_")
+    }.map { |n|
+      n.to_s.delete_prefix("rich_text_")
+    } + model.attachment_reflections.keys
   end
 
   # Get the sub-fields that may be serialized and filtered/ordered for a reflection.

data/lib/rest_framework/version.rb

@@ -28,7 +28,10 @@ module RESTFramework
     end
 
     def self.stamp_version
-      File.write(VERSION_FILEPATH, RESTFramework::VERSION)
+      # Only stamp the version if it's not unknown.
+      if RESTFramework::VERSION != "0.unknown"
+        File.write(VERSION_FILEPATH, RESTFramework::VERSION)
+      end
     end
 
     def self.unstamp_version

data/lib/rest_framework.rb

@@ -21,11 +21,7 @@ module RESTFramework
   # Global configuration should be kept minimal, as controller-level configurations allows multiple
   # APIs to be defined to behave differently.
   class Config
-    DEFAULT_EXCLUDE_ASSOCIATION_CLASSES = %w(
-      ActionText::RichText
-      ActiveStorage::Attachment
-      ActiveStorage::Blob
-    ).freeze
+    DEFAULT_EXCLUDE_ASSOCIATION_CLASSES = [].freeze
     DEFAULT_LABEL_FIELDS = %w(name label login title email username url).freeze
     DEFAULT_SEARCH_COLUMNS = DEFAULT_LABEL_FIELDS + %w(description note).freeze
 
@@ -78,9 +74,7 @@ module RESTFramework
   end
 
   def self.features
-    return @features ||= {
-      html_forms: false,
-    }
+    return @features ||= {}
   end
 end