datadome_fraud_sdk_ruby 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b8713046c4239173b65684b92fd86c95371bd74f7dfeb71ad7cfe7c8d3ba2f5
-  data.tar.gz: 5acc8e0e5f7b878ebc92637052cd10b7fca76f20492cafc47e02741fcc2064d2
+  metadata.gz: c2434a89b8290f901080492cb9491bfa2c56cf62da19504d1eb6ae987d411fdb
+  data.tar.gz: 121d6dbc02235af5e37c71a7acf58ce65bc1c8e3d65df37aea5e98ac115b8752
 SHA512:
-  metadata.gz: 42b2be325fe412f8e21a1a0f7be4641a01568f5b3e4ee06cdde3af8c264ec4f686530d00f34877c58fc8171c62ddc68dadd2ba0cafbb94504ba1798e2f5993e4
-  data.tar.gz: 72364626f1bfe4378696d3db32a3617a7f909642c0d18baa83f0c3cece393492321afe9830ca116aee0ea389d49459feedaf4c397538a9e566c7b57b6e1dfcd7
+  metadata.gz: 78b9a208bff8a41ea879cc4e70584f63156af5892b8cc2402647d112224902f071bc98b769903aa445ce5afebdde5d316de7064b1123028929a148cc63a4bce1
+  data.tar.gz: bebb991f6d5bd9f9c1faef493473e145cef3f4755b0633e26671d604e6ee0d39413d3f5f7c30c24adea391d52ce0d11364693de07f9c93841874a54a5a774445

data/lib/constants.rb

@@ -1,2 +1,2 @@
-SDK_VERSION = '1.0.0'
+SDK_VERSION = '2.0.0'
 SDK_NAME = 'datadome_fraud_sdk_ruby'

data/lib/datadome_fraud_sdk_ruby.rb

@@ -3,6 +3,7 @@
 require "faraday"
 require "json"
 require_relative "model/events"
+require_relative "model/location"
 require_relative "model/user"
 require_relative "model/session"
 require_relative "model/operation"
@@ -12,21 +13,21 @@ require_relative "model/api/response"
 class DataDome
   attr_accessor :timeout, :endpoint, :logger
 
-  def initialize(timeout = 1500, endpoint = "account-api.datadome.co", logger = Logger.new(STDOUT))
+  def initialize(timeout: 1500, endpoint: "account-api.datadome.co", logger: Logger.new(STDOUT))
     @timeout = timeout
     @endpoint = endpoint
     @logger = logger
   end
 
-  def validate(request, event)
-    if event.status == StatusType::UNDEFINED
-      event.status = StatusType::SUCCEEDED
+  def validate(request:, event:)
+    if event.status == DataDomeStatusType::UNDEFINED
+      event.status = DataDomeStatusType::SUCCEEDED
     end
 
     payload = build_payload(request, event)
 
     begin
-      api_response = sendRequest(OperationType::VALIDATE, event.action, payload)
+      api_response = send_request(DataDomeOperationType::VALIDATE, event.action, payload)
 
       begin
         body = JSON.parse(api_response.body) unless api_response.body.nil?
@@ -36,13 +37,13 @@ class DataDome
       end
 
       if api_response.success?
-        datadome_response = DataDomeResponseSuccess.new(DataDomeResponseAction::ALLOW, DataDomeResponseStatus::OK, body["reasons"], body["ip"], body["location"])
+        datadome_response = DataDomeResponseSuccess.new(DataDomeResponseAction::ALLOW, DataDomeResponseStatus::OK, body["reasons"], body["ip"], DataDomeLocation.new(location: body["location"]))
         if body["action"] === DataDomeResponseAction::DENY
           datadome_response.action = DataDomeResponseAction::DENY
         end
       else
         @logger.error("DataDome: error on Fraud API /validate response #{body["errors"]}")
