rails_admin_next 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f52de80007a2b162a4a4874efa2606e2ec24a056f63a2efbd3603f30867d0e8f
-  data.tar.gz: aa67aa9fbe010180f5313cebe83a569fdeb1808d1e936b86ee9201ff05b25f7e
+  metadata.gz: 821ddc2c14943ce137265d8c99d9784492cde1b2041dab27a1b5651795ce3cd4
+  data.tar.gz: f3c9d9906d117bb55e0eb4c2fcfc585d129b98c1bb2b32689fdd2a734f656d90
 SHA512:
-  metadata.gz: 40f67da005ec5b1c3b5d8825dc0b6d7a8bb92d01ba93c035f8371353b557fee9e1b0b76a7275a9f100ad79e4eb1b5a74dd59cd438ef79fb692bea50bc17c401e
-  data.tar.gz: 4204094e7e91124b1df69629a853988b4cc16284bf49003b59e13f486f33566ce3392f148c2a6d89e33ca24cb46d35c2e4c48c9b822e4fe95eba1513e23c514e
+  metadata.gz: 993ba29f1ae5ce41e276c0637660c791c0f3a6a47379082143b15079052c4f43ebc7a24a0d00f7433b4c0c1c37359154e0ef4ae3bf1c5a95340ac78472fca376
+  data.tar.gz: fa8ef20e12e1a670877e0d8f8719d87967e0398a11063d30e58a70a5bdff77984dc04e70695b7f12dfd7f632e04606388e4fd08c027b4e57dcc1121f2eec458c

data/README.md

@@ -192,7 +192,8 @@ The `admin.*` I18n namespace is likewise unchanged.
 the same `<key>?` rules the Pundit adapter calls (`index?`, `show?`, `new?`, `edit?`,
 `destroy?`, `export?`, `history?`, `show_in_app?`, `dashboard?`), and scopes lists, export
 and bulk delete through the policy's default `relation_scope`. A model with no policy, or a
-policy with no default relation scope, lists nothing. Bundle `action_policy` yourself; see
+policy with no default relation scope, lists nothing. Policies that declare context beyond
+`user` get it from `authorize_with :action_policy, context: {...}`. Bundle `action_policy` yourself; see
 the "ActionPolicy adapter" section of [docs/UPGRADING.md](docs/UPGRADING.md).
 
 ## Frontend and assets

data/app/controllers/rails_admin_next/application_controller.rb

@@ -28,12 +28,17 @@ module RailsAdminNext
 
     def get_model
       @model_name = to_model_name(params[:model_name])
-      raise RailsAdminNext::ModelNotFound unless (@abstract_model = RailsAdminNext::AbstractModel.new(@model_name))
-      raise RailsAdminNext::ModelNotFound if (@model_config = @abstract_model.config).excluded?
+      raise RailsAdminNext::ModelNotFound unless (@abstract_model = visible_abstract_model(@model_name))
 
+      @model_config = @abstract_model.config
       @properties = @abstract_model.properties
     end
 
+    def visible_abstract_model(model_name)
+      abstract_model = RailsAdminNext::AbstractModel.new(model_name)
+      abstract_model if abstract_model && !abstract_model.config.excluded?
+    end
+
     def get_object
       raise RailsAdminNext::ObjectNotFound unless (@object = @abstract_model.get(params[:id], @model_config.scope))
     end

data/app/controllers/rails_admin_next/main_controller.rb

@@ -231,9 +231,9 @@ module RailsAdminNext
     end
 
     def get_association_scope_from_params
-      return nil unless params[:associated_collection].present?
+      return nil unless params[:associated_collection].present? && params[:source_abstract_model].present?
+      return nil unless (source_abstract_model = visible_abstract_model(to_model_name(params[:source_abstract_model])))
 
-      source_abstract_model = RailsAdminNext::AbstractModel.new(to_model_name(params[:source_abstract_model]))
       source_model_config = source_abstract_model.config
       action = params[:current_action].in?(%w[create update]) ? params[:current_action] : "edit"
       field = source_model_config.send(action).fields.detect { |f| f.name == params[:associated_collection].to_sym }

