vern-sdk 0.0.1.pre.alpha.1

data/lib/vern_sdk/internal.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module VernSDK
+  module Internal
+    extend VernSDK::Internal::Util::SorbetRuntimeSupport
+
+    OMIT =
+      Object.new.tap do
+        _1.define_singleton_method(:inspect) { "#<#{VernSDK::Internal}::OMIT>" }
+      end
+        .freeze
+
+    define_sorbet_constant!(:AnyHash) do
+      T.type_alias { T::Hash[Symbol, T.anything] }
+    end
+    define_sorbet_constant!(:FileInput) do
+      T.type_alias { T.any(Pathname, StringIO, IO, String, VernSDK::FilePart) }
+    end
+  end
+end

data/lib/vern_sdk/models/run_create_params.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module VernSDK
+  module Models
+    # @see VernSDK::Resources::Runs#create
+    class RunCreateParams < VernSDK::Internal::Type::BaseModel
+      extend VernSDK::Internal::Type::RequestParameters::Converter
+      include VernSDK::Internal::Type::RequestParameters
+
+      # @!attribute task_id
+      #   The ID of the task to execute
+      #
+      #   @return [String]
+      required :task_id, String, api_name: :taskId
+
+      # @!attribute inputs
+      #   The inputs required for the task
+      #
+      #   @return [Hash{Symbol=>Object}, nil]
+      optional :inputs, VernSDK::Internal::Type::HashOf[VernSDK::Internal::Type::Unknown]
+
+      # @!attribute profile_id
+      #   Optional user-specified UID for a profile linked via magic link
+      #
+      #   @return [String, nil]
+      optional :profile_id, String, api_name: :profileId
+
+      # @!attribute url
+      #   An optional URL to be processed by the task
+      #
+      #   @return [String, nil]
+      optional :url, String
+
+      # @!method initialize(task_id:, inputs: nil, profile_id: nil, url: nil, request_options: {})
+      #   @param task_id [String] The ID of the task to execute
+      #
+      #   @param inputs [Hash{Symbol=>Object}] The inputs required for the task
+      #
+      #   @param profile_id [String] Optional user-specified UID for a profile linked via magic link
+      #
+      #   @param url [String] An optional URL to be processed by the task
+      #
+      #   @param request_options [VernSDK::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/vern_sdk/models/run_create_response.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module VernSDK
+  module Models
+    # @see VernSDK::Resources::Runs#create
+    class RunCreateResponse < VernSDK::Internal::Type::BaseModel
+      # @!attribute id
+      #   Unique identifier for the run
+      #
+      #   @return [String, nil]
+      optional :id, String
+
+      # @!attribute inputs
+      #   The inputs provided for the task
+      #
+      #   @return [Hash{Symbol=>Object}, nil]
+      optional :inputs, VernSDK::Internal::Type::HashOf[VernSDK::Internal::Type::Unknown]
+
+      # @!attribute queued_at
+      #   Timestamp when the run was queued
+      #
+      #   @return [Time, nil]
+      optional :queued_at, Time
+
+      # @!method initialize(id: nil, inputs: nil, queued_at: nil)
+      #   @param id [String] Unique identifier for the run
+      #
+      #   @param inputs [Hash{Symbol=>Object}] The inputs provided for the task
+      #
+      #   @param queued_at [Time] Timestamp when the run was queued
+    end
+  end
+end

