plutonium 0.21.0 → 0.21.1

data/lib/plutonium/interaction/README.md

@@ -262,6 +262,120 @@ class MyInteraction < Plutonium::Interaction::Base
 end
 ```
 
+### Interactions with Nested Attributes
+
+This example demonstrates how to handle nested attributes—specifically,
+a `User` with multiple `Contact` and `UserAddress` records using
+a Plutonium `Interaction`.
+
+#### Key Highlights
+
+The model definitions are included here for completeness, but the primary focus
+remains on demonstrating how to build interactions that handle nested
+attributes.
+
+- Core user attributes (`first_name`, `last_name`, `email`) are declared and
+  validated at the top level of the interaction.
+
+- Nested associations (`contacts`, `addresses`) are managed via
+  `accepts_nested_attributes_for`. The optional `reject_if` condition is used
+  to discard entries that lack required fields—helping ensure data integrity at
+  the input level.
+
+- The `nested_input` DSL provides a declarative way to structure nested inputs,
+  specifying accepted fields and mapping them to their respective definition
+  classes (`ContactDefinition` and `UserAddressDefinition`).
+
+- During execution, a `User` instance is initialized with both top-level and
+  nested attributes, then persisted with all applicable validations.
+
+**Note:** The `class_name` option is explicitly defined in the interaction's
+`accepts_nested_attributes_for` macro because the `addresses` association does
+not directly map to its underlying model name. Simply provide the class name,
+for example, `class_name: "UserAddress"`, to ensure the correct model is used.
+
+**This is essential only when the association name differs from the actual
+class name.**
+
+This approach enables seamless handling of complex nested input from forms or
+API requests, while keeping validation logic clean, maintainable, and modular.
+
+```ruby
+# app/models/user.rb
+class User < ApplicationRecord
+  include Plutonium::Resource::Record
+
+  has_many :contacts
+  has_many :addresses, class_name: "UserAddress"
+
+  accepts_nested_attributes_for :contacts, :addresses
+end
+
+# app/models/contact.rb
+class Contact < ApplicationRecord
+  include Plutonium::Resource::Record
+
+  belongs_to :user
+  validates :label, :phone_number, presence: true
+end
+
+# app/models/user_address.rb
+class UserAddress < ApplicationRecord
+  include Plutonium::Resource::Record
+
+  belongs_to :user
+  validates :label, :map_url, presence: true
+end
+
+# app/interactions/users/interactions/create_user_interaction.rb
+module Users
+  module Interactions
+    class CreateUserInteraction < Plutonium::Interaction::Base
+      include Plutonium::Definition::Presentable
+
+      presents label: "Add a new user", icon: Phlex::Tabler::UserPlus
+
+      attribute :first_name, :string
+      attribute :last_name, :string
+      attribute :email, :string
+      attribute :contacts
+      attribute :addresses
+
+      validates :first_name, :last_name, presence: true
+      validates :email, presence: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+
+      accepts_nested_attributes_for :contacts,
+        reject_if: proc { |attributes| attributes[:label].blank? }
+
+      accepts_nested_attributes_for :addresses, class_name: "UserAddress",
+        reject_if: proc { |attributes| attributes[:label].blank? }
+
+      nested_input :contacts,
+        using: ContactDefinition,
+        fields: %i[label phone_number],
+        description: "Add one or more contacts for this user."
+
+      nested_input :addresses,
+        using: UserAddressDefinition,
+        fields: %i[label map_url],
+        description: "Add one or more addresses for this user."
+
+      private
+
+      def execute
+        user = User.new(self.attributes)
+
+        if user.save
+          success(user).with_message("User created successfully")
+        else
+          failed(user.errors)
+        end
+      end
+    end
+  end
+end
+```
+
 ## Examples
 
 ### Chaining Operations
@@ -311,7 +425,6 @@ This example demonstrates how to chain multiple operations, handle potential fai
 
 By following these guidelines and examples, you can effectively implement and use the Use Case Driven Design pattern in your Rails applications, leading to more maintainable and testable code.
 
-
 ### Example interaction with workflow
 
 ```ruby
