handinger 0.0.2

data/lib/handinger/models/workers/schedule_create_params.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Handinger
+  module Models
+    module Workers
+      # @see Handinger::Resources::Workers::Schedules#create
+      class ScheduleCreateParams < Handinger::Internal::Type::BaseModel
+        extend Handinger::Internal::Type::RequestParameters::Converter
+        include Handinger::Internal::Type::RequestParameters
+
+        # @!attribute worker_id
+        #
+        #   @return [String]
+        required :worker_id, String
+
+        # @!attribute input
+        #
+        #   @return [String]
+        required :input, String
+
+        # @!attribute when_
+        #
+        #   @return [Handinger::Models::Workers::ScheduleCreateParams::When::Scheduled, Handinger::Models::Workers::ScheduleCreateParams::When::Delayed, Handinger::Models::Workers::ScheduleCreateParams::When::Cron, Handinger::Models::Workers::ScheduleCreateParams::When::Interval]
+        required :when_, union: -> { Handinger::Workers::ScheduleCreateParams::When }, api_name: :when
+
+        # @!attribute budget
+        #
+        #   @return [Symbol, Handinger::Models::Workers::ScheduleCreateParams::Budget, nil]
+        optional :budget, enum: -> { Handinger::Workers::ScheduleCreateParams::Budget }
+
+        # @!method initialize(worker_id:, input:, when_:, budget: nil, request_options: {})
+        #   @param worker_id [String]
+        #   @param input [String]
+        #   @param when_ [Handinger::Models::Workers::ScheduleCreateParams::When::Scheduled, Handinger::Models::Workers::ScheduleCreateParams::When::Delayed, Handinger::Models::Workers::ScheduleCreateParams::When::Cron, Handinger::Models::Workers::ScheduleCreateParams::When::Interval]
+        #   @param budget [Symbol, Handinger::Models::Workers::ScheduleCreateParams::Budget]
+        #   @param request_options [Handinger::RequestOptions, Hash{Symbol=>Object}]
+
+        module When
+          extend Handinger::Internal::Type::Union
+
+          discriminator :type
+
+          variant :scheduled, -> { Handinger::Workers::ScheduleCreateParams::When::Scheduled }
+
+          variant :delayed, -> { Handinger::Workers::ScheduleCreateParams::When::Delayed }
+
+          variant :cron, -> { Handinger::Workers::ScheduleCreateParams::When::Cron }
+
+          variant :interval, -> { Handinger::Workers::ScheduleCreateParams::When::Interval }
+
+          class Scheduled < Handinger::Internal::Type::BaseModel
+            # @!attribute date
+            #
+            #   @return [Time]
+            required :date, Time
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :scheduled]
+            required :type, const: :scheduled
+
+            # @!method initialize(date:, type: :scheduled)
+            #   @param date [Time]
+            #   @param type [Symbol, :scheduled]
+          end
+
+          class Delayed < Handinger::Internal::Type::BaseModel
+            # @!attribute delay_in_seconds
+            #
+            #   @return [Integer]
+            required :delay_in_seconds, Integer, api_name: :delayInSeconds
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :delayed]
+            required :type, const: :delayed
+
+            # @!method initialize(delay_in_seconds:, type: :delayed)
+            #   @param delay_in_seconds [Integer]
+            #   @param type [Symbol, :delayed]
+          end
+
+          class Cron < Handinger::Internal::Type::BaseModel
+            # @!attribute cron
+            #
+            #   @return [String]
+            required :cron, String
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :cron]
+            required :type, const: :cron
+
+            # @!method initialize(cron:, type: :cron)
+            #   @param cron [String]
+            #   @param type [Symbol, :cron]
+          end
+
+          class Interval < Handinger::Internal::Type::BaseModel
+            # @!attribute interval_seconds
+            #
+            #   @return [Integer]
+            required :interval_seconds, Integer, api_name: :intervalSeconds
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :interval]
+            required :type, const: :interval
+
+            # @!method initialize(interval_seconds:, type: :interval)
+            #   @param interval_seconds [Integer]
+            #   @param type [Symbol, :interval]
+          end
+
+          # @!method self.variants
+          #   @return [Array(Handinger::Models::Workers::ScheduleCreateParams::When::Scheduled, Handinger::Models::Workers::ScheduleCreateParams::When::Delayed, Handinger::Models::Workers::ScheduleCreateParams::When::Cron, Handinger::Models::Workers::ScheduleCreateParams::When::Interval)]
+        end
+
+        module Budget
+          extend Handinger::Internal::Type::Enum
+
+          LOW = :low
+          STANDARD = :standard
+          HIGH = :high
+          UNLIMITED = :unlimited
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/handinger/models/workers/schedule_list_params.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Handinger
+  module Models
+    module Workers
+      # @see Handinger::Resources::Workers::Schedules#list
+      class ScheduleListParams < Handinger::Internal::Type::BaseModel
+        extend Handinger::Internal::Type::RequestParameters::Converter
+        include Handinger::Internal::Type::RequestParameters
+
+        # @!attribute worker_id
+        #
+        #   @return [String]
+        required :worker_id, String
+
+        # @!method initialize(worker_id:, request_options: {})
+        #   @param worker_id [String]
+        #   @param request_options [Handinger::RequestOptions, Hash{Symbol=>Object}]
+      end
+    end
+  end
+end