data/lib/vern_sdk/models/run_retrieve_params.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module VernSDK
+  module Models
+    # @see VernSDK::Resources::Runs#retrieve
+    class RunRetrieveParams < VernSDK::Internal::Type::BaseModel
+      extend VernSDK::Internal::Type::RequestParameters::Converter
+      include VernSDK::Internal::Type::RequestParameters
+
+      # @!method initialize(request_options: {})
+      #   @param request_options [VernSDK::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/vern_sdk/models/run_retrieve_response.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module VernSDK
+  module Models
+    # @see VernSDK::Resources::Runs#retrieve
+    class RunRetrieveResponse < VernSDK::Internal::Type::BaseModel
+      # @!attribute id
+      #   Unique identifier for the run
+      #
+      #   @return [String, nil]
+      optional :id, String
+
+      # @!attribute completed_at
+      #   Timestamp when the run completed
+      #
+      #   @return [Time, nil]
+      optional :completed_at, Time
+
+      # @!attribute created_at
+      #   Timestamp when the run was created
+      #
+      #   @return [Time, nil]
+      optional :created_at, Time
+
+      # @!attribute inputs
+      #   The inputs provided for the task
+      #
+      #   @return [Hash{Symbol=>Object}, nil]
+      optional :inputs, VernSDK::Internal::Type::HashOf[VernSDK::Internal::Type::Unknown]
+
+      # @!attribute response
+      #   The response data from the task execution
+      #
+      #   @return [Hash{Symbol=>Object}, nil]
+      optional :response, VernSDK::Internal::Type::HashOf[VernSDK::Internal::Type::Unknown]
+
+      # @!attribute started_at
+      #   Timestamp when the run started executing
+      #
+      #   @return [Time, nil]
+      optional :started_at, Time
+
+      # @!attribute status
+      #   The current status of the run
+      #
+      #   @return [Symbol, VernSDK::Models::RunRetrieveResponse::Status, nil]
+      optional :status, enum: -> { VernSDK::Models::RunRetrieveResponse::Status }
+
+      # @!attribute task
+      #   The name of the task that was executed
+      #
+      #   @return [String, nil]
+      optional :task, String
+
+      # @!method initialize(id: nil, completed_at: nil, created_at: nil, inputs: nil, response: nil, started_at: nil, status: nil, task: nil)
+      #   @param id [String] Unique identifier for the run
+      #
+      #   @param completed_at [Time] Timestamp when the run completed
+      #
+      #   @param created_at [Time] Timestamp when the run was created
+      #
+      #   @param inputs [Hash{Symbol=>Object}] The inputs provided for the task
+      #
+      #   @param response [Hash{Symbol=>Object}] The response data from the task execution
+      #
+      #   @param started_at [Time] Timestamp when the run started executing
+      #
+      #   @param status [Symbol, VernSDK::Models::RunRetrieveResponse::Status] The current status of the run
+      #
+      #   @param task [String] The name of the task that was executed
+
+      # The current status of the run
+      #
+      # @see VernSDK::Models::RunRetrieveResponse#status
+      module Status
+        extend VernSDK::Internal::Type::Enum
+
+        QUEUED = :queued
+        RUNNING = :running
+        COMPLETE = :complete
+        FAILED = :failed
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/vern_sdk/models.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module VernSDK
+  [VernSDK::Internal::Type::BaseModel, *VernSDK::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, VernSDK::Internal::AnyHash) } }
+  end
+
+  VernSDK::Internal::Util.walk_namespaces(VernSDK::Models).each do |mod|
+    case mod
+    in VernSDK::Internal::Type::Enum | VernSDK::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.all(T::Boolean, mod) } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { T.all(Integer, mod) } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { T.all(Float, mod) } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { T.all(Symbol, mod) } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
+      end
+    else
+    end
+  end
+
+  VernSDK::Internal::Util.walk_namespaces(VernSDK::Models)
+                         .lazy
+                         .grep(VernSDK::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
+
+  RunCreateParams = VernSDK::Models::RunCreateParams
+
+  RunRetrieveParams = VernSDK::Models::RunRetrieveParams
+end

data/lib/vern_sdk/request_options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module VernSDK
+  # 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 < VernSDK::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [VernSDK::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in VernSDK::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, VernSDK::Internal::Type::HashOf[VernSDK::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, VernSDK::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, VernSDK::Internal::Type::HashOf[VernSDK::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(VernSDK::RequestOptions, VernSDK::Internal::AnyHash) }
+    end
+  end
+end

data/lib/vern_sdk/resources/runs.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module VernSDK
+  module Resources
+    class Runs
+      # Executes a task with the provided inputs
+      #
+      # @overload create(task_id:, inputs: nil, profile_id: nil, url: nil, request_options: {})
+      #
+      # @param task_id [String] The ID of the task to execute
+      #
+      # @param inputs [Hash{Symbol=>Object}] The inputs required for the task
+      #
+      # @param profile_id [String] Optional user-specified UID for a profile linked via magic link
+      #
+      # @param url [String] An optional URL to be processed by the task
+      #
+      # @param request_options [VernSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [VernSDK::Models::RunCreateResponse]
+      #
+      # @see VernSDK::Models::RunCreateParams
+      def create(params)
+        parsed, options = VernSDK::RunCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "runs",
+          body: parsed,
+          model: VernSDK::Models::RunCreateResponse,
+          options: options
+        )
+      end
+
+      # Retrieves the details of a specific task run
+      #
+      # @overload retrieve(id, request_options: {})
+      #
+      # @param id [String] The ID of the run to retrieve
+      #
+      # @param request_options [VernSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [VernSDK::Models::RunRetrieveResponse]
+      #
+      # @see VernSDK::Models::RunRetrieveParams
+      def retrieve(id, params = {})
+        @client.request(
+          method: :get,
+          path: ["runs/%1$s", id],
+          model: VernSDK::Models::RunRetrieveResponse,
+          options: params[:request_options]
+        )
+      end
+
+      # @api private
+      #
+      # @param client [VernSDK::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/vern_sdk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module VernSDK
+  VERSION = "0.0.1.pre.alpha.1"
+end

