rdux 0.13.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a4732501f420e77c07dc015b11abfbd2f8c1985229772a2665cde14a99f2752
-  data.tar.gz: 7f35b68fa9a573ac225ad2f1aeea19139b56ee9d4a56d2618d638c2cf0cda820
+  metadata.gz: 8afda82ad3e063c5a07eb7c3e8b2a9f86019bb35ccdaa8fc875a9aebcd463a29
+  data.tar.gz: 2d72f680e8cb5014fb55b003b09ea11cbf23107e54c8e83e2e0b5e7bff44b860
 SHA512:
-  metadata.gz: b067094df508e07f8165ec5e88c094ec4c6f54bec1ddba8206ecd0bf74b2c6b1f3706c97f1ca56c8b622c68d30c20c272d993da40ce604dfb3cccfaa43084fca
-  data.tar.gz: 1b72e8f3b2d4cebb015957c996cee3ad10a428d7d23551ae56ccb5daf70b74f6ce556e36968a851e17fea51bb78e4ac55307f2e86c92d5376be38bb91c54d400
+  metadata.gz: 982c68f70df4e2c579e88029551a969f54470c0fa328ce5d1cbf89007001ac93fc6f78aec1a2e0096081c852174265c2e3412714d8466b7eb6ee9073273e3d3a
+  data.tar.gz: 3e63ef96279b424c87f34a23292c70b3cc95d390b63d7f92d83ad1faf95df34b9f18ada2f969a18bf79bb6846da543f5d6b437322453844ea63fbbe21ba13129

data/README.md

@@ -16,11 +16,9 @@ Rdux is a lightweight, minimalistic Rails plugin designed to introduce event sou
 **Key Features**
 
 * **Audit Logging** 👉 Rdux stores sanitized input data, the name of module or class (action performer) responsible for processing them, processing results, and additional metadata in the database.
-* **Model Representation** 👉 Before action is executed it gets stored in the database through the `Rdux::Action` model. `Rdux::Action` is converted to the `Rdux::FailedAction` when it fails. These models can be nested, allowing for complex action structures.
-* **Revert and Retry** 👉 `Rdux::Action` can be reverted. `Rdux::FailedAction` retains the input data and processing results necessary for implementing custom mechanisms to retry failed actions.
-* **Exception Handling and Recovery** 👉 Rdux automatically creates a `Rdux::FailedAction` when an exception occurs during action execution. It retains the `up_payload` and allows you to capture additional data using `opts[:up_result]`, ensuring all necessary information is available for retrying the action.
+* **Model Representation** 👉 Before action is executed it gets stored in the database through the `Rdux::Action` model. This model can be nested, allowing for complex action structures.
+* **Exception Handling and Recovery** 👉 Rdux automatically creates a `Rdux::Action` record when an exception occurs during action execution. It retains the `payload` and allows you to capture additional data using `opts[:result]`, ensuring all necessary information is available for retrying the action.
 * **Metadata** 👉 Metadata can include the ID of the authenticated resource responsible for performing a given action, as well as resource IDs from external systems related to the action. This creates a clear audit trail of who executed each action and on whose behalf.
-* **Streams** 👉 Rdux enables the identification of action chains (streams) by utilizing resource IDs stored in metadata. This makes it easy to query and track related actions.
 
 Rdux is designed to integrate seamlessly with your existing Rails application, offering a straightforward and powerful solution for managing and auditing key actions.
 
@@ -69,10 +67,10 @@ alias perform dispatch
 
 Arguments:
 
