job-workflow 0.1.3

data/sig/generated/job_workflow/schedule.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/job_workflow/schedule.rb with RBS::Inline
+
+module JobWorkflow
+  class Schedule
+    attr_reader key: Symbol
+
+    attr_reader class_name: String
+
+    attr_reader expression: String
+
+    attr_reader queue: String?
+
+    attr_reader priority: Integer?
+
+    attr_reader args: Hash[Symbol, untyped]
+
+    attr_reader description: String?
+
+    # rubocop:disable Metrics/ParameterLists
+    # :  (
+    #     expression: String,
+    #     class_name: String,
+    #     ?key: (String | Symbol)?,
+    #     ?queue: String?,
+    #     ?priority: Integer?,
+    #     ?args: Hash[Symbol, untyped],
+    #     ?description: String?
+    #   ) -> void
+    def initialize: (expression: String, class_name: String, ?key: (String | Symbol)?, ?queue: String?, ?priority: Integer?, ?args: Hash[Symbol, untyped], ?description: String?) -> void
+
+    # :  () -> Hash[Symbol, untyped]
+    def to_config: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/generated/job_workflow/semaphore.rbs

@@ -0,0 +1,37 @@
+# Generated from lib/job_workflow/semaphore.rb with RBS::Inline
+
+module JobWorkflow
+  class Semaphore
+    DEFAULT_POLLING_INTERVAL: Float
+
+    attr_reader concurrency_key: String
+
+    attr_reader concurrency_limit: Integer
+
+    attr_reader concurrency_duration: ActiveSupport::Duration
+
+    # :  () -> bool
+    def self.available?: () -> bool
+
+    # :  (
+    #      concurrency_key: String,
+    #      concurrency_duration: ActiveSupport::Duration,
+    #      ?concurrency_limit: Integer,
+    #      ?polling_interval: Float
+    #    ) -> void
+    def initialize: (concurrency_key: String, concurrency_duration: ActiveSupport::Duration, ?concurrency_limit: Integer, ?polling_interval: Float) -> void
+
+    # :  () -> bool
+    def wait: () -> bool
+
+    # :  () -> bool
+    def signal: () -> bool
+
+    # : [T] () { () -> T } -> T
+    def with: [T] () { () -> T } -> T
+
+    private
+
+    attr_reader polling_interval: Float
+  end
+end

data/sig/generated/job_workflow/task.rbs

@@ -0,0 +1,60 @@
+# Generated from lib/job_workflow/task.rb with RBS::Inline
+
+module JobWorkflow
+  class Task
+    attr_reader job_name: String
+
+    attr_reader namespace: Namespace
+
+    attr_reader block: ^(untyped) -> void
+
+    attr_reader each: ^(Context) -> untyped
+
+    attr_reader enqueue: TaskEnqueue
+
+    attr_reader output: Array[OutputDef]
+
+    attr_reader depends_on: Array[Symbol]
+
+    attr_reader condition: ^(Context) -> bool
+
+    attr_reader task_retry: TaskRetry
+
+    attr_reader throttle: TaskThrottle
+
+    attr_reader timeout: Numeric?
+
+    attr_reader dependency_wait: TaskDependencyWait
+
+    attr_reader dry_run_config: DryRunConfig
+
+    # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength, Metrics/AbcSize
+    # :  (
+    #     job_name: String,
+    #     name: Symbol,
+    #     namespace: Namespace,
+    #     block: ^(untyped) -> void,
+    #     ?each: ^(Context) -> untyped,
+    #     ?enqueue: true | false | ^(Context) -> bool | Hash[Symbol, untyped],
+    #     ?output: Hash[Symbol, String],
+    #     ?depends_on: Array[Symbol],
+    #     condition: ^(Context) -> bool,
+    #     ?task_retry: Integer | Hash[Symbol, untyped],
+    #     ?throttle: Integer | Hash[Symbol, untyped],
+    #     ?timeout: Numeric?,
+    #     ?dependency_wait: Hash[Symbol, untyped],
+    #     ?dry_run: bool | ^(Context) -> bool
+    #   ) -> void
+    def initialize: (job_name: String, name: Symbol, namespace: Namespace, block: ^(untyped) -> void, condition: ^(Context) -> bool, ?each: ^(Context) -> untyped, ?enqueue: true | false | ^(Context) -> bool | Hash[Symbol, untyped], ?output: Hash[Symbol, String], ?depends_on: Array[Symbol], ?task_retry: Integer | Hash[Symbol, untyped], ?throttle: Integer | Hash[Symbol, untyped], ?timeout: Numeric?, ?dependency_wait: Hash[Symbol, untyped], ?dry_run: bool | ^(Context) -> bool) -> void
+
+    # :  () -> Symbol
+    def task_name: () -> Symbol
+
+    # :  () -> String
+    def throttle_prefix_key: () -> String
+
+    private
+
+    attr_reader name: Symbol
+  end
+end

