chrono_forge 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b16c027867c5aca8d3f168ccb252125feef563731af33f40a129bfa9bfb781c5
-  data.tar.gz: 0ebd43e1896ea8df4ceb00c9c9af49c57a1e74d309149e817e43f9acfdfd5b8a
+  metadata.gz: 8c9315ad74de7245484119f385f2eb9706d1e3e532e142696d03d204e37f81ad
+  data.tar.gz: 4ea5ef5858c6d5fc8903f5432dd1ddc643d3cb6d26e65693c8a30664224a51c5
 SHA512:
-  metadata.gz: c94edc3ed7339bf3c7304c54e547bb1f86bc098dda586ffa049cfaf2fc29efcc7b44cce9429789ee1c3c5559dd3dd75859b75e74a27587c2a804160fee600f42
-  data.tar.gz: f7350954cace2c26ca57c7c0253a81d098a2eb655a5f283e6627eedec9d2b4acc11e0f58d3bebe47cd8a4c82907e1c4410d3655c43695ec8f02b8cc0af6a52c2
+  metadata.gz: 4713568fd2d32ddc70737fb5eb2f91db90aa41ff80d446afcd91f79719938e427f87b06da69dae18fb253c751aec07a70954e2f941053cb748db7fed04304ff0
+  data.tar.gz: caed47e85300d073b9ee1309d33b05047f2b0e6f60e95612ca247c86f233a32c823f9d68307e77384573c250b1779407e630a2f7ecd3557d2c033482f4326263

data/README.md

@@ -47,17 +47,45 @@ $ rails db:migrate
 
 ## 📋 Usage
 
+### Creating and Executing Workflows
+
+ChronoForge workflows are ActiveJob classes that prepend the `ChronoForge::Executor` module. Each workflow can **only** accept keyword arguments:
+
+```ruby
+# Define your workflow class
+class OrderProcessingWorkflow < ApplicationJob
+  prepend ChronoForge::Executor
+  
+  def perform(order_id:, customer_id:)
+    # Workflow steps...
+  end
+end
+```
+
+All workflows require a unique identifier when executed. This identifier is used to track and manage the workflow:
+
+```ruby
+# Execute the workflow
+OrderProcessingWorkflow.perform_later(
+  "order-123",                 # Unique workflow key
+  order_id: "order-134",       # Custom kwargs
+  customer_id: "customer-456"  # More custom kwargs
+)
+```
+
 ### Basic Workflow Example
 
 Here's a complete example of a durable order processing workflow:
 
 ```ruby
 class OrderProcessingWorkflow < ApplicationJob
-  include ChronoForge::Executor
+  prepend ChronoForge::Executor
+
+  def perform(order_id:)
+    @order_id = order_id
 
-  def perform
     # Context can be used to pass and store data between executions
-    context.set_once "order_id", SecureRandom.hex
+    context.set_once "execution_id", SecureRandom.hex
 
     # Wait until payment is confirmed
     wait_until :payment_confirmed?
@@ -75,16 +103,16 @@ class OrderProcessingWorkflow < ApplicationJob
   private
 
   def payment_confirmed?
-    PaymentService.confirmed?(context["order_id"])
+    PaymentService.confirmed?(@order_id, context["execution_id"])
   end
 
   def process_order
-    OrderProcessor.process(context["order_id"])
+    OrderProcessor.process(@order_id, context["execution_id"])
     context["processed_at"] = Time.current.iso8601
   end
 
   def complete_order
-    OrderCompletionService.complete(context["order_id"])
+    OrderCompletionService.complete(@order_id, context["execution_id"])
     context["completed_at"] = Time.current.iso8601
   end
 end
@@ -92,6 +120,28 @@ end
 
 ### Core Workflow Features
 
+#### 🚀 Executing Workflows
+
+ChronoForge workflows are executed through ActiveJob's standard interface with a specific parameter structure:
+
+```ruby
+# Perform the workflow immediately
+OrderProcessingWorkflow.perform_now(
+  "order-123",                     # Unique workflow key
+  order_id: "O-123",               # Custom parameter
+  customer_id: "C-456"             # Another custom parameter
+)
+
+# Or queue it for background processing
+OrderProcessingWorkflow.perform_later(
+  "order-123-async",               # Unique workflow key
+  order_id: "O-124",
+  customer_id: "C-457"
+)
+```
+
+**Important:** Workflows must use keyword arguments only, not positional arguments.
+
 #### ⚡ Durable Execution
 
 The `durably_execute` method ensures operations are executed exactly once, even if the job fails and is retried:
@@ -147,13 +197,15 @@ if context.key?(:user_id)
 end
 ```
 
