que-scheduler 8.0.0 → 9.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77e19a08d2c15c1f6c40f0c3b924f5f72316fcf9827e3f99bcfff7a0df759b71
-  data.tar.gz: 7be4dbc6187cbbe530540bc64e2f4051f12cb0fc23ca4f69275dfd70d966e828
+  metadata.gz: 43c9761073fc43892c380b61ea7aeadb456c19b1f3d992eca44f93b7ec41c757
+  data.tar.gz: e7897e20ca62c7183f6db25289dc1781e825193238b1a0687eabe2ced6a3dcf5
 SHA512:
-  metadata.gz: be271ad6ca3d25ddf106352a44933cb1400381c006d1e7c15b1467093adec05f78e57beaf2eb51cba197ccf30b800561d74eb27d7dee367eb9af2106197c129c
-  data.tar.gz: abedfcada9b8fc855542844b2c5325a3d518523176d4070e8e912036934d6118d65e7627cf0c29cada59ca68c3f35eb9705872525a4d349ff7cdd460ba343084
+  metadata.gz: 3f5b2b777d5e52aff1d6422a84569b048db2b544e7b17457f1c413e5caa11d0505e90540a75264cd2fdecbdeb621a3f326f1591e5ff355169ecb1eba6b867d9d
+  data.tar.gz: 4b6ddb6b440fb761cecb48cdc815ecde9b1963535d2eb919b2f630ba899f54d6c21ace7c37a93258faa85c41f02164a0e52e1f8f5727a81e4148485b92811133

data/lib/que/scheduler/audit.rb

@@ -32,7 +32,7 @@ module Que
           params(
             scheduler_job_id: Integer,
             executed_at: Types::TIME,
-            enqueued_jobs: T::Array[Que::Scheduler::EnqueuedJobType]
+            enqueued_jobs: T::Array[Que::Scheduler::EnqueuedJob]
           ).void
         end
         def append(scheduler_job_id, executed_at, enqueued_jobs)
@@ -40,10 +40,11 @@ module Que
           enqueued_jobs.each do |j|
             inserted = ::Que::Scheduler::DbSupport.execute(
               INSERT_AUDIT_ENQUEUED,
-              [scheduler_job_id] +
-                j.values_at(:job_class, :queue, :priority, :args, :job_id, :run_at)
+              [scheduler_job_id, j.job_class, j.queue, j.priority, j.args, j.job_id, j.run_at]
             )
-            raise "Cannot save audit row #{scheduler_job_id} #{executed_at} #{j}" if inserted.empty?
+            next unless inserted.empty?
+
+            raise "Cannot save audit row #{scheduler_job_id} #{executed_at} #{j.inspect}"
           end
         end
       end

data/lib/que/scheduler/db_support.rb

@@ -31,17 +31,12 @@ module Que
           params(
             clazz: T.class_of(Que::Job),
             job_options: T::Hash[Symbol, T.anything],
-            job_args: T.anything
+            job_args: T::Array[T.anything]
           ).returns(T.nilable(T.any(Que::Job, FalseClass)))
         end
         def enqueue_a_job(clazz, job_options = {}, job_args = [])
-          case job_args
-          when Hash
-            clazz.enqueue(job_args, job_options: job_options)
-          else
-            # Sorbet cannot type a splat of a value of unknown size
-            T.unsafe(clazz).enqueue(*job_args, job_options: job_options)
-          end
+          # Sorbet cannot type a splat of an array of unknown size
+          T.unsafe(clazz).enqueue(*job_args, job_options: job_options)
         end
 
         sig { returns(String) }

data/lib/que/scheduler/defined_job.rb

@@ -1,39 +1,25 @@
 # typed: true
 
-require "hashie"
 require "sorbet-runtime"
 require "fugit"
+require_relative "schedule_type"
+require_relative "to_enqueue"
 require_relative "types"
 
 # This is the definition of one scheduleable job in the que-scheduler config yml file.
 module Que
   module Scheduler
-    class DefinedJob < Hashie::Dash
-      include Hashie::Extensions::Dash::PropertyTranslation
+    class DefinedJob < T::Struct
       extend T::Sig
 