data/sig/generated/job_workflow/task_callable.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/job_workflow/task_callable.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskCallable
+    class NotCalledError < StandardError
+      # :  (Symbol) -> void
+      def initialize: (Symbol) -> void
+    end
+
+    class AlreadyCalledError < StandardError
+      # :  () -> void
+      def initialize: () -> void
+    end
+
+    # :  () { () -> void } -> void
+    def initialize: () { () -> void } -> void
+
+    # :  () -> void
+    def call: () -> void
+
+    # :  () -> bool
+    def called?: () -> bool
+
+    private
+
+    attr_reader block: untyped
+
+    attr_accessor called: bool
+  end
+end

data/sig/generated/job_workflow/task_context.rbs

@@ -0,0 +1,52 @@
+# Generated from lib/job_workflow/task_context.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskContext
+    NULL_VALUE: nil
+
+    attr_reader task: Task?
+
+    attr_reader parent_job_id: String?
+
+    attr_reader index: Integer
+
+    attr_reader value: untyped
+
+    attr_reader retry_count: Integer
+
+    attr_reader dry_run: bool
+
+    # :  (Hash[String, untyped]) -> TaskContext
+    def self.deserialize: (Hash[String, untyped]) -> TaskContext
+
+    # :  (
+    #      ?task: Task?,
+    #      ?parent_job_id: String?,
+    #      ?index: Integer,
+    #      ?value: untyped,
+    #      ?retry_count: Integer,
+    #      ?dry_run: bool
+    #    ) -> void
+    def initialize: (?task: Task?, ?parent_job_id: String?, ?index: Integer, ?value: untyped, ?retry_count: Integer, ?dry_run: bool) -> void
+
+    # :  () -> bool
+    def enabled?: () -> bool
+
+    # :  () -> Hash[String, untyped]
+    def serialize: () -> Hash[String, untyped]
+
+    private
+
+    attr_writer task: Task?
+
+    attr_writer parent_job_id: String?
+
+    attr_writer index: Integer
+
+    attr_writer value: untyped
+
+    attr_writer retry_count: Integer
+
+    attr_writer dry_run: bool
+  end
+end

data/sig/generated/job_workflow/task_dependency_wait.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/job_workflow/task_dependency_wait.rb with RBS::Inline
+
+module JobWorkflow
+  # TaskDependencyWait holds configuration for waiting on dependent tasks.
+  #
+  # When a task has dependencies (depends_on:), the runner waits for those tasks to complete.
+  # This class configures how long to poll before rescheduling the job.
+  #
+  # @example Default behavior (polling only, no reschedule)
+  #   task :process, depends_on: [:fetch]
+  #
+  # @example Wait up to 30 seconds with polling, then reschedule
+  #   task :process, depends_on: [:fetch], dependency_wait: { poll_timeout: 30 }
+  #
+  # @example Wait 60 seconds total, poll every 10 seconds, reschedule after 5 seconds
+  #   task :process, depends_on: [:fetch], dependency_wait: { poll_timeout: 60, poll_interval: 10, reschedule_delay: 5 }
+  class TaskDependencyWait
+    DEFAULT_POLL_TIMEOUT: Integer
+
+    DEFAULT_POLL_INTERVAL: Integer
+
+    DEFAULT_RESCHEDULE_DELAY: Integer
+
+    attr_reader poll_timeout: Integer
+
+    attr_reader poll_interval: Integer
+
+    attr_reader reschedule_delay: Integer
+
+    # :  (Integer | Hash[Symbol, untyped] | nil) -> TaskDependencyWait
+    def self.from_primitive_value: (Integer | Hash[Symbol, untyped] | nil) -> TaskDependencyWait
+
+    # :  (?poll_timeout: Integer, ?poll_interval: Integer, ?reschedule_delay: Integer) -> void
+    def initialize: (?poll_timeout: Integer, ?poll_interval: Integer, ?reschedule_delay: Integer) -> void
+
+    # :  () -> bool
+    def polling_only?: () -> bool
+
+    # :  (Time) -> bool
+    def polling_keep?: (Time) -> bool
+  end
+end

