job-workflow 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ff0a254ebd8fee848ab5eb26036e0bd98392700811e0bd55ffeaf4c348e04b6
-  data.tar.gz: ada2c0170fe7776a15802416f65070911e464f98abff416f9cbb15ed207bc7a8
+  metadata.gz: 2a4a82b69372293b7bf689c33125b60b4cbdbcdf4f2e1f468e205cf9bf0c1d85
+  data.tar.gz: e2e6e91167d6127e6cee7e2af0339f79ffee244fe6e768d73e50ebb6c2e7b372
 SHA512:
-  metadata.gz: d406e2e4ed2671b79aac352abe0405c009d0f4b089b4ecd2fb400b2a79c7676689cdbb9992e365063f17fb7160bb45084bc18966ff101097b39c6f6e5d3ecb60
-  data.tar.gz: 8d51653d18ed1769e513c2c3b854ac21663e1a9ed168dbac1713689912fa24b0c9cb9c66469a892e946e014905fc825934b555e4d657786efd5becd99fd9a866
+  metadata.gz: 84356b092c371e103d601576f9fc6ed5cdee9025340948b0d1fe8222b5b1f49f301342f8254a0d858fc89da58e8f828241d7d8ec706103349e63d6f68a426945
+  data.tar.gz: b146df16edb3112fa10379437e03ebd6a7f74c46e3a83526bb195320e141e9493319caa96d601622cf1e2f5d8cf18b071cc56c93aac1ad39492b89cfa8e08392

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 ## [Unreleased]
 
+## [0.3.0] - 2026-03-13
+
+### Added
+
+- Add `fetch_job_contexts(job_ids)` to queue adapter interface (`Abstract`, `SolidQueueAdapter`, `NullAdapter`) for fetching sub-job context data without direct `SolidQueue::Job` dependency from domain classes
+- Add `persist_job_context(job)` to queue adapter interface for persisting task outputs back to SolidQueue job records after execution
+- Add `without_query_cache` private helper to `SolidQueueAdapter` to bypass ActiveRecord query cache during polling queries
+- Add `"job_workflow_context"` key to `find_job` return hash for direct access to workflow context data
+- Add `AcceptanceNoDependencyWaitJob` and acceptance tests for `depends_on` without `dependency_wait` (polling-only mode)
+- Add acceptance test for output aggregation verification in async workflows
+
+### Changed
+
+- **Breaking (internal):** Replace `Output#update_task_outputs_from_db` and `Output#update_task_outputs_from_jobs` with `Output#update_task_outputs_from_contexts` — callers now pass context data hashes instead of `SolidQueue::Job` objects
+- `Runner#update_task_outputs` now routes through `QueueAdapter.current.fetch_job_contexts` instead of directly querying `SolidQueue::Job`
+- `Runner#run` now calls `QueueAdapter.current.persist_job_context(job)` after both sub-job and workflow execution
+- `WorkflowStatus.from_job_data` now reads `job_workflow_context` from top-level data first, falling back to `arguments.first.dig("job_workflow_context")`
+- `reschedule_solid_queue_job` now saves full serialized job hash (`active_job.serialize.deep_stringify_keys`) instead of only `["arguments"]`
+- Wrap `find_job`, `fetch_job_statuses`, `job_status`, `reschedule_job`, and `fetch_job_contexts` with `without_query_cache` to prevent stale reads under SolidQueue executor
+
+## [0.2.0] - 2026-03-12
+
+### Added
+
+- Add `workflow_concurrency` DSL class method as a context-aware wrapper around SolidQueue's `limits_concurrency`. Unlike `limits_concurrency`, the key Proc receives a `Context` object, giving access to `ctx.arguments`, `ctx.sub_job?`, and `ctx.concurrency_key`. A fallback `Context` is built from job arguments when `_context` is not yet initialized (e.g. during enqueue before `perform`).
+
+### Fixed
+
+- Fix task-level concurrency key: internal `limits_concurrency` call for `enqueue: { concurrency: N }` tasks now goes through `workflow_concurrency`, ensuring the key Proc receives a proper `Context` instead of raw ActiveJob arguments. Also changed the internal key proc from `lambda` to `proc` for compatibility with SolidQueue's `instance_exec(*arguments, &proc)` call site.
+
 ## [0.1.3] - 2026-01-06
 
 ### Changed

data/README.md

@@ -1,6 +1,6 @@
 # JobWorkflow
 
