oursprivacy-ingest 0.1.0

data/lib/oursprivacy_ingest/models/visitor_upsert_response.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OursprivacyIngest
+  module Models
+    # @see OursprivacyIngest::Resources::Visitor#upsert
+    class VisitorUpsertResponse < OursprivacyIngest::Internal::Type::BaseModel
+      # @!attribute success
+      #
+      #   @return [Boolean, OursprivacyIngest::Models::VisitorUpsertResponse::Success]
+      required :success, enum: -> { OursprivacyIngest::Models::VisitorUpsertResponse::Success }
+
+      # @!method initialize(success:)
+      #   @param success [Boolean, OursprivacyIngest::Models::VisitorUpsertResponse::Success]
+
+      # @see OursprivacyIngest::Models::VisitorUpsertResponse#success
+      module Success
+        extend OursprivacyIngest::Internal::Type::Enum
+
+        TRUE = true
+
+        # @!method self.values
+        #   @return [Array<Boolean>]
+      end
+    end
+  end
+end

data/lib/oursprivacy_ingest/models.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module OursprivacyIngest
+  [
+    OursprivacyIngest::Internal::Type::BaseModel,
+    *OursprivacyIngest::Internal::Type::BaseModel.subclasses
+  ].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, OursprivacyIngest::Internal::AnyHash) } }
+  end
+
+  OursprivacyIngest::Internal::Util.walk_namespaces(OursprivacyIngest::Models).each do |mod|
+    case mod
+    in OursprivacyIngest::Internal::Type::Enum | OursprivacyIngest::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
+
+  OursprivacyIngest::Internal::Util.walk_namespaces(OursprivacyIngest::Models)
+                                   .lazy
+                                   .grep(OursprivacyIngest::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
+
+  TrackEventParams = OursprivacyIngest::Models::TrackEventParams
+
+  VisitorUpsertParams = OursprivacyIngest::Models::VisitorUpsertParams
+end

data/lib/oursprivacy_ingest/request_options.rb

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

data/lib/oursprivacy_ingest/resources/track.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module OursprivacyIngest
+  module Resources
+    class Track
+      # Some parameter documentations has been truncated, see
+      # {OursprivacyIngest::Models::TrackEventParams} for more details.
+      #
+      # Track events from your server. Please include at least one of: userId,
+      # externalId, or email. These properties help us associate events with existing
+      # users. For all fields, null values unset the property and undefined values do
+      # not unset existing properties.
+      #
+      # @overload event(token:, event:, default_properties: nil, distinct_id: nil, email: nil, event_properties: nil, external_id: nil, time: nil, user_id: nil, user_properties: nil, request_options: {})
+      #
+      # @param token [String] The token for your Ours Privacy Source. You can find this in the Ours dashboard.
+      #
+      # @param event [String] The name of the event you're tracking. This must be whitelisted in the Ours dash
+      #
+      # @param default_properties [OursprivacyIngest::Models::TrackEventParams::DefaultProperties, nil] These properties are used throughout the Ours app to pass known values onto dest
+      #
+      # @param distinct_id [String, nil] A unique identifier for the event. This helps prevent duplicate events.
+      #
+      # @param email [String, nil] The email address of a user. We will associate this event with the user or creat
+      #
+      # @param event_properties [Hash{Symbol=>Object, nil}, nil] Any additional event properties you want to pass along.
+      #
+      # @param external_id [String, nil] The externalId (the ID in your system) of a user. We will associate this event w
+      #
+      # @param time [Float, nil] The time at which the event occurred in milliseconds since UTC epoch. The time m
+      #
+      # @param user_id [String, nil] The Ours user id stored in local storage and cookies on your web properties. If
+      #
+      # @param user_properties [OursprivacyIngest::Models::TrackEventParams::UserProperties, nil] Properties to set on the visitor. (optional) You can also update these propertie
+      #
+      # @param request_options [OursprivacyIngest::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [OursprivacyIngest::Models::TrackEventResponse]
+      #
+      # @see OursprivacyIngest::Models::TrackEventParams
+      def event(params)
+        parsed, options = OursprivacyIngest::TrackEventParams.dump_request(params)
+        path = @client.base_url_overridden? ? "track" : "https://api.oursprivacy.com/api/v1/track"
+        @client.request(
+          method: :post,
+          path: path,
+          body: parsed,
+          model: OursprivacyIngest::Models::TrackEventResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [OursprivacyIngest::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/oursprivacy_ingest/resources/visitor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module OursprivacyIngest
+  module Resources
+    class Visitor
+      # Some parameter documentations has been truncated, see
+      # {OursprivacyIngest::Models::VisitorUpsertParams} for more details.
+      #
+      # Define visitor properties on an existing visitor or create a new visitor. Note:
+      # This does not fire an event. If you want to fire an event, use the track method
+      # and include properties for the visitor.
+      #
+      # @overload upsert(token:, user_properties:, default_properties: nil, email: nil, external_id: nil, user_id: nil, request_options: {})
+      #
+      # @param token [String] The token for your Ours Privacy Source. You can find this in the Ours dashboard.
+      #
+      # @param user_properties [OursprivacyIngest::Models::VisitorUpsertParams::UserProperties] User properties to associate with this user. The existing user properties will b
+      #
+      # @param default_properties [OursprivacyIngest::Models::VisitorUpsertParams::DefaultProperties, nil] These properties are used throughout the Ours app to pass known values onto dest
+      #
+      # @param email [String, nil] The email address of a user. We will associate this event with the user or creat
+      #
+      # @param external_id [String, nil] The externalId (the ID in your system) of a user. We will associate this event w
+      #
+      # @param user_id [String, nil] The Ours user id stored in local storage and cookies on your web properties. If
+      #
+      # @param request_options [OursprivacyIngest::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [OursprivacyIngest::Models::VisitorUpsertResponse]
+      #
+      # @see OursprivacyIngest::Models::VisitorUpsertParams
+      def upsert(params)
+        parsed, options = OursprivacyIngest::VisitorUpsertParams.dump_request(params)
+        path = @client.base_url_overridden? ? "identify" : "https://api.oursprivacy.com/api/v1/identify"
+        @client.request(
+          method: :post,
+          path: path,
+          body: parsed,
+          model: OursprivacyIngest::Models::VisitorUpsertResponse,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [OursprivacyIngest::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/oursprivacy_ingest/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OursprivacyIngest
+  VERSION = "0.1.0"
+end

data/lib/oursprivacy_ingest.rb

@@ -0,0 +1,59 @@
+# 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 "oursprivacy_ingest/version"
+require_relative "oursprivacy_ingest/internal/util"
+require_relative "oursprivacy_ingest/internal/type/converter"
+require_relative "oursprivacy_ingest/internal/type/unknown"
+require_relative "oursprivacy_ingest/internal/type/boolean"
+require_relative "oursprivacy_ingest/internal/type/file_input"
+require_relative "oursprivacy_ingest/internal/type/enum"
+require_relative "oursprivacy_ingest/internal/type/union"
+require_relative "oursprivacy_ingest/internal/type/array_of"
+require_relative "oursprivacy_ingest/internal/type/hash_of"
+require_relative "oursprivacy_ingest/internal/type/base_model"
+require_relative "oursprivacy_ingest/internal/type/base_page"
+require_relative "oursprivacy_ingest/internal/type/request_parameters"
+require_relative "oursprivacy_ingest/internal"
+require_relative "oursprivacy_ingest/request_options"
+require_relative "oursprivacy_ingest/file_part"
+require_relative "oursprivacy_ingest/errors"
+require_relative "oursprivacy_ingest/internal/transport/base_client"
+require_relative "oursprivacy_ingest/internal/transport/pooled_net_requester"
+require_relative "oursprivacy_ingest/client"
+require_relative "oursprivacy_ingest/models/track_event_params"
+require_relative "oursprivacy_ingest/models/track_event_response"
+require_relative "oursprivacy_ingest/models/visitor_upsert_params"
+require_relative "oursprivacy_ingest/models/visitor_upsert_response"
+require_relative "oursprivacy_ingest/models"
+require_relative "oursprivacy_ingest/resources/track"
+require_relative "oursprivacy_ingest/resources/visitor"

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

@@ -0,0 +1,46 @@
+# typed: strong
+
+module OursprivacyIngest
+  class Client < OursprivacyIngest::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(OursprivacyIngest::Resources::Track) }
+    attr_reader :track
+
+    sig { returns(OursprivacyIngest::Resources::Visitor) }
+    attr_reader :visitor
+
+    # @api private
+    sig { returns(T::Boolean) }
+    def base_url_overridden?
+    end
+
+    # Creates and returns a new client for interacting with the API.
+    sig do
+      params(
+        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(
+      # Override the default base URL for the API, e.g.,
+      # `"https://api.example.com/v2/"`. Defaults to `ENV["OURS_PRIVACY_BASE_URL"]`
+      base_url: ENV["OURS_PRIVACY_BASE_URL"],
+      # Max number of retries to attempt after a failed retryable request.
+      max_retries: OursprivacyIngest::Client::DEFAULT_MAX_RETRIES,
+      timeout: OursprivacyIngest::Client::DEFAULT_TIMEOUT_IN_SECONDS,
+      initial_retry_delay: OursprivacyIngest::Client::DEFAULT_INITIAL_RETRY_DELAY,
+      max_retry_delay: OursprivacyIngest::Client::DEFAULT_MAX_RETRY_DELAY
+    )
+    end
+  end
+end

data/rbi/oursprivacy_ingest/errors.rbi

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

data/rbi/oursprivacy_ingest/file_part.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module OursprivacyIngest
+  class FilePart
+    sig { returns(T.any(Pathname, StringIO, IO, String)) }
+    attr_reader :content
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :content_type
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :filename
+
+    # @api private
+    sig { returns(String) }
+    private def read
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_json(*a)
+    end
+
+    sig { params(a: T.anything).returns(String) }
+    def to_yaml(*a)
+    end
+
+    sig do
+      params(
+        content: T.any(Pathname, StringIO, IO, String),
+        filename: T.nilable(T.any(Pathname, String)),
+        content_type: T.nilable(String)
+      ).returns(T.attached_class)
+    end
+    def self.new(content, filename: nil, content_type: nil)
+    end
+  end
+end