-      DEFINED_JOB_TYPES = [
-        DEFINED_JOB_TYPE_DEFAULT = :default,
-        DEFINED_JOB_TYPE_EVERY_EVENT = :every_event,
-      ].freeze
-
-      property :name
-      property :job_class, transform_with: ->(v) { Object.const_get(v) }
-      property :cron, transform_with: ->(v) { Fugit::Cron.parse(v) }
-      property :queue
-      property :priority
-      property :args_array
-      property :schedule_type, default: DEFINED_JOB_TYPE_DEFAULT
-
-      class << self
-        extend T::Sig
-
-        sig { params(options: T::Hash[Symbol, T.anything]).returns(DefinedJob) }
-        def create(options)
-          defined_job = new(options.compact)
-          defined_job.freeze.tap { |dj| dj.validate(options) }
-        end
-      end
+      const :name, String
+      const :job_class, Class
+      const :cron, Fugit::Cron
+      # nil means use the job class's own queue and priority
+      const :queue, T.nilable(String)
+      const :priority, T.nilable(Integer)
+      const :args_array, T::Array[T.anything], default: []
+      const :schedule_type, ScheduleType, default: ScheduleType::DEFAULT
 
       # Given a "last time", return the next Time the event will occur, or nil if it
       # is after "to".
@@ -58,67 +44,24 @@ module Que
         generate_to_enqueue_list(missed_times)
       end
 
-      sig { params(options: T::Hash[Symbol, T.anything]).void }
-      def validate(options)
-        validate_fields_presence(options)
-        validate_fields_types(options)
-        validate_job_class_related(options)
-      end
-
-      # rubocop:disable Style/GuardClause -- This reads better as a conditional
-      sig { params(options: T::Hash[Symbol, T.anything]).void }
-      private def validate_fields_types(options)
-        unless queue.nil? || queue.is_a?(String)
-          err_field(:queue, options, "queue must be a string")
-        end
-        unless priority.nil? || priority.is_a?(Integer)
-          err_field(:priority, options, "priority must be an integer")
-        end
-        unless DEFINED_JOB_TYPES.include?(schedule_type)
-          err_field(:schedule_type, options, "Not in #{DEFINED_JOB_TYPES}")
-        end
-      end
-      # rubocop:enable Style/GuardClause
-
-      sig { params(options: T::Hash[Symbol, T.anything]).void }
-      private def validate_fields_presence(options)
-        err_field(:name, options, "name must be present") if name.nil?
-        err_field(:job_class, options, "job_class must be present") if job_class.nil?
-        # An invalid cron is nil
-        err_field(:cron, options, "cron must be present") if cron.nil?
-      end
-
-      sig { params(options: T::Hash[Symbol, T.anything]).void }
-      private def validate_job_class_related(options)
-        # Only support known job engines
-        return if Que::Scheduler::ToEnqueue.valid_job_class?(job_class)
-
-        err_field(:job_class, options, "Job #{job_class} was not a supported job type")
-      end
-
-      sig { params(field: Symbol, options: T::Hash[Symbol, T.anything], reason: String).returns(T.noreturn) }
-      private def err_field(field, options, reason = "")
-        schedule = Que::Scheduler.configuration.schedule_location
-        value = options[field]
-        raise "Invalid #{field} '#{value}' for '#{name}' in que-scheduler schedule #{schedule}.\n" \
-              "#{reason}"
-      end
-
       sig { params(missed_times: T::Array[ActiveSupport::TimeWithZone]).returns(T::Array[ToEnqueue]) }
       private def generate_to_enqueue_list(missed_times)
-        return [] if missed_times.empty?
-
-        options = to_h.slice(:args, :queue, :priority, :job_class).compact
+        last_missed_time = missed_times.last
+        return [] if last_missed_time.nil?
 
-        if schedule_type == DefinedJob::DEFINED_JOB_TYPE_EVERY_EVENT
-          missed_times.map do |time_missed|
-            ToEnqueue.create(options.merge(run_at: time_missed,
-                                           args: [time_missed.iso8601] + args_array))
-          end
+        if schedule_type == ScheduleType::EVERY_EVENT
+          missed_times.map { to_enqueue(it, [it.iso8601] + args_array) }
         else
-          [ToEnqueue.create(options.merge(run_at: missed_times.last, args: args_array))]
+          [to_enqueue(last_missed_time, args_array)]
         end
       end
