envless-sdk 0.0.1

data/lib/envless/sdk/defaults.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Envless
+  module Defaults
+    BASE_URL = "https://api.envless.cloud"
+    MAX_RETRIES = 3
+    TIMEOUT = 30
+    USER_AGENT = "envless-sdk-ruby/#{VERSION}"
+    KEEP_ALIVE_TIMEOUT = 2
+    MAX_IDLE_CONNECTIONS = 8
+    MAX_REDIRECTS = 20
+    MAX_TIMEOUT = 2_147_483
+    DEADLINE_GRACE = 0.1
+    MESSAGE_LIMIT = 300
+    REQUEST_ID_HEADER = "request-id"
+    LOCATION_HEADER = "location"
+    REDACTED = "[redacted]"
+
+    UPDATE_NOTICE_ENV_DISABLE = "ENVLESS_DISABLE_UPDATE_NOTICE"
+    UPDATE_NOTICE_TIMEOUT = 2
+    UPDATE_NOTICE_PACKAGE = "envless-sdk"
+    UPDATE_NOTICE_HOST = "rubygems.org"
+    UPDATE_NOTICE_PATH = "/api/v1/versions/envless-sdk/latest.json"
+    UPDATE_NOTICE_COMMAND = "bundle update envless-sdk"
+    UPDATE_NOTICE_CHANGELOG_URL = "https://envless.cloud/docs/ruby/changelog"
+    UPDATE_NOTICE_ICON = "ℹ"
+
+    NAMESPACES = %i[
+      me workspace workspaces products projects environments variables versions members invites roles keys webhooks
+    ].freeze
+  end
+end

data/lib/envless/sdk/envelope.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Envless
+  module Envelope
+    module_function
+
+    def read(status, reason, content)
+      text = Text.decode(content)
+      return fallback(status, reason.empty? ? format(Messages::HTTP_STATUS, status:) : reason) if text.empty?
+
+      parsed = Wire.decode(text)
+      parsed.is_a?(Hash) ? parsed : {}
+    rescue JSON::ParserError
+      fallback(status, text.to_s[0, Defaults::MESSAGE_LIMIT].to_s)
+    end
+
+    def fallback(status, message)
+      {success: false, code: status, message:, error: {code: Constants::ERROR_CODES[:SERVER_ERROR]}, data: nil}
+    end
+
+    def success?(status, envelope)
+      status.between?(200, 299) && Wire.truthy?(envelope[:success])
+    end
+
+    def api_error(status, headers, envelope, retry_after)
+      payload = mapping(envelope[:error])
+      code = payload[:code]
+
+      ApiError.new(
+        text(envelope[:message]) || format(Messages::REQUEST_FAILED, status:),
+        status:,
+        code: code.is_a?(String) ? code : Constants::ERROR_CODES[:SERVER_ERROR],
+        resource: text(payload[:resource]),
+        field: text(payload[:field]),
+        request_id: text(mapping(envelope[:_req])[:reqId]) || text(headers[Defaults::REQUEST_ID_HEADER]),
+        retry_after_seconds: retry_after.finite? ? Numbers.whole(retry_after) : nil
+      )
+    end
+
+    def mapping(value)
+      value.is_a?(Hash) ? value : {}
+    end
+
+    def text(value)
+      (value.is_a?(String) && !value.empty?) ? value : nil
+    end
+  end
+end

data/lib/envless/sdk/environment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Envless
+  module Environment
+    module_function
+
+    def from_environment(name)
+      value = ENV.fetch(name, nil)
+      (value.nil? || value.empty?) ? nil : value
+    end
+
+    def normalise_endpoint(value)
+      return nil if value.nil? || value.empty?
+
+      trimmed = Text.js_trim(value).sub(Urls::TRAILING_SLASHES, "")
+      return nil if trimmed.empty?
+      return trimmed if Constants::ENDPOINT_SCHEME_PATTERN.match?(trimmed)
+
+      host = trimmed.split(":", 2).first.to_s
+      "#{Constants::LOCAL_HOSTS.include?(host) ? "http" : "https"}://#{trimmed}"
+    end
+
+    def resolve_token(token)
+      resolved = token.nil? ? from_environment(Constants::ENV_VARS[:TOKEN]) : token
+      raise ArgumentError, Messages::TOKEN_SHAPE unless resolved.nil? || resolved.is_a?(String)
+
+      trimmed = resolved.nil? ? "" : Text.http_trim(resolved)
+      raise ArgumentError, Messages::TOKEN_REQUIRED if trimmed.empty?
+      raise ArgumentError, Messages::TOKEN_CHARACTERS unless Text.token?(trimmed)
+
+      trimmed
+    end
+
+    def resolve_base_url(base_url)
+      requested = base_url.nil? ? from_environment(Constants::ENV_VARS[:BASE_URL]) : base_url
+      requested = requested.to_s if requested.is_a?(URI::Generic)
+      raise ArgumentError, "#{requested.inspect} #{Messages::BASE_URL_SHAPE}" unless requested.nil? || requested.is_a?(String)
+
+      normalise_endpoint(requested) || Defaults::BASE_URL
+    end
+  end
+end

