praxis 2.0.pre.24 → 2.0.pre.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f399850436ae7099b3d2bcef4f1d0648b094af1d307f47498d92c3ce275379a
-  data.tar.gz: 5f1fa0dbad1f3cf54de9c1a398f93f72c994fe7e61e081ab0e4af3e90f1941b0
+  metadata.gz: dcecd5fd9fb69d436e75297f383ffeaa63373caf8ddfbefdb7361230c981ffc8
+  data.tar.gz: a5e00599183864a2fec4a3f197accaa8c8724fdd40400d91917a460bbd72f8aa
 SHA512:
-  metadata.gz: a1bb3ad07b0376ea46601104c0c5539cf39c4027e787f5228366cc5d5d7ff2a0ec44b8bf516ae3692ddd4ce781e4695faf760cb46750ad052e66f0618b454b71
-  data.tar.gz: 0d9689af7ec169f05a39113c69deb470f70cb41425b0aca71102fd7bb32f877fb8dfca73737ec6935b3b6afcf43e79d670881344c56cffdf13ee9162126c2a05
+  metadata.gz: cf23dd0e2cd395df1a956216987023b1427e50268a964a770d2b1649206a115ae345a91adefaf067d612c64f04b312f1e508e1dc8f56dfa1157a395c038ac31f
+  data.tar.gz: fd01611ba7921490e8fdfee9073ab83fab85130e4428271e1d0f448cde5afd844da6a2a930bbff206f6b9832589bc425d5fc15231eb44a7c47842942305e4b40

data/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 ## next
 
