eli 0.1.13

data/lib/eli/admin.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Eli
+  # Documentation for `Eli::Admin`.
+  #
+  # Administrative REST client used to manage admin sessions, accounts and to
+  # sign users in on their behalf.
+  module Admin
+    module_function
+
+    # Sign in.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.sign_in("user.email@domain.com", "seCr#t.passw0rd")
+    #     # 200
+    #     # { "data" => { "token" => "JWT session token" } }
+    #
+    #     # 400
+    #     # { "errors" => { "detail" => "invalid credentials" } }
+    def sign_in(email, password)
+      url = Eli::Config.base_url + "/rest/admin/sessions"
+
+      options = {
+        params: {
+          email: email,
+          password: password
+        }
+      }
+
+      Eli::RestApi.post(url, options)
+    end
+
+    # Checks whether the admin user is signed in or not.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.signed_in("JWT session token")
+    #     # true
+    #     # false
+    def signed_in(session_token)
+      url = Eli::Config.base_url + "/rest/admin/sessions/signed_in"
+
+      options = {
+        headers: { "authorization" => "Bearer #{session_token}" }
+      }
+
+      resp = Eli::RestApi.head(url, options)
+      resp.status == 200
+    end
+
+    # Returns the current admin user data.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.current_user("JWT session token")
+    #     # 200
+    #     # {
+    #     #   "data" => {
+    #     #     "active" => true,
+    #     #     "email" => "user@mail.com",
+    #     #     "id" => "732cf1c2-6299-41fa-8784-e458765743b7",
+    #     #     "language" => "en",
+    #     #     "name" => "User Name",
+    #     #     "timezone" => "Europe/London"
+    #     #   }
+    #     # }
+    #
+    #     # 404
+    #     # { "errors" => { "detail" => "Not Found" } }
+    def current_user(session_token)
+      url = Eli::Config.base_url + "/rest/admin/sessions"
+
+      options = {
+        headers: { "authorization" => "Bearer #{session_token}" }
+      }
+
+      Eli::RestApi.get(url, options)
+    end
+
+    # Refresh your token session returning a new session token.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.refresh("JWT session token")
+    #     # 200
+    #     # { "data" => { "token" => "JWT session token" } }
+    #
+    #     # 404
+    #     # { "errors" => { "detail" => "Not Found" } }
+    def refresh(session_token)
+      url = Eli::Config.base_url + "/rest/admin/sessions"
+
+      options = {
+        headers: { "authorization" => "Bearer #{session_token}" }
+      }
+
+      Eli::RestApi.put(url, options)
+    end
+
+    # Signs the admin user out closing and deleting the session.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.sign_out("JWT session token")
+    #     # 200
+    #     # { "data" => { "message" => "signed out successfully" } }
+    #
+    #     # 404
+    #     # { "errors" => { "detail" => "Not Found" } }
+    def sign_out(session_token)
+      url = Eli::Config.base_url + "/rest/admin/sessions"
+
+      options = {
+        headers: { "authorization" => "Bearer #{session_token}" }
+      }
+
+      Eli::RestApi.delete(url, options)
+    end
+
+    # Unlocks user making him/her able to sign in again.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.unlock("Unlock token")
+    #     # 202
+    #     # { "data" => { "message" => "account was successfully unlocked" } }
+    #
+    #     # 404
+    #     # { "errors" => { "detail" => "Not Found" } }
+    def unlock(unlock_token)
+      url = Eli::Config.base_url + "/rest/accounts/unlock"
+
+      options = {
+        params: { token: unlock_token }
+      }
+
+      Eli::RestApi.put(url, options)
+    end
+
+    # Confirms user's email.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.confirm("Confirmation token")
+    #     # 202
+    #     # { "data" => { "message" => "account was successfully confirmed" } }
+    #
+    #     # 404
+    #     # { "errors" => { "detail" => "Not Found" } }
+    def confirm(confirmation_token)
+      url = Eli::Config.base_url + "/rest/accounts/confirm"
+
+      options = {
+        params: { token: confirmation_token }
+      }
+
+      Eli::RestApi.put(url, options)
+    end
+
+    # Requests password recovery.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.request_password_recovery("app token", "user@example.com")
+    #     # 200
+    #     # { "data" => { "message" => "password recovery was successfully requested" } }
+    #
+    #     # 404
+    #     # { "errors" => { "detail" => "Not Found" } }
+    def request_password_recovery(app_token, email)
+      url = Eli::Config.base_url + "/rest/accounts/password/recover"
+
+      options = {
+        headers: { "app-token" => app_token },
+        params: { email: email }
+      }
+
+      Eli::RestApi.post(url, options)
+    end
+
+    # Recover password updating it.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.recover_password("token", "Secret.123", "Secret.123")
+    #     # 200
+    #     # { "data" => { "message" => "password was successfully recovered" } }
+    #
+    #     # 400
+    #     # { "errors" => { "detail" => "token is invalid" } }
+    #
+    #     # 400
+    #     # { "errors" => { "detail" => "password has an invalid format" } }
+    #
+    #     # 400
+    #     # { "errors" => { "detail" => "password and confirmation password are different" } }
+    def recover_password(token, password, password_confirmation)
+      url = Eli::Config.base_url + "/rest/accounts/password/recover"
+
+      options = {
+        params: {
+          token: token,
+          password: password,
+          password_confirmation: password_confirmation
+        }
+      }
+
+      Eli::RestApi.put(url, options)
+    end
+
+    # Admin signs in any user without password.
+    #
+    # ## Examples
+    #
+    #     Eli::Admin.signs_in(
+    #       "JWT session token",
+    #       { email: "user.email@domain.com", name: "User Name" },
+    #       "app_id"
+    #     )
+    #     # 200
+    #     # { "data" => { "user" => { "active" => true, "email" => "..." } } }
+    #
+    #     # 400
+    #     # { "errors" => { "detail" => "invalid credentials" } }
+    def signs_in(session_token, user_data, app_id)
+      url = Eli::Config.base_url + "/rest/admin/sessions/signs_in"
+
+      options = {
+        headers: { "authorization" => "Bearer #{session_token}" },
+        params: {
+          user_data: user_data,
+          app_id: app_id
+        }
+      }
+
+      Eli::RestApi.post(url, options)
+    end
+  end
+end