-        return DataDomeResponseError.new(DataDomeResponseAction::ALLOW, DataDomeResponseStatus::FAILURE, body["message"], body["errors"])
+        return DataDomeResponseError.new(DataDomeResponseAction::ALLOW, DataDomeResponseStatus::FAILURE, body["message"], body["errors"].map { |error| DataDomeError.new(error) })
       end
     rescue Faraday::TimeoutError => e
       return DataDomeResponseError.new(DataDomeResponseAction::ALLOW, DataDomeResponseStatus::TIMEOUT, "DataDome Fraud API request timeout", e.message)
@@ -53,15 +54,15 @@ class DataDome
     datadome_response
   end
 
-  def collect(request, event)
-    if event.status == StatusType::UNDEFINED
-      event.status = StatusType::FAILED
+  def collect(request:, event:)
+    if event.status == DataDomeStatusType::UNDEFINED
+      event.status = DataDomeStatusType::FAILED
     end
 
     payload = build_payload(request, event)
 
     begin
-      api_response = sendRequest(OperationType::COLLECT, event.action, payload)
+      api_response = send_request(DataDomeOperationType::COLLECT, event.action, payload)
 
       if api_response.success?
         datadome_response = DataDomeResponseSuccess.new(nil, DataDomeResponseStatus::OK, nil, nil, nil)
@@ -69,7 +70,7 @@ class DataDome
         begin
           body = JSON.parse(api_response.body)
           @logger.error("DataDome: error on Fraud API /collect response #{body["errors"]}")
-          datadome_response = DataDomeResponseError.new(nil, DataDomeResponseStatus::FAILURE, body["message"], body["errors"])
+          datadome_response = DataDomeResponseError.new(nil, DataDomeResponseStatus::FAILURE, body["message"], body["errors"].map { |error| DataDomeError.new(error) })
         rescue JSON::ParserError => e
           @logger.error("DataDome: error parsing JSON from Fraud API /collect #{e.message}")
           return DataDomeResponseError.new(nil, DataDomeResponseStatus::FAILURE, "DataDome: error parsing JSON from Fraud API", e.message)
@@ -86,21 +87,28 @@ class DataDome
 
   private
 
-  def sendRequest(operation, event, payload)
-    api_response = client.post("/v1/" + operation + "/" + event) do |req|
-      req.body = payload.to_json
+  def build_payload(request, event)
+    # Check if the request is an instance of DataDomeRequest
+    if request.instance_of?(DataDomeRequest)
+      # If it is, simply merge the event data with the request data
+      payload = event.merge_with(request)
+    else
+      # If it's not, create a new instance of DataDomeHeaders
+      datadome_headers = DataDomeHeaders.new
+      # Populate the DataDomeHeaders instance with data from the HTTP request
+      datadome_headers.build_from_http_request(request)
+      # Create a new DataDomeRequest instance with the DataDomeHeaders instance
+      # and merge the event data with the DataDomeRequest
+      payload = event.merge_with(DataDomeRequest.new(datadome_headers))
     end
-    api_response
+    payload
   end
 
-  def build_payload(request, event)
-    metadata = event.merge_with(DataDomeRequest.new(request))
-    payload = {}
-    metadata.instance_variables.each do |var|
-      key = var.to_s.delete("@") # Remove '@' from variable name to get key
-      payload[key] = metadata.instance_variable_get(var)
+  def send_request(operation, event, payload)
+    api_response = client.post("/v1/" + operation + "/" + event) do |req|
+      req.body = payload.to_json
     end
-    payload
+    api_response
   end
 
   def client

data/lib/model/address.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
-class Address
-  attr_accessor :name, :line1, :line2, :city, :countryCode, :regionCode, :zipCode
+class DataDomeAddress
+  attr_accessor :name, :line1, :line2, :city, :country_code, :region_code, :zip_code
 
-  def initialize(name = nil, line1 = nil, line2 = nil, city = nil, countryCode = nil, regionCode = nil, zipCode = nil)
+  def initialize(name: nil, line1: nil, line2: nil, city: nil, country_code: nil, region_code: nil, zip_code: nil)
     @name = name
     @line1 = line1
     @line2 = line2
     @city = city
-    @countryCode = countryCode
-    @regionCode = regionCode
-    @zipCode = zipCode
+    @country_code = country_code
+    @region_code = region_code
+    @zip_code = zip_code
   end
 
   def to_s
