nerbyk / activefunction Goto Github PK

Current implementation supports only %w() that is suboptimal in terms of memory efficiency and performance. Utilizing symbols instead of strings within the %w() would not only minimize memory footprint but also streamline callback execution, as the underlying callback mechanism employs the send method which inherently transforms strings into symbols.

Add minitest specs for:

• ActiveFunction::Callbacks
• ActiveFunction::Rendering
• ActiveFunction::Core

Extract ActiveFunction::Functions::Callbacks to activefunction-core gem to hook any method using callbackable DSL method

Example:

class MyController
  include ActiveFunctionCore::Plugins::Callbacks

  callbackable :process
  callbackable :serialize

  before_process :do_something

  def process
    # Action logic here
  end

  private

  def do_something
    # Callback logic here
  end
end

Problem

The current structure of the gem does not conform to Serverless Design Principles. The architecture lacks modularity and scalability, handling multiple scenarios within a single lambda function.

Core Issues:

• Modularity: Absence of a modular structure within the API complicates code maintenance and scalability.
• Serverless Integration: Lack of adherence to serverless design principles impedes smooth integration within serverless environments.

Update .rbs type signatures & return steep to CI

There is no way to permit all nested params. It could be great to make it possible to pass [] for permitting all nested params

class AppFunction < ActiveFunction::Base
   def index
      params.permit(data: []).to_h # =>  { data: { id: 1, text: "foobar" } }
   end
end

AppFunction.process(:index, { data: { id: 1, text: "foobar" } })

Implement #rescue_from callback for custom exception handling

class SomeFunction < ActiveFunction::Base
  rescue_from InvalidRequestFormatError do |exception| 
     render json: exception.message, status: 422  
  end
end

Currently :only options only accepts Array[Symbol]. It makes sense to handle Symbols as well

class AppFunction < ActiveFunction::Base
   before_acrtion :set_app, only: :index
end 

Current implementation of ActiveFunction::Functions::Callbacks doesn't provide callbacks inheritance due to singleton class instance variable __callbacks initializing logic https://github.com/DanilMaximov/activefunction/blob/10f282da4a29c32cfada967956c97377935376c9/lib/active_function/functions/callbacks.rb#L57-L61

Expected behavior:

class ApplicationFunction < ActiveFunction::Base
  before_action :set_current_user

  def set_current_user
     @current_user = 'current_user'
  end
end

class SomeFunction < ApplicationFunction
end

fn = SomeFunction.new
fn.dispatch(...)
fn.instance_variable_get(:@current_user) # => 'current_user'