dry-rails

The safe_params method returns a Dry::Schema::Result object containing the parameters processed by the schema defined for the current action.

This method is only populated if a schema was registered for the current action_name. It provides access to the coerced values and validation results (e.g., safe_params.success? or safe_params.errors).

# Inside a controller action
if safe_params.success?
  # Use safe_params.to_h to get the validated data
  params_data = safe_params.to_h
else
  # Handle validation errors
  render json: safe_params.errors.to_h, status: :unprocessable_entity
end

The stop_features method stops all currently started bootable components (features) within the dry-rails container. This is a critical operation during development reloading to ensure that components can execute their stop lifecycle logic, which typically involves cleaning up constants or resources created during the boot process.

Dry::Rails::Railtie.stop_features

The container method is a controller helper that returns the Dry::Rails::Container instance used by your application. This allows you to interact with the container directly for operations beyond simple resolution.

# Returns the application container
# @return [Dry::Rails::Container]
container

When using the :application_contract feature in dry-rails, you should inherit from Dry::Rails::Features::ApplicationContract instead of Dry::Validation::Contract.

This base class is pre-configured during the Rails boot process to integrate with your application's localization settings. Specifically, it:

1. Sets the message namespace to :contracts.
2. Uses the :i18n backend for messages.
3. Automatically loads translation files from config/locales/*.yml into the contract's message configuration.

This allows you to define validation error messages using standard Rails I18n YAML files.

class UserContract < Dry::Rails::Features::ApplicationContract
  params do
    required(:email).filled(:string)
  end

  rule(:email) do
    key.failure(:invalid_format) if value.glib_check_logic
  end
end

Use the schema class method in your controller to define validation rules for specific actions using dry-schema syntax. You can pass one or more action names as arguments and provide a block that defines the schema.

When a request hits an action with a defined schema, dry-rails automatically runs the validation before the action executes. The validated and coerced parameters are then available via the safe_params instance method.

class UsersController < ApplicationController
  schema :create, :update do
    required(:user).hash do
      required(:name).filled(:string)
      required(:email).filled(:string)
    end
  end

  def create
    # Access validated params via safe_params
    user_params = safe_params[:user]
    # ...
  end
end

The container method allows you to retrieve the current Dry::Rails::Container instance from the application's namespace. It dynamically looks up the constant defined by the container configuration.

# Returns the Dry::Rails::Container instance
container = Dry::Rails::Railtie.new.container

The resolve method is a controller helper provided by dry-rails that allows you to fetch a component directly from the application container using its key. This is useful for injecting business logic or services into your controller actions.

• Parameters: key (Symbol or String) representing the component key.
• Returns: The component associated with the key.
• Raises: Dry::Container::Error if the key is not found in the container.

def index
  users = resolve("users.index").(safe_params[:query])
  render json: users
end

Use Dry::Rails.container to define a configuration block that will be evaluated within the context of the container. This is typically used in a Rails initializer (e.g., config/initializer/system.rb) to set up auto-registration paths and namespaces for your components.

Common tasks include:

• Adding component directories via config.component_dirs.add.
• Defining namespaces within those directories using dir.namespaces.add to map directory structures to specific container keys.

# config/initializer/system.rb

Dry::Rails.container do
  config.component_dirs.add "lib" do |dir|
    dir.namespaces.add "my_super_cool_app", key: nil
  end

  config.component_dirs.add "app/operations"
end

You can manually trigger the finalization and setup process of the dry-rails container. This is useful if you need to ensure the container is fully booted and all providers are registered. The finalize! method performs the full setup, including registering default components and evaluating initializers. The reload method is an alias for finalize! and is intended for use during development when code changes require a fresh container state.

# To finalize the container setup
Dry::Rails::Railtie.finalize!

# To reload the container (alias for finalize!)
Dry::Rails::Railtie.reload!

When configuring the Dry::Rails::Container, you can specify which features are enabled by default using the features setting.

Supported feature symbols:

• application_contract
• safe_params
• controller_helpers

# Example of enabling specific features
config.features = [:application_contract, :safe_params]