-    "Address: name=#{name}, line1=#{line1}, line2=#{line2}, city=#{city}, countryCode=#{countryCode}, regionCode=#{regionCode}, zipCode=#{zipCode}"
+    "DataDomeAddress: name=#{@name}, line1=#{@line1}, line2=#{@line2}, city=#{@city}, countryCode=#{@country_code}, regionCode=#{@region_code}, zipCode=#{@zip_code}"
   end
 
   def to_json(options = {})
@@ -23,9 +23,9 @@ class Address
       line1: line1,
       line2: line2,
       city: city,
-      countryCode: countryCode,
-      regionCode: regionCode,
-      zipCode: zipCode,
+      countryCode: country_code,
+      regionCode: region_code,
+      zipCode: zip_code,
     }.to_json
   end
 end

data/lib/model/api/request.rb

@@ -3,80 +3,203 @@
 require_relative "../../constants"
 
 class DataDomeModule
-  attr_accessor :requestTimeMicros, :name, :version
+  attr_reader :request_time_micros, :name, :version
 
   def initialize
-    @requestTimeMicros = Time.now.strftime("%s%6N").to_i
+    @request_time_micros = Time.now.strftime("%s%6N").to_i
     @name = "Fraud SDK Ruby"
     @version = SDK_VERSION
   end
 
-  def to_json(options = {})
+  def to_hash
     {
-      requestTimeMicros: @requestTimeMicros,
+      requestTimeMicros: @request_time_micros,
       name: @name,
       version: @version,
-    }.to_json
+    }
   end
 end
 
 class DataDomeHeaders
-  attr_accessor :addr, :clientIp, :contentType, :host, :port, :xRealIP, :xForwardedForIp,
-                :acceptEncoding, :acceptLanguage, :accept, :method, :protocol, :serverHostname,
-                :referer, :userAgent, :from, :request, :origin, :acceptCharset, :connection,
-                :clientID, :secCHUA, :secCHUAMobile, :secCHUAPlatform, :secCHUAArch,
-                :secCHUAFullVersionList, :secCHUAModel, :secCHDeviceMemory
+  attr_accessor :addr, :client_ip, :content_type, :host, :port, :x_real_ip, :x_forwarded_for_ip,
+                :accept_encoding, :accept_language, :accept, :method, :protocol, :server_hostname,
+                :referer, :user_agent, :from, :request, :origin, :accept_charset, :connection,
+                :client_id, :sec_ch_ua, :sec_ch_ua_mobile, :sec_ch_ua_platform, :sec_ch_ua_arch,
+                :sec_ch_ua_full_version_list, :sec_ch_ua_model, :sec_ch_device_memory
+
+  def initialize(addr: nil, client_ip: nil, content_type: nil, host: nil, port: nil, x_real_ip: nil,
+                 x_forwarded_for_ip: nil, accept_encoding: nil, accept_language: nil, accept: nil,
+                 method: nil, protocol: nil, server_hostname: nil, referer: nil, user_agent: nil,
+                 from: nil, request: nil, origin: nil, accept_charset: nil, connection: nil,
+                 client_id: nil, sec_ch_ua: nil, sec_ch_ua_mobile: nil, sec_ch_ua_platform: nil,
+                 sec_ch_ua_arch: nil, sec_ch_ua_full_version_list: nil, sec_ch_ua_model: nil,
+                 sec_ch_device_memory: nil)
+    @addr = addr
+    @client_ip = client_ip
+    @content_type = content_type
+    @host = host
+    @port = port
+    @x_real_ip = x_real_ip
+    @x_forwarded_for_ip = x_forwarded_for_ip
+    @accept_encoding = accept_encoding
+    @accept_language = accept_language
+    @accept = accept
+    @method = method
+    @protocol = protocol
+    @server_hostname = server_hostname
+    @referer = referer
+    @user_agent = user_agent
+    @from = from
+    @request = request
+    @origin = origin
+    @accept_charset = accept_charset
+    @connection = connection
+    @client_id = client_id
+    @sec_ch_ua = sec_ch_ua
+    @sec_ch_ua_mobile = sec_ch_ua_mobile
+    @sec_ch_ua_platform = sec_ch_ua_platform
+    @sec_ch_ua_arch = sec_ch_ua_arch
+    @sec_ch_ua_full_version_list = sec_ch_ua_full_version_list
+    @sec_ch_ua_model = sec_ch_ua_model
+    @sec_ch_device_memory = sec_ch_device_memory
+  end
 
