warrant 3.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eedc398b4f1277eabdabf8252acde068e1a1398f0b3752d217793ec1d22570b3
-  data.tar.gz: 035f98bda116c4177ead75b9895a86582b2b37fd7d04b1b2175e68f73c0adff5
+  metadata.gz: e2f6af0b73e1d0ade950db2c0bce0e14176bb3f380914099ea5bb21382076ba0
+  data.tar.gz: 973470f3ac7c430e07258004d9e425d39ce338c7130ce9a23e694c49f6411286
 SHA512:
-  metadata.gz: b5d81834bffb0ac19ed371259e6b321ca23aa42a8ab0dd1bcf8c720fec168910ed8dcfe620942d17d4d399834593856080dbe802f786d273466db347089b10b4
-  data.tar.gz: 717cce9e98093c01c7412323894e7eb9f87742ae412eac1564e8e91184a3cea327dbb76ee7d5131196389c8df7e6b5a112ed24a6ccbd270f75a0277f2356b651
+  metadata.gz: 6d6a7b4e2b0a7a69a31ce8f04b6bb856edf7d4793795a237f3ba23a46cb3f9aab09caab3ab0511c005f7c018384d9c325987194e61956dfda0588274b7b74ce1
+  data.tar.gz: c488dc7bdc1d19775e793efe3eff35c785c870409e70c76c997f15473de93bb8b4f42f9203e4d807e0c5c7b90f641da286b2f4d067335664c441225522dc217a

data/README.md