data/lib/eli/client.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+# Documentation for `Eli`.
+#
+# Public REST client used by applications integrating with Letmein. These are
+# the end-user facing endpoints (sessions and account management). The methods
+# are available directly on the `Eli` module, e.g. `Eli.sign_in(...)`.
+module Eli
+  module_function
+
+  # Sign in.
+  #
+  # ## Examples
+  #
+  #     Eli.sign_in("app token", "user.email@domain.com", "secret.password")
+  #     # 200
+  #     # { "data" => { "token" => "JWT session token" } }
+  #
+  #     # 400
+  #     # { "errors" => { "detail" => "invalid credentials" } }
+  def sign_in(app_token, email, password)
+    url = Eli::Config.base_url + "/rest/sessions"
+
+    options = {
+      headers: { "app-token" => app_token },
+      params: {
+        email: email,
+        password: password
+      }
+    }
+
+    Eli::RestApi.post(url, options)
+  end
+
+  # Checks whether the user is signed in or not.
+  #
+  # ## Examples
+  #
+  #     Eli.signed_in("JWT session token")
+  #     # true
+  #     # false
+  def signed_in(session_token)
+    url = Eli::Config.base_url + "/rest/sessions/signed_in"
+
+    options = {
+      headers: { "authorization" => "Bearer #{session_token}" }
+    }
+
+    resp = Eli::RestApi.head(url, options)
+    resp.status == 200
+  end
+
+  # Returns the current user data.
+  #
+  # ## Examples
+  #
+  #     Eli.current_user("JWT session token")
+  #     # 200
+  #     # {
+  #     #   "data" => {
+  #     #     "active" => true,
+  #     #     "email" => "user.name@domain.com",
+  #     #     "id" => "732cf1c2-6299-41fa-8784-e458765743b7",
+  #     #     "language" => "en",
+  #     #     "name" => "Adilson Chacon",
+  #     #     "timezone" => "Europe/London"
+  #     #   }
+  #     # }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def current_user(session_token)
+    url = Eli::Config.base_url + "/rest/sessions"
+
+    options = {
+      headers: { "authorization" => "Bearer #{session_token}" }
+    }
+
+    Eli::RestApi.get(url, options)
+  end
+
+  # Refresh your token session returning a new session token.
+  #
+  # ## Examples
+  #
+  #     Eli.refresh("JWT session token")
+  #     # 200
+  #     # { "data" => { "token" => "JWT session token" } }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def refresh(session_token)
+    url = Eli::Config.base_url + "/rest/sessions"
+
+    options = {
+      headers: { "authorization" => "Bearer #{session_token}" }
+    }
+
+    Eli::RestApi.put(url, options)
+  end
+
+  # Signs user out closing and deleting session.
+  #
+  # ## Examples
+  #
+  #     Eli.sign_out("JWT session token")
+  #     # 200
+  #     # { "data" => { "message" => "signed out successfully" } }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def sign_out(session_token)
+    url = Eli::Config.base_url + "/rest/sessions"
+
+    options = {
+      headers: { "authorization" => "Bearer #{session_token}" }
+    }
+
+    Eli::RestApi.delete(url, options)
+  end
+
+  # Unlocks user making him/her able to sign in again.
+  #
+  # ## Examples
+  #
+  #     Eli.unlock("Unlock token")
+  #     # 202
+  #     # { "data" => { "message" => "account was successfully unlocked" } }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def unlock(unlock_token)
+    url = Eli::Config.base_url + "/rest/accounts/unlock"
+
+    options = {
+      params: { token: unlock_token }
+    }
+
+    Eli::RestApi.put(url, options)
+  end
+
+  # Confirms user email.
+  #
+  # ## Examples
+  #
+  #     Eli.confirm("Confirmation token")
+  #     # 202
+  #     # { "data" => { "message" => "account was successfully confirmed" } }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def confirm(confirmation_token)
+    url = Eli::Config.base_url + "/rest/accounts/confirm"
+
+    options = {
+      params: { token: confirmation_token }
+    }
+
+    Eli::RestApi.put(url, options)
+  end
+
+  # Requests password recovery.
+  #
+  # ## Examples
+  #
+  #     Eli.request_password_recovery("app token", "user@example.com")
+  #     # 200
+  #     # { "data" => { "message" => "password recovery was successfully requested" } }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def request_password_recovery(app_token, email)
+    url = Eli::Config.base_url + "/rest/accounts/password/recover"
+
+    options = {
+      headers: { "app-token" => app_token },
+      params: { email: email }
+    }
+
+    Eli::RestApi.post(url, options)
+  end
+
+  # Recover password updating it.
+  #
+  # ## Examples
+  #
+  #     Eli.recover_password("token", "Secret.123", "Secret.123")
+  #     # 200
+  #     # { "data" => { "message" => "password was successfully recovered" } }
+  #
+  #     # 400
+  #     # { "errors" => { "detail" => "token is invalid" } }
+  #
+  #     # 400
+  #     # { "errors" => { "detail" => "password has an invalid format" } }
+  #
+  #     # 400
+  #     # { "errors" => { "detail" => "password and confirmation password are different" } }
+  def recover_password(token, password, password_confirmation)
+    url = Eli::Config.base_url + "/rest/accounts/password/recover"
+
+    options = {
+      params: {
+        token: token,
+        password: password,
+        password_confirmation: password_confirmation
+      }
+    }
+
+    Eli::RestApi.put(url, options)
+  end
+
+  # Updates the password of the signed in user.
+  #
+  # ## Examples
+  #
+  #     passwords = {
+  #       current_password: "Secret.123",
+  #       new_password: "NewSecret.1234",
+  #       new_password_confirmation: "NewSecret.1234"
+  #     }
+  #     Eli.update_password("JWT session token", passwords)
+  #     # 200
+  #     # { "data" => { "message" => "password was successfully changed" } }
+  #
+  #     # 400 or 404
+  #     # { "errors" => { "detail" => "Error message" } }
+  def update_password(session_token, passwords)
+    url = Eli::Config.base_url + "/rest/accounts/password/update"
+
+    options = {
+      headers: { "authorization" => "Bearer #{session_token}" },
+      params: passwords
+    }
+
+    Eli::RestApi.put(url, options)
+  end
+
+  # Resend email for account confirmation.
+  #
+  # ## Examples
+  #
+  #     Eli.resend_account_confirmation_email("App token", "user@example.com")
+  #     # 200
+  #     # { "data" => { "message" => "account confirmation email was successfully sent" } }
+  #
+  #     # 404
+  #     # { "errors" => { "detail" => "Not Found" } }
+  def resend_account_confirmation_email(app_token, email)
+    url = Eli::Config.base_url + "/rest/accounts/confirm/resend"
+
+    options = {
+      headers: { "app-token" => app_token },
+      params: { email: email }
+    }
+
+    Eli::RestApi.post(url, options)
+  end
+end