data/lib/handinger/models/workers/schedule_list_response.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Handinger
+  module Models
+    module Workers
+      # @see Handinger::Resources::Workers::Schedules#list
+      class ScheduleListResponse < Handinger::Internal::Type::BaseModel
+        # @!attribute schedules
+        #
+        #   @return [Array<Handinger::Models::Workers::WorkerSchedule::Scheduled, Handinger::Models::Workers::WorkerSchedule::Delayed, Handinger::Models::Workers::WorkerSchedule::Cron, Handinger::Models::Workers::WorkerSchedule::Interval>]
+        required :schedules, -> { Handinger::Internal::Type::ArrayOf[union: Handinger::Workers::WorkerSchedule] }
+
+        # @!attribute worker_id
+        #
+        #   @return [String]
+        required :worker_id, String, api_name: :workerId
+
+        # @!method initialize(schedules:, worker_id:)
+        #   @param schedules [Array<Handinger::Models::Workers::WorkerSchedule::Scheduled, Handinger::Models::Workers::WorkerSchedule::Delayed, Handinger::Models::Workers::WorkerSchedule::Cron, Handinger::Models::Workers::WorkerSchedule::Interval>]
+        #   @param worker_id [String]
+      end
+    end
+  end
+end

data/lib/handinger/models/workers/worker_schedule.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Handinger
+  module Models
+    module Workers
+      # @see Handinger::Resources::Workers::Schedules#create
+      module WorkerSchedule
+        extend Handinger::Internal::Type::Union
+
+        discriminator :type
+
+        variant :scheduled, -> { Handinger::Workers::WorkerSchedule::Scheduled }
+
+        variant :delayed, -> { Handinger::Workers::WorkerSchedule::Delayed }
+
+        variant :cron, -> { Handinger::Workers::WorkerSchedule::Cron }
+
+        variant :interval, -> { Handinger::Workers::WorkerSchedule::Interval }
+
+        class Scheduled < Handinger::Internal::Type::BaseModel
+          # @!attribute id
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute budget
+          #
+          #   @return [Symbol, Handinger::Models::Workers::WorkerSchedule::Scheduled::Budget]
+          required :budget, enum: -> { Handinger::Workers::WorkerSchedule::Scheduled::Budget }
+
+          # @!attribute input
+          #
+          #   @return [String]
+          required :input, String
+
+          # @!attribute next_run_at
+          #
+          #   @return [Time]
+          required :next_run_at, Time, api_name: :nextRunAt
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :scheduled]
+          required :type, const: :scheduled
+
+          # @!method initialize(id:, budget:, input:, next_run_at:, type: :scheduled)
+          #   @param id [String]
+          #   @param budget [Symbol, Handinger::Models::Workers::WorkerSchedule::Scheduled::Budget]
+          #   @param input [String]
+          #   @param next_run_at [Time]
+          #   @param type [Symbol, :scheduled]
+
+          # @see Handinger::Models::Workers::WorkerSchedule::Scheduled#budget
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            LOW = :low
+            STANDARD = :standard
+            HIGH = :high
+            UNLIMITED = :unlimited
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        class Delayed < Handinger::Internal::Type::BaseModel
+          # @!attribute id
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute budget
+          #
+          #   @return [Symbol, Handinger::Models::Workers::WorkerSchedule::Delayed::Budget]
+          required :budget, enum: -> { Handinger::Workers::WorkerSchedule::Delayed::Budget }
+
+          # @!attribute delay_in_seconds
+          #
+          #   @return [Integer]
+          required :delay_in_seconds, Integer, api_name: :delayInSeconds
+
+          # @!attribute input
+          #
+          #   @return [String]
+          required :input, String
+
+          # @!attribute next_run_at
+          #
+          #   @return [Time]
+          required :next_run_at, Time, api_name: :nextRunAt
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :delayed]
+          required :type, const: :delayed
+
+          # @!method initialize(id:, budget:, delay_in_seconds:, input:, next_run_at:, type: :delayed)
+          #   @param id [String]
+          #   @param budget [Symbol, Handinger::Models::Workers::WorkerSchedule::Delayed::Budget]
+          #   @param delay_in_seconds [Integer]
+          #   @param input [String]
+          #   @param next_run_at [Time]
+          #   @param type [Symbol, :delayed]
+
+          # @see Handinger::Models::Workers::WorkerSchedule::Delayed#budget
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            LOW = :low
+            STANDARD = :standard
+            HIGH = :high
+            UNLIMITED = :unlimited
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        class Cron < Handinger::Internal::Type::BaseModel
+          # @!attribute id
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute budget
+          #
+          #   @return [Symbol, Handinger::Models::Workers::WorkerSchedule::Cron::Budget]
+          required :budget, enum: -> { Handinger::Workers::WorkerSchedule::Cron::Budget }
+
+          # @!attribute cron
+          #
+          #   @return [String]
+          required :cron, String
+
+          # @!attribute input
+          #
+          #   @return [String]
+          required :input, String
+
+          # @!attribute next_run_at
+          #
+          #   @return [Time]
+          required :next_run_at, Time, api_name: :nextRunAt
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :cron]
+          required :type, const: :cron
+
+          # @!method initialize(id:, budget:, cron:, input:, next_run_at:, type: :cron)
+          #   @param id [String]
+          #   @param budget [Symbol, Handinger::Models::Workers::WorkerSchedule::Cron::Budget]
+          #   @param cron [String]
+          #   @param input [String]
+          #   @param next_run_at [Time]
+          #   @param type [Symbol, :cron]
+
+          # @see Handinger::Models::Workers::WorkerSchedule::Cron#budget
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            LOW = :low
+            STANDARD = :standard
+            HIGH = :high
+            UNLIMITED = :unlimited
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        class Interval < Handinger::Internal::Type::BaseModel
+          # @!attribute id
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute budget
+          #
+          #   @return [Symbol, Handinger::Models::Workers::WorkerSchedule::Interval::Budget]
+          required :budget, enum: -> { Handinger::Workers::WorkerSchedule::Interval::Budget }
+
+          # @!attribute input
+          #
+          #   @return [String]
+          required :input, String
+
+          # @!attribute interval_seconds
+          #
+          #   @return [Integer]
+          required :interval_seconds, Integer, api_name: :intervalSeconds
+
+          # @!attribute next_run_at
+          #
+          #   @return [Time]
+          required :next_run_at, Time, api_name: :nextRunAt
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :interval]
+          required :type, const: :interval
+
+          # @!method initialize(id:, budget:, input:, interval_seconds:, next_run_at:, type: :interval)
+          #   @param id [String]
+          #   @param budget [Symbol, Handinger::Models::Workers::WorkerSchedule::Interval::Budget]
+          #   @param input [String]
+          #   @param interval_seconds [Integer]
+          #   @param next_run_at [Time]
+          #   @param type [Symbol, :interval]
+
+          # @see Handinger::Models::Workers::WorkerSchedule::Interval#budget
+          module Budget
+            extend Handinger::Internal::Type::Enum
+
+            LOW = :low
+            STANDARD = :standard
+            HIGH = :high
+            UNLIMITED = :unlimited
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        # @!method self.variants
+        #   @return [Array(Handinger::Models::Workers::WorkerSchedule::Scheduled, Handinger::Models::Workers::WorkerSchedule::Delayed, Handinger::Models::Workers::WorkerSchedule::Cron, Handinger::Models::Workers::WorkerSchedule::Interval)]
+      end
+    end
+
+    WorkerSchedule = Workers::WorkerSchedule
+  end
+end