data/sig/generated/job_workflow/task_enqueue.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/job_workflow/task_enqueue.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskEnqueue
+    attr_reader condition: true | false | ^(Context) -> bool
+
+    attr_reader queue: String?
+
+    attr_reader concurrency: Integer?
+
+    # :  (true | false | ^(Context) -> bool | Hash[Symbol, untyped] | nil) -> TaskEnqueue
+    def self.from_primitive_value: (true | false | ^(Context) -> bool | Hash[Symbol, untyped] | nil) -> TaskEnqueue
+
+    # :  (
+    #      ?condition: true | false | ^(Context) -> bool,
+    #      ?queue: String?,
+    #      ?concurrency: Integer?
+    #    ) -> void
+    def initialize: (?condition: true | false | ^(Context) -> bool, ?queue: String?, ?concurrency: Integer?) -> void
+
+    # :  (Context) -> bool
+    def should_enqueue?: (Context) -> bool
+
+    # :  () -> bool
+    def should_limits_concurrency?: () -> bool
+  end
+end

data/sig/generated/job_workflow/task_graph.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/job_workflow/task_graph.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskGraph
+    include TSort[Task]
+
+    include Enumerable[Task]
+
+    # :  () -> void
+    def initialize: () -> void
+
+    # :  (Task) -> void
+    def add: (Task) -> void
+
+    # :  (Symbol?) -> Task?
+    def fetch: (Symbol?) -> Task?
+
+    # :  () { (Task) -> void } -> void
+    def each: () { (Task) -> void } -> void
+
+    # :  () { (Task) -> void } -> void
+    def tsort_each_node: () { (Task) -> void } -> void
+
+    # :  (Task task) { (Task) -> void } -> void
+    def tsort_each_child: (Task task) { (Task) -> void } -> void
+  end
+end

data/sig/generated/job_workflow/task_job_status.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/job_workflow/task_job_status.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskJobStatus
+    attr_reader task_name: Symbol
+
+    attr_reader job_id: String
+
+    attr_reader each_index: Integer
+
+    attr_reader status: Symbol
+
+    # :  (Hash[Symbol, untyped]) -> TaskJobStatus
+    def self.from_hash: (Hash[Symbol, untyped]) -> TaskJobStatus
+
+    # :  (Hash[String, untyped]) -> TaskJobStatus
+    def self.deserialize: (Hash[String, untyped]) -> TaskJobStatus
+
+    # :  (
+    #       task_name: Symbol,
+    #       job_id: String,
+    #       each_index: Integer,
+    #       ?status: Symbol
+    #     ) -> void
+    def initialize: (task_name: Symbol, job_id: String, each_index: Integer, ?status: Symbol) -> void
+
+    # :  (Symbol) -> void
+    def update_status: (Symbol) -> void
+
+    # :  () -> bool
+    def finished?: () -> bool
+
+    # :  () -> bool
+    def succeeded?: () -> bool
+
+    # :  () -> bool
+    def failed?: () -> bool
+
+    # :  () -> Hash[String, untyped]
+    def serialize: () -> Hash[String, untyped]
+  end
+end

data/sig/generated/job_workflow/task_output.rbs

@@ -0,0 +1,29 @@
+# Generated from lib/job_workflow/task_output.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskOutput
+    attr_reader task_name: Symbol
+
+    attr_reader each_index: Integer
+
+    attr_reader data: Hash[Symbol, untyped]
+
+    # :  (task: Task, each_index: Integer, data: Hash[Symbol, untyped]) -> TaskOutput
+    def self.from_task: (task: Task, each_index: Integer, data: Hash[Symbol, untyped]) -> TaskOutput
+
+    # :  (Hash[String, untyped]) -> TaskOutput
+    def self.deserialize: (Hash[String, untyped]) -> TaskOutput
+
+    # :  (task_name: Symbol, each_index: Integer, ?data: Hash[Symbol, untyped]) -> void
+    def initialize: (task_name: Symbol, each_index: Integer, ?data: Hash[Symbol, untyped]) -> void
+
+    # :  () -> Hash[String, untyped]
+    def serialize: () -> Hash[String, untyped]
+
+    # :  ...
+    def method_missing: ...
+
+    # :  (Symbol, bool) -> bool
+    def respond_to_missing?: (Symbol, bool) -> bool
+  end
+end

