seam 2.0.0a2 → 2.0.0b0

data/lib/seam/base_resource.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "deep_hash_accessor"
+
+module Seam
+  module Resources
+    class BaseResource
+      attr_accessor :data, :client
+
+      def initialize(data, client = nil)
+        @data = data
+        @client = client
+
+        @data.each do |key, value|
+          value = Seam::DeepHashAccessor.new(value) if value.is_a?(Hash)
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def update_from_response(data)
+        @data = data
+        @data.each do |key, value|
+          instance_variable_set(:"@#{key}", value)
+        end
+      end
+
+      def self.load_from_response(data, client = nil)
+        if data.is_a?(Array)
+          data.map { |d| new(d, client) }
+        else
+          new(data, client)
+        end
+      end
+
+      def inspect
+        "<#{self.class.name}:#{"0x00%x" % (object_id << 1)}\n" + # rubocop:disable Style/StringConcatenation, Style/FormatString
+          instance_variables
+            .map { |k| k.to_s.sub("@", "") }
+            .filter { |k| k != "data" and k != "client" and respond_to? k }
+            .map { |k| "  #{k}=#{send(k).inspect}" }
+            .join("\n") + ">"
+      end
+
+      def self.date_accessor(*attrs)
+        attrs.each do |attr|
+          define_method(attr) do
+            value = instance_variable_get(:"@#{attr}")
+
+            raise "No value for #{attr} set" if value.nil?
+
+            parse_datetime(value)
+          end
+        end
+      end
+
+      protected
+
+      def parse_datetime(value)
+        Time.parse(value)
+      end
+    end
+  end
+end

data/lib/seam/deep_hash_accessor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Seam
+  class DeepHashAccessor
+    def initialize(data)
+      @data = data
+      create_accessor_methods
+    end
+
+    def [](key)
+      instance_variable_get(:"@#{key}")
+    end
+
+    private
+
+    def create_accessor_methods
+      @data.each do |key, value|
+        define_singleton_method(key) do
+          process_value(value)
+        end
+      end
+    end
+
+    def process_value(value)
+      case value
+      when Hash
+        DeepHashAccessor.new(value)
+      when Array
+        value.map { |v| process_value(v) }
+      else
+        value
+      end
+    end
+  end
+end

data/lib/seam/default_endpoint.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Seam
+  DEFAULT_ENDPOINT = "https://connect.getseam.com"
+end

data/lib/seam/helpers/action_attempt.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Seam
+  module Helpers
+    module ActionAttempt
+      def self.decide_and_wait(action_attempt, client, wait_for_action_attempt)
+        if wait_for_action_attempt == true
+          return wait_until_finished(action_attempt, client)
+        elsif wait_for_action_attempt.is_a?(Hash)
+          return wait_until_finished(action_attempt, client, timeout: wait_for_action_attempt[:timeout],
+            polling_interval: wait_for_action_attempt[:polling_interval])
+        end
+
+        action_attempt
+      end
+
+      def self.wait_until_finished(action_attempt, client, timeout: nil, polling_interval: nil)
+        timeout = timeout.nil? ? 5.0 : timeout
+        polling_interval = polling_interval.nil? ? 0.5 : polling_interval
+
+        time_waiting = 0.0
+
+        while action_attempt.status == "pending"
+          sleep(polling_interval)
+          time_waiting += polling_interval
+
+          raise Seam::ActionAttemptTimeoutError.new(action_attempt, timeout) if time_waiting > timeout
+
+          action_attempt = update_action_attempt(action_attempt, client)
+        end
+
+        raise Seam::ActionAttemptFailedError.new(action_attempt) if action_attempt.status == "error"
+
+        action_attempt
+      end
+
+      def self.update_action_attempt(action_attempt, client)
+        response = client.get("/action_attempts/get", {action_attempt_id: action_attempt.action_attempt_id})
+
+        action_attempt.update_from_response(response.body["action_attempt"])
+        action_attempt
+      end
+    end
+  end
+end