@@ -6,7 +6,6 @@ Use [Warrant](https://warrant.dev/) in ruby projects.
 [![Slack](https://img.shields.io/badge/slack-join-brightgreen)](https://join.slack.com/t/warrantcommunity/shared_invite/zt-12g84updv-5l1pktJf2bI5WIKN4_~f4w)
 
 ## Installation
----
 
 Add this line to your application's Gemfile:
 
@@ -27,18 +26,15 @@ You can also build the gem from source:
     $ gem build warrant.gemspec
 
 ## Documentation
----
 
 - [Ruby API Docs](https://rubydoc.info/gems/warrant)
 - [Warrant Docs](https://docs.warrant.dev/)
 
 ## Requirements
----
 
 - Ruby 2.3+.
 
 ## Usage
----
 
 ```ruby
 require 'warrant'
@@ -52,7 +48,6 @@ Warrant::Warrant.is_authorized?(object_type: "report", object_id: "7asm24", rela
 ```
 
 ## Configuring the API and Authorize Endpoints
----
 The API and Authorize endpoints the SDK makes requests to is configurable via the `Warrant.api_base` and `Warrant.authorize_endpoint` attributes:
 
 ```ruby
@@ -64,7 +59,6 @@ Warrant.authorize_endpoint = 'http://localhost:8000'
 ```
 
 ## Configuring SSL
----
 By default, the SDK will attempt to use SSL when making requests to the API. This setting is configurable via the `Warrant.use_ssl` attribute:
 
 ```ruby
@@ -74,7 +68,6 @@ require 'warrant'
 Warrant.use_ssl = false
 ```
 
-
 We’ve used a random API key in these code examples. Replace it with your [actual publishable API keys](https://app.warrant.dev) to
 test this code through your own Warrant account.
 

data/lib/warrant/api_operations.rb

@@ -4,49 +4,51 @@ module Warrant
     # @!visibility private
     class APIOperations
         class << self
-            def post(uri, params = {})
+            def post(uri, params: {}, options: {})
                 http = Net::HTTP.new(uri.host, uri.port)
                 http.use_ssl = ::Warrant.config.use_ssl
                 headers = {
                     "User-Agent": "warrant-ruby/#{VERSION}"
                 }
                 headers["Authorization"] = "ApiKey #{::Warrant.config.api_key}" unless ::Warrant.config.api_key.empty?
+                headers["Warrant-Token"] = options[:warrant_token] if options.has_key?(:warrant_token)
                 http.post(uri.path, params.to_json, headers)
             end
 
-            def delete(uri, params = {})
+            def delete(uri, params: {}, options: {})
                 http = Net::HTTP.new(uri.host, uri.port)
                 http.use_ssl = ::Warrant.config.use_ssl
                 request = Net::HTTP::Delete.new(uri.path)
                 request["Authorization"] = "ApiKey #{::Warrant.config.api_key}" unless ::Warrant.config.api_key.empty?
                 request["User-Agent"] = "warrant-ruby/#{VERSION}"
-
+                headers["Warrant-Token"] = options[:warrant_token] if options.has_key?(:warrant_token)
                 http.request(request, params.to_json)
             end
 
-            def get(uri, params = {})
+            def get(uri, params: {}, options: {})
                 http = Net::HTTP.new(uri.host, uri.port)
                 http.use_ssl = ::Warrant.config.use_ssl
                 headers = {
                     "User-Agent": "warrant-ruby/#{VERSION}"
                 }
                 headers["Authorization"] = "ApiKey #{::Warrant.config.api_key}" unless ::Warrant.config.api_key.empty?
+                headers["Warrant-Token"] = options[:warrant_token] if options.has_key?(:warrant_token)
 
                 unless params.empty?
-                    normalized_params = Util.normalize_params(params.compact)
-                    uri.query = URI.encode_www_form(normalized_params)
+                    uri.query = URI.encode_www_form(params)
                 end
 
                 http.get(uri, headers)
             end
 
-            def put(uri, params = {})
+            def put(uri, params: {}, options: {})
                 http = Net::HTTP.new(uri.host, uri.port)
                 http.use_ssl = ::Warrant.config.use_ssl
                 headers = {
                     "User-Agent": "warrant-ruby/#{VERSION}"
                 }
                 headers["Authorization"] = "ApiKey #{::Warrant.config.api_key}" unless ::Warrant.config.api_key.empty?
+                headers["Warrant-Token"] = options[:warrant_token] if options.has_key?(:warrant_token)
                 http.put(uri.path, params.to_json, headers)
             end
 

data/lib/warrant/models/feature.rb

@@ -1,21 +1,22 @@
 # frozen_string_literal: true
 
 module Warrant
-    class Feature
+    class Feature < Warrant::Object
         OBJECT_TYPE = "feature"
 
         include Warrant::WarrantObject
 
-        attr_reader :feature_id
+        alias :feature_id :object_id
 
         # @!visibility private
-        def initialize(feature_id)
-            @feature_id = feature_id
+        def initialize(feature_id, meta = {}, created_at = nil)
+            super(OBJECT_TYPE, feature_id, meta, created_at)
         end
 
         # Creates a feature with the given parameters
         #
-        # @option params [String] :feature_id A string identifier for this new feature. The feature_id can only be composed of lower-case alphanumeric chars and/or '-' and '_'.
+        # @option params [String] :feature_id User defined string identifier for this feature. If not provided, Warrant will create an id for the feature and return it. In this case, you should store the id in your system as you will need to provide it for any authorization requests for that feature. Note that featureIds in Warrant must be composed of alphanumeric chars, '-', and/or '_'. (optional)
+        # @option params [Hash] :meta A JSON object containing additional information about this feature (e.g. name/description) to be persisted to Warrant. (optional)
         #
         # @return [Feature] created feature
         #
@@ -26,16 +27,9 @@ module Warrant
         # @raise [Warrant::InternalError]
         # @raise [Warrant::InvalidRequestError]
         # @raise [Warrant::UnauthorizedError]
-        def self.create(params = {})
-            res = APIOperations.post(URI.parse("#{::Warrant.config.api_base}/v1/features"), Util.normalize_params(params))
-
-            case res
-            when Net::HTTPSuccess
-                res_json = JSON.parse(res.body)
-                Feature.new(res_json['featureId'])
-            else
-                APIOperations.raise_error(res)
-            end
+        def self.create(params = {}, options = {})
+            object = Object.create({ object_type: OBJECT_TYPE, object_id: params[:feature_id], meta: params[:meta] }, options)
+            return Feature.new(object.object_id, object.meta, object.created_at)
         end
 
         # Deletes a feature with given feature id
@@ -51,21 +45,20 @@ module Warrant
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
-        def self.delete(feature_id)
-            res = APIOperations.delete(URI.parse("#{::Warrant.config.api_base}/v1/features/#{feature_id}"))
-
-            case res
-            when Net::HTTPSuccess
-                return
-            else
-                APIOperations.raise_error(res)
-            end
+        def self.delete(feature_id, options = {})
+            return Object.delete(OBJECT_TYPE, feature_id, options)
         end
 
         # Lists all features for your organization
         #
-        # @option filters [Integer] :page A positive integer (starting with 1) representing the page of items to return in response. Used in conjunction with the limit param. (optional)
-        # @option filters [Integer] :limit A positive integer representing the max number of items to return in response. (optional)
+        # @param [Hash] filters Filters to apply to result set
+        # @param [Hash] options Options to apply on a per-request basis
+        # @option filters [Integer] :limit A positive integer representing the maximum number of items to return in the response. Must be less than or equal to 1000. Defaults to 25. (optional)
+        # @option filters [String] :prev_cursor A cursor representing your place in a list of results. Requests containing prev_cursor will return the results immediately preceding the cursor. (optional)
+        # @option filters [String] :next_cursor A cursor representing your place in a list of results. Requests containing next_cursor will return the results immediately following the cursor. (optional)
+        # @option filters [String] :sort_by The column to sort the result by. Unless otherwise specified, all list endpoints are sorted by their unique identifier by default. Supported values for objects are +object_type+, +object_id+, and +created_at+ (optional)
+        # @option filters [String] :sort_order The order in which to sort the result by. Valid values are +ASC+ and +DESC+. Defaults to +ASC+. (optional)
+        # @option options [String] :warrant_token A valid warrant token from a previous write operation or latest. Used to specify desired consistency for this read operation. (optional)
         #
         # @return [Array<Feature>] all features for your organization
         #
@@ -74,16 +67,11 @@ module Warrant
         #
         # @raise [Warrant::InternalError]
         # @raise [Warrant::UnauthorizedError]
-        def self.list(filters = {})
-            res = APIOperations.get(URI.parse("#{::Warrant.config.api_base}/v1/features"), Util.normalize_params(filters))
-
-            case res
-            when Net::HTTPSuccess
-                features = JSON.parse(res.body)
-                features.map{ |feature| Feature.new(feature['featureId']) }
-            else
-                APIOperations.raise_error(res)
-            end
+        def self.list(filters = {}, options = {})
+            filters.merge({ object_type: OBJECT_TYPE })
+            list_response = Object.list(filters, options)
+            features = list_response.results.map{ |object| Feature.new(object.object_id, object.meta, object.created_at)}
+            return ListResponse.new(features, list_response.prev_cursor, list_response.next_cursor)
         end
 
         # Get a feature with the given feature_id
@@ -96,45 +84,79 @@ module Warrant
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
-        def self.get(feature_id)
-            res = APIOperations.get(URI.parse("#{::Warrant.config.api_base}/v1/features/#{feature_id}"))
+        def self.get(feature_id, options = {})
+            object = Object.get(OBJECT_TYPE, feature_id, options)
+            return Feature.new(object.object_id, object.meta, object.created_at)
+        end
 
-            case res
-            when Net::HTTPSuccess
-                feature = JSON.parse(res.body)
-                Feature.new(feature['featureId'])
-            else
-                APIOperations.raise_error(res)
-            end
+        # Updates a feature with the given feature_id and params
+        #
+        # @param feature_id [String] The feature_id of the feature to be updated.
+        # @param meta [Hash] A JSON object containing additional information about this feature (e.g. name/description, etc.) to be persisted to Warrant.
+        #
+        # @return [Feature] updated feature
+        #
+        # @example Update feature "test-feature"'s name
+        #   Warrant::Feature.update("test-feature", { name: "Test Feature" })
+        #
+        # @raise [Warrant::InternalError]
+        # @raise [Warrant::InvalidParameterError]
+        # @raise [Warrant::InvalidRequestError]
+        # @raise [Warrant::NotFoundError]
+        # @raise [Warrant::UnauthorizedError]
+        def self.update(feature_id, meta, options = {})
+            object = Object.update(OBJECT_TYPE, feature_id, meta, options)
+            return Feature.new(object.object_id, object.meta, object.created_at)
+        end
+
+        # Updates a feature with the given params
+        #
+        # @param meta [Hash] A JSON object containing additional information about this feature (e.g. name/description, etc.) to be persisted to Warrant.
+        #
+        # @return [Feature] updated feature
+        #
+        # @example Update feature "test-feature"'s name
+        #   feature = Warrant::Feature.get("test-feature")
+        #   feature.update({ name: "Test Feature" })
+        #
+        # @raise [Warrant::InternalError]
+        # @raise [Warrant::InvalidParameterError]
+        # @raise [Warrant::InvalidRequestError]
+        # @raise [Warrant::NotFoundError]
+        # @raise [Warrant::UnauthorizedError]
+        def update(meta, options = {})
+            return Feature.update(feature_id, meta)
         end
 
         # List features for tenant
         #
         # @param tenant_id [String] The tenant_id of the tenant to list features for.
-        # @option filters [Integer] :page A positive integer (starting with 1) representing the page of items to return in response. Used in conjunction with the limit param. (optional)
-        # @option filters [Integer] :limit A positive integer representing the max number of items to return in response. (optional)
+        # @param [Hash] filters Filters to apply to result set
+        # @param [Hash] options Options to apply on a per-request basis
+        # @option filters [String] :object_type Only return objects with an `objectType` matching this value
+        # @option filters [Integer] :limit A positive integer representing the maximum number of items to return in the response. Must be less than or equal to 1000. Defaults to 25. (optional)
+        # @option filters [String] :prev_cursor A cursor representing your place in a list of results. Requests containing prev_cursor will return the results immediately preceding the cursor. (optional)
+        # @option filters [String] :next_cursor A cursor representing your place in a list of results. Requests containing next_cursor will return the results immediately following the cursor. (optional)
+        # @option filters [String] :sort_by The column to sort the result by. Unless otherwise specified, all list endpoints are sorted by their unique identifier by default. Supported values for objects are +object_type+, +object_id+, and +created_at+ (optional)
+        # @option filters [String] :sort_order The order in which to sort the result by. Valid values are +ASC+ and +DESC+. Defaults to +ASC+. (optional)
+        # @option options [String] :warrant_token A valid warrant token from a previous write operation or latest. Used to specify desired consistency for this read operation. (optional)
         #
         # @return [Array<Feature>] assigned features for the tenant
         #
         # @raise [Warrant::InternalError]
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::UnauthorizedError]
-        def self.list_for_tenant(tenant_id, filters = {})
-            res = APIOperations.get(URI.parse("#{::Warrant.config.api_base}/v1/tenants/#{tenant_id}/features"), Util.normalize_params(filters))
-
-            case res
-            when Net::HTTPSuccess
-                features = JSON.parse(res.body)
-                features.map{ |feature| Feature.new(feature['featureId']) }
-            else
-                APIOperations.raise_error(res)
-            end
+        def self.list_for_tenant(tenant_id, filters = {}, options = {})
+            query_response = Warrant.query("select feature where tenant:#{tenant_id} is *", filters: filters, options: options)
+            features = query_response.results.map{ |result| Feature.new(result.object_id, result.meta) }
+            return ListResponse.new(features, query_response.prev_cursor, query_response.next_cursor)
         end
 
         # Assign a feature to a tenant
         #
         # @param tenant_id [String] The tenant_id of the tenant you want to assign a feature to.
         # @param feature_id [String] The feature_id of the feature you want to assign to a tenant.
+        # @param relation [String] The relation for this feature to tenant association. The relation must be valid as per the +feature+ object type definition.
         #
         # @return [Warrant] warrant assigning feature to tenant
         #
@@ -143,14 +165,15 @@ module Warrant
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
-        def self.assign_to_tenant(tenant_id, feature_id)
-            Warrant.create({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, "member", { object_type: Tenant::OBJECT_TYPE, object_id: tenant_id })
+        def self.assign_to_tenant(tenant_id, feature_id, relation: "member", options: {})
+            Warrant.create({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, relation, { object_type: Tenant::OBJECT_TYPE, object_id: tenant_id }, nil, options)
         end
 
         # Remove a feature from a tenant
         #
         # @param tenant_id [String] The tenant_id of the tenant you want to remove a feature from.
         # @param feature_id [String] The feature_id of the feature you want to remove from a tenant.
+        # @param relation [String] The relation for this feature to tenant association. The relation must be valid as per the +feature+ object type definition.
         #
         # @return [nil] if remove was successful
         #
@@ -159,37 +182,39 @@ module Warrant
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
         # @raise [Warrant::WarrantError]
-        def self.remove_from_tenant(tenant_id, feature_id)
-            Warrant.delete({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, "member", { object_type: Tenant::OBJECT_TYPE, object_id: tenant_id })
+        def self.remove_from_tenant(tenant_id, feature_id, relation: "member", options: {})
+            Warrant.delete({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, relation, { object_type: Tenant::OBJECT_TYPE, object_id: tenant_id }, nil, options)
         end
 
         # List features for user
         #
         # @param user_id [String] The user_id of the user to list features for.
-        # @option filters [Integer] :page A positive integer (starting with 1) representing the page of items to return in response. Used in conjunction with the limit param. (optional)
-        # @option filters [Integer] :limit A positive integer representing the max number of items to return in response. (optional)
+        # @param [Hash] filters Filters to apply to result set
+        # @param [Hash] options Options to apply on a per-request basis
+        # @option filters [String] :object_type Only return objects with an `objectType` matching this value
+        # @option filters [Integer] :limit A positive integer representing the maximum number of items to return in the response. Must be less than or equal to 1000. Defaults to 25. (optional)
+        # @option filters [String] :prev_cursor A cursor representing your place in a list of results. Requests containing prev_cursor will return the results immediately preceding the cursor. (optional)
+        # @option filters [String] :next_cursor A cursor representing your place in a list of results. Requests containing next_cursor will return the results immediately following the cursor. (optional)
+        # @option filters [String] :sort_by The column to sort the result by. Unless otherwise specified, all list endpoints are sorted by their unique identifier by default. Supported values for objects are +object_type+, +object_id+, and +created_at+ (optional)
+        # @option filters [String] :sort_order The order in which to sort the result by. Valid values are +ASC+ and +DESC+. Defaults to +ASC+. (optional)
+        # @option options [String] :warrant_token A valid warrant token from a previous write operation or latest. Used to specify desired consistency for this read operation. (optional)
         #
         # @return [Array<Feature>] assigned features for the user
         #
         # @raise [Warrant::InternalError]
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::UnauthorizedError]
-        def self.list_for_user(user_id, filters = {})
-            res = APIOperations.get(URI.parse("#{::Warrant.config.api_base}/v1/users/#{user_id}/features"), Util.normalize_params(filters))
-
-            case res
-            when Net::HTTPSuccess
-                features = JSON.parse(res.body)
-                features.map{ |feature| Feature.new(feature['featureId']) }
-            else
-                APIOperations.raise_error(res)
-            end
+        def self.list_for_user(user_id, filters = {}, options = {})
+            query_response = Warrant.query("select feature where user:#{user_id} is *", filters: filters, options: options)
+            features = query_response.results.map{ |result| Feature.new(result.object_id, result.meta) }
+            return ListResponse.new(features, query_response.prev_cursor, query_response.next_cursor)
         end
 
         # Assign a feature to a user
         #
         # @param user_id [String] The user_id of the user you want to assign a feature to.
         # @param feature_id [String] The feature_id of the feature you want to assign to a user.
+        # @param relation [String] The relation for this feature to user association. The relation must be valid as per the +feature+ object type definition.
         #
         # @return [Warrant] warrant assigning feature to user
         #
@@ -198,14 +223,15 @@ module Warrant
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
-        def self.assign_to_user(user_id, feature_id)
-            Warrant.create({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, "member", { object_type: User::OBJECT_TYPE, object_id: user_id })
+        def self.assign_to_user(user_id, feature_id, relation: "member", options: {})
+            Warrant.create({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, relation, { object_type: User::OBJECT_TYPE, object_id: user_id }, nil, options)
         end
 
         # Remove a feature from a user
         #
         # @param user_id [String] The user_id of the user you want to remove a feature from.
         # @param feature_id [String] The feature_id of the feature you want to remove from a user.
+        # @param relation [String] The relation for this feature to user association. The relation must be valid as per the +feature+ object type definition.
         #
         # @return [nil] if remove was successful
         #
@@ -214,37 +240,39 @@ module Warrant
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
         # @raise [Warrant::WarrantError]
-        def self.remove_from_user(user_id, feature_id)
-            Warrant.delete({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, "member", { object_type: User::OBJECT_TYPE, object_id: user_id })
+        def self.remove_from_user(user_id, feature_id, relation: "member", options: {})
+            Warrant.delete({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, relation, { object_type: User::OBJECT_TYPE, object_id: user_id }, nil, options)
         end
 
         # List features for pricing tier
         #
         # @param pricing_tier_id [String] The pricing_tier_id of the pricing tier to list features for.
-        # @option filters [Integer] :page A positive integer (starting with 1) representing the page of items to return in response. Used in conjunction with the limit param. (optional)
-        # @option filters [Integer] :limit A positive integer representing the max number of items to return in response. (optional)
+        # @param [Hash] filters Filters to apply to result set
+        # @param [Hash] options Options to apply on a per-request basis
+        # @option filters [String] :object_type Only return objects with an `objectType` matching this value
+        # @option filters [Integer] :limit A positive integer representing the maximum number of items to return in the response. Must be less than or equal to 1000. Defaults to 25. (optional)
+        # @option filters [String] :prev_cursor A cursor representing your place in a list of results. Requests containing prev_cursor will return the results immediately preceding the cursor. (optional)
+        # @option filters [String] :next_cursor A cursor representing your place in a list of results. Requests containing next_cursor will return the results immediately following the cursor. (optional)
+        # @option filters [String] :sort_by The column to sort the result by. Unless otherwise specified, all list endpoints are sorted by their unique identifier by default. Supported values for objects are +object_type+, +object_id+, and +created_at+ (optional)
+        # @option filters [String] :sort_order The order in which to sort the result by. Valid values are +ASC+ and +DESC+. Defaults to +ASC+. (optional)
+        # @option options [String] :warrant_token A valid warrant token from a previous write operation or latest. Used to specify desired consistency for this read operation. (optional)
         #
         # @return [Array<Feature>] assigned features for the pricing tier
         #
         # @raise [Warrant::InternalError]
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::UnauthorizedError]
-        def self.list_for_pricing_tier(pricing_tier_id, filters = {})
-            res = APIOperations.get(URI.parse("#{::Warrant.config.api_base}/v1/pricing-tiers/#{pricing_tier_id}/features"), Util.normalize_params(filters))
-
-            case res
-            when Net::HTTPSuccess
-                features = JSON.parse(res.body)
-                features.map{ |feature| Feature.new(feature['featureId']) }
-            else
-                APIOperations.raise_error(res)
-            end
+        def self.list_for_pricing_tier(pricing_tier_id, filters = {}, options = {})
+            query_response = Warrant.query("select feature where pricing-tier:#{pricing_tier_id} is *", filters: filters, options: options)
+            features = query_response.results.map{ |result| Feature.new(result.object_id, result.meta) }
+            return ListResponse.new(features, query_response.prev_cursor, query_response.next_cursor)
         end
 
         # Assign a feature to a pricing tier
         #
         # @param pricing_tier_id [String] The pricing_tier_id of the pricing tier you want to assign a feature to.
         # @param feature_id [String] The feature_id of the feature you want to assign to a pricing tier.
+        # @param relation [String] The relation for this feature to pricing tier association. The relation must be valid as per the +feature+ object type definition.
         #
         # @return [Warrant] warrant assigning feature to pricing tier
         #
@@ -253,14 +281,15 @@ module Warrant
         # @raise [Warrant::InvalidParameterError]
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
-        def self.assign_to_pricing_tier(pricing_tier_id, feature_id)
-            Warrant.create({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, "member", { object_type: PricingTier::OBJECT_TYPE, object_id: pricing_tier_id })
+        def self.assign_to_pricing_tier(pricing_tier_id, feature_id, relation: "member", options: {})
+            Warrant.create({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, relation, { object_type: PricingTier::OBJECT_TYPE, object_id: pricing_tier_id }, nil, options)
         end
 
         # Remove a feature from a pricing tier
         #
         # @param pricing_tier_id [String] The pricing_tier_id of the pricing tier you want to remove a feature from.
         # @param feature_id [String] The feature_id of the feature you want to remove from a pricing tier.
+        # @param relation [String] The relation for this feature to pricing tier association. The relation must be valid as per the +feature+ object type definition.
         #
         # @return [nil] if remove was successful
         #
@@ -269,8 +298,8 @@ module Warrant
         # @raise [Warrant::NotFoundError]
         # @raise [Warrant::UnauthorizedError]
         # @raise [Warrant::WarrantError]
-        def self.remove_from_pricing_tier(pricing_tier_id, feature_id)
-            Warrant.delete({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, "member", { object_type: PricingTier::OBJECT_TYPE, object_id: pricing_tier_id })
+        def self.remove_from_pricing_tier(pricing_tier_id, feature_id, relation: "member", options: {})
+            Warrant.delete({ object_type: Feature::OBJECT_TYPE, object_id: feature_id }, relation, { object_type: PricingTier::OBJECT_TYPE, object_id: pricing_tier_id }, nil, options)
         end
 
         def warrant_object_type

data/lib/warrant/models/list_response.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Warrant
+    class ListResponse
+        attr_reader :results, :prev_cursor, :next_cursor
+
+        # @!visibility private
+        def initialize(results, prev_cursor, next_cursor)
+            @results = results
+            @prev_cursor = prev_cursor
+            @next_cursor = next_cursor
+        end
+    end
+end