-  def initialize(request)
+  def build_from_http_request(request)
     @addr = request.remote_ip
-    @clientIp = request.headers["HTTP_CLIENT_IP"]
-    @contentType = truncate(request.headers["Content-Type"], 64) # this value is a meta-variable of the request
-    @host = truncate(request.headers["HTTP_HOST"], 512)
+    @client_ip = request.headers["HTTP_CLIENT_IP"]
+    @content_type = request.headers["Content-Type"] # this value is a meta-variable of the request
+    @host = request.headers["HTTP_HOST"]
     @port = request.port || 0
-    @xRealIP = truncate(request.headers["HTTP_X_REAL_IP"], 128)
-    @xForwardedForIp = truncate(request.headers["HTTP_X_FORWARDED_FOR"], -512)
-    @acceptEncoding = truncate(request.headers["HTTP_ACCEPT_ENCODING"], 128)
-    @acceptLanguage = truncate(request.headers["HTTP_ACCEPT_LANGUAGE"], 256)
-    @accept = truncate(request.headers["HTTP_ACCEPT"], 512)
+    @x_real_ip = request.headers["HTTP_X_REAL_IP"]
+    @x_forwarded_for_ip = request.headers["HTTP_X_FORWARDED_FOR"]
+    @accept_encoding = request.headers["HTTP_ACCEPT_ENCODING"]
+    @accept_language = request.headers["HTTP_ACCEPT_LANGUAGE"]
+    @accept = request.headers["HTTP_ACCEPT"]
     @method = request.method
     @protocol = request.protocol.gsub("://", "")
-    @serverHostname = truncate(request.headers["HTTP_HOST"], 256)
-    @referer = truncate(request.headers["HTTP_REFERER"], 1024)
-    @userAgent = truncate(request.headers["HTTP_USER_AGENT"], 768)
-    @from = truncate(request.headers["HTTP_FROM"], 128)
-    @request = [request.path, request.query_string].reject(&:blank?).join("?")[0, 2048]
-    @origin = truncate(request.headers["HTTP_ORIGIN"], 512)
-    @acceptCharset = truncate(request.headers["HTTP_ACCEPT_CHARSET"], 128)
-    @connection = truncate(request.headers["HTTP_CONNECTION"], 128)
-    @clientID = request.cookies["datadome"]
-    @secCHUA = truncate(request.headers["HTTP_SEC_CH_UA"], 128)
-    @secCHUAMobile = truncate(request.headers["HTTP_SEC_CH_UA_MOBILE"], 8)
-    @secCHUAPlatform = truncate(request.headers["HTTP_SEC_CH_UA_PLATFORM"], 32)
-    @secCHUAArch = truncate(request.headers["HTTP_SEC_CH_UA_ARCH"], 16)
-    @secCHUAFullVersionList = truncate(request.headers["HTTP_SEC_CH_UA_FULL_VERSION_LIST"], 256)
-    @secCHUAModel = truncate(request.headers["HTTP_SEC_CH_UA_MODEL"], 128)
-    @secCHDeviceMemory = truncate(request.headers["HTTP_SEC_CH_DEVICE_MEMORY"], 8)
+    @server_hostname = request.headers["HTTP_HOST"]
+    @referer = request.headers["HTTP_REFERER"]
+    @user_agent = request.headers["HTTP_USER_AGENT"]
+    @from = request.headers["HTTP_FROM"]
+    @request = [request.path, request.query_string].reject(&:blank?).join("?")
+    @origin = request.headers["HTTP_ORIGIN"]
+    @accept_charset = request.headers["HTTP_ACCEPT_CHARSET"]
+    @connection = request.headers["HTTP_CONNECTION"]
+    @client_id = request.cookies["datadome"]
+    @sec_ch_ua = request.headers["HTTP_SEC_CH_UA"]
+    @sec_ch_ua_mobile = request.headers["HTTP_SEC_CH_UA_MOBILE"]
+    @sec_ch_ua_platform = request.headers["HTTP_SEC_CH_UA_PLATFORM"]
+    @sec_ch_ua_arch = request.headers["HTTP_SEC_CH_UA_ARCH"]
+    @sec_ch_ua_full_version_list = request.headers["HTTP_SEC_CH_UA_FULL_VERSION_LIST"]
+    @sec_ch_ua_model = request.headers["HTTP_SEC_CH_UA_MODEL"]
+    @sec_ch_device_memory = request.headers["HTTP_SEC_CH_DEVICE_MEMORY"]
   end
 