data/docs/UPGRADING.md

@@ -74,13 +74,17 @@ end
 ```
 
 The module defines an `AuthorizationAdapter` class. `authorize_with` builds it with
-`new(controller, *args, &block)` and it answers:
+`new(controller, *args, **options, &block)` and it answers:
 
 - `authorize(action, abstract_model, object)`: raises when the action is denied.
 - `authorized?(action, abstract_model, object)`: returns a boolean, for links and buttons.
 - `query(action, abstract_model)`: returns the scope lists, export and bulk actions read from.
 - `attributes_for(action, abstract_model)`: returns the attributes a new record starts with.
 - `self.setup` (optional): runs once when `authorize_with` names the key.
+- `self.validate_options!(*args, **options)` (optional): receives the extra arguments while the
+  config block runs; raise `ArgumentError` there so a misconfigured option fails at boot. A
+  subclass of a built-in adapter inherits its `validate_options!`, so one that takes options of
+  its own overrides it.
 
 `lib/rails_admin_next/extensions/pundit/authorization_adapter.rb` in the gem is the template.
 The removed CanCanCan adapter is a starting point you can copy:
@@ -596,6 +600,39 @@ class PlayerPolicy < ApplicationPolicy
 end
 ```
 
+### Authorization context beyond the user
+
+A policy that declares more context than `user`, such as a tenant's `authorize :account`,
+needs the adapter to supply it. Pass each key as a block:
+
+```ruby
+RailsAdminNext.config do |config|
+  config.authorize_with :action_policy, context: {account: -> { _current_user.account }}
+end
+```
+
+Each block runs on the admin controller once per request, the first time anything is
+authorized, whichever policy is checked; a block should return `nil` rather than raise for a
+user with no such context. A helper from your own controller, such as `current_account`, is
+only available there when `config.parent_controller` names that controller:
+
+```ruby
+config.parent_controller = "::ApplicationController"
+config.authorize_with :action_policy, context: {account: -> { current_account }}
+```
+
+The value is an authorization input, so derive it from the signed-in user, or check the user's
+membership when it comes from request data such as `params` or the subdomain. The relation scope
+only narrows lists, export and bulk actions: show, edit, delete and history load the record by
+id and check the rule alone, so a tenant rule such as `update?` must compare `record` with
+`account` itself.
+
+`user` always comes from `current_user_method` and is rejected inside `context:`. A key that is
+not a Symbol, a value that is not a block taking no arguments, or an unknown option raises
+`ArgumentError` while the config block runs. A key a policy declares that the host omits, or
+whose block returns `nil`, raises `ActionPolicy::AuthorizationContextMissing` on the request
+unless the policy declares it with `allow_nil:` or `optional:`.
+
 ## An `:enum` field with no option source offers no options
 
 An `:enum` field takes its options from `enum_method`, which defaults to `<name>_enum` on the

data/docs/security.md

@@ -20,6 +20,9 @@ destructive-action controls itself; a few things are left for the host to opt in
   `relation_scope`, lists no records. A rule the policy does not define (`history?`,
   `show_in_app?`, `export?`, a custom authorization key) resolves to the policy's `manage?`, so a
   permissive `manage?` grants every admin action the policy leaves undefined.