data/sig/generated/job_workflow/task_retry.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/job_workflow/task_retry.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskRetry
+    attr_reader count: Integer
+
+    attr_reader strategy: Symbol
+
+    attr_reader base_delay: Integer
+
+    attr_reader jitter: bool
+
+    # :  (Integer | Hash[Symbol, untyped]) -> TaskRetry
+    def self.from_primitive_value: (Integer | Hash[Symbol, untyped]) -> TaskRetry
+
+    # :  (?count: Integer, ?strategy: Symbol, ?base_delay: Integer, ?jitter: bool) -> void
+    def initialize: (?count: Integer, ?strategy: Symbol, ?base_delay: Integer, ?jitter: bool) -> void
+
+    # :  (Integer) -> Float
+    def delay_for: (Integer) -> Float
+
+    private
+
+    # :  (Integer) -> Integer
+    def calculate_base_delay: (Integer) -> Integer
+
+    # :  (Integer) -> Float
+    def apply_jitter: (Integer) -> Float
+  end
+end

data/sig/generated/job_workflow/task_throttle.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/job_workflow/task_throttle.rb with RBS::Inline
+
+module JobWorkflow
+  class TaskThrottle
+    attr_reader key: String
+
+    attr_reader limit: Integer?
+
+    attr_reader ttl: Integer
+
+    # :  (value: Integer | Hash[Symbol, untyped], task: Task) -> TaskThrottle
+    def self.from_primitive_value_with_task: (value: Integer | Hash[Symbol, untyped], task: Task) -> TaskThrottle
+
+    # :  (key: String, ?limit: Integer?, ?ttl: Integer) -> void
+    def initialize: (key: String, ?limit: Integer?, ?ttl: Integer) -> void
+
+    # :  () -> Semaphore?
+    def semaphore: () -> Semaphore?
+  end
+end

data/sig/generated/job_workflow/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/job_workflow/version.rb with RBS::Inline
+
+module JobWorkflow
+  VERSION: ::String
+end

data/sig/generated/job_workflow/workflow.rbs

@@ -0,0 +1,48 @@
+# Generated from lib/job_workflow/workflow.rb with RBS::Inline
+
+module JobWorkflow
+  class Workflow
+    attr_reader namespace: Namespace
+
+    attr_reader dry_run_config: DryRunConfig
+
+    # :  () -> void
+    def initialize: () -> void
+
+    # :  (bool | ^(Context) -> bool) -> void
+    def dry_run_config=: (bool | ^(Context) -> bool) -> void
+
+    # :  (Namespace) { () -> void } -> void
+    def add_namespace: (Namespace) { () -> void } -> void
+
+    # :  (Task) -> void
+    def add_task: (Task) -> void
+
+    # :  (ArgumentDef) -> void
+    def add_argument: (ArgumentDef) -> void
+
+    # :  (Schedule) -> void
+    def add_schedule: (Schedule) -> void
+
+    # :  (Symbol, task_names: Array[Symbol], block: untyped) -> void
+    def add_hook: (Symbol, task_names: Array[Symbol], block: untyped) -> void
+
+    # :  () -> HookRegistry
+    def hooks: () -> HookRegistry
+
+    # :  () -> Array[Task]
+    def tasks: () -> Array[Task]
+
+    # :  (Symbol?) -> Task?
+    def fetch_task: (Symbol?) -> Task?
+
+    # :  () -> Array[ArgumentDef]
+    def arguments: () -> Array[ArgumentDef]
+
+    # :  () -> Hash[Symbol, Hash[Symbol, untyped]]
+    def build_schedules_hash: () -> Hash[Symbol, Hash[Symbol, untyped]]
+
+    # :  () -> Hash[Symbol, untyped]
+    def build_arguments_hash: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/generated/job_workflow/workflow_status.rbs