-* `action`: The name of the module or class (action performer) that processes the action. This is stored in the database as an instance of `Rdux::Action`, with its `name` attribute set to `action` (e.g., `Task::Create`).
-* `payload` (Hash): The input data passed as the first argument to the `call` or `up` method of the action performer. The data is sanitized and stored in the database before being processed by the action performer. During deserialization, the keys in the `payload` are converted to strings.
-* `opts` (Hash): Optional parameters passed as the second argument to the `call` or `up` method, if defined. This can help avoid redundant database queries (e.g., if you already have an ActiveRecord object available before calling `Rdux.perform`). A helper is available to facilitate this use case: `(opts[:ars] || {}).each { |k, v| payload["#{k}_id"] = v.id }`, where `:ars` represents ActiveRecord objects. Note that `opts` is not stored in the database, and the `payload` should be fully sufficient to perform an **action**. `opts` provides an optimization.
-* `meta` (Hash): Additional metadata stored in the database alongside the `action` and `payload`. The `stream` key is particularly useful for specifying the stream of actions used during reversions. For example, a `stream` can be constructed based on the owner of the action.
+* `action`: The name of the module or class (action performer) that processes the action. `action` is stored in the database as the `name` attribute of the `Rdux::Action` instance (e.g., `Task::Create`).
+* `payload` (Hash): The input data passed as the first argument to the `call` method of the action performer. The data is sanitized and stored in the database before being processed by the action performer. During deserialization, the keys in the `payload` are converted to strings.
+* `opts` (Hash): Optional parameters passed as the second argument to the `call` method, if defined. This can help avoid redundant database queries (e.g., if you already have an ActiveRecord object available before calling `Rdux.perform`). A helper is available to facilitate this use case: `(opts[:ars] || {}).each { |k, v| payload["#{k}_id"] = v.id }`, where `:ars` represents ActiveRecord objects. Note that `opts` is not stored in the database, and the `payload` should be fully sufficient to perform an **action**. `opts` provides an optimization.
+* `meta` (Hash): Additional metadata stored in the database alongside the `action` and `payload`.
 
 Example:
 
@@ -81,10 +79,7 @@ Rdux.perform(
   Task::Create,
   { task: { name: 'Foo bar baz' } },
   { ars: { user: current_user } },
-  meta: {
-    stream: { user_id: current_user.id, context: 'foo' },
-    bar: 'baz'
-  }
+  meta: { bar: 'baz' }
 )
 ```
 
@@ -94,62 +89,39 @@ Rdux.perform(
 
 ### 🕵️‍♀️ Processing an action
 
-Action in Rdux is processed by an action performer which is a Plain Old Ruby Object (PORO) that implements a class or instance method `call` or `up`.  
-This method must return a `Rdux::Result` `struct`.  
-Optionally, an action can implement a class or instance method `down` to specify how to revert it.
-
-#### Action Structure:
-
-* `call` or `up` method: Accepts a required `payload` and an optional `opts` argument. This method processes the action and returns a `Rdux::Result`.
-* `down` method: Accepts the deserialized `down_payload` which is one of arguments of the `Rdux::Result` `struct` returned by the `up` method on success and saved in DB. `down` method can optionally accept the 2nd argument (Hash) which `:nested` key contains nested `Rdux::Action`s
+Action in Rdux is processed by an action performer which is a Plain Old Ruby Object (PORO) that implements a class or instance method `call`.
+This method accepts a required `payload` and an optional `opts` argument.
+`opts[:action]` stores the Active Record object.
+`call` method processes the action and must return a `Rdux::Result` struct.
 
 See [🚛 Dispatching an action](#-dispatching-an-action) section.
 
-Examples:
+Example:
 
 ```ruby
 # app/actions/task/create.rb
 
 class Task
   class Create
-    def up(payload, opts)
+    def call(payload, opts)
       user = opts.dig(:ars, :user) || User.find(payload['user_id'])
       task = user.tasks.new(payload['task'])
       if task.save
-        Rdux::Result[ok: true, down_payload: { user_id: user.id, task_id: task.id }, val: { task: }]
+        Rdux::Result[ok: true, val: { task: }]
       else
         Rdux::Result[false, { errors: task.errors }]
       end
     end
-
-    def down(payload)
-      Delete.up(payload)
-    end
   end
 end
 ```
 
-```ruby
-# app/actions/task/delete.rb
-
-class Task
-  module Delete
-    def self.up(payload)
-      user = User.find(payload['user_id'])
-      task = user.tasks.find(payload['task_id'])
-      task.destroy
-      Rdux::Result[true, { task: task.attributes }]
-    end
-  end
-end
-```
+#### Suggested Directory Structure
 
-#### Suggested Directory Structure:
-
-The location that is often used for entities like actions accross code bases is `app/services`.  
-This directory is de facto the bag of random objects.  
-I'd recomment to place actions inside `app/actions` for better organization and consistency.  
-Actions are consistent in terms of structure, input and output data.  
+The location that is often used for entities like actions accross code bases is `app/services`.
+This directory is de facto the bag of random objects.
+I'd recomment to place actions inside `app/actions` for better organization and consistency.
+Actions are consistent in terms of structure, input and output data.
 They are good canditates to create a new layer in Rails apps.
 
 Structure:
@@ -178,13 +150,9 @@ Definition:
 
 ```ruby
 module Rdux