+- **ActionPolicy context fails loudly.** A context key a policy declares that the host omits, or
+  whose block returns `nil`, raises `ActionPolicy::AuthorizationContextMissing` on every adapter
+  check rather than listing or allowing anything; `user` cannot be replaced through `context:`.
 - **Destructive actions.** `delete` and `bulk_delete` render a confirmation page and additionally
   carry `data-turbo-confirm` on the destructive submit (Turbo's confirmation, not `@rails/ujs`).
 - **Mass assignment.** Submitted attributes are sliced to the model config's `visible_fields`

data/lib/rails_admin_next/config.rb

@@ -190,13 +190,25 @@ module RailsAdminNext
       #     config.authorize_with :action_policy
       #   end
       #
+      # @example ActionPolicy with authorization context beyond the user
+      #   RailsAdminNext.config do |config|
+      #     config.authorize_with :action_policy, context: {account: -> { _current_user.account }}
+      #   end
+      #
+      # An adapter may define a class method validate_options!, which receives the extra arguments
+      # while this config block runs, so a misconfigured option fails at boot.
+      #
       # A custom adapter is registered with
       # RailsAdminNext.add_extension(key, mod, authorization: true) before it is named here.
       # See docs/UPGRADING.md for the adapter contract.
       #
       # @see RailsAdminNext::Config::DEFAULT_AUTHORIZE
-      def authorize_with(*args, &block)
+      def authorize_with(*args, **options, &block)
         extension = args.shift
+        if extension.nil? && options.any?
+          raise ArgumentError, "authorize_with options need an adapter key, such as authorize_with(:action_policy, **options)"
+        end
+
         if extension
           klass = RailsAdminNext::AUTHORIZATION_ADAPTERS.fetch(extension) do
             raise ArgumentError, "Unknown authorization adapter #{extension.inspect}. " \
@@ -206,8 +218,9 @@ module RailsAdminNext
               "(no per-record checks or list scoping). See docs/UPGRADING.md."
           end
           klass.setup if klass.respond_to? :setup
+          klass.validate_options!(*args, **options) if klass.respond_to? :validate_options!
           @authorize = proc do
-            @authorization_adapter = klass.new(*([self] + args).compact, &block)
+            @authorization_adapter = klass.new(*([self] + args).compact, **options, &block)
           end
         elsif block
           @authorize = block

data/lib/rails_admin_next/extensions/action_policy/authorization_adapter.rb

@@ -11,8 +11,19 @@ module RailsAdminNext
           authorize :user, through: -> { @controller._current_user }
         end
 
-        def initialize(controller)
+        def self.validate_options!(context: {})
+          context.each do |key, value|
+            raise ArgumentError, "ActionPolicy context key #{key.inspect} must be a Symbol" unless key.is_a?(Symbol)
+            raise ArgumentError, "ActionPolicy context #{key.inspect} is the current user; set it with config.current_user_method" if key == :user
+            unless value.is_a?(Proc) && value.parameters.none? { |type, _| type in :req | :keyreq }
+              raise ArgumentError, "ActionPolicy context #{key.inspect} must be a block taking no arguments, run on the admin controller"
+            end
+          end
+        end
+
+        def initialize(controller, context: {})
           @controller = controller
+          @context = context
         end
 
         def authorize(action, abstract_model = nil, model_object = nil)
@@ -45,6 +56,10 @@ module RailsAdminNext
 
         private
 
+        def build_authorization_context
+          super.merge(@context.transform_values { @controller.instance_exec(&it) })
+        end
+
         def policy_class_for(record)
           ::ActionPolicy.lookup(record, default: ::ApplicationPolicy)
         end

data/lib/rails_admin_next/extensions/pundit/authorization_adapter.rb

@@ -12,6 +12,10 @@ module RailsAdminNext
           RailsAdminNext::Extensions::ControllerExtension.include defined?(::Pundit::Authorization) ? ::Pundit::Authorization : ::Pundit
         end
 
+        # Pundit takes no options, so any passed to authorize_with fail at boot.
+        def self.validate_options!
+        end
+
         # See the +authorize_with+ config method for where the initialization happens.
         def initialize(controller)
           @controller = controller

data/lib/rails_admin_next/version.rb

@@ -6,8 +6,8 @@ module RailsAdminNext
     # the tag's version over these constants at build time, so the in-repo values are only
     # the floor a local `gem build` produces.
     MAJOR = 2
-    MINOR = 0
-    PATCH = 1
+    MINOR = 1
+    PATCH = 0
     PRE = nil
 
     class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_admin_next
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Daniel López Prat