data/lib/vern_sdk.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Standard libraries.
+# rubocop:disable Lint/RedundantRequireStatement
+require "English"
+require "cgi"
+require "date"
+require "erb"
+require "etc"
+require "json"
+require "net/http"
+require "pathname"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "stringio"
+require "time"
+require "uri"
+# rubocop:enable Lint/RedundantRequireStatement
+
+# We already ship the preferred sorbet manifests in the package itself.
+# `tapioca` currently does not offer us a way to opt out of unnecessary compilation.
+if Object.const_defined?(:Tapioca) &&
+   caller.chain([$PROGRAM_NAME]).chain(ARGV).any?(/tapioca/) &&
+   ARGV.none?(/dsl/)
+  return
+end
+
+# Gems.
+require "connection_pool"
+
+# Package files.
+require_relative "vern_sdk/version"
+require_relative "vern_sdk/internal/util"
+require_relative "vern_sdk/internal/type/converter"
+require_relative "vern_sdk/internal/type/unknown"
+require_relative "vern_sdk/internal/type/boolean"
+require_relative "vern_sdk/internal/type/file_input"
+require_relative "vern_sdk/internal/type/enum"
+require_relative "vern_sdk/internal/type/union"
+require_relative "vern_sdk/internal/type/array_of"
+require_relative "vern_sdk/internal/type/hash_of"
+require_relative "vern_sdk/internal/type/base_model"
+require_relative "vern_sdk/internal/type/base_page"
+require_relative "vern_sdk/internal/type/request_parameters"
+require_relative "vern_sdk/internal"
+require_relative "vern_sdk/request_options"
+require_relative "vern_sdk/file_part"
+require_relative "vern_sdk/errors"
+require_relative "vern_sdk/internal/transport/base_client"
+require_relative "vern_sdk/internal/transport/pooled_net_requester"
+require_relative "vern_sdk/client"
+require_relative "vern_sdk/models/run_create_params"
+require_relative "vern_sdk/models/run_create_response"
+require_relative "vern_sdk/models/run_retrieve_params"
+require_relative "vern_sdk/models/run_retrieve_response"
+require_relative "vern_sdk/models"
+require_relative "vern_sdk/resources/runs"

data/manifest.yaml

@@ -0,0 +1,15 @@
+dependencies:
+  - English
+  - cgi
+  - date
+  - erb
+  - etc
+  - json
+  - net/http
+  - pathname
+  - rbconfig
+  - securerandom
+  - set
+  - stringio
+  - time
+  - uri

data/rbi/vern_sdk/client.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module VernSDK
+  class Client < VernSDK::Internal::Transport::BaseClient
+    DEFAULT_MAX_RETRIES = 2
+
+    DEFAULT_TIMEOUT_IN_SECONDS = T.let(60.0, Float)
+
+    DEFAULT_INITIAL_RETRY_DELAY = T.let(0.5, Float)
+
+    DEFAULT_MAX_RETRY_DELAY = T.let(8.0, Float)
+
+    sig { returns(String) }
+    attr_reader :api_key
+
+    sig { returns(VernSDK::Resources::Runs) }
+    attr_reader :runs
+
+    # @api private
+    sig { override.returns(T::Hash[String, String]) }
+    private def auth_headers
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        api_key: T.nilable(String),
+        base_url: T.nilable(String),
+        max_retries: Integer,
+        timeout: Float,
+        initial_retry_delay: Float,
+        max_retry_delay: Float
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      # Defaults to `ENV["VERN_SDK_API_KEY"]`
+      api_key: ENV["VERN_SDK_API_KEY"],
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["VERN_BASE_URL"]`
+      base_url: ENV["VERN_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: VernSDK::Client::DEFAULT_MAX_RETRIES,
+      timeout: VernSDK::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: VernSDK::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: VernSDK::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/vern_sdk/errors.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module VernSDK
+  module Errors
+    class Error < StandardError
+      sig { returns(T.nilable(StandardError)) }
+      attr_accessor :cause
+    end
+
+    class ConversionError < VernSDK::Errors::Error
+    end
+
+    class APIError < VernSDK::Errors::Error
+      sig { returns(URI::Generic) }
+      attr_accessor :url
+
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :status
+
+      sig { returns(T.nilable(T.anything)) }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: T.nilable(Integer),
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: nil
+      )
+      end
+    end
+
+    class APIConnectionError < VernSDK::Errors::APIError
+      sig { void }
+      attr_accessor :status
+
+      sig { void }
+      attr_accessor :body
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Connection error."
+      )
+      end
+    end
+
+    class APITimeoutError < VernSDK::Errors::APIConnectionError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: NilClass,
+          body: NilClass,
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        url:,
+        status: nil,
+        body: nil,
+        request: nil,
+        response: nil,
+        message: "Request timed out."
+      )
+      end
+    end
+
+    class APIStatusError < VernSDK::Errors::APIError
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.for(url:, status:, body:, request:, response:, message: nil)
+      end
+
+      sig { returns(Integer) }
+      attr_accessor :status
+
+      # @api private
+      sig do
+        params(
+          url: URI::Generic,
+          status: Integer,
+          body: T.nilable(Object),
+          request: NilClass,
+          response: NilClass,
+          message: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(url:, status:, body:, request:, response:, message: nil)
+      end
+    end
+
+    class BadRequestError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 400
+    end
+
+    class AuthenticationError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 401
+    end
+
+    class PermissionDeniedError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 403
+    end
+
+    class NotFoundError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 404
+    end
+
+    class ConflictError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 409
+    end
+
+    class UnprocessableEntityError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 422
+    end
+
+    class RateLimitError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = 429
+    end
+
+    class InternalServerError < VernSDK::Errors::APIStatusError
+      HTTP_STATUS = T.let((500..), T::Range[Integer])
+    end
+  end
+end