+## 2.0.pre.26
+  * Make POST action forwarding more robust against technically malformed GET requests with no body but passing `Content-Type`. This could cause issues when using the `enable_large_params_proxy_action` DSL.
+
+## 2.0.pre.25
+  * Improve surfacing of requirement attributes in Structs for OpenApi generated documentation
+  * Introduction of a new dsl `enable_large_params_proxy_action` for GET verb action definitions. When used, two things will happen:
+    * A new POST verb equivalent action will be defined:
+      * It will have a `payload` matching the shape of the original GET's params (with the exception of any param that was originally in the URL)
+      * By default, the route for this new POST request is gonna have the same URL as the original GET action, but appending `/actions/<action_name>` to it. This can be customized by passing the path with the `at:` parameter of the DSL. I.e., `enable_large_params_proxy_action at: /actions/myspecialname` will change the generated path (can use the `//...` syntax to not include the prefix defined for the endpoint). NOTE: this route needs to be compatible with any params that might be defined for the URL (i.e., `:id` and such).
+      * This action will be fully visible and fully documented in the API generated docs. However, it will not need to have a corresponding controller implementation since it will special-forward it to the original GET action switching the parameters for the payload.
+    * Specifically, upon receiving a request to the POST equivalent action, Praxis will detect it is a special action and will:
+      * use directly the original action (i.e., will do the before/after filters and call the controller's method)
+      * will load the parameters for the action from the incoming payload
+    * This functionality is to allow having a POST counterpart to any GET requests that require long query strings, and for which the client cannot use a payload bodies (i.e,. Browser JS clients cannot send payload on GET requests).
+  * Performance improvement:
+    * Cache praxis associations' computation for ActiveRecord (so no communication with AR or DB happens after that)
+  * Performance improvement: Use OJ as the (faster) default JSON renderer.
+  * Introduce batch computation of resource attributes: This defines an optional DSL (`batch_computed`) to enable easier calculation of expensive attributes that can be calculated much more efficiently in group:
+    * The new DSL takes an attribute name (Symbol), options and an implementation block that is able to get a list of resource instances (a hash of them, indexed by id) and perform the computation for all of them at once.
+    * Defining an attribute this way, resources can be used to be much more efficiently to calculate values that can be retrieved much more efficiently in bulk, and/or that depend on other resources of the same type to do so (i.e., things that to calculate that attribute for one single resource can be greatly amortized by doing it for many).
+    * The provided block to calculate the value of the attribute for a collection of resources of the same type is stored as a method inside an inner module of the resource class called BatchProcessors
+    * The class level method is callable through `::BatchProcessors.<property_name>(rows_by_id: xxx)`. The rows_by_id: parameter has resource 'ids' as keys, and the resource instances themselves a values
+    * By default an instance method of the same `<property_name>` name will also be created, with a default implementation that will call the `BatchProcessor.<property_name>` with only its instance id and instance, and will return only its result from it.
+    * If creating the helper instance method is not desired, one can pass `with_instance_method: false` when defining the batched_computed block. This might be necessary if we want to define the method ourselves, or in cases where the resource itself has an 'id' property that is not called 'id' (in which case the implementation would not be correct as it uses the `id` property of the resource). If that's the case, disable the creation, and add your own instance method that uses the defined BatchProcessor method passing the right parameters.
+    * It is also possible to query which attributes for a resource class are batch computed. This is done through .batched_attributes (which returns and array of symbol names)
+    * NOTE: Defining batch_computed attributes needs to be done before finalization
+
 ## 2.0.pre.24
  Assorted set of fixes and cleanup:
   * better forwarding signature for query methods

data/Gemfile

@@ -9,5 +9,6 @@ group :test do
   gem 'builder'
 
   gem 'link_header'
+  gem 'oj'
   gem 'parslet'
 end

data/lib/praxis/action_definition.rb

@@ -11,12 +11,16 @@
 
 module Praxis
   class ActionDefinition
-    attr_reader :name, :endpoint_definition, :api_definition, :route, :responses, :traits
+    attr_reader :endpoint_definition, :api_definition, :route, :responses, :traits
 
     # opaque hash of user-defined medata, used to decorate the definition,
     # and also available in the generated JSON documents
     attr_reader :metadata
 
+    # Setter/reader for a possible 'sister' action that is defined as post, and has the payload with the same structure as this GET action
+    # (with the exception of the params in the path attributes)
+    attr_accessor :name, :sister_post_action, :sister_get_action
+
     class << self
       attr_accessor :doc_decorations
     end
@@ -312,9 +316,71 @@ module Praxis
       metadata[:doc_visibility] = :none
     end
 
+    def enable_large_params_proxy_action(at: true)
+      self.sister_post_action = at # Just true to mark it for now (needs to be lazily evaled)
+    end
+
     # [DEPRECATED] - Warn of the change of method name for the transition
     def resource_definition
       raise 'Praxis::ActionDefinition does not use `resource_definition` any longer. Use `endpoint_definition` instead.'
     end
+
+    def clone_action_as_post(at:)
+      action_name = name
+      cloned = clone_action_as(name: "#{action_name}_with_post")
+
+      # route
+      raise "Only GET actions support the 'enable_large_params_proxy_action' DSL. Action #{action_name} is a #{rt.verb}" unless route.verb == 'GET'
+
+      cloned.instance_eval do
+        routing do
+          # Double slash, as we do know the complete prefixed orig path at this point and we don't want the prefix to be applied again...
+          post "/#{at}"
+        end
+      end
+
+      # Payload
+      raise "Using enable_large_params_proxy_action for an action requires the GET payload to be empty. Action #{name} has a payload defined" unless payload.nil?
+
+      route_params = route.path.named_captures.keys.collect(&:to_sym)
+      params_in_route = []
+      params_in_query = []
+      cloned.params.type.attributes.each do |k, _val|
+        if route_params.include? k
+          params_in_route.push k
+        else
+          params_in_query.push k
+        end
+      end
+
+      cloned._internal_set(
+        payload: cloned.params.duplicate(type: params.type.clone.slice!(*params_in_query)),
+        params: cloned.params.duplicate(type: params.type.clone.slice!(*params_in_route))
+      )
+      cloned.sister_get_action = self
+      self.sister_post_action = cloned
+      cloned
+    end
+
+    def clone_action_as(name:)
+      cloned = clone
+      cloned.instance_eval do
+        @name = name.to_sym
+        @description = @description.clone
+        @metadata = @metadata.clone
+        @params = @params.clone
+        @responses = @responses.clone
+        @route = @route.clone
+        @routing_config = @routing_config.clone
+        @sister_post_action = @sister_post_action.clone
+        @traits = @traits.clone
+      end
+      cloned
+    end
+
+    def _internal_set(**args)
+      @payload = args[:payload] if args.key?(:payload)
+      @params = args[:params] if args.key?(:params)
+    end
   end
 end

data/lib/praxis/bootloader_stages/routing.rb

@@ -13,10 +13,16 @@ module Praxis
         end
 
         def call(request)
-          request.action = @action
           dispatcher = Dispatcher.current(application: @application)
-
-          dispatcher.dispatch(@controller, @action, request)
+          # Switch to the sister get action if configured that way (and mark the request as forwarded)
+          action = \
+            if @action.sister_get_action
+              request.forwarded_from_action = @action
+              @action.sister_get_action
+            else
+              @action
+            end
+          dispatcher.dispatch(@controller, action, request)
         end
       end
 

data/lib/praxis/dispatcher.rb

@@ -69,6 +69,7 @@ module Praxis
 
     def dispatch(controller_class, action, request)
       @controller = controller_class.new(request)
+      request.action = action
       @action = action
       @request = request
 

data/lib/praxis/docs/open_api/schema_object.rb

@@ -43,7 +43,11 @@ module Praxis
               h = @attribute_options[:description] ? { 'description' => @attribute_options[:description] } : {}
               h.merge!(type: 'array', items: items)
             else # Attributor::Struct, etc
-              props = type.attributes.transform_values do |definition|
+              required_attributes = (type.describe[:requirements] || []).filter { |r| r[:type] == :all }.map { |r| r[:attributes] }.flatten.compact.uniq
+              props = type.attributes.transform_values.with_index do |definition, index|
+                # if type has an attribute in its requirements all, then it should be marked as required here
+                field_name = type.attributes.keys[index]
+                definition.options.merge!(required: true) if required_attributes.include?(field_name)
                 OpenApi::SchemaObject.new(info: definition).dump_schema(allow_ref: true, shallow: shallow)
               end
               h = { type: :object, properties: props } # TODO: Example?
@@ -61,7 +65,8 @@ module Praxis
             h[:nullable] = @attribute_options[:null]
             h[:enum] = h[:enum] + [nil] if h[:enum] && !h[:enum].include?(nil)
           end
-
+          # Required: Mostly for request bodies
+          h[:required] = true if @attribute_options[:required]
           h
 
           # # TODO: FIXME: return a generic object type if the passed info was weird.

data/lib/praxis/endpoint_definition.rb

@@ -223,7 +223,27 @@ module Praxis
         raise ArgumentError, 'can not create ActionDefinition without block' unless block_given?
         raise ArgumentError, "Action names must be defined using symbols (Got: #{name} (of type #{name.class}))" unless name.is_a? Symbol
 
-        @actions[name] = ActionDefinition.new(name, self, &block)
+        action = ActionDefinition.new(name, self, &block)
+        if action.sister_post_action
+          post_path = \
+            if action.sister_post_action == true
+              "#{action.route.prefixed_path}/actions/#{action.name}"
+            elsif action.sister_post_action.start_with?('//')
+              action.sister_post_action # Avoid appending prefix
+            else
+              # Make sure to cleanup the leading '/' if any, as we're always adding it below
+              cleaned_path = action.sister_post_action.start_with?('/') ? action.sister_post_action[1..-1] : action.sister_post_action
+              "#{action.route.prefixed_path}/#{cleaned_path}"
+            end
+
+          # Save the finalization of the twin POST actions once we've loaded the endpoint definition
+          on_finalize do
+            # Create the sister POST action with a payload matching the original params
+            post_action = action.clone_action_as_post(at: post_path)
+            @actions[post_action.name] = post_action
+          end
+        end
+        @actions[name] = action
       end
 
       def description(text = nil)

data/lib/praxis/handlers/json.rb

@@ -7,11 +7,17 @@ module Praxis
       #
       # @raise [Praxis::Exceptions::InvalidConfiguration] if the handler is unsupported
       def initialize
-        require 'json'
+        require 'oj'
+        begin
+          require 'json'
+        rescue LoadError # rubocop:disable Lint/SuppressedException
+        end
+        # Enable mimicing needs to be done after loading the JSON gem (if there)
+        ::Oj.mimic_JSON
       rescue LoadError
         # Should never happen since JSON is a default gem; might as well be cautious!
         raise Praxis::Exceptions::InvalidConfiguration,
-              'JSON handler depends on json ~> 1.0; please add it to your Gemfile'
+              'JSON handler depends on oj ~> 3; please add it to your Gemfile'
       end
 
       # Parse a JSON document into structured data.
@@ -22,7 +28,7 @@ module Praxis
         # Try to be nice and accept an empty string as an empty payload (seems nice to do for dumb http clients)
         return nil if document.nil? || document == ''
 
-        ::JSON.parse(document)
+        ::Oj.load(document)
       end
 
       # Generate a pretty-printed JSON document from structured data.
@@ -30,7 +36,7 @@ module Praxis
       # @param [Hash,Array] structured_data
       # @return [String]
       def generate(structured_data)
-        ::JSON.pretty_generate(structured_data)
+        ::Oj.dump(structured_data, indent: 2)
       end
     end
   end

data/lib/praxis/mapper/active_model_compat.rb

@@ -28,9 +28,13 @@ module Praxis
         end
 
         def _praxis_associations
+          # Memoize the hash in the model, to avoid recomputing expensive AR reflection lookups
+          # NOTE: should this be finalized with the resources? or do we know if all associations and such that are needed here will never change?
+          return @_praxis_associations if @_praxis_associations
+
           orig = reflections.clone
 
-          orig.each_with_object({}) do |(k, v), hash|
+          @_praxis_associations = orig.each_with_object({}) do |(k, v), hash|
             # Assume an 'id' primary key if the system is initializing without AR connected
             # (or without the tables created). This probably means that it's a rake task initializing or so...
             pkey = \

data/lib/praxis/mapper/resource.rb

@@ -42,6 +42,7 @@ module Praxis
                        end
 
           @properties = superclass.properties.clone
+          @registered_batch_computations = {} # hash of attribute_name -> {proc: , with_instance_method: }
           @_filters_map = {}
           @memoized_variables = []
         end
@@ -63,14 +64,48 @@ module Praxis
         properties[name] = { dependencies: dependencies, through: through }
       end
 
+      def self.batch_computed(attribute, with_instance_method: true, &block)
+        raise "This resource (#{name})is already finalized. Defining batch_computed attributes needs to be done before finalization" if @finalized
+        raise 'It is necessary to pass a block when using the batch_computed method' unless block_given?
+
+        required_params = block.parameters.select { |t, _n| t == :keyreq }.map { |_a, b| b }.uniq
+        raise 'The block for batch_computed can only accept one required kw param named :rows_by_id' unless required_params == [:rows_by_id]
+
+        @registered_batch_computations[attribute.to_sym] = { proc: block.to_proc, with_instance_method: with_instance_method }
+      end
+
+      def self.batched_attributes
+        @registered_batch_computations.keys
+      end
+
       def self._finalize!
         finalize_resource_delegates
+        define_batch_processors
         define_model_accessors
 
         hookup_callbacks
         super
       end
 
+      def self.define_batch_processors
+        return unless @registered_batch_computations.presence
+
+        const_set(:BatchProcessors, Module.new)
+        @registered_batch_computations.each do |name, opts|
+          self::BatchProcessors.module_eval do
+            define_singleton_method(name, opts[:proc])
+          end
+          next unless opts[:with_instance_method]
+
+          # Define the instance method for it to call the batch processor...passing its 'id' and value
+          # This can be turned off by setting :with_instance_method, in case the 'id' of a resource
+          # it is not called 'id' (simply define an instance method similar to this one below)
+          define_method(name) do
+            self.class::BatchProcessors.send(name, rows_by_id: { id => self })[id]
+          end
+        end
+      end
+
       def self.finalize_resource_delegates
         return unless @resource_delegates
 

data/lib/praxis/request.rb

@@ -3,7 +3,7 @@
 module Praxis
   class Request < Praxis.request_superclass
     attr_reader :env, :query
-    attr_accessor :route_params, :action, :headers, :params, :payload
+    attr_accessor :route_params, :action, :headers, :params, :payload, :forwarded_from_action
 
     PATH_VERSION_PREFIX = '/v'
     CONTENT_TYPE_NAME = 'CONTENT_TYPE'
@@ -123,12 +123,25 @@ module Praxis
       return unless action.params
 
       self.params = action.params.load(raw_params, context)
+      return unless forwarded_from_action && content_type
+
+      # If it is coming from a forwarded action, and has a content type, let's parse it, and merge it to the params as well
+      raw = if (handler = Praxis::Application.instance.handlers[content_type.handler_name])
+              handler.parse(raw_payload)
+            else
+              # TODO: is this a good default?
+              raw_payload
+            end
+      loaded_payload = forwarded_from_action.payload.load(raw, context, content_type: content_type.to_s)
+      self.params = params.merge(loaded_payload)
     end
 
     def load_payload(context)
       return unless action.payload
       return if content_type.nil?
 
+      return if action.sister_post_action # Do not load payloads for a special GET action with a sister post one...(cause we've loaded into the params)
+
       raw = if (handler = Praxis::Application.instance.handlers[content_type.handler_name])
               handler.parse(raw_payload)
             else

data/lib/praxis/tasks/routes.rb

@@ -14,18 +14,20 @@ namespace :praxis do
     rows = []
     Praxis::Application.instance.endpoint_definitions.each do |endpoint_definition|
       endpoint_definition.actions.each do |name, action|
+        ctrl_method = action.sister_get_action ? action.sister_get_action.name : name
         method = begin
-          endpoint_definition.controller.instance_method(name)
+          endpoint_definition.controller.instance_method(ctrl_method)
         rescue StandardError
           nil
         end
 
-        method_name = method ? "#{method.owner.name}##{method.name}" : 'n/a'
+        implementation = method ? "#{method.owner.name}##{method.name}" : 'n/a'
+        implementation = "Proxied to -> #{implementation}" if action.sister_get_action
 
         row = {
           resource: endpoint_definition.name,
           action: name,
-          implementation: method_name
+          implementation: implementation
         }
 
         if action.route

data/lib/praxis/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Praxis
-  VERSION = '2.0.pre.24'
+  VERSION = '2.0.pre.26'
 end

data/praxis.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.executables << 'praxis'
 
   spec.add_dependency 'activesupport', '>= 3'
-  spec.add_dependency 'attributor', '>= 6.2'
+  spec.add_dependency 'attributor', '>= 6.4'
   spec.add_dependency 'mime', '~> 0'
   spec.add_dependency 'mustermann', '>=1.1'
   spec.add_dependency 'rack', '>= 1'

data/spec/functional_spec.rb

@@ -111,8 +111,30 @@ describe 'Functional specs' do
         end
       end
     end
+    context 'with a valid request but misusing request content-type' do
+      it 'is still successful and does not get confused about the sister post action' do
+        the_body = StringIO.new('') # This is a GET request passing a body
+        get '/api/clouds/1/instances?api_version=1.0', nil, 'rack.input' => the_body, 'CONTENT_TYPE' => 'application/json', 'global_session' => session
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers['Content-Type']).to(
+          eq('application/vnd.acme.instance;type=collection')
+        )
+      end
+    end
   end
 