-  Result = Struct.new(:ok, :down_payload, :val, :up_result, :save, :after_save, :nested, :action) do
-    def val
-      self[:val] || down_payload
-    end
-
+  Result = Struct.new(:ok, :val, :result, :save, :nested, :action) do
     def save_failed?
-      ok == false && save
+      ok == false && save ? true : false
     end
   end
 end
@@ -193,22 +161,11 @@ end
 Arguments:
 
 * `ok` (Boolean): Indicates whether the action was successful. If `true`, the `Rdux::Action` is persisted in the database.
-* `down_payload` (Hash): Passed to the action performer’s `down` method during reversion (`down` method is called on `Rdux::Action`). It does not have to be defined if an action performer does not implement the `down` method. `down_payload` is saved in the DB.
-* `val` (Hash): Contains different returned data than `down_payload`.
-* `up_result` (Hash): Stores data related to the action’s execution, such as created record IDs, DB changes, responses from 3rd parties, etc.
-* `save` (Boolean): If `true` and `ok` is `false`, the action is saved as a `Rdux::FailedAction`.
-* `after_save` (Proc): Called just before the `dispatch` method returns the `Rdux::Result` with `Rdux::Action` or `Rdux::FailedAction` as an argument.
-* `nested` (Array of `Rdux::Result`): `Rdux::Action` can be connected with other `rdux_actions`. `Rdux::FailedAction` can be connected with other `rdux_actions` and `rdux_failed_actions`. To establish an association, a given action must `Rdux.dispatch` other actions in the `up` or `call` method and add the returned by the `dispatch` value (`Rdux::Result`) to the `:nested` array
-* `action`: Rdux assigns `Rdux::Action` or `Rdux::FailedAction` to this argument
-
-### ⏮️ Reverting an Action
-
-To revert an action, call the `down` method on the persisted in DB `Rdux::Action` instance.  
-The `Rdux::Action` must have a `down_payload` defined and the action (action performer) must have the `down` method implemented.
-
-![Revert action](docs/down.png)
-
-The `down_at` attribute is set upon successful reversion. Actions cannot be reverted if there are newer, unreverted actions in the same stream (if defined) or in general. See `meta` in [🚛 Dispatching an action](#-dispatching-an-action) section.
+* `val` (Hash): returned data.
+* `result` (Hash): Stores data related to the action’s execution, such as created record IDs, DB changes, responses from 3rd parties, etc. that will be persisted as `Rdux::Action#result`.
+* `save` (Boolean): If `true` and `ok` is `false`, the action is still persisted in the database.
+* `nested` (Array of `Rdux::Result`): `Rdux::Action` can be connected with other `rdux_actions`. To establish an association, a given action must `Rdux.dispatch` other actions in the `call` method and add the returned by the `dispatch` value (`Rdux::Result`) to the `:nested` array
+* `action`: Rdux assigns persisted `Rdux::Action` to this argument
 
 ### 🗿 Data model
 
@@ -224,35 +181,28 @@ res.action
 # #<Rdux::Action:0x000000011c4d8e98
 #   id: 1,
 #   name: "Task::Create",
-#   up_payload: {"task"=>{"name"=>"Foo bar baz"}, "user_id"=>159163583},
-#   down_payload: {"task_id"=>207620945},
-#   down_at: nil,
-#   up_payload_sanitized: false,
-#   up_result: nil,
+#   payload: {"task"=>{"name"=>"Foo bar baz"}, "user_id"=>159163583},
+#   payload_sanitized: false,
+#   result: nil,
 #   meta: {},
-#   stream_hash: nil,
 #   rdux_action_id: nil,
-#   rdux_failed_action_id: nil,
 #   created_at: Fri, 28 Jun 2024 21:35:36.838898000 UTC +00:00,
 #   updated_at: Fri, 28 Jun 2024 21:35:36.839728000 UTC +00:00>>
-
-res.action.down
 ```
 
 ### 😷 Sanitization
 
-When `Rdux.perform` is called, the `up_payload` is sanitized using `Rails.application.config.filter_parameters` before being saved to the database.  
-The action performer’s `up` or `call` method receives the unsanitized version.  
-Note that once the `up_payload` is sanitized, the `Rdux::Action` cannot be retried by calling the `#up` method.
+When `Rdux.perform` is called, the `payload` is sanitized using `Rails.application.config.filter_parameters` before being saved to the database.
+The action performer’s `call` method receives the unsanitized version.
 
 ### 🗣️ Queries
 
-Most likely, it won't be necessary to save a `Rdux::Action` for every request a Rails app receives.  
-The suggested approach is to save `Rdux::Action`s for Create, Update, and Delete (CUD) operations.  
-This approach organically creates a new layer - queries in addition to actions.  
+Most likely, it won't be necessary to save a `Rdux::Action` for every request a Rails app receives.
+The suggested approach is to save `Rdux::Action`s for Create, Update, and Delete (CUD) operations.
+This approach organically creates a new layer - queries in addition to actions.
 Thus, it is required to call `Rdux.perform` only for actions.
 
-One approach is to create a `perform` method that invokes either `Rdux.perform` or a query, depending on the presence of `action` or `query` keywords.  
+One approach is to create a `perform` method that invokes either `Rdux.perform` or a query, depending on the presence of `action` or `query` keywords.
 This method can also handle setting `meta` attributes, performing parameter validation, and more.
 
 Example:
@@ -277,11 +227,12 @@ end
 
 ### 🕵️ Indexing
 
-Depending on your use case, it’s recommended to create indices, especially when using PostgreSQL and querying JSONB columns.  
-Both `Rdux::Action` and `Rdux::FailedAction` are standard ActiveRecord models.  
-You can inherit from them and extend.
+Depending on your use case, it’s recommended to create indices, especially when using PostgreSQL and querying JSONB columns.\
+`Rdux::Action` is a standard ActiveRecord model.
+You can inherit from it and extend.
 
 Example:
+
 ```ruby
 class Action < Rdux::Action
   include Actionable
@@ -290,13 +241,14 @@ end
 
 ### 🚑 Recovering from Exceptions
 
-Rdux creates a `Rdux::FailedAction` when an exception is raised during the execution of an action.  
-The `up_payload` is retained, but having only the input data is often not enough to retry an action.  
-It is crucial to capture data obtained during the action’s execution, up until the exception occurred.  
-This can be done by using `opts[:up_result]` to store all necessary data incrementally.  
-The assigned data will then be available as the `up_result` argument in the `Rdux::FailedAction`.
+Rdux captures exceptions raised during the execution of an action and sets the `Rdux::Action#ok` attribute to `false`.
+The `payload` is retained, but having only the input data is often not enough to retry an action.
+It is crucial to capture data obtained during the action’s execution, up until the exception occurred.
+This can be done by using `opts[:result]` to store all necessary data incrementally.
+The assigned data will then be available as the `Rdux::Action#result` attribute.
 
 Example:
+
 ```ruby
 class CreditCard
   class Charge
@@ -305,7 +257,7 @@ class CreditCard
         create_res = create(payload.slice('user_id', 'credit_card'), opts.slice(:user))
         return create_res unless create_res.ok
 
-        opts[:up_result] = { credit_card_create_action_id: create_res.action.id }
+        opts[:result] = { credit_card_create_action_id: create_res.action.id }
         charge_id = PaymentGateway.charge(create_res.val[:credit_card].token, payload['amount'])[:id]
         if charge_id.nil?
           Rdux::Result[ok: false, val: { errors: { base: 'Invalid credit card' } }, save: true,
@@ -319,9 +271,7 @@ class CreditCard
 
       def create(payload, opts)
         res = Rdux.perform(Create, payload, opts)
-        return res if res.ok
-
-        Rdux::Result[ok: false, val: { errors: res.val[:errors] }, save: true, nested: [res]]
+        res.ok ? res : Rdux::Result[ok: false, val: { errors: res.val[:errors] }, save: true]
       end
     end
   end

data/app/models/rdux/action.rb

@@ -2,77 +2,56 @@
 
 module Rdux
   class Action < ActiveRecord::Base
-    include Actionable
+    self.table_name_prefix = 'rdux_'
 
-    attr_accessor :up_payload_unsanitized
+    attr_accessor :payload_unsanitized
 
-    belongs_to :rdux_failed_action, optional: true, class_name: 'Rdux::FailedAction'
     belongs_to :rdux_action, optional: true, class_name: 'Rdux::Action'
     has_many :rdux_actions, class_name: 'Rdux::Action', foreign_key: 'rdux_action_id'
 
-    serialize :down_payload, coder: JSON if ActiveRecord::Base.connection.adapter_name != 'PostgreSQL'
-
-    scope :up, -> { where(down_at: nil) }
-    scope :down, -> { where.not(down_at: nil) }
-
-    def call(opts = {})
-      perform_action(:call, up_payload_unsanitized || up_payload, opts)
+    if ActiveRecord::Base.connection.adapter_name != 'PostgreSQL'
+      serialize :payload, coder: JSON
+      serialize :result, coder: JSON
+      serialize :meta, coder: JSON
     end
 
-    def up(opts = {})
-      return false if up_payload_sanitized && up_payload_unsanitized.nil?
-      return false unless down_at.nil?
-
-      perform_action(:up, up_payload_unsanitized || up_payload, opts)
-    end
+    validates :name, presence: true
+    validates :payload, presence: true
 
-    def down
-      return false unless down_at.nil?
-      return false unless can_down?
+    scope :ok, ->(val = true) { where(ok: val) }
+    scope :failed, -> { where(ok: false) }
 
-      res = perform_action(:down, down_payload, build_opts)
-      update(down_at: Time.current)
-      res
-    end
+    def call(opts = {})
+      return false if performed?
+      return false if payload_sanitized && payload_unsanitized.nil?
 
-    def to_failed_action
-      FailedAction.new(attributes.except('down_payload', 'down_at', 'rdux_action_id'))
+      opts.merge!(action: self)
+      perform_action(opts)
     end
 
     private
 
-    def can_down?
-      q = self.class.where('created_at > ?', created_at)
-              .where(down_at: nil)
-              .where('rdux_action_id IS NULL OR rdux_action_id != ?', id)
-      q = q.where(stream_hash:) unless stream_hash.nil?
-      !q.count.positive?
+    def performed?
+      !ok.nil?
     end
 
-    def action_performer(meth)
+    def action_performer
       name_const = name.to_s.constantize
-      return name_const if name_const.respond_to?(meth)
+      return name_const if name_const.respond_to?(:call)
       return unless name_const.is_a?(Class)
 
       obj = name_const.new
-      obj.respond_to?(meth) ? obj : nil
+      obj.respond_to?(:call) ? obj : nil
     end
 
-    def perform_action(meth, payload, opts)
-      performer = action_performer(meth)
+    def perform_action(opts)
+      performer = action_performer
       return if performer.nil?
 
-      if opts.any? || performer.method(meth).arity.abs == 2
-        performer.public_send(meth, payload, opts.merge!(action: self))
+      if performer.method(:call).arity.abs == 2
+        performer.call(payload_unsanitized || payload, opts)
       else
-        performer.public_send(meth, payload)
-      end
-    end
-
-    def build_opts
-      nested = rdux_actions.order(:created_at)
-      {}.tap do |h|
-        h[:nested] = nested if nested.any?
+        performer.call(payload_unsanitized || payload)
       end
     end
   end

data/db/migrate/20230621215718_create_rdux_actions.rb

@@ -4,16 +4,13 @@ class CreateRduxActions < ActiveRecord::Migration[7.0]
   def change
     create_table :rdux_actions do |t|
       t.string :name, null: false
-      t.column :up_payload, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text), null: false
-      t.column :down_payload, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
-      t.datetime :down_at
-      t.boolean :up_payload_sanitized, default: false, null: false
-      t.column :up_result, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
+      t.column :payload, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text), null: false
+      t.boolean :payload_sanitized, default: false, null: false
+      t.column :result, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
       t.column :meta, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
-      t.string :stream_hash
+      t.column :ok, :boolean
 
       t.belongs_to :rdux_action, index: true, foreign_key: true
-      t.belongs_to :rdux_failed_action, index: true, foreign_key: true
 
       t.timestamps
     end

data/lib/rdux/result.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
 module Rdux
-  Result = Struct.new(:ok, :down_payload, :val, :up_result, :save, :after_save, :nested, :action) do
-    def val
-      self[:val] || down_payload
-    end
-
+  Result = Struct.new(:ok, :val, :result, :save, :nested, :action) do
     def save_failed?
-      ok == false && save
+      ok == false && save ? true : false
     end
   end
 end

data/lib/rdux/store.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rdux
+  module Store
+    class << self
+      def call(name, payload, meta)
+        action = Action.new(name:, payload:, meta:)
+        sanitize(action)
+        action.save!
+        action
+      end
+
+      private
+
+      def sanitize(action)
+        param_filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
+        payload_sanitized = param_filter.filter(action.payload)
+        action.payload_sanitized = action.payload != payload_sanitized
+        action.payload_unsanitized = action.payload if action.payload_sanitized
+        action.payload = payload_sanitized
+      end
+    end
+  end
+end

data/lib/rdux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rdux
-  VERSION = '0.13.0'
+  VERSION = '1.0.0'
 end

data/lib/rdux.rb

@@ -1,100 +1,62 @@
 # frozen_string_literal: true
 
 require 'rdux/engine'
+require 'rdux/store'
 require 'rdux/result'
 require 'active_support/concern'
 
 module Rdux
   class << self
-    def dispatch(action_name, payload, opts = {}, meta: nil)
-      action = create_action(action_name, payload, opts, meta)
-      res = call_call_or_up_on_action(action, opts)
-      res.up_result ||= opts[:up_result]
-      assign_and_persist(res, action)
-      res.after_save.call(res.action) if res.after_save && res.action
-      res
+    def dispatch(name, payload, opts = {}, meta: nil)
+      action = store(name, payload, ars: opts[:ars], meta:)
+      process(action, opts)
     end
 
-    alias perform dispatch
-
-    private
-
-    def create_action(action_name, payload, opts, meta)
-      (opts[:ars] || {}).each { |k, v| payload["#{k}_id"] = v.id }
-      action = Action.new(name: action_name, up_payload: payload, meta:)
-      sanitize(action)
-      action.save!
-      action
+    def store(name, payload, ars: nil, meta: nil)
+      (ars || {}).each { |k, v| payload["#{k}_id"] = v.id }
+      Store.call(name, payload, meta)
     end
 
-    def call_call_or_up_on_action(action, opts)
+    def process(action, opts = {})
       res = action.call(opts)
-      if res
-        no_down(res)
-        return res
-      end
+      res.result ||= opts[:result]
+      return res if destroy_action(res, action)
 
-      action.up(opts)
+      assign_to_action(res, action)
+      persist(res, action)
+      res
     rescue StandardError => e
-      handle_exception(e, action, opts[:up_result])
+      handle_exception(e, action, opts[:result])
     end
 
-    def no_down(res)
-      res[:val] ||= res.down_payload
-      res.down_payload = nil
-    end
+    alias perform dispatch
 
-    def assign_and_persist(res, action)
-      action.down_payload = res.down_payload&.deep_stringify_keys!
-      if res.ok
-        assign_and_persist_for_ok(res, action)
-      elsif res.save_failed?
-        assign_and_persist_for_failed(res, action)
-      else
-        action.destroy
-      end
-    end
+    private
 
-    def assign_and_persist_for_ok(res, action)
-      action.up_result = res.up_result
-      res.action = action.tap(&:save!)
-      res.nested&.each { |nested_res| action.rdux_actions << nested_res.action }
-    end
+    def destroy_action(res, action)
+      return false if res.ok || res.save
 
-    def assign_and_persist_for_failed(res, action)
-      action.up_result = res.up_result
-      res.action = action.to_failed_action.tap(&:save!)
       action.destroy
-      assign_nested_responses_to_failed_action(res.action, res.nested) if res.nested
     end
 
-    def assign_nested_responses_to_failed_action(failed_action, nested)
-      nested.each do |nested_res|
-        if nested_res.action.is_a?(Rdux::Action)
-          failed_action.rdux_actions << nested_res.action
-        else
-          failed_action.rdux_failed_actions << nested_res.action
-        end
-      end
+    def assign_to_action(res, action)
+      action.ok = res.ok
+      action.result = res.result
     end
 
-    def sanitize(action)
-      param_filter = ActiveSupport::ParameterFilter.new(Rails.application.config.filter_parameters)
-      up_payload_sanitized = param_filter.filter(action.up_payload)
-      action.up_payload_sanitized = action.up_payload != up_payload_sanitized
-      action.up_payload_unsanitized = action.up_payload if action.up_payload_sanitized
-      action.up_payload = up_payload_sanitized
+    def persist(res, action)
+      res.action = action.tap(&:save!)
+      res.nested&.each { |nested_res| action.rdux_actions << nested_res.action }
     end
 
-    def handle_exception(exc, action, up_result)
-      failed_action = action.to_failed_action
-      failed_action.up_result ||= up_result || {}
-      failed_action.up_result.merge!({ 'Exception' => {
-                                       class: exc.class.name,
-                                       message: exc.message
-                                     } })
-      failed_action.save!
-      action.destroy
+    def handle_exception(exc, action, result)
+      action.ok = false
+      action.result ||= result || {}
+      action.result.merge!({ 'Exception' => {
+                             class: exc.class.name,
+                             message: exc.message
+                           } })
+      action.save!
       raise exc
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdux
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Zbigniew Humeniuk
@@ -99,13 +99,11 @@ files:
 - README.md
 - Rakefile
 - app/models/rdux/action.rb
-- app/models/rdux/actionable.rb
-- app/models/rdux/failed_action.rb
-- db/migrate/20230621215717_create_rdux_failed_actions.rb
 - db/migrate/20230621215718_create_rdux_actions.rb
 - lib/rdux.rb
 - lib/rdux/engine.rb
 - lib/rdux/result.rb
+- lib/rdux/store.rb
 - lib/rdux/version.rb
 homepage: https://artofcode.co
 licenses:

data/app/models/rdux/actionable.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Rdux
-  module Actionable
-    extend ActiveSupport::Concern
-
-    included do
-      if ActiveRecord::Base.connection.adapter_name != 'PostgreSQL'
-        serialize :up_payload, coder: JSON
-        serialize :up_result, coder: JSON
-        serialize :meta, coder: JSON
-      end
-
-      validates :name, presence: true
-      validates :up_payload, presence: true
-
-      before_save do
-        if meta_changed? && meta['stream'] && (meta_was || {})['stream'] != meta['stream']
-          self.stream_hash = Digest::SHA256.hexdigest(meta['stream'].to_json)
-        end
-      end
-    end
-
-    class_methods do
-      def table_name_prefix
-        'rdux_'
-      end
-    end
-  end
-end

data/app/models/rdux/failed_action.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Rdux
-  class FailedAction < ActiveRecord::Base
-    include Actionable
-
-    belongs_to :rdux_failed_action, optional: true, class_name: 'Rdux::FailedAction'
-    has_many :rdux_failed_actions, class_name: 'Rdux::FailedAction', foreign_key: 'rdux_failed_action_id'
-    has_many :rdux_actions, class_name: 'Rdux::Action', foreign_key: 'rdux_failed_action_id'
-  end
-end

data/db/migrate/20230621215717_create_rdux_failed_actions.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-class CreateRduxFailedActions < ActiveRecord::Migration[7.0]
-  def change
-    create_table :rdux_failed_actions do |t|
-      t.string :name, null: false
-      t.column :up_payload, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text), null: false
-      t.boolean :up_payload_sanitized, default: false, null: false
-      t.column :up_result, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
-      t.column :meta, (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' ? :jsonb : :text)
-      t.string :stream_hash
-
-      t.belongs_to :rdux_failed_action, index: true, foreign_key: true
-
-      t.timestamps
-    end
-  end
-end