-> ⚠️ **Early Stage (v0.1.3):** This library is in active development. APIs and features may change in breaking ways without notice. Use in production at your own risk and expect potential breaking changes in future releases.
+> ⚠️ **Early Stage (v0.3.0):** This library is in active development. APIs and features may change in breaking ways without notice. Use in production at your own risk and expect potential breaking changes in future releases.
 
 ## Overview
 

data/guides/API_REFERENCE.md

@@ -84,6 +84,73 @@ end
 
 **Map Task Output**: When `each:` is specified, outputs are automatically collected as an array.
 
+### workflow_concurrency
+
+Configure job-level concurrency limits with workflow-aware context.
+
+```ruby
+workflow_concurrency(to:, key:, **opts)
+```
+
+**Parameters**:
+- `to` (Integer): Maximum number of concurrent executions
+- `key` (Proc): A Proc that receives a `Context` and returns a String concurrency key
+- `opts` (Hash): Additional options passed to SolidQueue's `limits_concurrency`
+  - `on_conflict` (Symbol): `:discard` to drop duplicate jobs (optional)
+  - `duration` (ActiveSupport::Duration): How long the concurrency lock is held (optional)
+  - `group` (String): Concurrency group name (optional)
+
+Unlike SolidQueue's `limits_concurrency` (which passes raw ActiveJob arguments to the key Proc), `workflow_concurrency` passes a **Context** object, giving access to `arguments`, `sub_job?`, and `concurrency_key`.
+
+**Example — simple per-tenant key**:
+
+```ruby
+class ImportJob < ApplicationJob
+  include JobWorkflow::DSL
+
+  argument :tenant_id, "Integer"
+  argument :items, "Array[Integer]"
+
+  workflow_concurrency to: 1,
+                       key: ->(ctx) { "import:#{ctx.arguments.tenant_id}" },
+                       on_conflict: :discard
+
+  task :process,
+       each: ->(ctx) { ctx.arguments.items },
+       enqueue: { concurrency: 5 },
+       output: { result: "String" } do |ctx|
+    { result: handle(ctx.each_value) }
+  end
+end
+```
+
+**Example — separating parent and sub-job keys**:
+
+```ruby
+class BatchImportJob < ApplicationJob
+  include JobWorkflow::DSL
+
+  argument :tenant_id, "Integer"
+  argument :items, "Array[Integer]"
+
+  workflow_concurrency to: 1,
+                       key: lambda { |ctx|
+                         ctx.sub_job? ? ctx.concurrency_key : "batch:#{ctx.arguments.tenant_id}"
+                       },
+                       on_conflict: :discard
+
+  task :process,
+       each: ->(ctx) { ctx.arguments.items },
+       enqueue: { concurrency: 5 },
+       output: { result: "String" } do |ctx|
+    { result: handle(ctx.each_value) }
+  end
+end
+```
+
+> **Note**: `workflow_concurrency` calls `limits_concurrency` internally. Calling it multiple times in the same class will **overwrite** the previous setting (last-wins). Define it once per job class.
+> Requires SolidQueue.
+
 **Example**:
 
 ```ruby

data/guides/PARALLEL_PROCESSING.md

@@ -110,6 +110,68 @@ The `enqueue:` option determines how map task iterations are executed:
 
 **Note**: `enqueue:` works with both regular tasks and map tasks. For map tasks, it enables asynchronous sub-job execution. For regular tasks, it allows conditional enqueueing as a separate job. Legacy syntax (`enqueue: ->(_ctx) { true }` as a Proc) is still supported for backward compatibility.
 
+### Job-Level Concurrency with `workflow_concurrency`
+
+When using SolidQueue's `limits_concurrency` directly, the key Proc receives raw ActiveJob arguments (a Hash), making it difficult to distinguish parent jobs from sub-jobs. `workflow_concurrency` is a wrapper that passes a **Context** object to the key Proc, giving access to workflow-aware information.
+
+```ruby
+class ImportJob < ApplicationJob
+  include JobWorkflow::DSL
+
+  argument :tenant_id, "Integer"
+  argument :items, "Array[Integer]"
+
+  # Limit to 1 concurrent execution per tenant.
+  # The key Proc receives a Context, not raw arguments.
+  workflow_concurrency to: 1,
+                       key: ->(ctx) { "import:#{ctx.arguments.tenant_id}" },
+                       on_conflict: :discard
+
+  task :process_items,
+       each: ->(ctx) { ctx.arguments.items },
+       enqueue: { concurrency: 5 },
+       output: { result: "String" } do |ctx|
+    { result: process(ctx.each_value) }
+  end
+end
+```
+
+**Key differences from `limits_concurrency`:**
+
+| Feature | `limits_concurrency` (SolidQueue) | `workflow_concurrency` (JobWorkflow) |
+|---|---|---|
+| Key Proc argument | Raw Hash (ActiveJob arguments) | `Context` object |
+| Access to `sub_job?` | ❌ Not available | ✅ `ctx.sub_job?` |
+| Access to `concurrency_key` | ❌ Not available | ✅ `ctx.concurrency_key` |
+| Access to `arguments` | Manual Hash parsing | ✅ `ctx.arguments.<name>` |
+
+**Separating parent and sub-job concurrency keys:**
+
+When a parent job enqueues sub-jobs (via `enqueue:` option), they share the same job class. With `limits_concurrency`, both parent and sub-jobs resolve to the same concurrency key, which can cause sub-jobs to be discarded. Use `workflow_concurrency` with `ctx.sub_job?` to generate distinct keys:
+
+```ruby
+workflow_concurrency to: 1,
+                     key: lambda { |ctx|
+                       if ctx.sub_job?
+                         # Sub-jobs use a unique key per task iteration
+                         ctx.concurrency_key
+                       else
+                         # Parent job uses a tenant-scoped key
+                         "import:#{ctx.arguments.tenant_id}"
+                       end
+                     },
+                     on_conflict: :discard
+```
+
+**Parameters:**
+- `to:` (Integer): Maximum number of concurrent executions
+- `key:` (Proc): A Proc that receives a `Context` and returns a String used as the concurrency key
+- `on_conflict:` (Symbol, optional): `:discard` to drop duplicate jobs, or omit for default SolidQueue behavior
+- `duration:` (ActiveSupport::Duration, optional): How long the concurrency lock is held
+- `group:` (String, optional): Concurrency group name
+
+> **Note**: `workflow_concurrency` requires SolidQueue. It delegates to `limits_concurrency` internally.
+
 ## Fork-Join Pattern
 
 ### Context Isolation

data/guides/PRODUCTION_DEPLOYMENT.md

@@ -1,6 +1,6 @@
 # Production Deployment
 
-> ⚠️ **Early Stage (v0.1.3):** JobWorkflow is still in early development. While this section outlines potential deployment patterns, please thoroughly test in your specific environment and monitor for any issues before relying on JobWorkflow in critical production systems.
+> ⚠️ **Early Stage (v0.3.0):** JobWorkflow is still in early development. While this section outlines potential deployment patterns, please thoroughly test in your specific environment and monitor for any issues before relying on JobWorkflow in critical production systems.
 
 This section covers suggested settings and patterns for running JobWorkflow in production-like environments.
 

data/guides/README.md

@@ -1,6 +1,6 @@
 # JobWorkflow Guides
 
-> ⚠️ **Early Stage (v0.1.3):** JobWorkflow is in active development. APIs and features may change. The following guides provide patterns and examples for building workflows, but be aware that implementations may need adjustment as the library evolves.
+> ⚠️ **Early Stage (v0.3.0):** JobWorkflow is in active development. APIs and features may change. The following guides provide patterns and examples for building workflows, but be aware that implementations may need adjustment as the library evolves.
 
 Welcome to the JobWorkflow documentation! This directory contains comprehensive guides to help you build robust workflows with JobWorkflow.
 

data/lib/job_workflow/dsl.rb

@@ -165,7 +165,7 @@ module JobWorkflow
         _workflow.add_task(new_task)
         if new_task.enqueue.should_limits_concurrency? # rubocop:disable Style/GuardClause
           concurrency = new_task.enqueue.concurrency #: Integer
-          limits_concurrency(to: concurrency, key: ->(ctx) { ctx.concurrency_key }) # rubocop:disable Style/SymbolProc
+          workflow_concurrency(to: concurrency, key: :concurrency_key.to_proc)
         end
       end
       # rubocop:enable Metrics/ParameterLists
@@ -194,6 +194,50 @@ module JobWorkflow
         _workflow.add_hook(:error, task_names:, block:)
       end
 
+      # Configures concurrency limits for this workflow job.
+      #
+      # Unlike `limits_concurrency` (SolidQueue's raw API), this method passes a
+      # {Context} as the first argument to the key Proc, giving access to
+      # workflow-aware information such as `arguments`, `sub_job?`, and
+      # `concurrency_key`.
+      #
+      # When `_context` is not yet initialized (e.g. during enqueue before
+      # perform), a temporary Context is built from the job's arguments so the
+      # key Proc can always rely on `ctx.arguments`.
+      #
+      # @example Limit duplicate workflow runs by argument
+      #   workflow_concurrency to: 1,
+      #     key: ->(ctx) { "my_job:#{ctx.arguments.tenant_id}" },
+      #     on_conflict: :discard
+      #
+      # @example Separate parent and sub-job concurrency keys
+      #   workflow_concurrency to: 1,
+      #     key: ->(ctx) {
+      #       ctx.sub_job? ? ctx.concurrency_key : "my_job:#{ctx.arguments.name}"
+      #     },
+      #     on_conflict: :discard
+      #
+      #:  (
+      #     to: Integer,
+      #     key: ^(Context) -> String?,
+      #     ?duration: ActiveSupport::Duration?,
+      #     ?group: String?,
+      #     ?on_conflict: Symbol?
+      #   ) -> void
+      def workflow_concurrency(to:, key:, **opts)
+        concurrency_key_proc = key
+        limits_concurrency(
+          to:,
+          key: proc {
+            ctx = _context || Context.from_hash(
+              job: self, workflow: self.class._workflow
+            )._update_arguments((arguments.first || {}).symbolize_keys)
+            concurrency_key_proc.call(ctx)
+          },
+          **opts
+        )
+      end
+
       #:  (?bool) ?{ (Context) -> bool } -> void
       def dry_run(value = nil, &block)
         validate_namespace!

data/lib/job_workflow/output.rb

@@ -50,18 +50,10 @@ module JobWorkflow
       task_outputs[task_output.task_name][task_output.each_index] = task_output
     end
 
-    #:  (Array[String], Workflow) -> void
-    def update_task_outputs_from_db(job_ids, workflow)
-      jobs = SolidQueue::Job.where(active_job_id: job_ids)
-      return if jobs.empty?
-
-      update_task_outputs_from_jobs(jobs.to_a, workflow)
-    end
-
-    #:  (Array[SolidQueue::Job], Workflow) -> void
-    def update_task_outputs_from_jobs(jobs, workflow)
-      jobs.each do |job|
-        context = Context.deserialize(job.arguments["job_workflow_context"].merge("workflow" => workflow))
+    #:  (Array[Hash[String, untyped]], Workflow) -> void
+    def update_task_outputs_from_contexts(context_data_list, workflow)
+      context_data_list.each do |context_data|
+        context = Context.deserialize(context_data.merge("workflow" => workflow))
         task_output = context.each_task_output
         next if task_output.nil?
 

data/lib/job_workflow/queue_adapters/abstract.rb

@@ -77,10 +77,18 @@ module JobWorkflow
         raise NotImplementedError, "#{self.class}#find_job must be implemented"
       end
 
+      #:  (Array[String]) -> Array[Hash[String, untyped]]
+      def fetch_job_contexts(_job_ids)
+        raise NotImplementedError, "#{self.class}#fetch_job_contexts must be implemented"
+      end
+
       #:  (DSL, Numeric) -> bool
       def reschedule_job(_job, _wait)
         false
       end
+
+      #:  (DSL) -> void
+      def persist_job_context(_job); end
     end
     # rubocop:enable Naming/PredicateMethod
   end

data/lib/job_workflow/queue_adapters/null_adapter.rb

@@ -90,6 +90,11 @@ module JobWorkflow
         @stored_jobs[job_id]
       end
 
+      #:  (Array[String]) -> Array[Hash[String, untyped]]
+      def fetch_job_contexts(_job_ids)
+        []
+      end
+
       #:  (DSL, Numeric) -> bool
       def reschedule_job(_job, _wait)
         false

data/lib/job_workflow/queue_adapters/solid_queue_adapter.rb

@@ -2,7 +2,7 @@
 
 module JobWorkflow
   module QueueAdapters
-    # rubocop:disable Naming/PredicateMethod
+    # rubocop:disable Naming/PredicateMethod, Metrics/ClassLength
     class SolidQueueAdapter < Abstract
       # @note
       #   - Registry scope: @semaphore_registry is process-scoped (shared across fibers/threads
@@ -74,16 +74,20 @@ module JobWorkflow
       def fetch_job_statuses(job_ids)
         return {} unless defined?(SolidQueue::Job)
 
-        SolidQueue::Job.where(active_job_id: job_ids).index_by(&:active_job_id)
+        without_query_cache do
+          SolidQueue::Job.where(active_job_id: job_ids).index_by(&:active_job_id)
+        end
       end
 
       #:  (untyped) -> Symbol
       def job_status(job)
-        return :failed if job.failed?
-        return :succeeded if job.finished?
-        return :running if job.claimed?
+        without_query_cache do
+          return :failed if job.failed?
+          return :succeeded if job.finished?
+          return :running if job.claimed?
 
-        :pending
+          :pending
+        end
       end
 
       #:  () -> bool
@@ -153,23 +157,40 @@ module JobWorkflow
       def find_job(job_id)
         return unless defined?(SolidQueue::Job)
 
-        job = SolidQueue::Job.find_by(active_job_id: job_id)
+        job = without_query_cache { SolidQueue::Job.find_by(active_job_id: job_id) }
         return if job.nil?
 
+        args = job.arguments
         {
           "job_id" => job.active_job_id,
           "class_name" => job.class_name,
           "queue_name" => job.queue_name,
-          "arguments" => job.arguments.is_a?(Hash) ? job.arguments["arguments"] : job.arguments,
+          "arguments" => args.is_a?(Hash) ? args["arguments"] : args,
+          "job_workflow_context" => args.is_a?(Hash) ? args["job_workflow_context"] : nil,
           "status" => job_status(job)
         }
       end
 
+      # @note
+      #   - Fetches job_workflow_context hashes for the given job IDs.
+      #
+      #:  (Array[String]) -> Array[Hash[String, untyped]]
+      def fetch_job_contexts(job_ids)
+        return [] unless defined?(SolidQueue::Job)
+        return [] if job_ids.empty?
+
+        jobs = without_query_cache { SolidQueue::Job.where(active_job_id: job_ids).to_a }
+        jobs.filter_map do |job|
+          args = job.arguments
+          args.is_a?(Hash) ? args["job_workflow_context"] : nil
+        end
+      end
+
       #:  (DSL, Numeric) -> bool
       def reschedule_job(job, wait)
         return false unless defined?(SolidQueue::Job)
 
-        solid_queue_job = SolidQueue::Job.find_by(active_job_id: job.job_id)
+        solid_queue_job = without_query_cache { SolidQueue::Job.find_by(active_job_id: job.job_id) }
         return false unless solid_queue_job&.claimed?
 
         reschedule_solid_queue_job(solid_queue_job, job, wait)
@@ -177,17 +198,44 @@ module JobWorkflow
         false
       end
 
+      # @note
+      #   - Persists the job's updated context (including task outputs) back
+      #     to the SolidQueue job record after execution completes. Without this,
+      #     outputs computed during job execution would be lost because
+      #     SolidQueue does not re-serialize job arguments after perform.
+      #
+      #:  (DSL) -> void
+      def persist_job_context(job)
+        return unless defined?(SolidQueue::Job)
+
+        solid_queue_job = SolidQueue::Job.find_by(active_job_id: job.job_id)
+        return if solid_queue_job.nil?
+
+        solid_queue_job.update!(arguments: job.serialize.deep_stringify_keys)
+      end
+
       private
 
       attr_reader :semaphore_registry #: Hash[Object, ^(SolidQueue::Worker) -> void]
 
+      # @note
+      #   - Bypasses ActiveRecord query cache for the given block.
+      #   - When running under SolidQueue's executor, SELECT queries are cached
+      #     for the entire job execution. Polling queries must bypass this cache
+      #     to observe status changes made by other threads/processes.
+      #
+      #:  [T] () { () -> T } -> T
+      def without_query_cache(&)
+        defined?(SolidQueue::Job) ? SolidQueue::Job.uncached(&) : yield
+      end
+
       #:  (SolidQueue::Job, DSL, Numeric) -> bool
       def reschedule_solid_queue_job(solid_queue_job, active_job, wait)
         solid_queue_job.with_lock do
           solid_queue_job.claimed_execution&.destroy!
           solid_queue_job.update!(
             scheduled_at: wait.seconds.from_now,
-            arguments: active_job.serialize.deep_stringify_keys["arguments"]
+            arguments: active_job.serialize.deep_stringify_keys
           )
           solid_queue_job.prepare_for_execution
         end
@@ -219,6 +267,6 @@ module JobWorkflow
         end
       end
     end
-    # rubocop:enable Naming/PredicateMethod
+    # rubocop:enable Naming/PredicateMethod, Metrics/ClassLength
   end
 end

data/lib/job_workflow/runner.rb

@@ -13,9 +13,14 @@ module JobWorkflow
     #:  () -> void
     def run
       task = context._task_context.task
-      return run_task(task) if !task.nil? && context.sub_job?
+      if !task.nil? && context.sub_job?
+        run_task(task)
+        QueueAdapter.current.persist_job_context(job)
+        return
+      end
 
       catch(:rescheduled) { run_workflow }
+      QueueAdapter.current.persist_job_context(job)
     end
 
     private
@@ -167,7 +172,8 @@ module JobWorkflow
     #:  (Task) -> void
     def update_task_outputs(task)
       finished_job_ids = context.job_status.finished_job_ids(task_name: task.task_name)
-      context.output.update_task_outputs_from_db(finished_job_ids, context.workflow)
+      context_data_list = QueueAdapter.current.fetch_job_contexts(finished_job_ids)
+      context.output.update_task_outputs_from_contexts(context_data_list, context.workflow)
     end
   end
 end

data/lib/job_workflow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JobWorkflow
-  VERSION = "0.1.3" # : String
+  VERSION = "0.3.0" # : String
 end

data/lib/job_workflow/workflow_status.rb

@@ -34,7 +34,7 @@ module JobWorkflow
         job_class = job_class_name.constantize
         workflow = job_class._workflow
 
-        context_data = data["arguments"].first["job_workflow_context"]
+        context_data = data["job_workflow_context"] || data["arguments"]&.first&.dig("job_workflow_context")
         context = if context_data
                     Context.deserialize(context_data.merge("workflow" => workflow))
                   else

data/rbs_collection.lock.yaml

@@ -6,7 +6,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: activerecord
@@ -14,7 +14,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: activesupport
@@ -22,7 +22,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: base64
@@ -34,7 +34,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: concurrent-ruby
@@ -42,7 +42,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: connection_pool
@@ -50,7 +50,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: date
@@ -74,7 +74,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: i18n
@@ -82,7 +82,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: json
@@ -98,7 +98,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: monitor
@@ -138,7 +138,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: stringio
@@ -162,7 +162,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: 2af46cde7fec5e4130f6c84c5b691c0538af8789
+    revision: 9bf2eebb1c54b5d6f23f2acb65d4c36f195b4783
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: uri

data/sig/generated/job_workflow/dsl.rbs

@@ -94,6 +94,38 @@ module JobWorkflow
       # :  (*Symbol) { (Context, StandardError, Task) -> void } -> void
       def on_error: (*Symbol) { (Context, StandardError, Task) -> void } -> void
 
+      # Configures concurrency limits for this workflow job.
+      #
+      # Unlike `limits_concurrency` (SolidQueue's raw API), this method passes a
+      # {Context} as the first argument to the key Proc, giving access to
+      # workflow-aware information such as `arguments`, `sub_job?`, and
+      # `concurrency_key`.
+      #
+      # When `_context` is not yet initialized (e.g. during enqueue before
+      # perform), a temporary Context is built from the job's arguments so the
+      # key Proc can always rely on `ctx.arguments`.
+      #
+      # @example Limit duplicate workflow runs by argument
+      #   workflow_concurrency to: 1,
+      #     key: ->(ctx) { "my_job:#{ctx.arguments.tenant_id}" },
+      #     on_conflict: :discard
+      #
+      # @example Separate parent and sub-job concurrency keys
+      #   workflow_concurrency to: 1,
+      #     key: ->(ctx) {
+      #       ctx.sub_job? ? ctx.concurrency_key : "my_job:#{ctx.arguments.name}"
+      #     },
+      #     on_conflict: :discard
+      #
+      # :  (
+      #     to: Integer,
+      #     key: ^(Context) -> String?,
+      #     ?duration: ActiveSupport::Duration?,
+      #     ?group: String?,
+      #     ?on_conflict: Symbol?
+      #   ) -> void
+      def workflow_concurrency: (to: Integer, key: ^(Context) -> String?, ?duration: ActiveSupport::Duration?, ?group: String?, ?on_conflict: Symbol?) -> void
+
       # :  (?bool) ?{ (Context) -> bool } -> void
       def dry_run: (?bool) ?{ (Context) -> bool } -> void
 

data/sig/generated/job_workflow/output.rbs

@@ -23,11 +23,8 @@ module JobWorkflow
     # :  (TaskOutput) -> void
     def add_task_output: (TaskOutput) -> void
 
-    # :  (Array[String], Workflow) -> void
-    def update_task_outputs_from_db: (Array[String], Workflow) -> void
-
-    # :  (Array[SolidQueue::Job], Workflow) -> void
-    def update_task_outputs_from_jobs: (Array[SolidQueue::Job], Workflow) -> void
+    # :  (Array[Hash[String, untyped]], Workflow) -> void
+    def update_task_outputs_from_contexts: (Array[Hash[String, untyped]], Workflow) -> void
 
     # :  () -> Array[TaskOutput]
     def flat_task_outputs: () -> Array[TaskOutput]

data/sig/generated/job_workflow/queue_adapters/abstract.rbs

@@ -49,8 +49,14 @@ module JobWorkflow
       # :  (String) -> Hash[String, untyped]?
       def find_job: (String) -> Hash[String, untyped]?
 
+      # :  (Array[String]) -> Array[Hash[String, untyped]]
+      def fetch_job_contexts: (Array[String]) -> Array[Hash[String, untyped]]
+
       # :  (DSL, Numeric) -> bool
       def reschedule_job: (DSL, Numeric) -> bool
+
+      # :  (DSL) -> void
+      def persist_job_context: (DSL) -> void
     end
   end
 end

data/sig/generated/job_workflow/queue_adapters/null_adapter.rbs

@@ -51,6 +51,9 @@ module JobWorkflow
       # :  (String) -> Hash[String, untyped]?
       def find_job: (String) -> Hash[String, untyped]?
 
+      # :  (Array[String]) -> Array[Hash[String, untyped]]
+      def fetch_job_contexts: (Array[String]) -> Array[Hash[String, untyped]]
+
       # :  (DSL, Numeric) -> bool
       def reschedule_job: (DSL, Numeric) -> bool
 

data/sig/generated/job_workflow/queue_adapters/solid_queue_adapter.rbs

@@ -2,7 +2,7 @@
 
 module JobWorkflow
   module QueueAdapters
-    # rubocop:disable Naming/PredicateMethod
+    # rubocop:disable Naming/PredicateMethod, Metrics/ClassLength
     class SolidQueueAdapter < Abstract
       # @note
       #   - Registry scope: @semaphore_registry is process-scoped (shared across fibers/threads
@@ -82,13 +82,37 @@ module JobWorkflow
       # :  (String) -> Hash[String, untyped]?
       def find_job: (String) -> Hash[String, untyped]?
 
+      # @note
+      #   - Fetches job_workflow_context hashes for the given job IDs.
+      #
+      # :  (Array[String]) -> Array[Hash[String, untyped]]
+      def fetch_job_contexts: (Array[String]) -> Array[Hash[String, untyped]]
+
       # :  (DSL, Numeric) -> bool
       def reschedule_job: (DSL, Numeric) -> bool
 
+      # @note
+      #   - Persists the job's updated context (including task outputs) back
+      #     to the SolidQueue job record after execution completes. Without this,
+      #     outputs computed during job execution would be lost because
+      #     SolidQueue does not re-serialize job arguments after perform.
+      #
+      # :  (DSL) -> void
+      def persist_job_context: (DSL) -> void
+
       private
 
       attr_reader semaphore_registry: Hash[Object, ^(SolidQueue::Worker) -> void]
 
+      # @note
+      #   - Bypasses ActiveRecord query cache for the given block.
+      #   - When running under SolidQueue's executor, SELECT queries are cached
+      #     for the entire job execution. Polling queries must bypass this cache
+      #     to observe status changes made by other threads/processes.
+      #
+      # :  [T] () { () -> T } -> T
+      def without_query_cache: [T] () { () -> T } -> T
+
       # :  (SolidQueue::Job, DSL, Numeric) -> bool
       def reschedule_solid_queue_job: (SolidQueue::Job, DSL, Numeric) -> bool
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: job-workflow
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - shoma07
@@ -184,7 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Declarative workflow orchestration engine for Ruby on Rails
 test_files: []