+  context 'index using POST sister action' do
+    context 'with a valid request' do
+      it 'is successful and round trips the content type we pass in the body' do
+        payload = { response_content_type: 'application/vnd.acme.instance; type=collection; other=thing' }
+        post '/api/clouds/1/instances/actions/index_using_post?api_version=1.0', JSON.dump(payload), 'CONTENT_TYPE' => 'application/json', 'global_session' => session
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers['Content-Type']).to(
+          eq(payload[:response_content_type])
+        )
+      end
+    end
+  end
   it 'works' do
     the_body = StringIO.new('{}') # This is a funny, GET request expecting a body
     get '/api/clouds/1/instances/2?junk=foo&api_version=1.0', nil, 'rack.input' => the_body, 'CONTENT_TYPE' => 'application/json', 'global_session' => session
@@ -122,7 +144,7 @@ describe 'Functional specs' do
       'id' => 2,
       'junk' => 'foo',
       'other_params' => {
-        'some_date' => '2012-12-21T00:00:00+00:00',
+        'some_date' => '2012-12-21T00:00:00.000+00:00',
         'fail_filter' => false
       },
       'payload' => {

data/spec/praxis/action_definition_spec.rb

@@ -292,6 +292,49 @@ describe Praxis::ActionDefinition do
     end
   end
 
+  context 'enable_large_params_proxy_action' do
+    it 'exposes the add_post_equivalent boolean' do
+      subject.instance_eval do
+        enable_large_params_proxy_action
+      end
+      expect(subject.sister_post_action).to be_truthy
+    end
+    it 'does NOT expose the add_post_equivalent boolean when enable_large_params_proxy_action is not called' do
+      expect(subject).to_not receive(:enable_large_params_proxy_action)
+      expect(subject.sister_post_action).to be_nil
+    end
+  end
+
+  context 'creating a duplicate action with POST' do
+    let(:action) { PeopleResource.actions[:show] }
+    let(:post_action_path) { action.route.path.to_s + "/actions/#{action.name}" }
+    subject { action.clone_action_as_post(at: post_action_path) }
+
+    it 'changes the route to a post and well-known route' do
+      route = subject.route
+      expect(route.verb).to eq('POST')
+      expect(route.path.to_s).to eq(post_action_path)
+    end
+    it 'sets the name postfixed with "with_post"' do
+      expect(subject.name).to eq("#{action.name}_with_post".to_sym)
+    end
+
+    it 'sets the payload to contain all the original param ones, except the required URL ones' do
+      expect(subject.payload.attributes.keys).to eq(action.params.attributes.keys - [:id])
+      expect(subject.params.attributes.keys).to eq([:id])
+    end
+
+    it 'keeps the same headers and response definitions' do
+      expect(subject.headers).to eq(action.headers)
+      expect(subject.responses).to eq(action.responses)
+    end
+
+    it 'links the get and post sister actions appropriately' do
+      expect(subject.sister_get_action).to be(action)
+      expect(action.sister_post_action).to be(subject)
+    end
+  end
+
   context 'with a base_path and base_params on ApiDefinition' do
     # Without getting a fresh new ApiDefinition it is very difficult to test stuff using the Singleton
     # So for some tests we're gonna create a new instance and work with it to avoid the singleton issues

data/spec/praxis/endpoint_definition_spec.rb

@@ -12,7 +12,7 @@ describe Praxis::EndpointDefinition do
 
   its(:prefix) { should eq('/people') }
 
-  its(:actions) { should have(2).items }
+  its(:actions) { should have(4).items } # Two real actions, and two post versions of the GET
   its(:metadata) { should_not have_key(:doc_visibility) }
 
   context '.describe' do
@@ -21,7 +21,7 @@ describe Praxis::EndpointDefinition do
     its([:description]) { should eq(endpoint_definition.description) }
     its([:media_type]) { should eq(endpoint_definition.media_type.describe(true)) }
 
-    its([:actions]) { should have(2).items }
+    its([:actions]) { should have(4).items }  # Two real actions, and two post versions of the GET
     its([:metadata]) { should be_kind_of(Hash) }
     its([:traits]) { should eq [:test] }
     it { should_not have_key(:parent) }
@@ -70,6 +70,34 @@ describe Praxis::EndpointDefinition do
         end
       end.to raise_error(ArgumentError, /Action names must be defined using symbols/)
     end
+    context 'enable_large_params_proxy_action' do
+      it 'duplicates the show action with a sister _with_post one' do
+        action_names = endpoint_definition.actions.keys
+        expect(action_names).to match_array(%i[index show show_with_post index_with_post])
+      end
+      context 'defaults the exposed path for the POST action "' do
+        it 'to add a prefix of "actions/<action_name' do
+          expect(endpoint_definition.actions[:show_with_post].route.verb).to eq('POST')
+          expect(endpoint_definition.actions[:show_with_post].route.prefixed_path).to eq('/people/:id/actions/show')
+        end
+      end
+      context 'allows to specify the exposed path with the at: argument' do
+        it 'will use /people/some/custom/path postfix (cause at: parameter was "some/custom/path")' do
+          expect(endpoint_definition.actions[:index_with_post].route.verb).to eq('POST')
+          expect(endpoint_definition.actions[:index_with_post].route.prefixed_path).to eq('/people/some/custom/path')
+        end
+      end
+
+      it 'it sets its payload to match the original action params (except any params in the URL path)' do
+        payload_for_show_with_post = endpoint_definition.actions[:show_with_post].payload.attributes
+        params_for_show = endpoint_definition.actions[:show].params.attributes
+        expect(payload_for_show_with_post.keys).to eq(params_for_show.keys - [:id])
+      end
+      it 'it sets its params to only contain the the original action params that were in the URL' do
+        params_for_show_with_post = endpoint_definition.actions[:show_with_post].params.attributes
+        expect(params_for_show_with_post.keys).to eq([:id])
+      end
+    end
   end
 
   context 'action_defaults' do

data/spec/praxis/mapper/resource_spec.rb

@@ -214,4 +214,48 @@ describe Praxis::Mapper::Resource do
       end
     end
   end
+
+  context 'batch computed attributes' do
+    context 'default case' do
+      subject { SimpleResource.new(SimpleModel.new(id: 103, name: 'bigfoot')) }
+      it 'creates the class level method inside the BatchProcessors const in the class' do
+        inner_constant = subject.class.const_get(:BatchProcessors)
+        expect(inner_constant).to be_truthy
+        expect(inner_constant.method(:computed_name)).to be_truthy
+      end
+      it 'connects the class level method to the proc, returning results for all ids' do
+        inner_constant = subject.class.const_get(:BatchProcessors)
+        two = SimpleResource.new(SimpleModel.new(id: 111, name: 'smallshoe'))
+        by_id = { subject.id => subject, two.id => two }
+        expected_batch_result = {
+          103 => 'BATCH_COMPUTED_bigfoot',
+          111 => 'BATCH_COMPUTED_smallshoe'
+        }
+        expect(inner_constant.computed_name(rows_by_id: by_id)).to eq(expected_batch_result)
+      end
+      it 'creates the optional instance method with the same name (by default)' do
+        expect(subject.method(:computed_name)).to be_truthy
+      end
+      it 'connects the instance method to call the proc, returning only its id result' do
+        expect(subject.computed_name).to eq('BATCH_COMPUTED_bigfoot')
+      end
+    end
+
+    context 'disabling instance method creation' do
+      subject { ParentResource.new(SimpleModel.new(id: 3, name: 'papa')) }
+      it 'still creates the class level method inside the BatchProcessors const in the class' do
+        inner_constant = subject.class.const_get(:BatchProcessors)
+        expect(inner_constant).to be_truthy
+        expect(inner_constant.method(:computed_display)).to be_truthy
+      end
+      it 'doe NOT create the optional instance' do
+        expect(subject.methods).to_not include(:computed_display)
+      end
+    end
+
+    it 'can retrieve which attribute names are batched' do
+      expect(SimpleResource.batched_attributes).to eq([:computed_name])
+      expect(ParentResource.batched_attributes).to eq([:computed_display])
+    end
+  end
 end

data/spec/spec_app/design/resources/instances.rb

@@ -24,6 +24,8 @@ module ApiResources
     end
 
     action :index do
+      enable_large_params_proxy_action at: '/actions/index_using_post'
+
       routing do
         get ''
       end

data/spec/support/spec_endpoint_definitions.rb

@@ -24,13 +24,18 @@ class PeopleResource
   prefix '/people'
 
   action :index do
+    enable_large_params_proxy_action at: '/some/custom/path'
     description 'index description'
     routing do
       get ''
     end
+    params do
+      attribute :filters, String
+    end
   end
 
   action :show do
+    enable_large_params_proxy_action # Create an equivalent action named 'show_with_post' with the payload matching this action's parameters (except :id)
     description 'show description'
     routing do
       get '/:id'

data/spec/support/spec_resources.rb

@@ -103,6 +103,15 @@ class ParentResource < BaseResource
   model ParentModel
 
   property :display_name, dependencies: %i[simple_name id other_attribute]
+
+  def display_name
+    "#{id}-#{name}"
+  end
+  batch_computed(:computed_display, with_instance_method: false) do |rows_by_id:|
+    rows_by_id.transform_values do |v|
+      "BATCH_COMPUTED_#{v.display_name}"
+    end
+  end
 end
 
 class SimpleResource < BaseResource
@@ -116,6 +125,12 @@ class SimpleResource < BaseResource
     other_model
   end
 
+  batch_computed(:computed_name) do |rows_by_id:|
+    rows_by_id.transform_values do |v|
+      "BATCH_COMPUTED_#{v.name}"
+    end
+  end
+
   property :aliased_method, dependencies: %i[column1 other_model]
   property :other_resource, dependencies: [:other_model]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.24
+  version: 2.0.pre.26
 platform: ruby
 authors:
 - Josep M. Blanquer
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-10 00:00:00.000000000 Z
+date: 2022-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.2'
+        version: '6.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.2'
+        version: '6.4'
 - !ruby/object:Gem::Dependency
   name: mime
   requirement: !ruby/object:Gem::Requirement