+
+      sig { params(run_at: ActiveSupport::TimeWithZone, args: T::Array[T.anything]).returns(ToEnqueue) }
+      private def to_enqueue(run_at, args)
+        ToEnqueue.new(
+          job_class: job_class, args: args, queue: queue, priority: priority, run_at: run_at
+        )
+      end
     end
   end
 end

data/lib/que/scheduler/defined_job_parser.rb

@@ -0,0 +1,96 @@
+# typed: true
+
+require "fugit"
+require "sorbet-runtime"
+require_relative "defined_job"
+require_relative "job_adapters"
+require_relative "schedule_type"
+
+# Turns one job's entry in the schedule config into a validated DefinedJob.
+module Que
+  module Scheduler
+    module DefinedJobParser
+      # One job's entry in the schedule, with string keys
+      CONFIG = T.type_alias { T::Hash[String, Object] }
+
+      class << self
+        extend T::Sig
+
+        sig { params(name: String, config: CONFIG).returns(DefinedJob) }
+        def parse(name, config)
+          DefinedJob.new(
+            name: name,
+            job_class: parse_job_class(name, config),
+            cron: parse_cron(name, config),
+            queue: parse_queue(name, config),
+            priority: parse_priority(name, config),
+            args_array: parse_args(config),
+            schedule_type: parse_schedule_type(name, config)
+          )
+        end
+
+        sig { params(name: String, config: CONFIG).returns(Class) }
+        private def parse_job_class(name, config)
+          class_name = String(config.fetch("class", name))
+          job_class = Object.const_get(class_name)
+          return job_class if job_class.is_a?(Class) && JobAdapters.supports?(job_class)
+
+          reason = "Job #{class_name} was not a supported job type"
+          raise_invalid(name, :job_class, class_name, reason)
+        end
+
+        sig { params(name: String, config: CONFIG).returns(Fugit::Cron) }
+        private def parse_cron(name, config)
+          value = config["cron"]
+          # An invalid cron parses to nil
+          Fugit::Cron.parse(value) || raise_invalid(name, :cron, value, "cron must be present")
+        end
+
+        sig { params(name: String, config: CONFIG).returns(T.nilable(String)) }
+        private def parse_queue(name, config)
+          value = config["queue"]
+          return value if value.nil? || value.is_a?(String)
+
+          raise_invalid(name, :queue, value, "queue must be a string")
+        end
+
+        sig { params(name: String, config: CONFIG).returns(T.nilable(Integer)) }
+        private def parse_priority(name, config)
+          value = config["priority"]
+          return value if value.nil? || value.is_a?(Integer)
+
+          raise_invalid(name, :priority, value, "priority must be an integer")
+        end
+
+        # Que stores args as a json array. A single value (including a hash or nil) becomes an
+        # array of that one value.
+        sig { params(config: CONFIG).returns(T::Array[T.anything]) }
+        private def parse_args(config)
+          return [] unless config.key?("args")
+
+          args = config["args"]
+          args.is_a?(Array) ? args : [args]
+        end
+
+        sig { params(name: String, config: CONFIG).returns(ScheduleType) }
+        private def parse_schedule_type(name, config)
+          value = config["schedule_type"]
+          return ScheduleType::DEFAULT if value.nil?
+
+          reason = "Not in #{ScheduleType.values.map(&:serialize)}"
+          ScheduleType.try_deserialize(String(value)) ||
+            raise_invalid(name, :schedule_type, value, reason)
+        end
+
+        sig do
+          params(name: String, field: Symbol, value: T.anything, reason: String).returns(T.noreturn)
+        end
+        private def raise_invalid(name, field, value, reason)
+          location = Que::Scheduler.configuration.schedule_location
+          raise "Invalid #{field} '#{value}' for '#{name}' " \
+                "in que-scheduler schedule #{location}.\n#{reason}"
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/enqueueing_calculator.rb

@@ -2,13 +2,16 @@
 
 require "fugit"
 require "sorbet-runtime"
+require_relative "defined_job"
+require_relative "scheduler_job_args"
+require_relative "to_enqueue"
 
 module Que
   module Scheduler
     module EnqueueingCalculator
-      class Result < Hashie::Dash
-        property :missed_jobs, required: true
-        property :job_dictionary, required: true
+      class Result < T::Struct
+        const :missed_jobs, T::Array[ToEnqueue]
+        const :job_dictionary, T::Array[String]
       end
 
       class << self
