envless-sdk 0.0.1

data/lib/envless/sdk/redirects.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Envless
+  module Redirects
+    STATUSES = [301, 302, 303, 307, 308].freeze
+    SAFE_METHODS = %w[GET HEAD].freeze
+    BODY_HEADERS = %w[content-type content-encoding content-language content-location].freeze
+    UNSAFE = %r{[^A-Za-z0-9\-._~:/?#\[\]@!$&'()*+,;=%]}
+
+    module_function
+
+    def follow(adapter, request, deadline)
+      current = request
+
+      (Defaults::MAX_REDIRECTS + 1).times do
+        response = HttpResponse.from(adapter.call(current.with(timeout: Clock.remaining(deadline))))
+        location = response.header(Defaults::LOCATION_HEADER)
+        return response unless STATUSES.include?(response.status) && location && !location.empty?
+
+        current = following(current, response.status, location)
+      end
+
+      raise NetworkError, format(Messages::TOO_MANY_REDIRECTS, count: Defaults::MAX_REDIRECTS)
+    end
+
+    def following(request, status, location)
+      target = target_of(request.url, location)
+
+      method, body, headers = rewritten(request, status)
+      headers = headers.reject { |name, _| name.casecmp?(Constants::HEADER_KEYS[:AUTHORIZATION]) } unless same_origin?(request.url, target)
+
+      request.with(method:, url: target, headers:, body:)
+    end
+
+    def target_of(base, location)
+      cleaned = Text.utf8(location).strip.delete("\t\n\r").tr("\\", "/")
+      encoded = cleaned.gsub(UNSAFE) { |character| character.bytes.map { |byte| format("%%%02X", byte) }.join }
+      target = URI.join(base, encoded)
+      raise NetworkError, Messages::REDIRECT_SCHEME unless target.is_a?(URI::HTTP) && !target.host.to_s.empty?
+
+      target.to_s
+    end
+
+    def rewritten(request, status)
+      drop = (status == 303 && !SAFE_METHODS.include?(request.method)) || ([301, 302].include?(status) && request.method == "POST")
+      return [request.method, request.body, request.headers] unless drop
+
+      kept = request.headers.reject { |name, _| BODY_HEADERS.include?(name.downcase) }
+      [(request.method == "HEAD") ? "HEAD" : "GET", nil, kept]
+    end
+
+    def same_origin?(left, right)
+      Urls.origin(left) == Urls.origin(right)
+    end
+  end
+end

data/lib/envless/sdk/resource.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Envless
+  class Resource
+    include Constants
+
+    def initialize(transport)
+      @transport = transport
+      freeze
+    end
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+
+    private
+
+    def request(path, method: HTTP_METHODS[:GET], query: nil, body: nil, timeout: nil)
+      @transport.request(path, method:, query:, body:, timeout:)
+    end
+
+    def scoped(product)
+      {QUERY_KEYS[:PRODUCT] => product}
+    end
+
+    def page(path, collection, listing, timeout)
+      Pagination.fetch_page(@transport, path, collection, listing, timeout)
+    end
+
+    def all(path, collection, listing, timeout)
+      Pagination.collect_all(@transport, path, collection, listing, timeout)
+    end
+
+    def each_item(path, collection, listing, timeout, &block)
+      walk = Pagination.iterate(@transport, path, collection, listing, timeout)
+      return walk unless block
+
+      walk.each(&block)
+      nil
+    end
+
+    def body_of(body, fields)
+      Bodies.merge(body, fields)
+    end
+
+    def list_of(values, name)
+      Bodies.list(values, name)
+    end
+  end
+end

data/lib/envless/sdk/resources/environments.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Environments < Resource
+      def list(project, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(Paths.environments_path(project), COLLECTIONS[:ENVIRONMENTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(project, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(Paths.environments_path(project), COLLECTIONS[:ENVIRONMENTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(project, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(Paths.environments_path(project), COLLECTIONS[:ENVIRONMENTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+
+      def get(project, environment, product: nil, timeout: nil)
+        request(Paths.environment_path(project, environment), query: scoped(product), timeout:)
+      end
+
+      def create(project, body = nil, product: nil, timeout: nil, **fields)
+        request(Paths.environments_path(project), method: HTTP_METHODS[:POST], query: scoped(product),
+          body: body_of(body, fields), timeout:)
+      end
+
+      def update(project, environment, patch = nil, product: nil, timeout: nil, **fields)
+        request(Paths.environment_path(project, environment), method: HTTP_METHODS[:PATCH], query: scoped(product),
+          body: body_of(patch, fields), timeout:)
+      end
+
+      def delete(project, environment, product: nil, timeout: nil)
+        request(Paths.environment_path(project, environment), method: HTTP_METHODS[:DELETE], query: scoped(product),
+          timeout:)
+      end
+
+      def duplicate(project, environment, product: nil, timeout: nil)
+        request("#{Paths.environment_path(project, environment)}/#{SEGMENTS[:DUPLICATE]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), timeout:)
+      end
+
+      def expose(project, environment, product: nil, timeout: nil)
+        set_exposed(project, environment, true, product, timeout)
+      end
+
+      def unexpose(project, environment, product: nil, timeout: nil)
+        set_exposed(project, environment, false, product, timeout)
+      end
+
+      private
+
+      def set_exposed(project, environment, exposed, product, timeout)
+        request("#{Paths.environment_path(project, environment)}/#{SEGMENTS[:EXPOSE]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), body: {"exposed" => exposed}, timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/invites.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Invites < Resource
+      def list(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(PATHS[:INVITES], COLLECTIONS[:INVITES], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(PATHS[:INVITES], COLLECTIONS[:INVITES], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(PATHS[:INVITES], COLLECTIONS[:INVITES], Listing.of(limit:, offset:, search:, order:, product:),
+          timeout, &block)
+      end
+
+      def revoke(id, timeout: nil)
+        request(Paths.invite_path(id), method: HTTP_METHODS[:DELETE], timeout:)
+      end
+
+      def resend(id, timeout: nil)
+        request("#{Paths.invite_path(id)}/#{SEGMENTS[:RESEND]}", method: HTTP_METHODS[:POST], timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/keys.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Keys < Resource
+      def list(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(PATHS[:KEYS], COLLECTIONS[:KEYS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(PATHS[:KEYS], COLLECTIONS[:KEYS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(PATHS[:KEYS], COLLECTIONS[:KEYS], Listing.of(limit:, offset:, search:, order:, product:), timeout,
+          &block)
+      end
+
+      def get(id, timeout: nil)
+        request(Paths.key_path(id), timeout:)
+      end
+
+      def create(body = nil, timeout: nil, **fields)
+        request(PATHS[:KEYS], method: HTTP_METHODS[:POST], body: body_of(body, fields), timeout:)
+      end
+
+      def update(id, patch = nil, timeout: nil, **fields)
+        request(Paths.key_path(id), method: HTTP_METHODS[:PATCH], body: body_of(patch, fields), timeout:)
+      end
+
+      def delete(id, timeout: nil)
+        request(Paths.key_path(id), method: HTTP_METHODS[:DELETE], timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/me.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Me < Resource
+      def get(timeout: nil)
+        request(PATHS[:ME], timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/members.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Members < Resource
+      def list(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(PATHS[:MEMBERS], COLLECTIONS[:MEMBERS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(PATHS[:MEMBERS], COLLECTIONS[:MEMBERS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(PATHS[:MEMBERS], COLLECTIONS[:MEMBERS], Listing.of(limit:, offset:, search:, order:, product:),
+          timeout, &block)
+      end
+
+      def invite(body = nil, timeout: nil, **fields)
+        request(PATHS[:MEMBERS], method: HTTP_METHODS[:POST], body: body_of(body, fields), timeout:)
+      end
+
+      def update(id, patch = nil, timeout: nil, **fields)
+        request(Paths.member_path(id), method: HTTP_METHODS[:PATCH], body: body_of(patch, fields), timeout:)
+      end
+
+      def remove(id, timeout: nil)
+        request(Paths.member_path(id), method: HTTP_METHODS[:DELETE], timeout:)
+      end
+
+      def leave(timeout: nil)
+        request(PATHS[:MEMBERS_ME], method: HTTP_METHODS[:DELETE], timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/product_access.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class ProductAccess < Resource
+      def list(slug, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        query = Listing.of(limit:, offset:, search:, order:).query
+        Pages.access_page_of(request(Paths.product_access_path(slug), query:, timeout:), COLLECTIONS[:ACCESS])
+      end
+
+      def list_all(slug, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(Paths.product_access_path(slug), COLLECTIONS[:ACCESS], Listing.of(limit:, offset:, search:, order:, product:),
+          timeout)
+      end
+
+      def iterate(slug, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(Paths.product_access_path(slug), COLLECTIONS[:ACCESS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+
+      def grant(slug, member_id, timeout: nil)
+        request(Paths.product_access_member_path(slug, member_id), method: HTTP_METHODS[:PUT], timeout:)
+      end
+
+      def revoke(slug, member_id, timeout: nil)
+        request(Paths.product_access_member_path(slug, member_id), method: HTTP_METHODS[:DELETE], timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/products.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Products < Resource
+      attr_reader :access
+
+      def initialize(transport)
+        @access = ProductAccess.new(transport)
+        super
+      end
+
+      def list(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(PATHS[:PRODUCTS], COLLECTIONS[:PRODUCTS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(PATHS[:PRODUCTS], COLLECTIONS[:PRODUCTS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(PATHS[:PRODUCTS], COLLECTIONS[:PRODUCTS], Listing.of(limit:, offset:, search:, order:, product:),
+          timeout, &block)
+      end
+
+      def get(slug, timeout: nil)
+        request(Paths.product_path(slug), timeout:)
+      end
+
+      def create(body = nil, timeout: nil, **fields)
+        request(PATHS[:PRODUCTS], method: HTTP_METHODS[:POST], body: body_of(body, fields), timeout:)
+      end
+
+      def update(slug, patch = nil, timeout: nil, **fields)
+        request(Paths.product_path(slug), method: HTTP_METHODS[:PATCH], body: body_of(patch, fields), timeout:)
+      end
+
+      def delete(slug, timeout: nil)
+        request(Paths.product_path(slug), method: HTTP_METHODS[:DELETE], timeout:)
+      end
+
+      def duplicate(slug, timeout: nil)
+        request("#{Paths.product_path(slug)}/#{SEGMENTS[:DUPLICATE]}", method: HTTP_METHODS[:POST], timeout:)
+      end
+
+      def list_projects(slug, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(Paths.product_projects_path(slug), COLLECTIONS[:PROJECTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all_projects(slug, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(Paths.product_projects_path(slug), COLLECTIONS[:PROJECTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate_projects(slug, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(Paths.product_projects_path(slug), COLLECTIONS[:PROJECTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/projects.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Projects < Resource
+      def list(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(PATHS[:PROJECTS], COLLECTIONS[:PROJECTS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(PATHS[:PROJECTS], COLLECTIONS[:PROJECTS], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(PATHS[:PROJECTS], COLLECTIONS[:PROJECTS], Listing.of(limit:, offset:, search:, order:, product:),
+          timeout, &block)
+      end
+
+      def get(slug, product: nil, timeout: nil)
+        request(Paths.project_path(slug), query: scoped(product), timeout:)
+      end
+
+      def create(body = nil, timeout: nil, **fields)
+        request(PATHS[:PROJECTS], method: HTTP_METHODS[:POST], body: body_of(body, fields), timeout:)
+      end
+
+      def update(slug, patch = nil, product: nil, timeout: nil, **fields)
+        request(Paths.project_path(slug), method: HTTP_METHODS[:PATCH], query: scoped(product),
+          body: body_of(patch, fields), timeout:)
+      end
+
+      def delete(slug, product: nil, timeout: nil)
+        request(Paths.project_path(slug), method: HTTP_METHODS[:DELETE], query: scoped(product), timeout:)
+      end
+
+      def duplicate(slug, product: nil, timeout: nil)
+        request("#{Paths.project_path(slug)}/#{SEGMENTS[:DUPLICATE]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/roles.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Roles < Resource
+      def list(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(PATHS[:ROLES], COLLECTIONS[:ROLES], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(PATHS[:ROLES], COLLECTIONS[:ROLES], Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil, &block)
+        each_item(PATHS[:ROLES], COLLECTIONS[:ROLES], Listing.of(limit:, offset:, search:, order:, product:), timeout,
+          &block)
+      end
+
+      def get(id, timeout: nil)
+        request(Paths.role_path(id), timeout:)
+      end
+
+      def create(body = nil, timeout: nil, **fields)
+        request(PATHS[:ROLES], method: HTTP_METHODS[:POST], body: body_of(body, fields), timeout:)
+      end
+
+      def update(id, patch = nil, timeout: nil, **fields)
+        request(Paths.role_path(id), method: HTTP_METHODS[:PATCH], body: body_of(patch, fields), timeout:)
+      end
+
+      def delete(id, timeout: nil)
+        request(Paths.role_path(id), method: HTTP_METHODS[:DELETE], timeout:)
+      end
+
+      def list_permissions(timeout: nil)
+        request(PATHS[:PERMISSIONS], timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/variable_changes.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Variables < Resource
+      def create(project, environment, body = nil, product: nil, timeout: nil, **fields)
+        payload = body_of(body, fields)
+        VariableNames.assert_input(payload)
+        request(Paths.variables_path(project, environment), method: HTTP_METHODS[:POST], query: scoped(product),
+          body: payload, timeout:)
+      end
+
+      def create_many(project, environment, items, product: nil, timeout: nil)
+        variables = Bodies.entries(items, "items")
+        VariableNames.assert_inputs(variables)
+        request("#{Paths.variables_path(project, environment)}/#{SEGMENTS[:BULK]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), body: {"variables" => variables}, timeout:)
+      end
+
+      def update(project, environment, name, patch = nil, product: nil, timeout: nil, **fields)
+        payload = body_of(patch, fields)
+        VariableNames.assert_patch(payload)
+        request(Paths.variable_path(project, environment, name), method: HTTP_METHODS[:PATCH], query: scoped(product),
+          body: payload, timeout:)
+      end
+
+      def update_by_id(id, patch = nil, product: nil, timeout: nil, **fields)
+        payload = body_of(patch, fields)
+        VariableNames.assert_patch(payload)
+        request(Paths.variable_by_id_path(id), method: HTTP_METHODS[:PATCH], query: scoped(product), body: payload,
+          timeout:)
+      end
+
+      def delete(project, environment, name, product: nil, timeout: nil)
+        request(Paths.variable_path(project, environment, name), method: HTTP_METHODS[:DELETE], query: scoped(product),
+          timeout:)
+      end
+
+      def delete_by_id(id, product: nil, timeout: nil)
+        request(Paths.variable_by_id_path(id), method: HTTP_METHODS[:DELETE], query: scoped(product), timeout:)
+      end
+
+      def delete_many(project, environment, names, product: nil, timeout: nil)
+        request(Paths.variables_path(project, environment), method: HTTP_METHODS[:DELETE], query: scoped(product),
+          body: {"names" => list_of(names, "names")}, timeout:)
+      end
+
+      def apply(project, environment, changes = nil, product: nil, timeout: nil, **fields)
+        payload = body_of(changes, fields)
+        payload["creates"] = Bodies.entries(payload["creates"], "creates") if Wire.truthy?(payload["creates"])
+        VariableNames.assert_changes(payload)
+        request("#{Paths.variables_path(project, environment)}/#{SEGMENTS[:APPLY]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), body: payload, timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/variables.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Variables < Resource
+      def list(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(Paths.variables_path(project, environment), COLLECTIONS[:VARIABLES],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(Paths.variables_path(project, environment), COLLECTIONS[:VARIABLES],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil,
+        &block)
+        each_item(Paths.variables_path(project, environment), COLLECTIONS[:VARIABLES],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+
+      def get(project, environment, name, product: nil, timeout: nil)
+        request(Paths.variable_path(project, environment, name), query: scoped(product), timeout:)
+      end
+
+      def get_by_id(id, product: nil, timeout: nil)
+        request(Paths.variable_by_id_path(id), query: scoped(product), timeout:)
+      end
+
+      def list_history(project, environment, name, limit: nil, offset: nil, search: nil, order: nil, product: nil,
+        timeout: nil)
+        page(Paths.history_path(project, environment, name), COLLECTIONS[:EVENTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all_history(project, environment, name, limit: nil, offset: nil, search: nil, order: nil, product: nil,
+        timeout: nil)
+        all(Paths.history_path(project, environment, name), COLLECTIONS[:EVENTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate_history(project, environment, name, limit: nil, offset: nil, search: nil, order: nil, product: nil,
+        timeout: nil, &block)
+        each_item(Paths.history_path(project, environment, name), COLLECTIONS[:EVENTS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/versions.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Versions < Resource
+      def list(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        page(Paths.versions_path(project, environment), COLLECTIONS[:VERSIONS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil)
+        all(Paths.versions_path(project, environment), COLLECTIONS[:VERSIONS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil, timeout: nil,
+        &block)
+        each_item(Paths.versions_path(project, environment), COLLECTIONS[:VERSIONS],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+
+      def create(project, environment, body = nil, product: nil, timeout: nil, **fields)
+        request(Paths.versions_path(project, environment), method: HTTP_METHODS[:POST], query: scoped(product),
+          body: body_of(body, fields), timeout:)
+      end
+
+      def get(id, product: nil, timeout: nil)
+        request(Paths.version_by_id_path(id), query: scoped(product), timeout:)
+      end
+
+      def rollback(id, product: nil, timeout: nil)
+        request("#{Paths.version_by_id_path(id)}/#{SEGMENTS[:ROLLBACK]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), timeout:)
+      end
+
+      def list_entries(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil,
+        timeout: nil)
+        page(Paths.entries_path(project, environment), COLLECTIONS[:ENTRIES],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def list_all_entries(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil,
+        timeout: nil)
+        all(Paths.entries_path(project, environment), COLLECTIONS[:ENTRIES],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout)
+      end
+
+      def iterate_entries(project, environment, limit: nil, offset: nil, search: nil, order: nil, product: nil,
+        timeout: nil, &block)
+        each_item(Paths.entries_path(project, environment), COLLECTIONS[:ENTRIES],
+          Listing.of(limit:, offset:, search:, order:, product:), timeout, &block)
+      end
+
+      def reencrypt_entries(project, environment, entries, product: nil, timeout: nil)
+        request("#{Paths.entries_path(project, environment)}/#{SEGMENTS[:REENCRYPT]}", method: HTTP_METHODS[:POST],
+          query: scoped(product), body: {"entries" => list_of(entries, "entries")}, timeout:)
+      end
+    end
+  end
+end

data/lib/envless/sdk/resources/webhook_deliveries.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Envless
+  module Resources
+    class Webhooks < Resource
+      def list_deliveries(id, limit: nil, offset: nil, search: nil, order: nil, product: nil, status: nil, timeout: nil)
+        page(Paths.deliveries_path(id), COLLECTIONS[:DELIVERIES],
+          Listing.of(limit:, offset:, search:, order:, product:, status:), timeout)
+      end
+
+      def list_all_deliveries(id, limit: nil, offset: nil, search: nil, order: nil, product: nil, status: nil,
+        timeout: nil)
+        all(Paths.deliveries_path(id), COLLECTIONS[:DELIVERIES],
+          Listing.of(limit:, offset:, search:, order:, product:, status:), timeout)
+      end
+
+      def iterate_deliveries(id, limit: nil, offset: nil, search: nil, order: nil, product: nil, status: nil,
+        timeout: nil, &block)
+        each_item(Paths.deliveries_path(id), COLLECTIONS[:DELIVERIES],
+          Listing.of(limit:, offset:, search:, order:, product:, status:), timeout, &block)
+      end
+
+      def get_delivery(id, delivery_id, timeout: nil)
+        request(Paths.delivery_path(id, delivery_id), timeout:)
+      end
+
+      def redeliver(id, delivery_id, timeout: nil)
+        request("#{Paths.delivery_path(id, delivery_id)}/#{SEGMENTS[:REDELIVER]}", method: HTTP_METHODS[:POST],
+          timeout:)
+      end
+    end
+  end
+end