data/lib/envless/sdk/errors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Envless
+  class Error < StandardError
+  end
+
+  class NetworkError < Error
+    def initialize(message = nil, timeout: false)
+      super(message)
+      @timeout = timeout
+    end
+
+    def timeout?
+      @timeout == true
+    end
+  end
+
+  class DecryptionError < Error
+  end
+
+  class WebhookVerificationError < Error
+  end
+end

data/lib/envless/sdk/exchange.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Envless
+  module Exchange
+    PROGRAMMING_ERRORS = [NameError, TypeError, ArgumentError, FrozenError, NotImplementedError].freeze
+
+    module_function
+
+    def call(adapter, request, seconds, base_url)
+      limit = Options.deadline_of(seconds)
+      deadline = Clock.deadline(limit)
+      return Redirects.follow(adapter, request, deadline) if limit.nil?
+
+      Timeout.timeout(limit + Defaults::DEADLINE_GRACE) { Redirects.follow(adapter, request, deadline) }
+    rescue Timeout::Error
+      raise NetworkError.new(format(Messages::TIMED_OUT, seconds: Numbers.text(seconds)), timeout: true)
+    rescue NetworkError, *PROGRAMMING_ERRORS
+      raise
+    rescue => error
+      raise NetworkError, format(Messages::UNREACHABLE, base_url:, reason: reason_of(error))
+    end
+
+    def reason_of(error)
+      error.message.to_s.empty? ? error.class.name.to_s : error.message
+    end
+  end
+end

data/lib/envless/sdk/helpers.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Envless
+  class << self
+    def encrypt_value(plaintext, passphrase, workspace_unique_id)
+      Crypto::Values.encrypt_value(plaintext, passphrase, workspace_unique_id)
+    end
+
+    def decrypt_value(ciphertext, passphrase, workspace_unique_id)
+      Crypto::Values.decrypt_value(ciphertext, passphrase, workspace_unique_id)
+    end
+
+    def encrypt_with_key(key, plaintext)
+      Crypto::Cipher.encrypt_with_key(key, plaintext)
+    end
+
+    def decrypt_with_key(key, ciphertext)
+      Crypto::Cipher.decrypt_with_key(key, ciphertext)
+    end
+
+    def derive_workspace_key(passphrase, workspace_unique_id)
+      Crypto::Keys.derive_workspace_key(passphrase, workspace_unique_id)
+    end
+
+    def import_workspace_key(key)
+      Crypto::Keys.import_workspace_key(key)
+    end
+
+    def ciphertext?(value)
+      Crypto::Values.ciphertext?(value)
+    end
+
+    def passphrase_strength(passphrase)
+      Crypto::Passphrase.strength(passphrase)
+    end
+
+    def variable_name_validation(name)
+      VariableNames.validation(name)
+    end
+
+    def verify_webhook_signature(payload:, headers:, secret:, tolerance_seconds: nil)
+      Webhooks::Verify.call(payload:, headers:, secret:, tolerance_seconds:)
+    end
+
+    def rotate_workspace_passphrase(client:, workspace_unique_id:, from:, to:, project:, environment:, product: nil)
+      Rotation::Runner.new(client:, workspace_unique_id:, from:, to:, project:, environment:, product:).run
+    end
+  end
+end