@@ -21,22 +24,22 @@ module Que
           ).returns(Result)
         end
         def parse(scheduler_config, scheduler_job_args)
-          job_dictionary = []
+          job_dictionary = T.let([], T::Array[String])
 
           # For each scheduled item:
           # 1) If never seen before, schedule nothing, but add to known list
           # 2) If seen before, calculate what (if anything) needs to be enqueued.
-          missed_jobs = scheduler_config.map do |desc|
+          missed_jobs = scheduler_config.flat_map do |desc|
             job_name = desc.name
             job_dictionary << job_name
 
             # If we have never seen this job before, we don't want to scheduled any jobs for it.
             # But we have added it to the dictionary, so it will be used to enqueue jobs next time.
-            next unless scheduler_job_args.job_dictionary.include?(job_name)
+            next [] unless scheduler_job_args.job_dictionary.include?(job_name)
 
             # This has been seen before. We should check if we have missed any executions.
             desc.calculate_missed_runs(scheduler_job_args.last_run_time, scheduler_job_args.as_time)
-          end.flatten.compact
+          end
 
           Result.new(missed_jobs: missed_jobs, job_dictionary: job_dictionary)
         end

data/lib/que/scheduler/job_adapters.rb

@@ -0,0 +1,122 @@
+# typed: true
+
+require "json"
+require "que"
+require "sorbet-runtime"
+require_relative "db_support"
+require_relative "time_zone"
+
+# Centralises the differences between enqueueing a Que::Job and an ActiveJob.
+module Que
+  module Scheduler
+    module JobAdapter
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(to_enqueue: ToEnqueue).returns(T.nilable(EnqueuedJob)) }
+      def enqueue(to_enqueue); end
+    end
+
+    class QueAdapter
+      extend T::Sig
+      include JobAdapter
+
+      sig { override.params(to_enqueue: ToEnqueue).returns(T.nilable(EnqueuedJob)) }
+      def enqueue(to_enqueue)
+        job_options = {
+          queue: to_enqueue.queue,
+          priority: to_enqueue.priority,
+          run_at: to_enqueue.run_at,
+        }.compact
+        job = DbSupport.enqueue_a_job(
+          T.cast(to_enqueue.job_class, T.class_of(Que::Job)), job_options, to_enqueue.args
+        )
+        read_back(job) if job
+      end
+
+      # Read the job back to get the values that will be used when it is worked
+      sig { params(job: Que::Job).returns(EnqueuedJob) }
+      private def read_back(job)
+        attrs = DbSupport.job_attributes(job)
+        EnqueuedJob.new(
+          job_class: T.cast(attrs.fetch(:job_class), String),
+          args: T.cast(attrs.fetch(:args), T::Array[T.anything]),
+          queue: T.cast(attrs.fetch(:queue), String),
+          priority: T.cast(attrs.fetch(:priority), Integer),
+          run_at: T.cast(attrs.fetch(:run_at), Time),
+          job_id: DbSupport.job_id(job)
+        )
+      end
+    end
+
+    class ActiveJobAdapter
+      extend T::Sig
+      include JobAdapter
+
+      # Que's column default, which ActiveJob does not let us read back. t.ly/1jRK5
+      QUE_DEFAULT_PRIORITY = 100
+
+      sig { override.params(to_enqueue: ToEnqueue).returns(T.nilable(EnqueuedJob)) }
+      def enqueue(to_enqueue)
+        job_class = T.cast(to_enqueue.job_class, T.class_of(::ActiveJob::Base))
+        job_settings = {
+          priority: to_enqueue.priority,
+          wait_until: to_enqueue.run_at,
+          queue: to_enqueue.queue || Que::DEFAULT_QUEUE,
+        }.compact
+        # Sorbet cannot type a splat of an array of unknown size
+        job = T.unsafe(job_class.set(**job_settings)).perform_later(*to_enqueue.args)
+        read_back(job, to_enqueue) if job
+      end
+
+      sig { params(job: ::ActiveJob::Base, to_enqueue: ToEnqueue).returns(EnqueuedJob) }
+      private def read_back(job, to_enqueue)
+        data = JSON.parse(job.to_json, symbolize_names: true)
+        EnqueuedJob.new(
+          job_class: to_enqueue.job_class.to_s,
+          args: data.fetch(:arguments),
+          queue: data.fetch(:queue_name),
+          # The enqueued job does not expose its priority, so assume it is what we asked for
+          priority: to_enqueue.priority || QUE_DEFAULT_PRIORITY,
+          run_at: self.class.extract_scheduled_at(data.fetch(:scheduled_at)),
+          job_id: data.fetch(:provider_job_id)
+        )
+      end
+
+      # ActiveJob serialises scheduled_at as an ISO 8601 string; we want a Time
+      sig { params(scheduled_at: String).returns(ActiveSupport::TimeWithZone) }
+      def self.extract_scheduled_at(scheduled_at)
+        T.must(Que::Scheduler::TimeZone.time_zone.parse(scheduled_at))
+      end
+    end
+
+    module JobAdapters
+      QUE_ADAPTER = QueAdapter.new
+      ACTIVE_JOB_ADAPTER = ActiveJobAdapter.new
+
+      class << self
+        extend T::Sig
+
+        sig { returns(T::Boolean) }
+        def active_job_defined? = Object.const_defined?(:ActiveJob)
+
+        sig { params(job_class: Class).returns(T::Boolean) }
+        def supports?(job_class) = !!find(job_class)
+
+        sig { params(job_class: Class).returns(JobAdapter) }
+        def adapter_for(job_class) = T.must(find(job_class))
+
+        sig { params(job_class: Class).returns(T.nilable(JobAdapter)) }
+        private def find(job_class)
+          if job_class < ::Que::Job
+            QUE_ADAPTER
+          elsif active_job_defined? && job_class < ::ActiveJob::Base
+            ACTIVE_JOB_ADAPTER
+          end
+        end
+      end
+    end
+  end
+end