data/lib/seam/http.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "http_single_workspace"
+
+module Seam
+  module Http
+    def self.new(**args)
+      Http::SingleWorkspace.new(**args)
+    end
+
+    def self.from_api_key(api_key, endpoint: nil, wait_for_action_attempt: false)
+      Http::SingleWorkspace.from_api_key(api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt)
+    end
+
+    def self.from_personal_access_token(personal_access_token, workspace_id, endpoint: nil, wait_for_action_attempt: false)
+      Http::SingleWorkspace.from_personal_access_token(personal_access_token, workspace_id, endpoint: endpoint,
+        wait_for_action_attempt: wait_for_action_attempt)
+    end
+
+    class ApiError < StandardError
+      attr_reader :code, :status_code, :request_id, :data
+
+      def initialize(error, status_code, request_id)
+        super(error[:message])
+        @code = error[:type]
+        @status_code = status_code
+        @request_id = request_id
+        @data = error[:data]
+      end
+    end
+
+    class UnauthorizedError < ApiError
+      def initialize(request_id)
+        super({type: "unauthorized", message: "Unauthorized"}, 401, request_id)
+      end
+    end
+
+    class InvalidInputError < ApiError
+      attr_reader :validation_errors
+
+      def initialize(error, status_code, request_id)
+        super
+        @code = "invalid_input"
+        @validation_errors = error["validation_errors"] || {}
+      end
+
+      def get_validation_error_messages(param_name)
+        @validation_errors.dig(param_name, "_errors") || []
+      end
+    end
+  end
+end

data/lib/seam/http_multi_workspace.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "request"
+require_relative "parse_options"
+require_relative "lts_version"
+require_relative "auth"
+
+module Seam
+  module Http
+    class MultiWorkspace
+      attr_reader :client, :defaults
+
+      def initialize(personal_access_token:, endpoint: nil, wait_for_action_attempt: true, faraday_options: {},
+        faraday_retry_options: {})
+        @wait_for_action_attempt = wait_for_action_attempt
+        @defaults = {"wait_for_action_attempt" => wait_for_action_attempt}
+        @endpoint = Http::Options.get_endpoint(endpoint)
+        @auth_headers = Http::Auth.get_auth_headers_for_multi_workspace_personal_access_token(personal_access_token)
+        @client = Seam::Http::Request.create_faraday_client(@endpoint, @auth_headers, faraday_options,
+          faraday_retry_options)
+      end
+
+      def self.lts_version
+        Seam::LTS_VERSION
+      end
+
+      def lts_version
+        Seam::LTS_VERSION
+      end
+
+      def workspaces
+        @workspaces ||= WorkspacesProxy.new(Seam::Clients::Workspaces.new(client: @client, defaults: @defaults))
+      end
+
+      def self.from_personal_access_token(personal_access_token, endpoint: nil, wait_for_action_attempt: true, faraday_options: {}, faraday_retry_options: {})
+        new(
+          personal_access_token: personal_access_token,
+          endpoint: endpoint,
+          wait_for_action_attempt: wait_for_action_attempt,
+          faraday_options: faraday_options,
+          faraday_retry_options: faraday_retry_options
+        )
+      end
+    end
+
+    class WorkspacesProxy
+      def initialize(workspaces)
+        @workspaces = workspaces
+      end
+
+      def list(**kwargs)
+        @workspaces.list(**kwargs)
+      end
+
+      def create(**kwargs)
+        @workspaces.create(**kwargs)
+      end
+    end
+
+    private_constant :WorkspacesProxy
+  end
+end

data/lib/seam/http_single_workspace.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "request"
+require_relative "parse_options"
+require_relative "routes/routes"
+
+module Seam
+  module Http
+    class SingleWorkspace
+      include Seam::Routes
+
+      attr_reader :client, :defaults
+
+      def initialize(client: nil, api_key: nil, personal_access_token: nil, workspace_id: nil, endpoint: nil,
+        wait_for_action_attempt: true, faraday_options: {}, faraday_retry_options: {})
+        options = Http::Options.parse_options(api_key: api_key, personal_access_token: personal_access_token,
+          workspace_id: workspace_id, endpoint: endpoint)
+        @endpoint = options[:endpoint]
+        @auth_headers = options[:auth_headers]
+        @defaults = Seam::DeepHashAccessor.new({"wait_for_action_attempt" => wait_for_action_attempt})
+        @client = client || Seam::Http::Request.create_faraday_client(@endpoint, @auth_headers, faraday_options,
+          faraday_retry_options)
+
+        initialize_routes(client: @client, defaults: @defaults)
+      end
+
+      def lts_version
+        Seam::LTS_VERSION
+      end
+
+      def self.from_api_key(api_key, endpoint: nil, wait_for_action_attempt: false, faraday_options: {}, faraday_retry_options: {})
+        new(api_key: api_key, endpoint: endpoint, wait_for_action_attempt: wait_for_action_attempt,
+          faraday_options: faraday_options, faraday_retry_options: faraday_retry_options)
+      end
+
+      def self.from_personal_access_token(personal_access_token, workspace_id, endpoint: nil, wait_for_action_attempt: false, faraday_options: {}, faraday_retry_options: {})
+        new(personal_access_token: personal_access_token, workspace_id: workspace_id, endpoint: endpoint,
+          wait_for_action_attempt: wait_for_action_attempt, faraday_options: faraday_options, faraday_retry_options: faraday_retry_options)
+      end
+    end
+  end
+end