-  def truncate(value, max_length = nil)
-    return value if value.nil? || max_length.nil?
+  def truncate_attributes
+    # Hash containing the headers size limit
+    headers_max_length = {
+      addr: nil, # No size limit
+      client_ip: nil,
+      content_type: 64,
+      host: 512,
+      port: nil,
+      x_real_ip: 128,
+      x_forwarded_for_ip: -512, # Truncate backwards
+      accept_encoding: 128,
+      accept_language: 256,
+      accept: 512,
+      method: nil,
+      protocol: nil,
+      server_hostname: 256,
+      referer: 1024,
+      user_agent: 768,
+      from: 128,
+      request: 2048,
+      origin: 512,
+      accept_charset: 128,
+      connection: 128,
+      client_id: nil,
+      sec_ch_ua: 128,
+      sec_ch_ua_mobile: 8,
+      sec_ch_ua_platform: 32,
+      sec_ch_ua_arch: 16,
+      sec_ch_ua_full_version_list: 256,
+      sec_ch_ua_model: 128,
+      sec_ch_device_memory: 8,
+    }
+
+    headers_max_length.each do |attribute, max_size|
+      next unless self.respond_to?("#{attribute}=") # Skip if attribute setter method doesn't exist
+
+      value = self.send(attribute) # Get the value of the attribute dynamically
+      next unless value.is_a?(String) # Skip if the value is not a string
 
-    max_length < 0 ? value[max_length] : value[0, max_length]
+      if max_size && value.length > max_size
+        # Truncate the value if it exceeds the max size
+        truncated_value = max_size < 0 ? value[max_size] : value[0, max_size]
+        self.send("#{attribute}=", truncated_value) # Set the truncated value to the attribute
+      end
+    end
+  end
+
+  def to_hash
+    {
+      addr: @addr,
+      clientIp: @client_ip,
+      contentType: @content_type,
+      host: @host,
+      port: @port,
+      xRealIP: @x_real_ip,
+      xForwardedForIp: @x_forwarded_for_ip,
+      acceptEncoding: @accept_encoding,
+      acceptLanguage: @accept_language,
+      accept: @accept,
+      method: @method,
+      protocol: @protocol,
+      serverHostname: @server_hostname,
+      referer: @referer,
+      userAgent: @user_agent,
+      from: @from,
+      request: @request,
+      origin: @origin,
+      acceptCharset: @accept_charset,
+      connection: @connection,
+      clientID: @client_id,
+      secCHUA: @sec_ch_ua,
+      secCHUAMobile: @sec_ch_ua_mobile,
+      secCHUAPlatform: @sec_ch_ua_platform,
+      secCHUAArch: @sec_ch_ua_arch,
+      secCHUAFullVersionList: @sec_ch_ua_full_version_list,
+      secCHUAModel: @sec_ch_ua_model,
+      secCHDeviceMemory: @sec_ch_device_memory,
+    }
   end
 end
 
 class DataDomeRequest
-  attr_accessor :module, :header
+  attr_reader :module, :header, :account, :status, :session, :user
 
-  def initialize(request)
+  def initialize(datadome_headers)
     @module = DataDomeModule.new
