appnigma-sdk 0.1.0

data/lib/appnigma/generated/models/sdk_problem.rb

@@ -0,0 +1,205 @@
+=begin
+#Appnigma SDK API
+
+#The routes a customer's product calls through an Appnigma SDK. Every answer carries a request id in X-Request-Id; quote it when you write to support.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.26.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Appnigma::Generated
+  class SdkProblem < ApiModelBase
+    # The field, as a dotted path for a nested one
+    attr_accessor :field
+
+    # What is wrong with it, in plain words
+    attr_accessor :problem
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'field' => :'field',
+        :'problem' => :'problem'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'field' => :'String',
+        :'problem' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Returns attribute type mapping
+    def self.acceptable_openapi_types
+      openapi_types
+    end
+
+    # Returns the nullable attributes
+    def self.acceptable_openapi_nullable
+      openapi_nullable
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Appnigma::Generated::SdkProblem` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Appnigma::Generated::SdkProblem`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'field')
+        self.field = attributes[:'field']
+      else
+        self.field = nil
+      end
+
+      if attributes.key?(:'problem')
+        self.problem = attributes[:'problem']
+      else
+        self.problem = nil
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      if @field.nil?
+        invalid_properties.push('invalid value for "field", field cannot be nil.')
+      end
+
+      if @problem.nil?
+        invalid_properties.push('invalid value for "problem", problem cannot be nil.')
+      end
+
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      return false if @field.nil?
+      return false if @problem.nil?
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] field Value to be assigned
+    def field=(field)
+      if field.nil?
+        fail ArgumentError, 'field cannot be nil'
+      end
+
+      @field = field
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] problem Value to be assigned
+    def problem=(problem)
+      if problem.nil?
+        fail ArgumentError, 'problem cannot be nil'
+      end
+
+      @problem = problem
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          field == o.field &&
+          problem == o.problem
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [field, problem].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      map = acceptable_attribute_map
+      transformed_hash = {}
+      acceptable_openapi_types.each_pair do |key, type|
+        if attributes.key?(map[key]) && attributes[map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      # include attributes inherited from allOf parents (the nearest declaration wins)
+      self.class.acceptable_attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.acceptable_openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+  end
+
+end

data/lib/appnigma/generated/version.rb

@@ -0,0 +1,15 @@
+=begin
+#Appnigma SDK API
+
+#The routes a customer's product calls through an Appnigma SDK. Every answer carries a request id in X-Request-Id; quote it when you write to support.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.26.0
+
+=end
+
+module Appnigma::Generated
+  VERSION = '1.0.0'
+end

data/lib/appnigma/generated.rb

@@ -0,0 +1,82 @@
+=begin
+#Appnigma SDK API
+
+#The routes a customer's product calls through an Appnigma SDK. Every answer carries a request id in X-Request-Id; quote it when you write to support.
+
+The version of the OpenAPI document: 1.0.0
+
+Generated by: https://openapi-generator.tech
+Generator version: 7.26.0
+
+=end
+
+# Common files
+require 'appnigma/generated/api_client'
+require 'appnigma/generated/api_error'
+require 'appnigma/generated/api_model_base'
+require 'appnigma/generated/version'
+require 'appnigma/generated/configuration'
+
+# Models
+require 'appnigma/generated/models/connection_status'
+require 'appnigma/generated/models/create_connection_link_input'
+require 'appnigma/generated/models/create_connection_link_output'
+require 'appnigma/generated/models/crm_company'
+require 'appnigma/generated/models/crm_company_get_output'
+require 'appnigma/generated/models/crm_company_list_output'
+require 'appnigma/generated/models/crm_contact'
+require 'appnigma/generated/models/crm_contact_get_output'
+require 'appnigma/generated/models/crm_contact_list_output'
+require 'appnigma/generated/models/crm_custom_field'
+require 'appnigma/generated/models/crm_deal'
+require 'appnigma/generated/models/crm_deal_get_output'
+require 'appnigma/generated/models/crm_deal_list_output'
+require 'appnigma/generated/models/crm_email'
+require 'appnigma/generated/models/crm_get_input'
+require 'appnigma/generated/models/crm_labelled'
+require 'appnigma/generated/models/crm_list_input'
+require 'appnigma/generated/models/crm_phone'
+require 'appnigma/generated/models/function_entry'
+require 'appnigma/generated/models/function_owner'
+require 'appnigma/generated/models/function_owner_one_of'
+require 'appnigma/generated/models/function_owner_one_of1'
+require 'appnigma/generated/models/get_connection_output'
+require 'appnigma/generated/models/get_guide_output'
+require 'appnigma/generated/models/json_value'
+require 'appnigma/generated/models/list_functions_output'
+require 'appnigma/generated/models/platform_request_input'
+require 'appnigma/generated/models/platform_request_input_body'
+require 'appnigma/generated/models/platform_request_output'
+require 'appnigma/generated/models/post_input'
+require 'appnigma/generated/models/post_input_record_value'
+require 'appnigma/generated/models/post_output'
+require 'appnigma/generated/models/pull_input'
+require 'appnigma/generated/models/pull_output'
+require 'appnigma/generated/models/pull_output_records_inner'
+require 'appnigma/generated/models/run_input'
+require 'appnigma/generated/models/run_output'
+require 'appnigma/generated/models/sdk_error'
+require 'appnigma/generated/models/sdk_error_error'
+require 'appnigma/generated/models/sdk_error_error_details'
+require 'appnigma/generated/models/sdk_problem'
+
+# APIs
+require 'appnigma/generated/api/default_api'
+
+module Appnigma::Generated
+  class << self
+    # Customize default settings for the SDK using block.
+    #   Appnigma::Generated.configure do |config|
+    #     config.username = "xxx"
+    #     config.password = "xxx"
+    #   end
+    # If no block given, return the default Configuration object.
+    def configure
+      if block_given?
+        yield(Configuration.default)
+      else
+        Configuration.default
+      end
+    end
+  end
+end

data/lib/appnigma/names.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Appnigma
+  # The wire speaks camelCase; Ruby speaks snake_case. Only the known fields
+  # of a call cross this boundary: free-form content (a record, a function's
+  # input or output, a CRM record's raw form) passes through untouched.
+  module Names
+    module_function
+
+    def to_snake(name)
+      name.to_s.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    end
+
+    def to_camel(name)
+      first, *rest = name.to_s.split("_")
+      ([first] + rest.map(&:capitalize)).join
+    end
+
+    # The top level of an answer: known keys become snake_case symbols,
+    # values stay as they came. `only` names the keys to convert; the rest
+    # are kept under their wire name.
+    def snake_keys(hash, only: nil)
+      hash.to_h do |key, value|
+        convert = only.nil? || only.include?(key.to_s)
+        [convert ? to_snake(key).to_sym : key, value]
+      end
+    end
+
+    # Wire keys whose value is someone else's content, passed through as it
+    # came: a record's properties, a function's output and its schemas, a
+    # platform's headers and body, a CRM record's raw form, a custom field's
+    # value.
+    FREE_FORM = %w[properties output inputSchema outputSchema headers body raw value].freeze
+
+    # Wire keys whose value is a map keyed by someone else's names: the keys
+    # are kept, the values converted.
+    KEYED_BY_DATA = %w[customFields].freeze
+
+    # A whole answer: every key this gem knows becomes a snake_case symbol,
+    # at every depth, except inside free-form content.
+    def answer(value)
+      case value
+      when Array then value.map { |item| answer(item) }
+      when Hash then value.to_h { |key, item| [to_snake(key).to_sym, answer_field(key, item)] }
+      else value
+      end
+    end
+
+    def answer_field(key, value)
+      return value if FREE_FORM.include?(key)
+      return value.transform_values { |item| answer(item) } if KEYED_BY_DATA.include?(key) && value.is_a?(Hash)
+
+      answer(value)
+    end
+
+    # The top level of a request: snake_case keyword arguments become the
+    # wire's camelCase string keys, and a nil value is left out.
+    def camel_keys(hash)
+      hash.compact.to_h { |key, value| [to_camel(key), value] }
+    end
+  end
+end

data/lib/appnigma/retry.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Appnigma
+  # Tries again only when trying again is safe: the network failed, the
+  # server answered 5xx, or it answered 429. Never on 400, 401, 403, 404 or
+  # 409, because the same request would be refused the same way. The same
+  # rules, waits and jitter as the TypeScript package.
+  module Retry
+    # The wait before each retry when the server sent no Retry-After, with
+    # the last one repeated when there are more retries than steps.
+    BACKOFF_MS = [500, 1000].freeze
+
+    # Up to this share of the backoff is added at random, so many clients
+    # that failed together do not all try again in the same instant.
+    JITTER_SHARE = 0.25
+
+    # `sleep` takes milliseconds; `random` answers a number in [0, 1). Tests
+    # pin them; callers leave them nil for the real ones.
+    Policy = Struct.new(:max_retries, :max_retry_wait_ms, :sleep, :random, keyword_init: true)
+
+    DEFAULT_SLEEP = ->(ms) { Kernel.sleep(ms / 1000.0) }
+    DEFAULT_RANDOM = -> { Kernel.rand }
+
+    module_function
+
+    def retryable_status?(status)
+      status == 429 || status >= 500
+    end
+
+    # Retry-After wins when the server sent one and is taken as given: that
+    # wait is the server's instruction. Otherwise the fixed backoff plus
+    # jitter.
+    def wait_before_retry(answer, retry_index, random)
+      return answer[:retry_after_seconds] * 1000 if answer && !answer[:retry_after_seconds].nil?
+
+      base = BACKOFF_MS[[retry_index, BACKOFF_MS.length - 1].min]
+      base + (base * JITTER_SHARE * random.call).floor
+    end
+
+    # Runs the block up to `max_retries + 1` times. Returns the last answer,
+    # good or bad, so the caller judges it; raises only when no answer ever
+    # came back. Anything other than a NetworkError is a bug, not a bad
+    # second, and is raised at once.
+    def with_retries(policy, &block)
+      random = policy.random || DEFAULT_RANDOM
+      pause = policy.sleep || DEFAULT_SLEEP
+      retry_index = 0
+      loop do
+        answer = attempt(retry_index < policy.max_retries, &block)
+        wait_ms = wait_or_stop(answer, retry_index, policy, random)
+        return answer if wait_ms.nil?
+
+        pause.call(wait_ms)
+        retry_index += 1
+      end
+    end
+
+    # How long to wait before the next attempt, or nil to hand this answer
+    # back. A nil answer is a network failure with retries left (attempt
+    # raises when none are left).
+    def wait_or_stop(answer, retry_index, policy, random)
+      return wait_before_retry(nil, retry_index, random) if answer.nil?
+      return nil if !retryable_status?(answer[:status]) || retry_index >= policy.max_retries
+
+      wait_ms = wait_before_retry(answer, retry_index, random)
+      wait_ms > policy.max_retry_wait_ms ? nil : wait_ms
+    end
+
+    # One attempt: the answer, or nil when a network failure may be retried.
+    def attempt(retries_left)
+      yield
+    rescue NetworkError
+      raise unless retries_left
+
+      nil
+    end
+  end
+end

data/lib/appnigma/transport.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "faraday"
+require_relative "constants"
+require_relative "errors"
+require_relative "version"
+
+# The generated client is loaded with Ruby's warnings off. Its models
+# redefine every setter after declaring it, and its API file requires "cgi",
+# which Ruby 4.0 trimmed to the escaping it still uses; both only print
+# under `ruby -w`, and neither is ours to change. The gem's own files load
+# with warnings as usual.
+begin
+  verbose = $VERBOSE
+  $VERBOSE = nil
+  require "appnigma/generated"
+ensure
+  $VERBOSE = verbose
+end
+
+module Appnigma
+  # One attempt at one call, through the client generated from the API
+  # description. The only hand-written file that touches Appnigma::Generated.
+  # It reports what came back without judging it: the client decides what
+  # an answer means, and Retry decides whether to try again. The only thing
+  # raised here is NetworkError: nothing came back.
+  #
+  # The generated client knows the routes, the path and query values and the
+  # key header. It is asked for the body as text, which is parsed here with
+  # string keys, so free-form content (a record, a function's output) comes
+  # back exactly as the server sent it, and a body that is not JSON is seen
+  # as such.
+  class Transport
+    USER_AGENT = "appnigma-sdk-ruby/#{VERSION}".freeze
+
+    # Builds the generated API for one configuration. Tests pass their own.
+    DEFAULT_API_FACTORY = ->(config) { Generated::DefaultApi.new(Generated::ApiClient.new(config)) }
+
+    def initialize(base_url:, key:, api_factory: DEFAULT_API_FACTORY)
+      @base_url = URI.parse(base_url)
+      @key = key
+      @api_factory = api_factory
+      @apis = {}
+      @lock = Mutex.new
+    end
+
+    # Calls `<operation>_with_http_info` on the generated API with `args`,
+    # within `timeout_ms`. `opts` carries the generated method's optional
+    # values (catalog's platform). `header_params` adds request headers (a
+    # test uses it to pick a mock server's example). Answers
+    # `{ status:, ok:, request_id:, retry_after_seconds:, json: }`, where
+    # `json` is nil when the body was empty or not JSON.
+    def attempt(operation, *args, timeout_ms:, header_params: {}, opts: {})
+      body, status, headers = call_generated(operation, args, timeout_ms, header_params, opts)
+      answer(status, headers, body)
+    rescue Generated::ApiError => e
+      raise network_error(e, timeout_ms) if e.code.nil? || e.code.zero?
+
+      answer(e.code, e.response_headers, e.response_body)
+    rescue Faraday::Error => e
+      raise NetworkError.new(message: "Could not reach the Appnigma API: #{e.message}", cause: e)
+    end
+
+    private
+
+    def call_generated(operation, args, timeout_ms, header_params, opts)
+      api_for(timeout_ms).public_send(
+        :"#{operation}_with_http_info", *args, **opts, debug_return_type: "String", header_params: header_params.dup
+      )
+    end
+
+    def api_for(timeout_ms)
+      @lock.synchronize { @apis[timeout_ms] ||= @api_factory.call(configuration(timeout_ms)) }
+    end
+
+    def configuration(timeout_ms)
+      config = Generated::Configuration.new
+      config.scheme = @base_url.scheme
+      config.host = @base_url.port == @base_url.default_port ? @base_url.host : "#{@base_url.host}:#{@base_url.port}"
+      config.base_path = @base_url.path
+      config.access_token = @key
+      config.timeout = timeout_ms / 1000.0
+      # The server refuses a bad input, with the shape every other refusal
+      # has; the generated client's own checks would raise ArgumentError.
+      config.client_side_validation = false
+      config
+    end
+
+    def answer(status, headers, body)
+      {
+        status: status,
+        ok: (200..299).cover?(status),
+        request_id: header(headers, REQUEST_ID_HEADER),
+        retry_after_seconds: read_retry_after(header(headers, RETRY_AFTER_HEADER)),
+        json: parse_json(body)
+      }
+    end
+
+    def network_error(error, timeout_ms)
+      message = if error.message.start_with?("Connection timed out")
+                  "No answer from the Appnigma API within #{timeout_ms} ms"
+                else
+                  "Could not reach the Appnigma API: #{error.message.lines.first&.strip}"
+                end
+      NetworkError.new(message: message, cause: error)
+    end
+
+    # Header names are case-insensitive; Faraday's headers already are, a
+    # plain Hash is not.
+    def header(headers, name)
+      return nil if headers.nil?
+
+      headers.each { |key, value| return value if key.to_s.casecmp?(name) }
+      nil
+    end
+
+    # Our server sends seconds. Anything else (an HTTP date from a proxy,
+    # junk) reads as "not given" rather than as a wait.
+    def read_retry_after(value)
+      return nil if value.nil?
+
+      seconds = Float(value, exception: false)
+      return nil if seconds.nil? || !seconds.finite? || seconds.negative?
+
+      seconds == seconds.floor ? seconds.to_i : seconds
+    end
+
+    def parse_json(body)
+      return nil if body.nil? || body.to_s.empty?
+
+      JSON.parse(body.to_s)
+    rescue JSON::ParserError
+      nil
+    end
+  end
+end

data/lib/appnigma/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Appnigma
+  VERSION = "0.1.0"
+
+  # The version of the API description (openapi/sdk-v1.yaml) this gem was
+  # generated from. Written by bin/generate; a test ties it to the file.
+  API_DESCRIPTION_VERSION = "1.0.0"
+end

data/lib/appnigma.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "appnigma/version"
+require_relative "appnigma/constants"
+require_relative "appnigma/errors"
+require_relative "appnigma/retry"
+require_relative "appnigma/names"
+require_relative "appnigma/checks"
+require_relative "appnigma/transport"
+require_relative "appnigma/connections"
+require_relative "appnigma/crm"
+require_relative "appnigma/client"
+
+# The gem a customer's product installs to reach its Appnigma microserver.
+module Appnigma
+end