data/lib/que/scheduler/schedule.rb

@@ -3,6 +3,7 @@
 require "sorbet-runtime"
 require_relative "configuration"
 require_relative "defined_job"
+require_relative "defined_job_parser"
 require_relative "types"
 
 module Que
@@ -55,40 +56,11 @@ module Que
         sig do
           params(
             name: String,
-            defined_job_hash_in: T::Hash[T.any(String, Symbol), T.anything]
+            defined_job_hash_in: T::Hash[T.any(String, Symbol), Object]
           ).returns(DefinedJob)
         end
         def hash_item_to_defined_job(name, defined_job_hash_in)
-          defined_job_hash = defined_job_hash_in.stringify_keys
-          # Que stores arguments as a json array. If the args we have to provide are already an
-          # array we can can simply pass them through. If it is a single non-nil value, then we make
-          # an array with one item which is that value (this includes if it is a hash). It could
-          # also be a single nil value.
-          args_array =
-            if defined_job_hash.key?("args")
-              args = defined_job_hash["args"]
-              if args.is_a?(Array)
-                # An array of args was requested
-                args
-              else
-                # A single value, a nil, or a hash was requested. que expects this to
-                # be enqueued as an array of 1 item
-                [args]
-              end
-            else
-              # No args were requested
-              []
-            end
-
-          Que::Scheduler::DefinedJob.create(
-            name: name,
-            job_class: defined_job_hash["class"]&.to_s || name,
-            queue: defined_job_hash["queue"],
-            args_array: args_array,
-            priority: defined_job_hash["priority"],
-            cron: defined_job_hash["cron"],
-            schedule_type: defined_job_hash["schedule_type"]&.to_sym
-          )
+          DefinedJobParser.parse(name, defined_job_hash_in.stringify_keys)
         end
       end
     end

data/lib/que/scheduler/schedule_type.rb

@@ -0,0 +1,17 @@
+# typed: true
+
+require "sorbet-runtime"
+
+module Que
+  module Scheduler
+    # How a job catches up on runs missed while the scheduler was not running.
+    class ScheduleType < T::Enum
+      enums do
+        # Enqueue only the most recent missed run
+        DEFAULT = new("default")
+        # Enqueue every missed run, passing each its scheduled time as the first arg
+        EVERY_EVENT = new("every_event")
+      end
+    end
+  end
+end

data/lib/que/scheduler/scheduler_job.rb

@@ -30,7 +30,7 @@ module Que
       self.maximum_retry_count = 1 << 128 # Heat death of universe
       self.retry_interval = RETRY_PROC
 