data/lib/envless/sdk/http.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Envless
+  HttpRequest = Data.define(:method, :url, :headers, :body, :timeout)
+
+  class HttpRequest
+    def inspect
+      shown = headers.to_h do |name, value|
+        [name, name.to_s.casecmp?(Constants::HEADER_KEYS[:AUTHORIZATION]) ? Defaults::REDACTED : value]
+      end
+      size = body.nil? ? "nil" : "#{body.bytesize} bytes"
+
+      "#<data #{self.class.name} method=#{method.inspect}, url=#{url.inspect}, headers=#{shown.inspect}, " \
+        "body=#{size}, timeout=#{timeout.inspect}>"
+    end
+
+    def to_s
+      inspect
+    end
+
+    def pretty_print(printer)
+      printer.text(inspect)
+    end
+  end
+
+  HttpResponse = Data.define(:status, :headers, :body, :reason)
+
+  class HttpResponse
+    def self.from(response)
+      new(
+        status: Integer(response.status),
+        headers: (response.headers || {}).to_h { |name, value| [name.to_s.downcase, Text.utf8(header_text(value))] },
+        body: response.body.to_s.b,
+        reason: response.respond_to?(:reason) ? Text.utf8(response.reason.to_s) : ""
+      )
+    end
+
+    def self.header_text(value)
+      value.is_a?(Array) ? value.join(", ") : value.to_s
+    end
+
+    def header(name)
+      headers[name.downcase]
+    end
+  end
+end

data/lib/envless/sdk/listing.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Envless
+  Listing = Data.define(:limit, :offset, :search, :order, :product, :status)
+
+  class Listing
+    KEYS = Constants::QUERY_KEYS
+    MAX_LIMIT = Constants::PAGINATION[:MAX_LIMIT]
+
+    def self.of(limit: nil, offset: nil, search: nil, order: nil, product: nil, status: nil)
+      new(limit: Options.paging(limit, "limit"), offset: Options.paging(offset, "offset"), search:, order:, product:,
+        status:)
+    end
+
+    def query
+      {KEYS[:LIMIT] => limit, KEYS[:OFFSET] => offset, KEYS[:SEARCH] => search, KEYS[:ORDER] => order,
+       KEYS[:PRODUCT] => product, KEYS[:STATUS] => status}
+    end
+
+    def walk
+      with(limit: [limit.nil? ? MAX_LIMIT : limit, MAX_LIMIT].min, offset: offset.nil? ? 0 : offset)
+    end
+
+    def advance(count)
+      with(offset: offset.to_i + count)
+    end
+  end
+
+  module Pages
+    module_function
+
+    def page_of(payload, collection)
+      items = field(payload, collection.to_sym)
+      pagination = field(payload, :pagination)
+
+      Page.new(items: items.is_a?(Array) ? items : [],
+        pagination: pagination.respond_to?(:to_hash) ? pagination.to_hash : Constants::EMPTY_PAGINATION)
+    end
+
+    def field(payload, key)
+      payload.is_a?(Hash) ? payload[key] : nil
+    end
+
+    def access_page_of(payload, collection)
+      page = page_of(payload, collection)
+      ProductAccessPage.new(items: page.items, pagination: page.pagination,
+        is_private: Wire.truthy?(field(payload, :isPrivate)))
+    end
+
+    def more?(page)
+      !page.items.empty? && Wire.truthy?(page.pagination[:hasMore])
+    end
+  end
+end

