workos 0.10.1 → 0.11.2

data/lib/workos/client.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: false
 
 module WorkOS
   # A Net::HTTP based API client for interacting with the WorkOS API
@@ -19,7 +19,7 @@ module WorkOS
 
     sig do
       params(
-        request: T.any(Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Delete),
+        request: T.any(Net::HTTP::Get, Net::HTTP::Post, Net::HTTP::Delete, Net::HTTP::Put),
       ).returns(::T.untyped)
     end
     def execute_request(request:)
@@ -90,6 +90,23 @@ module WorkOS
       request
     end
 
+    sig do
+      params(
+        path: String,
+        auth: T.nilable(T::Boolean),
+        idempotency_key: T.nilable(String),
+        body: T.nilable(Hash),
+      ).returns(Net::HTTP::Put)
+    end
+    def put_request(path:, auth: false, idempotency_key: nil, body: nil)
+      request = Net::HTTP::Put.new(path, 'Content-Type' => 'application/json')
+      request.body = body.to_json if body
+      request['Authorization'] = "Bearer #{WorkOS.key!}" if auth
+      request['Idempotency-Key'] = idempotency_key if idempotency_key
+      request['User-Agent'] = user_agent
+      request
+    end
+
     sig { returns(String) }
     def user_agent
       engine = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : 'Ruby'
@@ -102,7 +119,7 @@ module WorkOS
       ].join('; ')
     end
 
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
     sig { params(response: ::T.untyped).void }
     def handle_error_response(response:)
       http_status = response.code.to_i
@@ -139,7 +156,7 @@ module WorkOS
         )
       end
     end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     private
 

data/lib/workos/connection.rb

@@ -5,10 +5,12 @@ module WorkOS
   # The Connection class provides a lightweight wrapper around
   # a WorkOS Connection resource. This class is not meant to be instantiated
   # in user space, and is instantiated internally but exposed.
+  # Note: status is deprecated - use state instead
   class Connection
     extend T::Sig
 
-    attr_accessor :id, :name, :connection_type, :domains
+    attr_accessor :id, :name, :connection_type, :domains, :organization_id,
+                  :state, :status
 
     sig { params(json: String).void }
     def initialize(json)
@@ -18,6 +20,9 @@ module WorkOS
       @name = T.let(raw.name, String)
       @connection_type = T.let(raw.connection_type, String)
       @domains = T.let(raw.domains, Array)
+      @organization_id = T.let(raw.organization_id, String)
+      @state = T.let(raw.state, String)
+      @status = T.let(raw.status, String)
     end
 
     def to_json(*)
@@ -26,6 +31,9 @@ module WorkOS
         name: name,
         connection_type: connection_type,
         domains: domains,
+        organization_id: organization_id,
+        state: state,
+        status: status,
       }
     end
 
@@ -40,6 +48,9 @@ module WorkOS
         name: hash[:name],
         connection_type: hash[:connection_type],
         domains: hash[:domains],
+        organization_id: hash[:organization_id],
+        state: hash[:state],
+        status: hash[:status],
       )
     end
   end

data/lib/workos/directory.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+# typed: true
+
+module WorkOS
+  # The Directory class provides a lightweight wrapper around
+  # a WorkOS Directory resource. This class is not meant to be instantiated
+  # in user space, and is instantiated internally but exposed.
+  class Directory
+    extend T::Sig
+
+    attr_accessor :id, :domain, :name, :type, :state
+
+    sig { params(json: String).void }
+    def initialize(json)
+      raw = parse_json(json)
+
+      @id = T.let(raw.id, String)
+      @name = T.let(raw.name, String)
+      @domain = T.let(raw.domain, String)
+      @type = T.let(raw.type, String)
+      @state = T.let(raw.state, String)
+    end
+
+    def to_json(*)
+      {
+        id: id,
+        name: name,
+        domain: domain,
+        type: type,
+        state: state,
+      }
+    end
+
+    private
+
+    sig do
+      params(
+        json_string: String,
+      ).returns(WorkOS::Types::DirectoryStruct)
+    end
+    def parse_json(json_string)
+      hash = JSON.parse(json_string, symbolize_names: true)
+
+      WorkOS::Types::DirectoryStruct.new(
+        id: hash[:id],
+        name: hash[:name],
+        domain: hash[:domain],
+        type: hash[:type],
+        state: hash[:state],
+      )
+    end
+  end
+end