-      sig { params(options: T.nilable(T::Hash[T.any(String, Symbol), T.anything])).void }
+      sig { params(options: T.nilable(T::Hash[T.any(String, Symbol), Object])).void }
       def run(options = nil)
         Que::Scheduler::Db.transaction do
           Que::Scheduler::StateChecks.check
@@ -53,7 +53,7 @@ module Que
         params(
           calculator_result: EnqueueingCalculator::Result,
           logs: T::Array[String]
-        ).returns(T::Array[EnqueuedJobType])
+        ).returns(T::Array[EnqueuedJob])
       end
       def enqueue_required_jobs(calculator_result, logs)
         calculator_result.missed_jobs.filter_map do |to_enqueue|
@@ -66,7 +66,7 @@ module Que
       sig do
         params(
           to_enqueue: ToEnqueue,
-          enqueued_job: T.nilable(EnqueuedJobType),
+          enqueued_job: T.nilable(EnqueuedJob),
           logs: T::Array[String]
         ).void
       end
@@ -86,7 +86,7 @@ module Que
           scheduler_job_args: SchedulerJobArgs,
           last_full_execution: Types::TIME,
           job_dictionary: T::Array[String],
-          enqueued_jobs: T::Array[EnqueuedJobType]
+          enqueued_jobs: T::Array[EnqueuedJob]
         ).void
       end
       private def enqueue_self_again(scheduler_job_args, last_full_execution, job_dictionary,
@@ -103,17 +103,12 @@ module Que
             queue: Que::Scheduler.configuration.que_scheduler_queue,
             run_at: next_run_at,
           },
-          {
-            last_run_time: last_full_execution.iso8601,
-            job_dictionary: job_dictionary,
-          }
+          [{ last_run_time: last_full_execution.iso8601, job_dictionary: job_dictionary }]
         )
 
-        # rubocop:disable Style/GuardClause -- This reads better as a conditional
-        unless enqueued_job && DbSupport.job_attributes(enqueued_job).fetch(:job_id)
-          raise "SchedulerJob could not self-schedule. Has `.enqueue` been monkey patched?"
-        end
-        # rubocop:enable Style/GuardClause
+        return if enqueued_job
+
+        raise "SchedulerJob could not self-schedule. Has `.enqueue` been monkey patched?"
       end
     end
   end

data/lib/que/scheduler/scheduler_job_args.rb

@@ -1,39 +1,33 @@
 # typed: true
 
-require "hashie"
 require "sorbet-runtime"
 require "active_support"
 require "active_support/time_with_zone"
+require_relative "types"
 
 # These are the args that are used for this particular run of the scheduler.
 module Que
   module Scheduler
-    class SchedulerJobArgs < Hashie::Dash
-      property :last_run_time, required: true
-      property :job_dictionary, required: true
-      property :as_time, required: true
-
+    class SchedulerJobArgs < T::Struct
       extend T::Sig
 
-      sig { params(options: T.nilable(T::Hash[T.any(String, Symbol), T.anything])).returns(SchedulerJobArgs) }
+      const :last_run_time, Types::TIME
+      const :job_dictionary, T::Array[String]
+      const :as_time, Types::TIME
+
+      sig { params(options: T.nilable(T::Hash[T.any(String, Symbol), Object])).returns(SchedulerJobArgs) }
       def self.build(options)
         now = Que::Scheduler::Db.now
-        parsed =
-          if options.nil?
-            # First ever run, there is nothing to do but reschedule self to run on the next minute.
-            {
-              last_run_time: now,
-              job_dictionary: [],
-            }
-          else
-            options = options.symbolize_keys
-            {
-              last_run_time:
-                Que::Scheduler::TimeZone.time_zone.parse(options.fetch(:last_run_time)),
-              job_dictionary: options.fetch(:job_dictionary),
-            }
-          end
-        SchedulerJobArgs.new(parsed.merge(as_time: now))
+        # First ever run, there is nothing to do but reschedule self to run on the next minute.
+        return new(last_run_time: now, job_dictionary: [], as_time: now) if options.nil?
+
+        options = options.symbolize_keys
+        last_run_time = String(options.fetch(:last_run_time))
+        new(
+          last_run_time: T.must(Que::Scheduler::TimeZone.time_zone.parse(last_run_time)),
+          job_dictionary: T.cast(options.fetch(:job_dictionary), T::Array[String]),
+          as_time: now
+        )
       end
     end
   end