data/lib/envless/sdk/messages.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Envless
+  module Messages
+    TOKEN_REQUIRED = "An Envless API key is required. Pass token: or set #{Constants::ENV_VARS[:TOKEN]}. " \
+      "Create one in the dashboard under Keys."
+    TOKEN_TWICE = "Pass the API key once, either as the first argument or as token:."
+    TOKEN_SHAPE = "token: must be a String: the Envless API key, which begins \"ev_sk_\"."
+    TOKEN_CHARACTERS = "token: holds a character an Envless API key never contains, such as a space, a line break " \
+      "or a curly quote. Copy the key again from where it was shown."
+    USER_AGENT_SHAPE = "user_agent: must be printable ASCII on a single line, because it is sent as a header."
+    BASE_URL_SHAPE = "is not a usable base URL. Pass an http or https origin such as \"https://api.envless.cloud\"."
+    BASE_URL_USERINFO = "A base URL must not carry a user name or password. Pass the origin alone and the key as token:."
+    PATH_SHAPE = "is not a usable request path. Pass a path on the API that begins with a single \"/\", such as " \
+      "\"/projects\". Anything else could send the request, and the key it carries, to another host."
+    SEGMENT_SHAPE = "A slug, name or id must be a String."
+    EMPTY_SEGMENT = "A slug, name or id must not be empty."
+    DOT_SEGMENT = "is not a usable slug, name or id: a path segment made only of dots is removed by URL parsers, so " \
+      "the request would reach a different endpoint."
+    TIMEOUT_SHAPE = "timeout: must be a number of seconds, 0 or more. 0 turns the deadline off."
+    RETRIES_SHAPE = "max_retries: must be a whole number of retries, 0 or more."
+    PAGING_SHAPE = "%<name>s: must be a whole number."
+    ADAPTER_SHAPE = "adapter: must respond to call(request) and return the response."
+    METHOD_SHAPE = "method: must be an HTTP method such as :get or \"POST\"."
+    QUERY_SHAPE = "A query value must be a String, Symbol, Integer, Float, true or false, not %<kind>s."
+    BODY_SHAPE = "Pass the request body as a Hash, or as keyword arguments."
+    LIST_SHAPE = "%<name>s must be an Array, not %<kind>s. Wrap a single value in an Array."
+    JSON_SHAPE = "%<kind>s cannot be sent as JSON. Pass a String, Symbol, Integer, Float, true, false, nil, Array, " \
+      "Hash, Time or Date."
+    JSON_KEY_SHAPE = "A key in a request body must be a String or a Symbol, not %<kind>s."
+    JSON_DEPTH = "The request body is nested too deeply, or refers to itself."
+    NOT_FINITE = "%<value>s cannot be sent as JSON, because JSON has no NaN or Infinity."
+    TIMED_OUT = "Request timed out after %<seconds>ss."
+    UNREACHABLE = "Could not reach %<base_url>s: %<reason>s"
+    TOO_MANY_REDIRECTS = "Stopped following redirects after %<count>s of them."
+    REDIRECT_SCHEME = "Refused to follow a redirect to a URL that is not a usable http or https address."
+    NO_RESPONSE = "The connection closed before a response arrived."
+    REQUEST_FAILED = "Request failed with status %<status>s"
+    HTTP_STATUS = "HTTP %<status>s"
+    UPDATE_AVAILABLE = "%<icon>s %<package>s %<latest>s is available, you are on %<current>s. Upgrade with %<command>s. " \
+      "%<changelog>s."
+  end
+end

data/lib/envless/sdk/net_http_adapter.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Envless
+  class NetHttpAdapter
+    STALE_ERRORS = [IOError, Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED, OpenSSL::SSL::SSLError].freeze
+    BODY_ERRORS = [IOError, SystemCallError, OpenSSL::SSL::SSLError, Zlib::Error, Net::HTTPBadResponse].freeze
+    EMPTY_WRITES = %w[POST PUT].freeze
+
+    def initialize(max_idle: Defaults::MAX_IDLE_CONNECTIONS, keep_alive_timeout: Defaults::KEEP_ALIVE_TIMEOUT)
+      @pool = ConnectionPool.new(max_idle:, keep_alive_timeout:)
+    end
+
+    def call(request)
+      uri = URI.parse(request.url)
+      raise ArgumentError, "#{request.url.inspect} #{Messages::BASE_URL_SHAPE}" unless uri.is_a?(URI::HTTP)
+
+      attempt(uri, request, Clock.deadline(request.timeout), false)
+    end
+
+    def close
+      @pool.close
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+
+    private
+
+    def attempt(uri, request, deadline, retried)
+      connection, reused = @pool.checkout(uri, Clock.remaining(deadline))
+      received = Received.new
+      complete = false
+
+      begin
+        complete = transfer(connection, outbound(uri, request), received, deadline)
+      rescue *STALE_ERRORS
+        raise unless reused && !retried && Constants::RETRYABLE_METHODS.include?(request.method)
+      ensure
+        complete ? @pool.checkin(uri, connection) : @pool.discard(connection)
+      end
+
+      return received.response if received.head
+
+      @pool.close
+      attempt(uri, request, deadline, true)
+    end
+
+    def transfer(connection, outbound, received, deadline)
+      limit(connection, deadline)
+      connection.request(outbound) do |incoming|
+        received.head = incoming
+        incoming.read_body do |chunk|
+          received.append(chunk)
+          limit(connection, deadline)
+        end
+      end
+      true
+    rescue Timeout::Error
+      raise
+    rescue *BODY_ERRORS
+      raise if received.head.nil?
+
+      received.truncate
+      false
+    end
+
+    def outbound(uri, request)
+      empty = request.body.nil? && EMPTY_WRITES.include?(request.method)
+      headers = empty ? request.headers.merge("Content-Length" => "0") : request.headers
+      outbound = Net::HTTPGenericRequest.new(request.method, !request.body.nil?, request.method != "HEAD",
+        uri.request_uri, headers)
+      outbound.body = request.body unless request.body.nil?
+      outbound
+    end
+
+    def limit(connection, deadline)
+      left = Clock.remaining(deadline)
+      connection.open_timeout = left
+      connection.read_timeout = left
+      connection.write_timeout = left
+    end
+  end
+end