data/lib/workos/directory_group.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+# typed: true
+
+module WorkOS
+  # The DirectoryGroup class provides a lightweight wrapper around
+  # a WorkOS DirectoryGroup resource. This class is not meant to be instantiated
+  # in user space, and is instantiated internally but exposed.
+  class DirectoryGroup
+    extend T::Sig
+
+    attr_accessor :id, :name
+
+    sig { params(json: String).void }
+    def initialize(json)
+      raw = parse_json(json)
+
+      @id = T.let(raw.id, String)
+      @name = T.let(raw.name, String)
+    end
+
+    def to_json(*)
+      {
+        id: id,
+        name: name,
+      }
+    end
+
+    private
+
+    sig do
+      params(
+        json_string: String,
+      ).returns(WorkOS::Types::DirectoryGroupStruct)
+    end
+    def parse_json(json_string)
+      hash = JSON.parse(json_string, symbolize_names: true)
+
+      WorkOS::Types::DirectoryGroupStruct.new(
+        id: hash[:id],
+        name: hash[:name],
+      )
+    end
+  end
+end

data/lib/workos/directory_sync.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# typed: true
+# typed: strict
 
 require 'net/http'
 
@@ -21,12 +21,17 @@ module WorkOS
       # @option options [String] domain The domain of the directory to be
       #  retrieved.
       # @option options [String] search A search term for direcory names.
+      # @option options [String] limit Maximum number of records to return.
+      # @option options [String] before Pagination cursor to receive records
+      #  before a provided Directory ID.
+      # @option options [String] after Pagination cursor to receive records
+      #  before a provided Directory ID.
       #
       # @return [Hash]
       sig do
         params(
           options: T::Hash[Symbol, String],
-        ).returns(T::Array[T::Hash[String, T.nilable(String)]])
+        ).returns(WorkOS::Types::ListStruct)
       end
       def list_directories(options = {})
         response = execute_request(
@@ -37,7 +42,15 @@ module WorkOS
           ),
         )
 
-        JSON.parse(response.body)['data']
+        parsed_response = JSON.parse(response.body)
+        directories = parsed_response['data'].map do |directory|
+          ::WorkOS::Directory.new(directory.to_json)
+        end
+
+        WorkOS::Types::ListStruct.new(
+          data: directories,
+          list_metadata: parsed_response['listMetadata'],
+        )
       end
 
       # Retrieve directory groups.
@@ -47,12 +60,17 @@ module WorkOS
       #  directory groups will be retrieved.
       # @option options [String] user The ID of the directory user whose
       #  directory groups will be retrieved.
+      # @option options [String] limit Maximum number of records to return.
+      # @option options [String] before Pagination cursor to receive records
+      #  before a provided Directory Group ID.
+      # @option options [String] after Pagination cursor to receive records
+      #  before a provided Directory Group ID.
       #
       # @return [Hash]
       sig do
         params(
           options: T::Hash[Symbol, String],
-        ).returns(T::Array[T::Hash[String, T.nilable(String)]])
+        ).returns(WorkOS::Types::ListStruct)
       end
       def list_groups(options = {})
         response = execute_request(
@@ -63,7 +81,15 @@ module WorkOS
           ),
         )
 
-        JSON.parse(response.body)['data']
+        parsed_response = JSON.parse(response.body)
+        groups = parsed_response['data'].map do |group|
+          ::WorkOS::DirectoryGroup.new(group.to_json)
+        end
+
+        WorkOS::Types::ListStruct.new(
+          data: groups,
+          list_metadata: parsed_response['listMetadata'],
+        )
       end
 
       # Retrieve directory users.
@@ -73,12 +99,17 @@ module WorkOS
       #  directory users will be retrieved.
       # @option options [String] user The ID of the directory group whose
       #  directory users will be retrieved.
+      # @option options [String] limit Maximum number of records to return.
+      # @option options [String] before Pagination cursor to receive records
+      #  before a provided Directory User ID.
+      # @option options [String] after Pagination cursor to receive records
+      #  before a provided Directory User ID.
       #
       # @return [Hash]
       sig do
         params(
           options: T::Hash[Symbol, String],
-        ).returns(T::Array[T::Hash[String, T.untyped]])
+        ).returns(WorkOS::Types::ListStruct)
       end
       def list_users(options = {})
         response = execute_request(
@@ -89,7 +120,15 @@ module WorkOS
           ),
         )
 
-        JSON.parse(response.body)['data']
+        parsed_response = JSON.parse(response.body)
+        users = parsed_response['data'].map do |user|
+          ::WorkOS::DirectoryUser.new(user.to_json)
+        end
+
+        WorkOS::Types::ListStruct.new(
+          data: users,
+          list_metadata: parsed_response['listMetadata'],
+        )
       end
 
       # Retrieve the directory group with the given ID.
@@ -125,6 +164,23 @@ module WorkOS
 
         JSON.parse(response.body)
       end
+
+      # Delete the directory with the given ID.
+      #
+      # @param [String] id The ID of the directory.
+      #
+      # @return Boolean
+      sig { params(id: String).returns(T::Boolean) }
+      def delete_directory(id)
+        request = delete_request(
+          auth: true,
+          path: "/directories/#{id}",
+        )
+
+        response = execute_request(request: request)
+
+        response.is_a? Net::HTTPSuccess
+      end
     end
   end
 end