@@ -367,7 +480,6 @@ module Orders
 end
 ```
 
-
   class Sample < Phlex::HTML
     def view_template
       p { "my custom template" }

data/lib/plutonium/interaction/base.rb

@@ -25,6 +25,8 @@ module Plutonium
       include Plutonium::Definition::DefineableProps
       include Plutonium::Definition::ConfigAttr
       include Plutonium::Definition::Presentable
+      include Plutonium::Definition::NestedInputs
+      include Plutonium::Interaction::NestedAttributes
       # include Plutonium::Interaction::Concerns::WorkflowDSL
 
       class Form < Plutonium::UI::Form::Interaction; end
@@ -89,6 +91,7 @@ module Plutonium
       def succeed(value = nil)
         Plutonium::Interaction::Outcome::Success.new(value)
       end
+
       alias_method :success, :succeed
 
       def failed(errors = nil, attribute = :base)

data/lib/plutonium/interaction/nested_attributes.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Plutonium
+  module Interaction
+    module NestedAttributes
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Dynamically defines writer and reader methods for handling nested
+        # attributes in form objects or interaction classes, mimicking the
+        # behavior of ActiveRecord's `accepts_nested_attributes_for`.
+        #
+        # This method allows you to pass in nested data (e.g. from a form) and
+        # automatically build or destroy associated records based on that input.
+        #
+        # === Example 1: Basic usage with default naming
+        #   # If `Contact` is the associated model inferred from the
+        #   `:contacts` association:
+        #
+        #   `accepts_nested_attributes_for :contacts`
+        #
+        # === Example 2: When association name and model name differ
+        #   Suppose the `User` model has a `has_many :contacts` association
+        #   pointing to a `UserContactInfo` model. You need to specify the
+        #   model name.
+        #
+        #   `accepts_nested_attributes_for :contacts, class_name: "UserAddress"`
+        #
+        # This macro defines:
+        #   - `contacts_attributes=` — used to assign nested attributes,
+        #     including support for `_destroy`
+        #   - `contacts_attributes` — returns the current attributes of
+        #     associated records
+        #
+        # @param association [Symbol] The association name. (e.g., `:contacts`).
+        # @param class_name [String, nil] Required if association reflection
+        # is needed to determine the associated model class (e.g. when the
+        # association name doesn't match the class name).
+        # @param reject_if [Proc, Symbol, nil] Used to skip building association
+        #   records when the condition returns true.
+        def accepts_nested_attributes_for(
+          association,
+          class_name: nil,
+          reject_if: nil
+        )
+          destroy_values = [1, "1", "true", true]
+
+          should_destroy = ->(value) { destroy_values.include?(value) }
+
+          should_reject =
+            lambda do |attrs|
+              case reject_if
+              when Symbol
+                send(reject_if, attrs)
+              when Proc
+                reject_if.call(attrs)
+              else
+                false
+              end
+            end
+
+          assoc_class =
+            class_name&.constantize || association.to_s.classify.constantize
+
+          define_method(:"#{association}_attributes=") do |attributes|
+            result =
+              case attributes
+              when Hash
+                attrs = attributes.except(:_destroy)
+                unless should_destroy.call(attributes[:_destroy]) ||
+                    should_reject.call(attrs)
+                  assoc_class.new(attrs)
+                end
+              when Array
+                attributes.filter_map do |attrs|
+                  unless should_destroy.call(attrs[:_destroy]) ||
+                      should_reject.call(attrs)
+                    assoc_class.new(attrs.except(:_destroy))
+                  end
+                end
+              end
+
+            send(:"#{association}=", result)
+          end
+
+          define_method(:"#{association}_attributes") do
+            Array(send(association)).map(&:attributes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plutonium/resource/controllers/crud_actions.rb

@@ -46,16 +46,20 @@ module Plutonium
           @resource_record = resource_class.new resource_params
 
           respond_to do |format|
-            if resource_record!.save
+            if params[:pre_submit]
+              format.html { render :new, status: :unprocessable_entity }
+            elsif resource_record!.save
               format.html do
                 redirect_to redirect_url_after_submit,
                   notice: "#{resource_class.model_name.human} was successfully created."
               end
-              format.any { render :show, status: :created, location: redirect_url_after_submit }
-            else
-              format.html do
-                render :new, status: :unprocessable_entity
+              format.any do
+                render :show,
+                  status: :created,
+                  location: redirect_url_after_submit
               end
+            else
+              format.html { render :new, status: :unprocessable_entity }
               format.any do
                 @errors = resource_record!.errors
                 render "errors", status: :unprocessable_entity
@@ -79,17 +83,23 @@ module Plutonium
           authorize_current! resource_record!
           set_page_title "Update #{resource_record!.to_label.titleize}"
 
+          resource_record!.attributes = resource_params
+
           respond_to do |format|
-            if resource_record!.update(resource_params)
+            if params[:pre_submit]
+              format.html { render :edit, status: :unprocessable_entity }
+            elsif resource_record!.save
               format.html do
-                redirect_to redirect_url_after_submit, notice: "#{resource_class.model_name.human} was successfully updated.",
+                redirect_to redirect_url_after_submit,
+                  notice:
+                    "#{resource_class.model_name.human} was successfully updated.",
                   status: :see_other
               end
-              format.any { render :show, status: :ok, location: redirect_url_after_submit }
-            else
-              format.html do
-                render :edit, status: :unprocessable_entity
+              format.any do
+                render :show, status: :ok, location: redirect_url_after_submit
               end
+            else
+              format.html { render :edit, status: :unprocessable_entity }
               format.any do
                 @errors = resource_record!.errors
                 render "errors", status: :unprocessable_entity
@@ -107,17 +117,21 @@ module Plutonium
 
             format.html do
               redirect_to redirect_url_after_destroy,
-                notice: "#{resource_class.model_name.human} was successfully deleted."
+                notice:
+                  "#{resource_class.model_name.human} was successfully deleted."
             end
             format.json { head :no_content }
           rescue ActiveRecord::InvalidForeignKey
             format.html do
               redirect_to resource_url_for(resource_record!),
-                alert: "#{resource_class.model_name.human} is referenced by other records."
+                alert:
+                  "#{resource_class.model_name.human} is referenced by other records."
             end
             format.any do
               @errors = ActiveModel::Errors.new resource_record!
-              @errors.add :base, :existing_references, message: "is referenced by other records"
+              @errors.add :base,
+                :existing_references,
+                message: "is referenced by other records"
 
               render "errors", status: :unprocessable_entity
             end

data/lib/plutonium/resource/controllers/interactive_actions.rb

@@ -38,12 +38,24 @@ module Plutonium
         def commit_interactive_record_action
           build_interactive_record_action_interaction
 
+          if params[:pre_submit]
+            respond_to do |format|
+              format.html do
+                render :interactive_record_action, status: :unprocessable_entity
+              end
+            end
+            return
+          end
+
           outcome = @interaction.call
-          if outcome.success?
-            outcome.to_response.process(self) do |value|
-              respond_to do |format|
-                return_url = redirect_url_after_action_on(resource_record!)
+
+          outcome.to_response.process(self) do |value|
+            respond_to do |format|
+              if outcome.success?
+                return_url = redirect_url_after_action_on(resource_class)
+
                 format.any { redirect_to return_url, status: :see_other }
+
                 if helpers.current_turbo_frame == "modal"
                   format.turbo_stream do
                     render turbo_stream: [
@@ -51,18 +63,16 @@ module Plutonium
                     ]
                   end
                 end
-              end
-            end
-          else
-            outcome.to_response.process(self) do
-              respond_to do |format|
+              else
                 format.html do
                   render :interactive_record_action, status: :unprocessable_entity
                 end
+
                 format.any do
                   @errors = @interaction.errors
                   render "errors", status: :unprocessable_entity
                 end
+
                 if helpers.current_turbo_frame == "modal"
                   format.turbo_stream do
                     render turbo_stream: [
@@ -92,12 +102,24 @@ module Plutonium
           skip_verify_current_authorized_scope!
           build_interactive_resource_action_interaction
 
+          if params[:pre_submit]
+            respond_to do |format|
+              format.html do
+                render :interactive_resource_action, status: :unprocessable_entity
+              end
+            end
+            return
+          end
+
           outcome = @interaction.call
-          if outcome.success?
-            outcome.to_response.process(self) do |value|
-              respond_to do |format|
+
+          outcome.to_response.process(self) do |value|
+            respond_to do |format|
+              if outcome.success?
                 return_url = redirect_url_after_action_on(resource_class)
+
                 format.any { redirect_to return_url, status: :see_other }
+
                 if helpers.current_turbo_frame == "modal"
                   format.turbo_stream do
                     render turbo_stream: [
@@ -105,18 +127,16 @@ module Plutonium
                     ]
                   end
                 end
-              end
-            end
-          else
-            outcome.to_response.process(self) do
-              respond_to do |format|
+              else
                 format.html do
-                  render :interactive_record_action, status: :unprocessable_entity
+                  render :interactive_resource_action, status: :unprocessable_entity
                 end
+
                 format.any do
                   @errors = @interaction.errors
                   render "errors", status: :unprocessable_entity
                 end
+
                 if helpers.current_turbo_frame == "modal"
                   format.turbo_stream do
                     render turbo_stream: [

data/lib/plutonium/resource/record/associated_with.rb

@@ -59,11 +59,11 @@ module Plutonium
           def query_based_on_association(assoc, record)
             case assoc.macro
             when :has_one
-              joins(assoc.name).where(assoc.name => {record.class.primary_key => record.id})
+              joins(assoc.name).where(assoc.name => {record.class.primary_key => record})
             when :belongs_to
               where(assoc.name => record)
             when :has_many
-              joins(assoc.name).where(assoc.klass.table_name => record)
+              joins(assoc.name).where(assoc.name => {record.class.primary_key => record})
             else
               raise NotImplementedError, "associated_with->##{assoc.macro}"
             end

data/lib/plutonium/ui/form/base.rb

@@ -84,6 +84,12 @@ module Plutonium
 
           @form_action ||= url_for(object, action: object.new_record? ? :create : :update)
         end
+
+        def initialize_attributes
+          super
+
+          attributes["data-controller"] = "form"
+        end
       end
     end
   end

data/lib/plutonium/ui/form/resource.rb

@@ -8,6 +8,8 @@ module Plutonium
 
         attr_reader :resource_fields, :resource_definition
 
+        alias_method :record, :object
+
         def initialize(*, resource_fields:, resource_definition:, **, &)
           super(*, **, &)
           @resource_fields = resource_fields
@@ -59,12 +61,23 @@ module Plutonium
           input_definition = definition.defined_inputs[name] || {}
           input_options = input_definition[:options] || {}
 
+          condition = input_options[:condition] || field_options[:condition]
+          return if condition && !instance_exec(&condition)
+
           tag = input_options[:as] || field_options[:as]
-          tag_attributes = input_options.except(:wrapper, :as)
-          tag_block = input_definition[:block] || ->(f) {
-            tag ||= f.inferred_field_component
-            f.send(:"#{tag}_tag", **tag_attributes)
-          }
+          tag_attributes =
+            input_options.except(:wrapper, :as, :pre_submit, :condition)
+          if input_options[:pre_submit]
+            tag_attributes[
+              "data-action"
+            ] = "change->form#preSubmit"
+          end
+          tag_block =
+            input_definition[:block] ||
+            ->(f) do
+              tag ||= f.inferred_field_component
+              f.send(:"#{tag}_tag", **tag_attributes)
+            end
 
           wrapper_options = input_options[:wrapper] || {}
           if !wrapper_options[:class] || !wrapper_options[:class].include?("col-span")
@@ -73,8 +86,10 @@ module Plutonium
             wrapper_options[:class] = tokens("col-span-full", wrapper_options[:class])
           end
 
-          field_options = field_options.except(:as)
-          render form.field(name, **field_options).wrapped(**wrapper_options) do |f|
+          field_options = field_options.except(:as, :condition)
+          render form.field(name, **field_options).wrapped(
+            **wrapper_options
+          ) do |f|
             render instance_exec(f, &tag_block)
           end
         end

data/lib/plutonium/ui/form/theme.rb

@@ -37,7 +37,7 @@ module Plutonium
             # file
             # file: "w-full border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700 focus:outline-none",
             # hint themes
-            hint: "mt-2 text-sm text-gray-500 dark:text-gray-200",
+            hint: "mt-2 text-sm text-gray-500 dark:text-gray-200 whitespace-pre",
             # error themes
             error: "mt-2 text-sm text-red-600 dark:text-red-500",
             # button themes

data/lib/plutonium/version.rb

@@ -1,5 +1,5 @@
 module Plutonium
-  VERSION = "0.21.0"
+  VERSION = "0.21.1"
   NEXT_MAJOR_VERSION = VERSION.split(".").tap { |v|
     v[1] = v[1].to_i + 1
     v[2] = 0

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radioactive-labs/plutonium",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Core assets for the Plutonium gem",
   "type": "module",
   "main": "src/js/core.js",

data/src/js/controllers/form_controller.js

@@ -1,11 +1,27 @@
 import { Controller } from "@hotwired/stimulus"
-import debounce from "lodash.debounce";
 
 // Connects to data-controller="form"
 export default class extends Controller {
   connect() {
   }
+ 
+  preSubmit() {
+    // Create a hidden input field
+    const hiddenField = document.createElement('input');
+    hiddenField.type = 'hidden';
+    hiddenField.name = 'pre_submit';
+    hiddenField.value = 'true';
+ 
+    // Append it to the form
+    this.element.appendChild(hiddenField);
 
+    // Skip validation by setting novalidate attribute
+    this.element.setAttribute('novalidate', '');
+
+    // Submit the form
+    this.submit();
+  }
+ 
   submit() {
     this.element.requestSubmit()
   }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plutonium
 version: !ruby/object:Gem::Version
-  version: 0.21.0
+  version: 0.21.1
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-01 00:00:00.000000000 Z
+date: 2025-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -750,6 +750,7 @@ files:
 - lib/plutonium/interaction/README.md
 - lib/plutonium/interaction/base.rb
 - lib/plutonium/interaction/concerns/workflow_dsl.rb
+- lib/plutonium/interaction/nested_attributes.rb
 - lib/plutonium/interaction/outcome.rb
 - lib/plutonium/interaction/response/base.rb
 - lib/plutonium/interaction/response/failure.rb