data/lib/handinger/models.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Handinger
+  [Handinger::Internal::Type::BaseModel, *Handinger::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, Handinger::Internal::AnyHash) } }
+  end
+
+  Handinger::Internal::Util.walk_namespaces(Handinger::Models).each do |mod|
+    case mod
+    in Handinger::Internal::Type::Enum | Handinger::Internal::Type::Union
+      mod.constants.each do |name|
+        case mod.const_get(name)
+        in true | false
+          mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T::Boolean } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { Integer } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { Float } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { Symbol } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
+      end
+    else
+    end
+  end
+
+  Handinger::Internal::Util.walk_namespaces(Handinger::Models)
+                           .lazy
+                           .grep(Handinger::Internal::Type::Union)
+                           .each do |mod|
+    const = :Variants
+    next if mod.sorbet_constant_defined?(const)
+
+    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+  end
+
+  CreateWorker = Handinger::Models::CreateWorker
+
+  Worker = Handinger::Models::Worker
+
+  WorkerContinueParams = Handinger::Models::WorkerContinueParams
+
+  WorkerCreateParams = Handinger::Models::WorkerCreateParams
+
+  WorkerRetrieveEmailParams = Handinger::Models::WorkerRetrieveEmailParams
+
+  WorkerRetrieveFileParams = Handinger::Models::WorkerRetrieveFileParams
+
+  WorkerRetrieveParams = Handinger::Models::WorkerRetrieveParams
+
+  Workers = Handinger::Models::Workers
+
+  WorkerStreamUpdatesParams = Handinger::Models::WorkerStreamUpdatesParams
+end