data/lib/seam/options.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "default_endpoint"
+
+module Seam
+  module Http
+    module Options
+      def self.get_endpoint(endpoint = nil)
+        endpoint || get_endpoint_from_env || Seam::DEFAULT_ENDPOINT
+      end
+
+      def self.get_endpoint_from_env
+        seam_api_url = ENV["SEAM_API_URL"]
+        seam_endpoint = ENV["SEAM_ENDPOINT"]
+
+        if seam_api_url
+          warn "\033[93mUsing the SEAM_API_URL environment variable is deprecated. Support will be removed in a later major version. Use SEAM_ENDPOINT instead.\033[0m"
+        end
+
+        if seam_api_url && seam_endpoint
+          warn "\033[93mDetected both the SEAM_API_URL and SEAM_ENDPOINT environment variables. Using SEAM_ENDPOINT.\033[0m"
+        end
+
+        seam_endpoint || seam_api_url
+      end
+
+      class SeamInvalidOptionsError < StandardError
+        def initialize(message)
+          super("Seam received invalid options: #{message}")
+        end
+      end
+
+      def self.seam_http_options_with_api_key?(api_key: nil, personal_access_token: nil)
+        return false if api_key.nil?
+
+        if personal_access_token
+          raise SeamInvalidOptionsError.new(
+            "The personal_access_token option cannot be used with the api_key option"
+          )
+        end
+
+        true
+      end
+
+      def self.seam_http_options_with_personal_access_token?(personal_access_token: nil, api_key: nil, workspace_id: nil)
+        return false if personal_access_token.nil?
+
+        if api_key
+          raise SeamInvalidOptionsError.new(
+            "The api_key option cannot be used with the personal_access_token option"
+          )
+        end
+
+        if workspace_id.nil?
+          raise SeamInvalidOptionsError.new(
+            "Must pass a workspace_id when using a personal_access_token"
+          )
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/seam/parse_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "auth"
+require_relative "options"
+
+module Seam
+  module Http
+    module Options
+      def self.parse_options(api_key: nil, personal_access_token: nil, workspace_id: nil, endpoint: nil)
+        api_key ||= ENV["SEAM_API_KEY"] if personal_access_token.nil?
+
+        auth_headers = Http::Auth.get_auth_headers(
+          api_key: api_key,
+          personal_access_token: personal_access_token,
+          workspace_id: workspace_id
+        )
+        endpoint = Http::Options.get_endpoint(endpoint)
+
+        {auth_headers: auth_headers, endpoint: endpoint}
+      end
+    end
+  end
+end

data/lib/seam/request.rb

@@ -1,73 +1,104 @@
 # frozen_string_literal: true
 
-require "http"
+require "faraday"
+require "faraday/retry"
 
 module Seam
-  class Request
-    attr_reader :base_uri, :api_key, :debug
-
-    class Error < StandardError
-      attr_reader :status, :response
+  module Http
+    module Request
+      def self.create_faraday_client(endpoint, auth_headers, faraday_options = {}, faraday_retry_options = {})
+        default_options = {
+          url: endpoint,
+          headers: auth_headers.merge(default_headers)
+        }
+
+        options = deep_merge(default_options, faraday_options)
+
+        default_faraday_retry_options = {
+          max: 2,
+          backoff_factor: 2
+        }
+
+        faraday_retry_options = default_faraday_retry_options.merge(faraday_retry_options)
+
+        Faraday.new(options) do |builder|
+          builder.request :json
+          builder.response :json
+          builder.use ResponseMiddleware
+          builder.request :retry, faraday_retry_options
+        end
+      end
 
-      def initialize(message, status, response)
-        super(message)
-        @status = status
-        @response = response
+      def self.default_headers
+        {
+          "User-Agent" => "seam-ruby/#{Seam::VERSION}",
+          "Content-Type" => "application/json",
+          :"seam-sdk-name" => "seamapi/ruby",
+          :"seam-sdk-version" => Seam::VERSION,
+          :"seam-lts-version" => Seam::LTS_VERSION
+        }
       end
-    end
 
-    def initialize(api_key:, base_uri:, debug: false)
-      @api_key = api_key
-      @base_uri = base_uri
-      @debug = debug
-    end
+      class ResponseMiddleware < Faraday::Response::RaiseError
+        def on_complete(env)
+          return if env.success?
 
-    def perform(method, uri, config = {})
-      Logger.info("Request: #{method} #{uri} #{config}") if debug
+          status_code = env.status
+          request_id = env.response_headers["seam-request-id"]
 