data/lib/envless/sdk/numbers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Envless
+  module Numbers
+    DECIMAL = /\A[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?\z/
+    INFINITY = /\A([+-]?)Infinity\z/
+    RADIX_DIGITS = /\A[0-9A-Za-z]+\z/
+    RADIXES = {"0x" => 16, "0o" => 8, "0b" => 2}.freeze
+
+    module_function
+
+    def js_number(text)
+      trimmed = Text.js_trim(text)
+      return 0.0 if trimmed.empty?
+      return trimmed.to_f if DECIMAL.match?(trimmed)
+
+      infinity = INFINITY.match(trimmed)
+      return (infinity[1] == "-") ? -Float::INFINITY : Float::INFINITY if infinity
+
+      radix(trimmed)
+    end
+
+    def radix(trimmed)
+      base = RADIXES[trimmed[0, 2].to_s.downcase]
+      digits = trimmed[2..].to_s
+      return Float::NAN if base.nil? || !RADIX_DIGITS.match?(digits)
+
+      value = Integer(digits, base, exception: false)
+      value.nil? ? Float::NAN : value.to_f
+    end
+
+    def whole(value)
+      (value.is_a?(Float) && value.finite? && value == value.floor) ? value.to_i : value
+    end
+
+    def text(value)
+      number = value.is_a?(Integer) ? value : value.to_f
+      return "NaN" if number.is_a?(Float) && number.nan?
+      return number.positive? ? "Infinity" : "-Infinity" if number.is_a?(Float) && number.infinite?
+
+      whole(number).to_s
+    end
+  end
+end

data/lib/envless/sdk/options.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Envless
+  module Options
+    VERB = /\A[A-Z]+\z/
+
+    module_function
+
+    def valid_timeout(value)
+      number = value.is_a?(Integer) || value.is_a?(Float) || value.is_a?(Rational)
+      raise ArgumentError, Messages::TIMEOUT_SHAPE unless number && !(value.is_a?(Float) && value.nan?) && value >= 0
+
+      value
+    end
+
+    def deadline_of(seconds)
+      (seconds.positive? && seconds <= Defaults::MAX_TIMEOUT) ? seconds : nil
+    end
+
+    def valid_retries(value)
+      return Defaults::MAX_RETRIES if value.nil?
+      raise ArgumentError, Messages::RETRIES_SHAPE unless value.is_a?(Integer)
+
+      [value, 0].max
+    end
+
+    def user_agent(value)
+      agent = value.nil? ? Defaults::USER_AGENT : value
+      raise ArgumentError, Messages::USER_AGENT_SHAPE unless agent.is_a?(String)
+
+      trimmed = Text.http_trim(agent)
+      raise ArgumentError, Messages::USER_AGENT_SHAPE unless Text.header_value?(trimmed)
+
+      trimmed
+    end
+
+    def adapter(value)
+      raise ArgumentError, Messages::ADAPTER_SHAPE unless value.respond_to?(:call)
+
+      value
+    end
+
+    def verb(method)
+      text = (method.is_a?(String) || method.is_a?(Symbol)) ? method.to_s.upcase : ""
+      raise ArgumentError, Messages::METHOD_SHAPE unless VERB.match?(text)
+
+      text
+    end
+
+    def paging(value, name)
+      return value if value.nil? || value.is_a?(Integer)
+
+      raise ArgumentError, format(Messages::PAGING_SHAPE, name:)
+    end
+  end
+end

data/lib/envless/sdk/pagination.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Envless
+  module Pagination
+    module_function
+
+    def fetch_page(transport, path, collection, listing, timeout)
+      Pages.page_of(transport.request(path, query: listing.query, timeout:), collection)
+    end
+
+    def iterate(transport, path, collection, listing, timeout)
+      Enumerator.new do |yielder|
+        cursor = listing.walk
+
+        loop do
+          page = fetch_page(transport, path, collection, cursor, timeout)
+          page.items.each { |item| yielder << item }
+          break unless Pages.more?(page)
+
+          cursor = cursor.advance(page.items.size)
+        end
+
+        nil
+      end
+    end
+
+    def collect_all(transport, path, collection, listing, timeout)
+      iterate(transport, path, collection, listing, timeout).to_a
+    end
+  end
+end

data/lib/envless/sdk/paths.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Envless
+  module Paths
+    UNSAFE = /[^A-Za-z0-9\-_.!~*'()]/
+    DOTS = /\A\.+\z/
+    PATHS = Constants::PATHS
+    SEGMENTS = Constants::SEGMENTS
+
+    module_function
+
+    def segment(value)
+      text = segment_text(value)
+      raise ArgumentError, Messages::EMPTY_SEGMENT if text.empty?
+      raise ArgumentError, "#{text.inspect} #{Messages::DOT_SEGMENT}" if DOTS.match?(text)
+
+      text.gsub(UNSAFE) { |character| character.bytes.map { |byte| format("%%%02X", byte) }.join }
+    end
+
+    def segment_text(value)
+      case value
+      when String, Symbol then Text.utf8(value.to_s)
+      when Integer then value.to_s
+      else raise ArgumentError, Messages::SEGMENT_SHAPE
+      end
+    end
+
+    def product_path(slug) = "#{PATHS[:PRODUCTS]}/#{segment(slug)}"
+
+    def product_projects_path(slug) = "#{product_path(slug)}/#{SEGMENTS[:PROJECTS]}"
+
+    def product_access_path(slug) = "#{product_path(slug)}/#{SEGMENTS[:ACCESS]}"
+
+    def product_access_member_path(slug, member_id) = "#{product_access_path(slug)}/#{segment(member_id)}"
+
+    def project_path(slug) = "#{PATHS[:PROJECTS]}/#{segment(slug)}"
+
+    def environments_path(project) = "#{project_path(project)}/#{SEGMENTS[:ENVIRONMENTS]}"
+
+    def environment_path(project, environment) = "#{environments_path(project)}/#{segment(environment)}"
+
+    def variables_path(project, environment) = "#{environment_path(project, environment)}/#{SEGMENTS[:VARIABLES]}"
+
+    def variable_path(project, environment, name) = "#{variables_path(project, environment)}/#{segment(name)}"
+
+    def history_path(project, environment, name) = "#{variable_path(project, environment, name)}/#{SEGMENTS[:HISTORY]}"
+
+    def versions_path(project, environment) = "#{environment_path(project, environment)}/#{SEGMENTS[:VERSIONS]}"
+
+    def entries_path(project, environment) = "#{versions_path(project, environment)}/#{SEGMENTS[:ENTRIES]}"
+
+    def variable_by_id_path(id) = "#{PATHS[:VARIABLES]}/#{segment(id)}"
+
+    def version_by_id_path(id) = "#{PATHS[:VERSIONS]}/#{segment(id)}"
+
+    def member_path(id) = "#{PATHS[:MEMBERS]}/#{segment(id)}"
+
+    def invite_path(id) = "#{PATHS[:INVITES]}/#{segment(id)}"
+
+    def role_path(id) = "#{PATHS[:ROLES]}/#{segment(id)}"
+
+    def key_path(id) = "#{PATHS[:KEYS]}/#{segment(id)}"
+
+    def webhook_path(id) = "#{PATHS[:WEBHOOKS]}/#{segment(id)}"
+
+    def deliveries_path(id) = "#{webhook_path(id)}/#{SEGMENTS[:DELIVERIES]}"
+
+    def delivery_path(id, delivery_id) = "#{deliveries_path(id)}/#{segment(delivery_id)}"
+  end
+end

data/lib/envless/sdk/received.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Envless
+  class Received
+    attr_accessor :head
+
+    def initialize
+      @head = nil
+      @body = "".b
+    end
+
+    def append(chunk)
+      @body << chunk
+    end
+
+    def truncate
+      @body = "".b
+    end
+
+    def response
+      current = head
+      raise Net::HTTPBadResponse, Messages::NO_RESPONSE if current.nil?
+
+      HttpResponse.new(status: current.code.to_i, headers: current.each_header.to_h, body: @body,
+        reason: current.message.to_s)
+    end
+  end
+end