data/lib/que/scheduler/to_enqueue.rb

@@ -1,166 +1,34 @@
 # typed: true
 
-require "que"
 require "sorbet-runtime"
+require_relative "job_adapters"
+require_relative "types"
 
-# This module uses polymorphic dispatch to centralise the differences between supporting Que::Job
-# and other job systems.
 module Que
   module Scheduler
-    class ToEnqueue < Hashie::Dash
+    # A job the scheduler has decided to enqueue.
+    class ToEnqueue < T::Struct
       extend T::Sig
-      extend T::Helpers
 
-      abstract!
+      const :job_class, Class
+      const :args, T::Array[T.anything], default: []
+      # nil means use the job class's own queue and priority
+      const :queue, T.nilable(String)
+      const :priority, T.nilable(Integer)
+      const :run_at, Types::TIME
 
-      property :args, required: true, default: []
-      property :queue
-      property :priority
-      property :run_at, required: true
-      property :job_class, required: true
-
-      sig { abstract.returns(T.nilable(EnqueuedJobType)) }
-      def enqueue; end
-
-      class << self
-        extend T::Sig
-
-        sig { params(options: T::Hash[Symbol, T.anything]).returns(ToEnqueue) }
-        def create(options)
-          T.must(type_from_job_class(T.cast(options.fetch(:job_class), Class))).new(
-            options.merge(run_at: options.fetch(:run_at) { Que::Scheduler::Db.now })
-          )
-        end
-
-        sig { params(job_class: Class).returns(T::Boolean) }
-        def valid_job_class?(job_class)
-          type_from_job_class(job_class).present?
-        end
-
-        sig { returns(T::Boolean) }
-        def active_job_defined?
-          Object.const_defined?(:ActiveJob)
-        end
-
-        sig { params(job_class: Class).returns(T.nilable(T.class_of(ToEnqueue))) }
-        private def type_from_job_class(job_class)
-          types.each do |type, implementation|
-            return implementation if job_class < type
-          end
-          nil
-        end
-
-        sig { returns(T::Hash[Class, T.class_of(ToEnqueue)]) }
-        private def types
-          @types ||=
-            begin
-              hash = {
-                ::Que::Job => QueJobType,
-              }
-              hash[::ActiveJob::Base] = ActiveJobType if ToEnqueue.active_job_defined?
-              hash
-            end
-        end
-      end
-    end
-
-    # For jobs of type Que::Job
-    class QueJobType < ToEnqueue
-      sig { override.returns(T.nilable(EnqueuedJobType)) }
-      def enqueue
-        job_settings = to_h.slice(:queue, :priority, :run_at).compact
-        job = Que::Scheduler::DbSupport.enqueue_a_job(
-          T.cast(job_class, T.class_of(Que::Job)),
-          job_settings,
-          args
-        )
-
-        return nil if job.nil? || !job
-
-        # Now read the just inserted job back out of the DB to get the actual values that will
-        # be used when the job is worked.
-        values = Que::Scheduler::DbSupport.job_attributes(job).slice(
-          :args, :queue, :priority, :run_at, :job_class, :job_id
-        )
-        EnqueuedJobType.new(values)
-      end
-    end
-
-    # For jobs of type ActiveJob
-    class ActiveJobType < ToEnqueue
-      sig { override.returns(T.nilable(EnqueuedJobType)) }
-      def enqueue
-        job = enqueue_active_job
-
-        return nil if job.nil? || !job
-
-        enqueued_values = calculate_enqueued_values(job)
-        EnqueuedJobType.new(enqueued_values)
-      end
-
-      sig { params(job: ::ActiveJob::Base).returns(T::Hash[Symbol, T.anything]) }
-      def calculate_enqueued_values(job)
-        # Now read the just inserted job back out of the DB to get the actual values that will
-        # be used when the job is worked.
-        data = JSON.parse(job.to_json, symbolize_names: true)
-
-        scheduled_at = self.class.extract_scheduled_at(data[:scheduled_at])
-
-        # We can't get the priority out of the DB, as the returned `job` doesn't give us access
-        # to the underlying ActiveJob that was scheduled. We have no option but to assume
-        # it was what we told it to use. If no priority was specified, we must assume it was
-        # the Que default, which is 100 t.ly/1jRK5
-        assume_used_priority = priority.nil? ? 100 : priority
-
-        {
-          args: data.fetch(:arguments),
-          queue: data[:queue_name],
-          priority: assume_used_priority,
-          run_at: scheduled_at,
-          job_class: job_class.to_s,
-          job_id: data.fetch(:provider_job_id),
-        }
-      end
-
-      sig { returns(T.nilable(T.any(::ActiveJob::Base, FalseClass))) }
-      def enqueue_active_job
-        job_settings = {
-          priority: priority,
-          wait_until: run_at,
-          queue: queue || Que::DEFAULT_QUEUE,
-        }.compact
-
-        job_class_set = T.cast(job_class, T.class_of(::ActiveJob::Base)).set(**job_settings)
-        job_args = args
-        case job_args
-        when Hash
-          job_class_set.perform_later(**job_args)
-        else
-          # Sorbet cannot type a splat of a value of unknown size
-          T.unsafe(job_class_set).perform_later(*job_args)
-        end
-      end
-
-      class << self
-        extend T::Sig
-
-        # ActiveJob serialises scheduled_at as an ISO 8601 string; we want a Time
-        sig { params(scheduled_at: T.nilable(String)).returns(T.nilable(ActiveSupport::TimeWithZone)) }
-        def extract_scheduled_at(scheduled_at)
-          scheduled_at && Que::Scheduler::TimeZone.time_zone.parse(scheduled_at)
-        end
-      end
+      sig { returns(T.nilable(EnqueuedJob)) }
+      def enqueue = JobAdapters.adapter_for(job_class).enqueue(self)
     end
 