+The context supports serializable Ruby objects (Hash, Array, String, Integer, Float, Boolean, and nil) and validates types automatically.
+
 ### 🛡️ Error Handling
 
 ChronoForge automatically tracks errors and provides configurable retry capabilities:
 
 ```ruby
 class MyWorkflow < ApplicationJob
-  include ChronoForge::Executor
+  prepend ChronoForge::Executor
 
   private
 
@@ -198,14 +250,18 @@ class WorkflowTest < ActiveJob::TestCase
   include ChaoticJob::Helpers
 
   def test_workflow_completion
-    # Enqueue the job
-    OrderProcessingWorkflow.perform_later("order_123")
+    # Enqueue the job with a unique key and custom parameters
+    OrderProcessingWorkflow.perform_later(
+      "order-test-123",
+      order_id: "O-123",
+      customer_id: "C-456"
+    )
     
     # Perform all enqueued jobs
     perform_all_jobs
     
     # Assert workflow completed successfully
-    workflow = ChronoForge::Workflow.last
+    workflow = ChronoForge::Workflow.find_by(key: "order-test-123")
     assert workflow.completed?
     
     # Check workflow context

data/export.json

@@ -5,7 +5,7 @@
   },
   {
     "path": "/Users/stefan/Documents/plutonium/chrono_forge/README.md",
-    "contents": "# ChronoForge\n\nChronoForge is a Ruby gem that provides a robust framework for building durable, distributed workflows in Ruby on Rails applications. It offers a reliable way to handle long-running processes, state management, and error recovery.\n\n## Features\n\n- **Durable Execution**: Automatically tracks and recovers from failures during workflow execution\n- **State Management**: Built-in workflow state tracking with support for custom contexts\n- **Concurrency Control**: Advanced locking mechanisms to prevent concurrent execution of the same workflow\n- **Error Handling**: Comprehensive error tracking and retry strategies\n- **Execution Logging**: Detailed logging of workflow execution steps and errors\n- **Wait States**: Support for time-based waits and condition-based waiting\n- **Database-Backed**: All workflow state is persisted to the database for durability\n- **ActiveJob Integration**: Seamlessly works with any ActiveJob backend\n\n## Installation\n\nAdd this line to your application's Gemfile:\n\n```ruby\ngem 'chrono_forge'\n```\n\nThen execute:\n\n```bash\n$ bundle install\n```\n\nOr install it directly:\n\n```bash\n$ gem install chrono_forge\n```\n\nAfter installation, run the generator to create the necessary database migrations:\n\n```bash\n$ rails generate chrono_forge:install\n$ rails db:migrate\n```\n\n## Usage\n\n### Basic Workflow Example\n\nHere's a complete example of a durable order processing workflow:\n\n```ruby\nclass OrderProcessingWorkflow < ApplicationJob\n  include ChronoForge::Executor\n\n  def perform\n    # Context can be used to pass and store data between executions\n    context[\"order_id\"] = SecureRandom.hex\n\n    # Wait until payment is confirmed\n    wait_until :payment_confirmed?\n\n    # Wait for potential fraud check\n    wait 1.minute, :fraud_check_delay\n\n    # Durably execute order processing\n    durably_execute :process_order\n\n    # Final steps\n    complete_order\n  end\n\n  private\n\n  def payment_confirmed?\n    PaymentService.confirmed?(context[\"order_id\"])\n  end\n\n  def process_order\n    context[\"processed_at\"] = Time.current.iso8601\n    OrderProcessor.process(context[\"order_id\"])\n  end\n\n  def complete_order\n    context[\"completed_at\"] = Time.current.iso8601\n    OrderCompletionService.complete(context[\"order_id\"])\n  end\nend\n```\n\n### Workflow Features\n\n#### Durable Execution\n\nThe `durably_execute` method ensures operations are executed exactly once:\n\n```ruby\n# Execute a method\ndurably_execute(:process_payment, max_attempts: 3)\n\n# Or with a block\ndurably_execute -> (ctx) {\n  Payment.process(ctx[:payment_id])\n}\n```\n\n#### Wait States\n\nChronoForge supports both time-based and condition-based waits:\n\n```ruby\n# Wait for a specific duration\nwait 1.hour, :cooling_period\n\n# Wait until a condition is met\nwait_until :payment_processed, \n  timeout: 1.hour,\n  check_interval: 5.minutes\n```\n\n#### Workflow Context\n\nChronoForge provides a persistent context that survives job restarts:\n\n```ruby\n# Set context values\ncontext[:user_name] = \"John Doe\"\ncontext[:status] = \"processing\"\n\n# Read context values\nuser_name = context[:user_name]\n```\n\n### Error Handling\n\nChronoForge automatically tracks errors and provides retry capabilities:\n\n```ruby\nclass MyWorkflow < ApplicationJob\n  include ChronoForge::Executor\n\n  private\n\n  def should_retry?(error, attempt_count)\n    case error\n    when NetworkError\n      attempt_count < 5\n    when ValidationError\n      false  # Don't retry validation errors\n    else\n      attempt_count < 3\n    end\n  end\nend\n```\n\n## Testing\n\nChronoForge is designed to be easily testable using [ChaoticJob](https://github.com/fractaledmind/chaotic_job), a testing framework that makes it simple to test complex job workflows. Here's how to set up your test environment:\n\n1. Add ChaoticJob to your Gemfile's test group:\n\n```ruby\ngroup :test do\n  gem 'chaotic_job'\nend\n```\n\n2. Set up your test helper:\n\n```ruby\n# test_helper.rb\nrequire 'chrono_forge'\nrequire 'minitest/autorun'\nrequire 'chaotic_job'\n```\n\nExample test:\n\n```ruby\nclass WorkflowTest < ActiveJob::TestCase\n  include ChaoticJob::Helpers\n\n  def test_workflow_completion\n    # Enqueue the job\n    OrderProcessingWorkflow.perform_later(\"order_123\")\n    \n    # Perform all enqueued jobs\n    perform_all_jobs\n    \n    # Assert workflow completed successfully\n    workflow = ChronoForge::Workflow.last\n    assert workflow.completed?\n    \n    # Check workflow context\n    assert workflow.context[\"processed_at\"].present?\n    assert workflow.context[\"completed_at\"].present?\n  end\nend\n```\n\nChaoticJob provides several helpful methods for testing workflows:\n\n- `perform_all_jobs`: Processes all enqueued jobs, including those enqueued during job execution\n\nFor testing with specific job processing libraries like Sidekiq or Delayed Job, you can still use their respective testing modes, but ChaoticJob is recommended for testing ChronoForge workflows as it better handles the complexities of nested job scheduling and wait states.\n\n\n## Database Schema\n\nChronoForge creates three main tables:\n\n1. `chrono_forge_workflows`: Stores workflow state and context\n2. `chrono_forge_execution_logs`: Tracks individual execution steps\n3. `chrono_forge_error_logs`: Records detailed error information\n\n## Development\n\nAfter checking out the repo, run:\n\n```bash\n$ bin/setup                 # Install dependencies\n$ bundle exec rake test     # Run the tests\n$ bin/appraise              # Run the full suite of appraisals\n$ bin/console               # Start an interactive console\n```\n\nThe test suite uses SQLite by default and includes:\n- Unit tests for core functionality\n- Integration tests with ActiveJob\n- Example workflow implementations\n\n## Contributing\n\n1. Fork the repository\n2. Create your feature branch (`git checkout -b feature/my-new-feature`)\n3. Commit your changes (`git commit -am 'Add some feature'`)\n4. Push to the branch (`git push origin feature/my-new-feature`)\n5. Create a new Pull Request\n\nPlease include tests for any new features or bug fixes.\n\n## License\n\nThis gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).\n"
+    "contents": "# ChronoForge\n\n![Version](https://img.shields.io/badge/version-0.3.0-blue.svg)\n[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\n\n> A robust framework for building durable, distributed workflows in Ruby on Rails applications\n\nChronoForge provides a powerful solution for handling long-running processes, managing state, and recovering from failures in your Rails applications. Built on top of ActiveJob, it ensures your critical business processes remain resilient and traceable.\n\n## 🌟 Features\n\n- **Durable Execution**: Automatically tracks and recovers from failures during workflow execution\n- **State Management**: Built-in workflow state tracking with persistent context storage\n- **Concurrency Control**: Advanced locking mechanisms to prevent parallel execution of the same workflow\n- **Error Handling**: Comprehensive error tracking with configurable retry strategies\n- **Execution Logging**: Detailed logging of workflow steps and errors for visibility\n- **Wait States**: Support for time-based waits and condition-based waiting\n- **Database-Backed**: All workflow state is persisted to ensure durability\n- **ActiveJob Integration**: Compatible with all ActiveJob backends, though database-backed processors (like Solid Queue) provide the most reliable experience for long-running workflows\n\n## 📦 Installation\n\nAdd to your application's Gemfile:\n\n```ruby\ngem 'chrono_forge'\n```\n\nThen execute:\n\n```bash\n$ bundle install\n```\n\nOr install directly:\n\n```bash\n$ gem install chrono_forge\n```\n\nAfter installation, run the generator to create the necessary database migrations:\n\n```bash\n$ rails generate chrono_forge:install\n$ rails db:migrate\n```\n\n## 📋 Usage\n\n### Creating and Executing Workflows\n\nChronoForge workflows are ActiveJob classes that prepend the `ChronoForge::Executor` module. Each workflow can **only** accept keyword arguments:\n\n```ruby\n# Define your workflow class\nclass OrderProcessingWorkflow < ApplicationJob\n  prepend ChronoForge::Executor\n  \n  def perform(order_id:, customer_id:)\n    # Workflow steps...\n  end\nend\n```\n\nAll workflows require a unique identifier when executed. This identifier is used to track and manage the workflow:\n\n```ruby\n# Execute the workflow\nOrderProcessingWorkflow.perform_later(\n  \"order-123\",                 # Unique workflow key\n  order_id: \"order-134\",       # Custom kwargs\n  customer_id: \"customer-456\"  # More custom kwargs\n)\n```\n\n### Basic Workflow Example\n\nHere's a complete example of a durable order processing workflow:\n\n```ruby\nclass OrderProcessingWorkflow < ApplicationJob\n  prepend ChronoForge::Executor\n\n  def perform(order_id:)\n    @order_id = order_id\n\n    # Context can be used to pass and store data between executions\n    context.set_once \"execution_id\", SecureRandom.hex\n\n    # Wait until payment is confirmed\n    wait_until :payment_confirmed?\n\n    # Wait for potential fraud check\n    wait 1.minute, :fraud_check_delay\n\n    # Durably execute order processing\n    durably_execute :process_order\n\n    # Final steps\n    complete_order\n  end\n\n  private\n\n  def payment_confirmed?\n    PaymentService.confirmed?(@order_id, context[\"execution_id\"])\n  end\n\n  def process_order\n    OrderProcessor.process(@order_id, context[\"execution_id\"])\n    context[\"processed_at\"] = Time.current.iso8601\n  end\n\n  def complete_order\n    OrderCompletionService.complete(@order_id, context[\"execution_id\"])\n    context[\"completed_at\"] = Time.current.iso8601\n  end\nend\n```\n\n### Core Workflow Features\n\n#### 🚀 Executing Workflows\n\nChronoForge workflows are executed through ActiveJob's standard interface with a specific parameter structure:\n\n```ruby\n# Perform the workflow immediately\nOrderProcessingWorkflow.perform_now(\n  \"order-123\",                     # Unique workflow key\n  order_id: \"O-123\",               # Custom parameter\n  customer_id: \"C-456\"             # Another custom parameter\n)\n\n# Or queue it for background processing\nOrderProcessingWorkflow.perform_later(\n  \"order-123-async\",               # Unique workflow key\n  order_id: \"O-124\",\n  customer_id: \"C-457\"\n)\n```\n\n**Important:** Workflows must use keyword arguments only, not positional arguments.\n\n#### ⚡ Durable Execution\n\nThe `durably_execute` method ensures operations are executed exactly once, even if the job fails and is retried:\n\n```ruby\n# Execute a method\ndurably_execute(:process_payment, max_attempts: 3)\n\n# Or with a block\ndurably_execute -> (ctx) {\n  Payment.process(ctx[:payment_id])\n}\n```\n\n#### ⏱️ Wait States\n\nChronoForge supports both time-based and condition-based waits:\n\n```ruby\n# Wait for a specific duration\nwait 1.hour, :cooling_period\n\n# Wait until a condition is met\nwait_until :payment_processed, \n  timeout: 1.hour,\n  check_interval: 5.minutes\n```\n\n#### 🔄 Workflow Context\n\nChronoForge provides a persistent context that survives job restarts. The context behaves like a Hash but with additional capabilities:\n\n```ruby\n# Set context values\ncontext[:user_name] = \"John Doe\"\ncontext[:status] = \"processing\"\n\n# Read context values\nuser_name = context[:user_name]\n\n# Using the fetch method (returns default if key doesn't exist)\nstatus = context.fetch(:status, \"pending\")\n\n# Set a value with the set method (alias for []=)\ncontext.set(:total_amount, 99.99)\n\n# Set a value only if the key doesn't already exist\ncontext.set_once(:created_at, Time.current.iso8601)\n\n# Check if a key exists\nif context.key?(:user_id)\n  # Do something with the user ID\nend\n```\n\nThe context supports serializable Ruby objects (Hash, Array, String, Integer, Float, Boolean, and nil) and validates types automatically.\n\n### 🛡️ Error Handling\n\nChronoForge automatically tracks errors and provides configurable retry capabilities:\n\n```ruby\nclass MyWorkflow < ApplicationJob\n  prepend ChronoForge::Executor\n\n  private\n\n  def should_retry?(error, attempt_count)\n    case error\n    when NetworkError\n      attempt_count < 5  # Retry network errors up to 5 times\n    when ValidationError\n      false  # Don't retry validation errors\n    else\n      attempt_count < 3  # Default retry policy\n    end\n  end\nend\n```\n\n## 🧪 Testing\n\nChronoForge is designed to be easily testable using [ChaoticJob](https://github.com/fractaledmind/chaotic_job), a testing framework that makes it simple to test complex job workflows:\n\n1. Add ChaoticJob to your Gemfile's test group:\n\n```ruby\ngroup :test do\n  gem 'chaotic_job'\nend\n```\n\n2. Set up your test helper:\n\n```ruby\n# test_helper.rb\nrequire 'chrono_forge'\nrequire 'minitest/autorun'\nrequire 'chaotic_job'\n```\n\nExample test:\n\n```ruby\nclass WorkflowTest < ActiveJob::TestCase\n  include ChaoticJob::Helpers\n\n  def test_workflow_completion\n    # Enqueue the job with a unique key and custom parameters\n    OrderProcessingWorkflow.perform_later(\n      \"order-test-123\",\n      order_id: \"O-123\",\n      customer_id: \"C-456\"\n    )\n    \n    # Perform all enqueued jobs\n    perform_all_jobs\n    \n    # Assert workflow completed successfully\n    workflow = ChronoForge::Workflow.find_by(key: \"order-test-123\")\n    assert workflow.completed?\n    \n    # Check workflow context\n    assert workflow.context[\"processed_at\"].present?\n    assert workflow.context[\"completed_at\"].present?\n  end\nend\n```\n\n## 🗄️ Database Schema\n\nChronoForge creates three main tables:\n\n1. **chrono_forge_workflows**: Stores workflow state and context\n2. **chrono_forge_execution_logs**: Tracks individual execution steps\n3. **chrono_forge_error_logs**: Records detailed error information\n\n## 🔍 When to Use ChronoForge\n\nChronoForge is ideal for:\n\n- **Long-running business processes** - Order processing, account registration flows\n- **Processes requiring durability** - Financial transactions, data migrations\n- **Multi-step workflows** - Onboarding flows, approval processes, multi-stage jobs\n- **State machines with time-based transitions** - Document approval, subscription lifecycle\n\n## 🚀 Development\n\nAfter checking out the repo, run:\n\n```bash\n$ bin/setup                 # Install dependencies\n$ bundle exec rake test     # Run the tests\n$ bin/appraise              # Run the full suite of appraisals\n$ bin/console               # Start an interactive console\n```\n\nThe test suite uses SQLite by default and includes:\n- Unit tests for core functionality\n- Integration tests with ActiveJob\n- Example workflow implementations\n\n## 👥 Contributing\n\n1. Fork the repository\n2. Create your feature branch (`git checkout -b feature/my-new-feature`)\n3. Commit your changes (`git commit -am 'Add some feature'`)\n4. Push to the branch (`git push origin feature/my-new-feature`)\n5. Create a new Pull Request\n\nPlease include tests for any new features or bug fixes.\n\n## 📜 License\n\nThis gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).\n"
   },
   {
     "path": "/Users/stefan/Documents/plutonium/chrono_forge/chrono_forge.gemspec",
@@ -61,11 +61,11 @@
   },
   {
     "path": "/Users/stefan/Documents/plutonium/chrono_forge/lib/chrono_forge/version.rb",
-    "contents": "# frozen_string_literal: true\n\nmodule ChronoForge\n  VERSION = \"0.2.0\"\nend\n"
+    "contents": "# frozen_string_literal: true\n\nmodule ChronoForge\n  VERSION = \"0.3.1\"\nend\n"
   },
   {
     "path": "/Users/stefan/Documents/plutonium/chrono_forge/lib/chrono_forge/workflow.rb",
-    "contents": "# frozen_string_literal: true\n\n# == Schema Information\n#\n# Table name: chrono_forge_workflows\n#\n#  id           :integer          not null, primary key\n#  completed_at :datetime\n#  context      :json             not null\n#  job_class    :string           not null\n#  key          :string           not null\n#  kwargs       :json             not null\n#  options      :json             not null\n#  locked_at    :datetime\n#  started_at   :datetime\n#  state        :integer          default(\"idle\"), not null\n#  created_at   :datetime         not null\n#  updated_at   :datetime         not null\n#\n# Indexes\n#\n#  index_chrono_forge_workflows_on_key  (key) UNIQUE\n#\nmodule ChronoForge\n  class Workflow < ActiveRecord::Base\n    self.table_name = \"chrono_forge_workflows\"\n\n    has_many :execution_logs, -> { order(id: :asc) }\n    has_many :error_logs, -> { order(id: :asc) }\n\n    enum :state, %i[\n      idle\n      running\n      completed\n      failed\n      stalled\n    ]\n\n    # Serialization for metadata\n    serialize :metadata, coder: JSON\n\n    def executable?\n      idle? || running?\n    end\n\n    def job_klass\n      job_class.constantize\n    end\n  end\nend\n"
+    "contents": "# frozen_string_literal: true\n\n# == Schema Information\n#\n# Table name: chrono_forge_workflows\n#\n#  id           :integer          not null, primary key\n#  completed_at :datetime\n#  context      :json             not null\n#  job_class    :string           not null\n#  key          :string           not null\n#  kwargs       :json             not null\n#  options      :json             not null\n#  locked_at    :datetime\n#  started_at   :datetime\n#  state        :integer          default(\"idle\"), not null\n#  created_at   :datetime         not null\n#  updated_at   :datetime         not null\n#\n# Indexes\n#\n#  index_chrono_forge_workflows_on_key  (key) UNIQUE\n#\nmodule ChronoForge\n  class Workflow < ActiveRecord::Base\n    self.table_name = \"chrono_forge_workflows\"\n\n    has_many :execution_logs, -> { order(id: :asc) }, dependent: :destroy\n    has_many :error_logs, -> { order(id: :asc) }, dependent: :destroy\n\n    enum :state, %i[\n      idle\n      running\n      completed\n      failed\n      stalled\n    ]\n\n    # Serialization for metadata\n    serialize :metadata, coder: JSON\n\n    def executable?\n      idle? || running?\n    end\n\n    def job_klass\n      job_class.constantize\n    end\n  end\nend\n"
   },
   {
     "path": "/Users/stefan/Documents/plutonium/chrono_forge/lib/chrono_forge.rb",

data/lib/chrono_forge/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ChronoForge
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/lib/chrono_forge/workflow.rb

@@ -25,8 +25,8 @@ module ChronoForge
   class Workflow < ActiveRecord::Base
     self.table_name = "chrono_forge_workflows"
 
-    has_many :execution_logs, -> { order(id: :asc) }
-    has_many :error_logs, -> { order(id: :asc) }
+    has_many :execution_logs, -> { order(id: :asc) }, dependent: :destroy
+    has_many :error_logs, -> { order(id: :asc) }, dependent: :destroy
 
     enum :state, %i[
       idle

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chrono_forge
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Stefan Froelich