data/lib/eli/config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Eli
+  # Documentation for `Eli::Config`.
+  #
+  # Holds the configuration used by the library, the most important being the
+  # base URL of the Letmein server the client talks to.
+  class Config
+    DEFAULT_BASE_URL = "http://localhost:4000"
+
+    class << self
+      # Set base_url value.
+      #
+      # ### Example
+      #   Eli::Config.base_url = "http://localhost:4000"
+      def base_url=(value)
+        raise ArgumentError, "base_url must be a string" unless value.is_a?(String)
+
+        @base_url = value
+      end
+
+      # Get base_url value.
+      #
+      # Falls back to the `LETMEIN_BASE_URL` environment variable and finally to
+      # `DEFAULT_BASE_URL` when nothing was explicitly configured.
+      #
+      # ### Example
+      #   Eli::Config.base_url
+      def base_url
+        @base_url || ENV["LETMEIN_BASE_URL"] || DEFAULT_BASE_URL
+      end
+
+      # Resets any value set through `base_url=` (useful for tests).
+      def reset!
+        @base_url = nil
+      end
+    end
+  end
+end

data/lib/eli/rest_api.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "faraday"
+
+module Eli
+  # Documentation for `Eli::RestApi`.
+  #
+  # Thin wrapper around Faraday that mirrors the behaviour of the Elixir `Req`
+  # based client: it normalizes headers (always sending a JSON content type),
+  # encodes request bodies as JSON and appends params to the query string for
+  # the verbs that don't carry a body.
+  class RestApi
+    JSON_CONTENT_TYPE = "application/json"
+
+    # Lightweight response value object exposing `status` and the parsed `body`.
+    Response = Struct.new(:status, :body)
+
+    class << self
+      # Post.
+      #
+      # ## Examples
+      #
+      #     Eli::RestApi.post("/rest/your/endpoint", params: { foo: "bar" }, headers: { "token" => "A_TOKEN" })
+      def post(url, options = {})
+        request_with_body(:post, url, options)
+      end
+
+      # Put.
+      #
+      # ## Examples
+      #
+      #     Eli::RestApi.put("/rest/your/endpoint", params: { foo: "bar" }, headers: { "token" => "A_TOKEN" })
+      def put(url, options = {})
+        request_with_body(:put, url, options)
+      end
+
+      # Patch.
+      #
+      # ## Examples
+      #
+      #     Eli::RestApi.patch("/rest/your/endpoint", params: { foo: "bar" }, headers: { "token" => "A_TOKEN" })
+      def patch(url, options = {})
+        request_with_body(:patch, url, options)
+      end
+
+      # Get.
+      #
+      # ## Examples
+      #
+      #     Eli::RestApi.get("/rest/your/endpoint", params: { foo: "bar" }, headers: { "token" => "A_TOKEN" })
+      def get(url, options = {})
+        request_with_query(:get, url, options)
+      end
+
+      # Head.
+      #
+      # ## Examples
+      #
+      #     Eli::RestApi.head("/rest/your/endpoint", params: { foo: "bar" }, headers: { "token" => "A_TOKEN" })
+      def head(url, options = {})
+        request_with_query(:head, url, options)
+      end
+
+      # Delete.
+      #
+      # ## Examples
+      #
+      #     Eli::RestApi.delete("/rest/your/endpoint", params: { foo: "bar" }, headers: { "token" => "A_TOKEN" })
+      def delete(url, options = {})
+        request_with_query(:delete, url, options)
+      end
+
+      private
+
+      def request_with_body(method, url, options)
+        response = connection.run_request(
+          method,
+          url,
+          JSON.generate(options[:params] || {}),
+          normalize_headers(options[:headers])
+        )
+
+        build_response(response)
+      end
+
+      def request_with_query(method, url, options)
+        response = connection.run_request(
+          method,
+          build_url(url, options[:params]),
+          nil,
+          normalize_headers(options[:headers])
+        )
+
+        build_response(response)
+      end
+
+      def connection
+        Faraday.new
+      end
+
+      def build_response(response)
+        Response.new(response.status, parse_body(response.body))
+      end
+
+      def parse_body(body)
+        return body if body.nil? || body.to_s.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        body
+      end
+
+      def normalize_headers(headers)
+        headers = build_headers(headers)
+
+        if app_json_content_type?(headers)
+          headers
+        else
+          headers.merge(default_headers)
+        end
+      end
+
+      def build_headers(headers)
+        case headers
+        when nil
+          default_headers
+        when Hash
+          stringify(headers)
+        when Array
+          stringify(headers.to_h)
+        else
+          raise ArgumentError, "headers must be a Hash, an Array of pairs or nil"
+        end
+      end
+
+      def default_headers
+        { "content-type" => JSON_CONTENT_TYPE }
+      end
+
+      def stringify(headers)
+        headers.each_with_object({}) do |(key, value), acc|
+          acc[key.to_s] = value.to_s
+        end
+      end
+
+      def app_json_content_type?(headers)
+        headers.any? do |key, value|
+          key.to_s.upcase == "CONTENT-TYPE" && value.to_s.upcase == JSON_CONTENT_TYPE.upcase
+        end
+      end
+
+      def build_url(url, params)
+        return url if params.nil? || params.empty?
+
+        uri = URI.parse(url)
+        existing = uri.query ? URI.decode_www_form(uri.query).to_h : {}
+        merged = existing.merge(stringify_params(params))
+        uri.query = URI.encode_www_form(merged)
+        uri.to_s
+      end
+
+      def stringify_params(params)
+        params.each_with_object({}) do |(key, value), acc|
+          acc[key.to_s] = value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/eli/version.rb

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