-    # A value object returned after a job has been enqueued. This is necessary as Que (normal) and
-    # ActiveJob return very different objects from the `enqueue` call.
-    class EnqueuedJobType < Hashie::Dash
-      property :args
-      property :queue
-      property :priority
-      property :run_at, required: true
-      property :job_class, required: true
-      property :job_id, required: true
+    # A job as it was actually enqueued, read back after the enqueue.
+    class EnqueuedJob < T::Struct
+      const :job_class, String
+      const :args, T::Array[T.anything]
+      const :queue, String
+      const :priority, Integer
+      const :run_at, Types::TIME
+      const :job_id, Integer
     end
   end
 end

data/lib/que/scheduler/types.rb

@@ -11,7 +11,7 @@ module Que
       TIME = T.type_alias { T.any(Time, ActiveSupport::TimeWithZone) }
       # A schedule as given in config: job name to its options
       SCHEDULE_CONFIG = T.type_alias do
-        T::Hash[T.any(String, Symbol), T::Hash[T.any(String, Symbol), T.anything]]
+        T::Hash[T.any(String, Symbol), T::Hash[T.any(String, Symbol), Object]]
       end
     end
   end

data/lib/que/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Que
   module Scheduler
-    VERSION = "8.0.0".freeze
+    VERSION = "9.0.0".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: que-scheduler
 version: !ruby/object:Gem::Version
-  version: 8.0.0
+  version: 9.0.0
 platform: ruby
 authors:
 - Harry Lascelles
@@ -43,26 +43,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.11.1
-- !ruby/object:Gem::Dependency
-  name: hashie
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '6'
 - !ruby/object:Gem::Dependency
   name: que
   requirement: !ruby/object:Gem::Requirement
@@ -398,7 +378,9 @@ files:
 - lib/que/scheduler/db.rb
 - lib/que/scheduler/db_support.rb
 - lib/que/scheduler/defined_job.rb
+- lib/que/scheduler/defined_job_parser.rb
 - lib/que/scheduler/enqueueing_calculator.rb
+- lib/que/scheduler/job_adapters.rb
 - lib/que/scheduler/jobs/que_scheduler_audit_clear_down_job.rb
 - lib/que/scheduler/migrations.rb
 - lib/que/scheduler/migrations/1/down.sql
@@ -418,6 +400,7 @@ files:
 - lib/que/scheduler/migrations/8/down.sql
 - lib/que/scheduler/migrations/8/up.sql
 - lib/que/scheduler/schedule.rb
+- lib/que/scheduler/schedule_type.rb
 - lib/que/scheduler/scheduler_job.rb
 - lib/que/scheduler/scheduler_job_args.rb
 - lib/que/scheduler/state_checks.rb