-    @header = DataDomeHeaders.new(request)
+    @header = datadome_headers
+    # Do not forget headers truncation
+    @header.truncate_attributes
+    # Dynamic attributes that holds Event data when payload is created
+    @account = {}
+    @status = {}
+    @session = {}
+    @user = {}
   end
 
   def to_json(options = {})
-    {
-      module: @module.to_json,
-      header: @header.to_json,
-    }.to_json
+    data = {
+      module: @module.to_hash,
+      header: @header.to_hash,
+      account: @account,
+      status: @status,
+      session: @session,
+      user: @user,
+    }
+    JSON.generate(data, options)
   end
 end

data/lib/model/api/response.rb

@@ -11,8 +11,13 @@ module DataDomeResponseStatus
   TIMEOUT = "timeout"
 end
 
-class Error
-  attr_accessor :field, :error
+class DataDomeError
+  attr_reader :field, :error
+
+  def initialize(error)
+    @field = error&.fetch("field", nil)
+    @error = error&.fetch("error", nil)
+  end
 end
 
 class DataDomeResponse
@@ -24,7 +29,7 @@ class DataDomeResponse
   end
 
   def to_s
-    "DataDomeResponse: action=#{action}, status=#{status}"
+    "DataDomeResponse: action=#{@action}, status=#{@status}"
   end
 
   def to_json(options = {})
@@ -36,7 +41,7 @@ class DataDomeResponse
 end
 
 class DataDomeResponseSuccess < DataDomeResponse
-  attr_accessor :ip, :reasons, :location
+  attr_reader :ip, :reasons, :location
 
   def initialize(action, status, reasons, ip, location)
     super(action, status)
@@ -46,7 +51,7 @@ class DataDomeResponseSuccess < DataDomeResponse
   end
 
   def to_s
-    "DataDomeResponseSuccess: action=#{action}, status=#{status}, reasons=#{reasons}, ip=#{ip}, location=#{location}"
+    "DataDomeResponseSuccess: action=#{@action}, status=#{@status}, reasons=#{@reasons}, ip=#{@ip}, location=#{@location}"
   end
 
   def to_json(options = {})
@@ -61,7 +66,7 @@ class DataDomeResponseSuccess < DataDomeResponse
 end
 
 class DataDomeResponseError < DataDomeResponse
-  attr_accessor :message, :errors
+  attr_reader :message, :errors
 
   def initialize(action, status, message, errors)
     super(action, status)
@@ -70,7 +75,7 @@ class DataDomeResponseError < DataDomeResponse
   end
 
   def to_s
-    "DataDomeResponseError: action=#{action}, status=#{status}, message=#{message}, errors=#{errors}"
+    "DataDomeResponseError: action=#{@action}, status=#{@status}, message=#{@message}, errors=#{@errors}"
   end
 
   def to_json(options = {})

data/lib/model/events.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-module ActionType
+module DataDomeActionType
   LOGIN = "login"
   REGISTER = "registration"
 end
 
-module StatusType
+module DataDomeStatusType
   SUCCEEDED = "succeeded"
   FAILED = "failed"
   UNDEFINED = "undefined"
@@ -14,7 +14,7 @@ end
 class DataDomeEvent
   attr_accessor :action, :status, :account
 
-  def initialize(action, account, status = StatusType::UNDEFINED)
+  def initialize(action, account, status = DataDomeStatusType::UNDEFINED)
     @action = action
     @account = account
     @status = status
@@ -27,17 +27,17 @@ class DataDomeEvent
   end
 end
 
-class LoginEvent < DataDomeEvent
-  def initialize(account, status = StatusType::UNDEFINED)
-    super(ActionType::LOGIN, account, status)
+class DataDomeLoginEvent < DataDomeEvent
+  def initialize(account:, status: DataDomeStatusType::UNDEFINED)
+    super(DataDomeActionType::LOGIN, account, status)
   end
 end
 
-class RegistrationEvent < DataDomeEvent
+class DataDomeRegistrationEvent < DataDomeEvent
   attr_accessor :user, :session
 
