prelude-sdk 0.1.0.pre.alpha.2

data/lib/prelude_sdk/models.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module PreludeSDK
+  [PreludeSDK::Internal::Type::BaseModel, *PreludeSDK::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, PreludeSDK::Internal::AnyHash) } }
+  end
+
+  PreludeSDK::Internal::Util.walk_namespaces(PreludeSDK::Models).each do |mod|
+    case mod
+    in PreludeSDK::Internal::Type::Enum | PreludeSDK::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
+
+  PreludeSDK::Internal::Util.walk_namespaces(PreludeSDK::Models)
+                            .lazy
+                            .grep(PreludeSDK::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
+
+  LookupLookupParams = PreludeSDK::Models::LookupLookupParams
+
+  TransactionalSendParams = PreludeSDK::Models::TransactionalSendParams
+
+  VerificationCheckParams = PreludeSDK::Models::VerificationCheckParams
+
+  VerificationCreateParams = PreludeSDK::Models::VerificationCreateParams
+
+  WatchPredictParams = PreludeSDK::Models::WatchPredictParams
+
+  WatchSendEventsParams = PreludeSDK::Models::WatchSendEventsParams
+
+  WatchSendFeedbacksParams = PreludeSDK::Models::WatchSendFeedbacksParams
+end

data/lib/prelude_sdk/request_options.rb

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

data/lib/prelude_sdk/resources/lookup.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module PreludeSDK
+  module Resources
+    class Lookup
+      # Some parameter documentations has been truncated, see
+      # {PreludeSDK::Models::LookupLookupParams} for more details.
+      #
+      # Retrieve detailed information about a phone number including carrier data, line
+      # type, and portability status.
+      #
+      # @overload lookup(phone_number, type: nil, request_options: {})
+      #
+      # @param phone_number [String] An E.164 formatted phone number to look up.
+      #
+      # @param type [Array<Symbol, PreludeSDK::Models::LookupLookupParams::Type>] Optional features. Possible values are:
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::LookupLookupResponse]
+      #
+      # @see PreludeSDK::Models::LookupLookupParams
+      def lookup(phone_number, params = {})
+        parsed, options = PreludeSDK::LookupLookupParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["v2/lookup/%1$s", phone_number],
+          query: parsed,
+          model: PreludeSDK::Models::LookupLookupResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [PreludeSDK::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/prelude_sdk/resources/transactional.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PreludeSDK
+  module Resources
+    class Transactional
+      # Some parameter documentations has been truncated, see
+      # {PreludeSDK::Models::TransactionalSendParams} for more details.
+      #
+      # Send a transactional message to your user.
+      #
+      # @overload send_(template_id:, to:, callback_url: nil, correlation_id: nil, expires_at: nil, from: nil, locale: nil, variables: nil, request_options: {})
+      #
+      # @param template_id [String] The template identifier.
+      #
+      # @param to [String] The recipient's phone number.
+      #
+      # @param callback_url [String] The callback URL.
+      #
+      # @param correlation_id [String] A unique, user-defined identifier that will be included in webhook events.
+      #
+      # @param expires_at [String] The message expiration date.
+      #
+      # @param from [String] The Sender ID.
+      #
+      # @param locale [String] A BCP-47 formatted locale string with the language the text message will be sent
+      #
+      # @param variables [Hash{Symbol=>String}] The variables to be replaced in the template.
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::TransactionalSendResponse]
+      #
+      # @see PreludeSDK::Models::TransactionalSendParams
+      def send_(params)
+        parsed, options = PreludeSDK::TransactionalSendParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/transactional",
+          body: parsed,
+          model: PreludeSDK::Models::TransactionalSendResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [PreludeSDK::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/prelude_sdk/resources/verification.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module PreludeSDK
+  module Resources
+    class Verification
+      # Some parameter documentations has been truncated, see
+      # {PreludeSDK::Models::VerificationCreateParams} for more details.
+      #
+      # Create a new verification for a specific phone number. If another non-expired
+      # verification exists (the request is performed within the verification window),
+      # this endpoint will perform a retry instead.
+      #
+      # @overload create(target:, dispatch_id: nil, metadata: nil, options: nil, signals: nil, request_options: {})
+      #
+      # @param target [PreludeSDK::Models::VerificationCreateParams::Target] The verification target. Either a phone number or an email address. To use the e
+      #
+      # @param dispatch_id [String] The identifier of the dispatch that came from the front-end SDK.
+      #
+      # @param metadata [PreludeSDK::Models::VerificationCreateParams::Metadata] The metadata for this verification. This object will be returned with every resp
+      #
+      # @param options [PreludeSDK::Models::VerificationCreateParams::Options] Verification options
+      #
+      # @param signals [PreludeSDK::Models::VerificationCreateParams::Signals] The signals used for anti-fraud. For more details, refer to [Signals](/verify/v2
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::VerificationCreateResponse]
+      #
+      # @see PreludeSDK::Models::VerificationCreateParams
+      def create(params)
+        parsed, options = PreludeSDK::VerificationCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/verification",
+          body: parsed,
+          model: PreludeSDK::Models::VerificationCreateResponse,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {PreludeSDK::Models::VerificationCheckParams} for more details.
+      #
+      # Check the validity of a verification code.
+      #
+      # @overload check(code:, target:, request_options: {})
+      #
+      # @param code [String] The OTP code to validate.
+      #
+      # @param target [PreludeSDK::Models::VerificationCheckParams::Target] The verification target. Either a phone number or an email address. To use the e
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::VerificationCheckResponse]
+      #
+      # @see PreludeSDK::Models::VerificationCheckParams
+      def check(params)
+        parsed, options = PreludeSDK::VerificationCheckParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/verification/check",
+          body: parsed,
+          model: PreludeSDK::Models::VerificationCheckResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [PreludeSDK::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/prelude_sdk/resources/watch.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module PreludeSDK
+  module Resources
+    class Watch
+      # Some parameter documentations has been truncated, see
+      # {PreludeSDK::Models::WatchPredictParams} for more details.
+      #
+      # Predict the outcome of a verification based on Prelude’s anti-fraud system.
+      #
+      # @overload predict(target:, dispatch_id: nil, metadata: nil, signals: nil, request_options: {})
+      #
+      # @param target [PreludeSDK::Models::WatchPredictParams::Target] The prediction target. Only supports phone numbers for now.
+      #
+      # @param dispatch_id [String] The identifier of the dispatch that came from the front-end SDK.
+      #
+      # @param metadata [PreludeSDK::Models::WatchPredictParams::Metadata] The metadata for this prediction.
+      #
+      # @param signals [PreludeSDK::Models::WatchPredictParams::Signals] The signals used for anti-fraud. For more details, refer to [Signals](/verify/v2
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::WatchPredictResponse]
+      #
+      # @see PreludeSDK::Models::WatchPredictParams
+      def predict(params)
+        parsed, options = PreludeSDK::WatchPredictParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/watch/predict",
+          body: parsed,
+          model: PreludeSDK::Models::WatchPredictResponse,
+          options: options
+        )
+      end
+
+      # Send real-time event data from end-user interactions within your application.
+      # Events will be analyzed for proactive fraud prevention and risk scoring.
+      #
+      # @overload send_events(events:, request_options: {})
+      #
+      # @param events [Array<PreludeSDK::Models::WatchSendEventsParams::Event>] A list of events to dispatch.
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::WatchSendEventsResponse]
+      #
+      # @see PreludeSDK::Models::WatchSendEventsParams
+      def send_events(params)
+        parsed, options = PreludeSDK::WatchSendEventsParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/watch/event",
+          body: parsed,
+          model: PreludeSDK::Models::WatchSendEventsResponse,
+          options: options
+        )
+      end
+
+      # Send feedback regarding your end-users verification funnel. Events will be
+      # analyzed for proactive fraud prevention and risk scoring.
+      #
+      # @overload send_feedbacks(feedbacks:, request_options: {})
+      #
+      # @param feedbacks [Array<PreludeSDK::Models::WatchSendFeedbacksParams::Feedback>] A list of feedbacks to send.
+      #
+      # @param request_options [PreludeSDK::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [PreludeSDK::Models::WatchSendFeedbacksResponse]
+      #
+      # @see PreludeSDK::Models::WatchSendFeedbacksParams
+      def send_feedbacks(params)
+        parsed, options = PreludeSDK::WatchSendFeedbacksParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v2/watch/feedback",
+          body: parsed,
+          model: PreludeSDK::Models::WatchSendFeedbacksResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [PreludeSDK::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/prelude_sdk/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PreludeSDK
+  VERSION = "0.1.0.pre.alpha.2"
+end

data/lib/prelude_sdk.rb

@@ -0,0 +1,71 @@
+# 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 "prelude_sdk/version"
+require_relative "prelude_sdk/internal/util"
+require_relative "prelude_sdk/internal/type/converter"
+require_relative "prelude_sdk/internal/type/unknown"
+require_relative "prelude_sdk/internal/type/boolean"
+require_relative "prelude_sdk/internal/type/file_input"
+require_relative "prelude_sdk/internal/type/enum"
+require_relative "prelude_sdk/internal/type/union"
+require_relative "prelude_sdk/internal/type/array_of"
+require_relative "prelude_sdk/internal/type/hash_of"
+require_relative "prelude_sdk/internal/type/base_model"
+require_relative "prelude_sdk/internal/type/base_page"
+require_relative "prelude_sdk/internal/type/request_parameters"
+require_relative "prelude_sdk/internal"
+require_relative "prelude_sdk/request_options"
+require_relative "prelude_sdk/file_part"
+require_relative "prelude_sdk/errors"
+require_relative "prelude_sdk/internal/transport/base_client"
+require_relative "prelude_sdk/internal/transport/pooled_net_requester"
+require_relative "prelude_sdk/client"
+require_relative "prelude_sdk/models/lookup_lookup_params"
+require_relative "prelude_sdk/models/lookup_lookup_response"
+require_relative "prelude_sdk/models/transactional_send_params"
+require_relative "prelude_sdk/models/transactional_send_response"
+require_relative "prelude_sdk/models/verification_check_params"
+require_relative "prelude_sdk/models/verification_check_response"
+require_relative "prelude_sdk/models/verification_create_params"
+require_relative "prelude_sdk/models/verification_create_response"
+require_relative "prelude_sdk/models/watch_predict_params"
+require_relative "prelude_sdk/models/watch_predict_response"
+require_relative "prelude_sdk/models/watch_send_events_params"
+require_relative "prelude_sdk/models/watch_send_events_response"
+require_relative "prelude_sdk/models/watch_send_feedbacks_params"
+require_relative "prelude_sdk/models/watch_send_feedbacks_response"
+require_relative "prelude_sdk/models"
+require_relative "prelude_sdk/resources/lookup"
+require_relative "prelude_sdk/resources/transactional"
+require_relative "prelude_sdk/resources/verification"
+require_relative "prelude_sdk/resources/watch"

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/prelude_sdk/client.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module PreludeSDK
+  class Client < PreludeSDK::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)
+
+    # Bearer token for authorizing API requests.
+    sig { returns(String) }
+    attr_reader :api_token
+
+    sig { returns(PreludeSDK::Resources::Lookup) }
+    attr_reader :lookup
+
+    sig { returns(PreludeSDK::Resources::Transactional) }
+    attr_reader :transactional
+
+    sig { returns(PreludeSDK::Resources::Verification) }
+    attr_reader :verification
+
+    sig { returns(PreludeSDK::Resources::Watch) }
+    attr_reader :watch
+
+    # @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_token: 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(
+      # Bearer token for authorizing API requests. Defaults to `ENV["API_TOKEN"]`
+      api_token: ENV["API_TOKEN"],
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["PRELUDE_BASE_URL"]`
+      base_url: ENV["PRELUDE_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: PreludeSDK::Client::DEFAULT_MAX_RETRIES,
+      timeout: PreludeSDK::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: PreludeSDK::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: PreludeSDK::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end