@@ -0,0 +1,55 @@
+# Generated from lib/job_workflow/workflow_status.rb with RBS::Inline
+
+module JobWorkflow
+  class WorkflowStatus
+    class NotFoundError < StandardError
+    end
+
+    type status_type = :pending | :running | :completed | :failed
+
+    attr_reader context: Context
+
+    attr_reader job_class_name: String
+
+    attr_reader status: status_type
+
+    # :  (String) -> WorkflowStatus
+    def self.find: (String) -> WorkflowStatus
+
+    # :  (job_id: String) -> WorkflowStatus?
+    def self.find_by: (job_id: String) -> WorkflowStatus?
+
+    # :  (Hash[String, untyped]) -> WorkflowStatus
+    def self.from_job_data: (Hash[String, untyped]) -> WorkflowStatus
+
+    # :  (context: Context, job_class_name: String, status: status_type) -> void
+    def initialize: (context: Context, job_class_name: String, status: status_type) -> void
+
+    # :  () -> Symbol?
+    def current_task_name: () -> Symbol?
+
+    # :  () -> Arguments
+    def arguments: () -> Arguments
+
+    # :  () -> Output
+    def output: () -> Output
+
+    # :  () -> JobStatus
+    def job_status: () -> JobStatus
+
+    # :  () -> bool
+    def running?: () -> bool
+
+    # :  () -> bool
+    def completed?: () -> bool
+
+    # :  () -> bool
+    def failed?: () -> bool
+
+    # :  () -> bool
+    def pending?: () -> bool
+
+    # :  () -> Hash[Symbol, untyped]
+    def to_h: () -> Hash[Symbol, untyped]
+  end
+end

data/sig/generated/job_workflow.rbs

@@ -0,0 +1,8 @@
+# Generated from lib/job_workflow.rb with RBS::Inline
+
+module JobWorkflow
+  class Error < StandardError
+  end
+
+  extend Logger
+end

data/sig-private/activejob.rbs

@@ -0,0 +1,35 @@
+module ActiveJob
+  def self.perform_all_later: (*ActiveJob::Base) -> void
+
+  module Continuable
+    def step: (Symbol, ?start: ActiveJob::Continuation::_Succ, ?isolated: bool) -> void
+            | (Symbol, ?start: ActiveJob::Continuation::_Succ, ?isolated: bool) { (ActiveJob::Continuation::Step) -> void } -> void
+  end
+
+  module Continuation
+    class Interrupt < StandardError
+    end
+
+    interface _Succ
+      def succ: () -> self
+    end
+
+    class Step
+      def advance!: (?from: _Succ?) -> void
+
+      def advanced?: () -> bool
+
+      def checkpoint!: () -> void
+
+      def description: () -> String
+
+      def initialize: (Symbol, _Succ, job: ActiveJob::Base, resumed: bool) -> void
+
+      def resumed?: () -> bool
+
+      def set!: (_Succ) -> void
+
+      def to_a: () -> [String, _Succ]
+    end
+  end
+end

data/sig-private/activesupport.rbs

@@ -0,0 +1,23 @@
+module ActiveSupport
+  module Notifications
+    # Interface for start/finish subscribers (Monotonic subscriber)
+    interface _StartFinishSubscriber
+      def start: (String, String, Hash[Symbol, untyped]) -> void
+      def finish: (String, String, Hash[Symbol, untyped]) -> void
+    end
+
+    # Allow start/finish subscriber objects
+    def self.subscribe: (String | Regexp, _StartFinishSubscriber) -> Subscriber
+                      | ...
+
+    # Allow instrument with a no-arg block
+    def self.instrument: (String name, ?Hash[untyped, untyped] payload) ?{ () -> untyped } -> untyped
+                       | ...
+  end
+
+  module Cache
+    # SolidCacheStore is an optional cache store provided by the solid_cache gem
+    class SolidCacheStore < Store
+    end
+  end
+end

data/sig-private/aws.rbs

@@ -0,0 +1,32 @@
+module Aws
+  module ECS
+    class Client
+      def describe_services: (Hash[untyped, untyped]) -> Types::DescribeServicesResponse
+      def describe_tasks: (Hash[untyped, untyped]) -> Types::DescribeTasksResponse
+      def update_service: (Hash[untyped, untyped]) -> Types::UpdateServiceResponse
+    end
+
+    module Types
+      class Task
+        def group: () -> String
+      end
+
+      class Service
+        def cluster_arn: () -> String
+        def service_name: () -> String
+        def desired_count: () -> Integer
+      end
+
+      class DescribeTasksResponse
+        def tasks: () -> Array[Task]
+      end
+
+      class DescribeServicesResponse
+        def services: () -> Array[Service]
+      end
+
+      class UpdateServiceResponse
+      end
+    end
+  end
+end