-      config[:body] = config[:body].to_json if config[:body]
+          raise Http::UnauthorizedError.new(request_id) if status_code == 401
 
-      response = HTTP.request(
-        method,
-        build_url(uri),
-        {headers: headers}.merge(config)
-      )
+          if seam_api_error_response?(env)
+            body = JSON.parse(env.body)
+            error = body["error"]
+            error_details = {
+              type: error["type"] || "unknown_error",
+              message: error["message"] || "Unknown error",
+              data: error["data"]
+            }
 
-      return response.parse if response.status.success?
+            if error["type"] == "invalid_input"
+              error_details["validation_errors"] = error["validation_errors"]
+              raise Http::InvalidInputError.new(error_details, status_code, request_id)
+            end
 
-      handle_error_response(response, method, uri)
-    end
+            raise Http::ApiError.new(error_details, status_code, request_id)
+          end
 
-    protected
+          super
+        end
 
-    def handle_error_response(response, method, uri)
-      msg = "Api Error #{response.status.code} #{method} #{uri}"
-      code = response.status.code
+        def seam_api_error_response?(env)
+          return false unless env.response_headers
 
-      if code >= 400 && code < 500 && (err = response.parse["error"])
-        msg = "Api Error #{err["type"]}\nrequest_id: #{err["request_id"]}\n#{err["message"]}"
-      end
+          content_type = env.response_headers["Content-Type"]
+          return false unless content_type&.start_with?("application/json")
 
-      raise Error.new(msg, code, response)
-    end
+          begin
+            body = JSON.parse(env.body)
+            return false unless body.is_a?(Hash) && body["error"].is_a?(Hash)
 
-    def build_url(uri)
-      "#{base_uri}#{uri}"
-    end
+            error = body["error"]
+            error["type"].is_a?(String) && error["message"].is_a?(String)
+          rescue JSON::ParserError
+            false
+          end
+        end
+      end
 
-    def headers
-      {
-        "User-Agent" => user_agent,
-        "Content-Type" => "application/json",
-        "Authorization" => "Bearer #{api_key}",
-        :"seam-sdk-name" => "seamapi/ruby",
-        :"seam-sdk-version" => Seam::VERSION,
-        :"seam-lts-version" => Seam::LTS_VERSION
-      }
-    end
+      def self.deep_merge(hash1, hash2)
+        result = hash1.dup
+        hash2.each do |key, value|
+          result[key] = if value.is_a?(Hash) && result[key].is_a?(Hash)
+            deep_merge(result[key], value)
+          else
+            value
+          end
+        end
+        result
+      end
 
-    def user_agent
-      "seam-ruby/#{Seam::VERSION}"
+      private_class_method :deep_merge
     end
   end
 end