data/lib/workos/directory_user.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+# typed: true
+
+module WorkOS
+  # The DirectoryUser class provides a lightweight wrapper around
+  # a WorkOS DirectoryUser resource. This class is not meant to be instantiated
+  # in DirectoryUser space, and is instantiated internally but exposed.
+  class DirectoryUser
+    extend T::Sig
+
+    attr_accessor :id, :idp_id, :emails, :first_name, :last_name, :username, :state,
+                  :raw_attributes
+
+    sig { params(json: String).void }
+    def initialize(json)
+      raw = parse_json(json)
+
+      @id = T.let(raw.id, String)
+      @idp_id = T.let(raw.idp_id, String)
+      @emails = T.let(raw.emails, Array)
+      @first_name = raw.first_name
+      @last_name = raw.last_name
+      @username = raw.username
+      @state = raw.state
+      @raw_attributes = raw.raw_attributes
+    end
+
+    def to_json(*)
+      {
+        id: id,
+        idp_id: idp_id,
+        emails: emails,
+        first_name: first_name,
+        last_name: last_name,
+        username: username,
+        state: state,
+        raw_attributes: raw_attributes,
+      }
+    end
+
+    private
+
+    sig do
+      params(
+        json_string: String,
+      ).returns(WorkOS::Types::DirectoryUserStruct)
+    end
+    def parse_json(json_string)
+      hash = JSON.parse(json_string, symbolize_names: true)
+
+      WorkOS::Types::DirectoryUserStruct.new(
+        id: hash[:id],
+        idp_id: hash[:idp_id],
+        emails: hash[:emails],
+        first_name: hash[:first_name],
+        last_name: hash[:last_name],
+        username: hash[:username],
+        state: hash[:state],
+        raw_attributes: hash[:raw_attributes],
+      )
+    end
+  end
+end

data/lib/workos/passwordless.rb

@@ -23,6 +23,10 @@ module WorkOS
       #  received from WorkOS will contain. The state parameter can be used to
       #  encode arbitrary information to help restore application state between
       #  redirects.
+      # @option options [String] connection Optional parameter for the ID of a
+      #  specific connection. This can be used to create a Passwordless Session
+      #  for a specific connection rather than using the domain from the email
+      #  to determine the Organization and Connection.
       # @option options [String] type The type of Passwordless Session to
       #  create. Currently, the only supported value is 'MagicLink'.
       # @option options [String] redirect_uri The URI where users are directed

data/lib/workos/portal.rb

@@ -42,7 +42,7 @@ module WorkOS
       # Generate a link to grant access to an organization's Admin Portal
       #
       # @param [String] intent The access scope for the generated Admin Portal
-      #  link. Valid values are: ["sso"]
+      #  link. Valid values are: ["sso", "dsync"]
       # @param [String] organization The ID of the organization the Admin
       #  Portal link will be generated for.
       # @param [String] The URL that the end user will be redirected to upon
@@ -110,6 +110,59 @@ module WorkOS
         )
       end
 
+      # Get an Organization
+      #
+      # @param [String] id Organization unique identifier
+      #
+      # @example
+      #   WorkOS::Portal.get_organization(id: 'org_02DRA1XNSJDZ19A31F183ECQW9')
+      #   => #<WorkOS::Organization:0x00007fb6e4193d20
+      #         @id="org_02DRA1XNSJDZ19A31F183ECQW9",
+      #         @name="Foo Corp",
+      #         @domains=
+      #          [{:object=>"organization_domain",
+      #            :id=>"org_domain_01E6PK9N3XMD8RHWF7S66380AR",
+      #            :domain=>"foo-corp.com"}]>
+      #
+      # @return [WorkOS::Connection]
+      sig { params(id: String).returns(WorkOS::Organization) }
+      def get_organization(id:)
+        request = get_request(
+          auth: true,
+          path: "/organizations/#{id}",
+        )
+
+        response = execute_request(request: request)
+
+        WorkOS::Organization.new(response.body)
+      end
+
+      # Update an organization
+      #
+      # @param [String] organization Organization unique identifier
+      # @param [Array<String>] domains List of domains that belong to the
+      #  organization
+      # @param [String] name A unique, descriptive name for the organization
+      sig do
+        params(
+          organization: String,
+          domains: T::Array[String],
+          name: String,
+        ).returns(WorkOS::Organization)
+      end
+      def update_organization(organization:, domains:, name:)
+        request = put_request(
+          auth: true,
+          body: { domains: domains, name: name },
+          path: "/organizations/#{organization}",
+        )
+
+        response = execute_request(request: request)
+        check_and_raise_organization_error(response: response)
+
+        WorkOS::Organization.new(response.body)
+      end
+
       private
 
       sig { params(response: Net::HTTPResponse).void }