-  def initialize(account, user, session = nil, status = StatusType::UNDEFINED)
-    super(ActionType::REGISTER, account, status)
+  def initialize(account:, user:, session: nil, status: DataDomeStatusType::UNDEFINED)
+    super(DataDomeActionType::REGISTER, account, status)
     @session = session
     @user = user
   end

data/lib/model/location.rb

@@ -0,0 +1,21 @@
+class DataDomeLocation
+  attr_reader :country_code, :country, :city
+
+  def initialize(location: nil)
+    @country_code = location&.fetch("countryCode", nil)
+    @country = location&.fetch("country", nil)
+    @city = location&.fetch("city", nil)
+  end
+
+  def to_s
+    "DataDomeLocation: countryCode=#{@country_code}, country=#{@country}, city=#{@city}"
+  end
+
+  def to_json(options = {})
+    {
+      countryCode: @country_code,
+      country: @country,
+      city: @city,
+    }.to_json
+  end
+end

data/lib/model/operation.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module OperationType
+module DataDomeOperationType
   VALIDATE = "validate"
   COLLECT = "collect"
 end

data/lib/model/session.rb

@@ -3,22 +3,21 @@
 require "time"
 
 class DataDomeSession
-  attr_reader :id, :createdAt
+  attr_reader :id, :created_at
 
-  def initialize(id, createdAt = Time.now.iso8601)
+  def initialize(id:, created_at: Time.now.iso8601)
     @id = id
-    @createdAt = createdAt
+    @created_at = created_at
   end
 
   def to_s
-    "DataDomeSession: id=#{id}, createdAt =#{createdAt}"
+    "DataDomeSession: id=#{@id}, createdAt =#{@created_at}"
   end
 
   def to_json(options = {})
     {
       id: id,
-      createdAt: createdAt,
+      createdAt: created_at,
     }.to_json
   end
 end
-

data/lib/model/user.rb

@@ -3,7 +3,7 @@
 require "time"
 require_relative "./address"
 
-module Title
+module DataDomeTitle
   EMPTY = nil
   MR = "mr"
   MRS = "mrs"
@@ -11,27 +11,29 @@ module Title
 end
 
 class DataDomeUser
-  def initialize(id, title = nil, firstName = nil, lastName = nil, createdAt = Time.now.iso8601, phone = nil, email = nil, address = nil)
+  attr_accessor :id, :title, :first_name, :last_name, :created_at, :phone, :email, :address
+
+  def initialize(id:, title: nil, first_name: nil, last_name: nil, created_at: Time.now.iso8601, phone: nil, email: nil, address: nil)
     @id = id
     @title = title
-    @firstName = firstName
-    @lastName = lastName
-    @createdAt = createdAt
+    @first_name = first_name
+    @last_name = last_name
+    @created_at = created_at
     @phone = phone
     @email = email
     @address = address
   end
 
   def to_s
-    "DataDomeUser: id=#{id}, title =#{title}, firstname =#{firstName}, lastname =#{lastName} createdAt =#{createdAt}, phone =#{phone}, address= #{address}"
+    "DataDomeUser: id=#{@id}, title=#{@title}, firstName=#{@first_name}, lastName=#{@last_name}, createdAt=#{@created_at}, phone=#{@phone}, address=#{@address}"
   end
 
   def to_json(options = {})
     {
       id: @id,
-      firstName: @firstName,
-      lastName: @lastName,
-      createdAt: @createdAt,
+      firstName: @first_name,
+      lastName: @last_name,
+      createdAt: @created_at,
       phone: @phone,
       email: @email,
       address: @address,

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: datadome_fraud_sdk_ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - DataDome
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-04-18 00:00:00.000000000 Z
+date: 2024-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '0'
 description: DataDome Fraud Protection - Ruby SDK
 email: support@datadome.co
 executables: []
@@ -37,6 +37,7 @@ files:
 - lib/model/api/request.rb
 - lib/model/api/response.rb
 - lib/model/events.rb
+- lib/model/location.rb
 - lib/model/operation.rb
 - lib/model/session.rb
 - lib/model/user.rb