data/lib/seam/routes/clients/access_codes.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Seam
+  module Clients
+    class AccessCodes
+      def initialize(client:, defaults:)
+        @client = client
+        @defaults = defaults
+      end
+
+      def simulate
+        @simulate ||= Seam::Clients::AccessCodesSimulate.new(client: @client, defaults: @defaults)
+      end
+
+      def unmanaged
+        @unmanaged ||= Seam::Clients::AccessCodesUnmanaged.new(client: @client, defaults: @defaults)
+      end
+
+      def create(device_id:, allow_external_modification: nil, attempt_for_offline_device: nil, code: nil, common_code_key: nil, ends_at: nil, is_external_modification_allowed: nil, is_offline_access_code: nil, is_one_time_use: nil, max_time_rounding: nil, name: nil, prefer_native_scheduling: nil, preferred_code_length: nil, starts_at: nil, sync: nil, use_backup_access_code_pool: nil, use_offline_access_code: nil)
+        res = @client.post("/access_codes/create", {device_id: device_id, allow_external_modification: allow_external_modification, attempt_for_offline_device: attempt_for_offline_device, code: code, common_code_key: common_code_key, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, is_offline_access_code: is_offline_access_code, is_one_time_use: is_one_time_use, max_time_rounding: max_time_rounding, name: name, prefer_native_scheduling: prefer_native_scheduling, preferred_code_length: preferred_code_length, starts_at: starts_at, sync: sync, use_backup_access_code_pool: use_backup_access_code_pool, use_offline_access_code: use_offline_access_code}.compact)
+
+        Seam::Resources::AccessCode.load_from_response(res.body["access_code"])
+      end
+
+      def create_multiple(device_ids:, allow_external_modification: nil, attempt_for_offline_device: nil, behavior_when_code_cannot_be_shared: nil, code: nil, ends_at: nil, is_external_modification_allowed: nil, is_offline_access_code: nil, is_one_time_use: nil, max_time_rounding: nil, name: nil, prefer_native_scheduling: nil, preferred_code_length: nil, starts_at: nil, use_backup_access_code_pool: nil, use_offline_access_code: nil)
+        res = @client.post("/access_codes/create_multiple", {device_ids: device_ids, allow_external_modification: allow_external_modification, attempt_for_offline_device: attempt_for_offline_device, behavior_when_code_cannot_be_shared: behavior_when_code_cannot_be_shared, code: code, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, is_offline_access_code: is_offline_access_code, is_one_time_use: is_one_time_use, max_time_rounding: max_time_rounding, name: name, prefer_native_scheduling: prefer_native_scheduling, preferred_code_length: preferred_code_length, starts_at: starts_at, use_backup_access_code_pool: use_backup_access_code_pool, use_offline_access_code: use_offline_access_code}.compact)
+
+        Seam::Resources::AccessCode.load_from_response(res.body["access_codes"])
+      end
+
+      def delete(access_code_id:, device_id: nil, sync: nil)
+        @client.post("/access_codes/delete", {access_code_id: access_code_id, device_id: device_id, sync: sync}.compact)
+
+        nil
+      end
+
+      def generate_code(device_id:)
+        res = @client.post("/access_codes/generate_code", {device_id: device_id}.compact)
+
+        Seam::Resources::AccessCode.load_from_response(res.body["generated_code"])
+      end
+
+      def get(access_code_id: nil, code: nil, device_id: nil)
+        res = @client.post("/access_codes/get", {access_code_id: access_code_id, code: code, device_id: device_id}.compact)
+
+        Seam::Resources::AccessCode.load_from_response(res.body["access_code"])
+      end
+
+      def list(access_code_ids: nil, device_id: nil, user_identifier_key: nil)
+        res = @client.post("/access_codes/list", {access_code_ids: access_code_ids, device_id: device_id, user_identifier_key: user_identifier_key}.compact)
+
+        Seam::Resources::AccessCode.load_from_response(res.body["access_codes"])
+      end
+
+      def pull_backup_access_code(access_code_id:)
+        res = @client.post("/access_codes/pull_backup_access_code", {access_code_id: access_code_id}.compact)
+
+        Seam::Resources::AccessCode.load_from_response(res.body["backup_access_code"])
+      end
+
+      def update(access_code_id:, allow_external_modification: nil, attempt_for_offline_device: nil, code: nil, device_id: nil, ends_at: nil, is_external_modification_allowed: nil, is_managed: nil, is_offline_access_code: nil, is_one_time_use: nil, max_time_rounding: nil, name: nil, prefer_native_scheduling: nil, preferred_code_length: nil, starts_at: nil, sync: nil, type: nil, use_backup_access_code_pool: nil, use_offline_access_code: nil)
+        @client.post("/access_codes/update", {access_code_id: access_code_id, allow_external_modification: allow_external_modification, attempt_for_offline_device: attempt_for_offline_device, code: code, device_id: device_id, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, is_managed: is_managed, is_offline_access_code: is_offline_access_code, is_one_time_use: is_one_time_use, max_time_rounding: max_time_rounding, name: name, prefer_native_scheduling: prefer_native_scheduling, preferred_code_length: preferred_code_length, starts_at: starts_at, sync: sync, type: type, use_backup_access_code_pool: use_backup_access_code_pool, use_offline_access_code: use_offline_access_code}.compact)
+
+        nil
+      end
+
+      def update_multiple(common_code_key:, allow_external_modification: nil, code: nil, ends_at: nil, is_external_modification_allowed: nil, name: nil, prefer_native_scheduling: nil, starts_at: nil)
+        @client.post("/access_codes/update_multiple", {common_code_key: common_code_key, allow_external_modification: allow_external_modification, code: code, ends_at: ends_at, is_external_modification_allowed: is_external_modification_allowed, name: name, prefer_native_scheduling: prefer_native_scheduling, starts_at: starts_at}.compact)
+
+        nil
+      end
+    end
+  end
+end

data/lib/seam/routes/clients/access_codes_simulate.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Seam
+  module Clients
+    class AccessCodesSimulate
+      def initialize(client:, defaults:)
+        @client = client
+        @defaults = defaults
+      end
+
+      def create_unmanaged_access_code(code:, device_id:, name:)
+        res = @client.post("/access_codes/simulate/create_unmanaged_access_code", {code: code, device_id: device_id, name: name}.compact)
+
+        Seam::Resources::UnmanagedAccessCode.load_from_response(res.body["access_code"])
+      end
+    end
+  end
+end