data/lib/handinger/request_options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Handinger
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Handinger::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [Handinger::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Handinger::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, Handinger::Internal::Type::HashOf[Handinger::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, Handinger::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, Handinger::Internal::Type::HashOf[Handinger::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(Handinger::RequestOptions, Handinger::Internal::AnyHash) }
+    end
+  end
+end

data/lib/handinger/resources/workers/schedules.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Handinger
+  module Resources
+    class Workers
+      # Manage future and recurring worker tasks.
+      class Schedules
+        # Schedule a worker instruction for a future or recurring run.
+        #
+        # @overload create(worker_id, input:, when_:, budget: nil, request_options: {})
+        #
+        # @param worker_id [String] Worker id returned by the create worker endpoint.
+        #
+        # @param input [String]
+        #
+        # @param when_ [Handinger::Models::Workers::ScheduleCreateParams::When::Scheduled, Handinger::Models::Workers::ScheduleCreateParams::When::Delayed, Handinger::Models::Workers::ScheduleCreateParams::When::Cron, Handinger::Models::Workers::ScheduleCreateParams::When::Interval]
+        #
+        # @param budget [Symbol, Handinger::Models::Workers::ScheduleCreateParams::Budget]
+        #
+        # @param request_options [Handinger::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Handinger::Models::Workers::WorkerSchedule::Scheduled, Handinger::Models::Workers::WorkerSchedule::Delayed, Handinger::Models::Workers::WorkerSchedule::Cron, Handinger::Models::Workers::WorkerSchedule::Interval]
+        #
+        # @see Handinger::Models::Workers::ScheduleCreateParams
+        def create(worker_id, params)
+          parsed, options = Handinger::Workers::ScheduleCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: ["api/workers/%1$s/schedules", worker_id],
+            body: parsed,
+            model: Handinger::Workers::WorkerSchedule,
+            options: options
+          )
+        end
+
+        # List scheduled tasks for a worker.
+        #
+        # @overload list(worker_id, request_options: {})
+        #
+        # @param worker_id [String] Worker id returned by the create worker endpoint.
+        #
+        # @param request_options [Handinger::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Handinger::Models::Workers::ScheduleListResponse]
+        #
+        # @see Handinger::Models::Workers::ScheduleListParams
+        def list(worker_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["api/workers/%1$s/schedules", worker_id],
+            model: Handinger::Models::Workers::ScheduleListResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # Cancel a scheduled task for a worker.
+        #
+        # @overload cancel(schedule_id, worker_id:, request_options: {})
+        #
+        # @param schedule_id [String] Scheduled task id returned by the create schedule endpoint.
+        #
+        # @param worker_id [String] Worker id returned by the create worker endpoint.
+        #
+        # @param request_options [Handinger::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Handinger::Models::Workers::ScheduleCancelResponse]
+        #
+        # @see Handinger::Models::Workers::ScheduleCancelParams
+        def cancel(schedule_id, params)
+          parsed, options = Handinger::Workers::ScheduleCancelParams.dump_request(params)
+          worker_id =
+            parsed.delete(:worker_id) do
+              raise ArgumentError.new("missing required path argument #{_1}")
+            end
+          @client.request(
+            method: :delete,
+            path: ["api/workers/%1$s/schedules/%2$s", worker_id, schedule_id],
+            model: Handinger::Models::Workers::ScheduleCancelResponse,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Handinger::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end