workos 0.10.0 → 1.0.0

data/lib/workos/sso.rb

@@ -26,10 +26,10 @@ module WorkOS
       #  required
       # @param [String] provider A provider name for an Identity Provider
       #  configured on your WorkOS dashboard. Only 'Google' is supported.
+      # @param [String] connection The ID for a Connection configured on
+      #  WorkOS.
       # @param [String] client_id The WorkOS client ID for the environment
       #  where you've configured your SSO connection.
-      # @param [String] project_id The WorkOS project ID for the project.
-      # The project_id is deprecated in Dashboard2.
       # @param [String] redirect_uri The URI where users are directed
       #  after completing the authentication step. Must match a
       #  configured redirect URI on your WorkOS dashboard.
@@ -54,28 +54,26 @@ module WorkOS
       sig do
         params(
           redirect_uri: String,
-          project_id: T.nilable(String),
           client_id: T.nilable(String),
           domain: T.nilable(String),
           provider: T.nilable(String),
+          connection: T.nilable(String),
           state: T.nilable(String),
         ).returns(String)
       end
       def authorization_url(
         redirect_uri:,
-        project_id: nil,
         client_id: nil,
         domain: nil,
         provider: nil,
+        connection: nil,
         state: ''
       )
-        if project_id
-          warn '[DEPRECATION] `project_id` is deprecated.
-          Please use `client_id` instead.'
-          client_id = project_id
-        end
-
-        validate_domain_and_provider(provider: provider, domain: domain)
+        validate_authorization_url_arguments(
+          provider: provider,
+          domain: domain,
+          connection: connection,
+        )
 
         query = URI.encode_www_form({
           client_id: client_id,
@@ -84,6 +82,7 @@ module WorkOS
           state: state,
           domain: domain,
           provider: provider,
+          connection: connection,
         }.compact)
 
         "https://#{WorkOS::API_HOSTNAME}/sso/authorize?#{query}"
@@ -93,40 +92,16 @@ module WorkOS
       #
       # @param [String] code The authorization code provided in the callback URL
       # @param [String] client_id The WorkOS client ID for the environment
-      #  where you've  configured your SSO connection
-      # @param [String] project_id The WorkOS project ID for the project.
-      # The project_id is deprecated in Dashboard2.
+      #  where you've configured your SSO connection
       #
-      # @example
-      #   WorkOS::SSO.profile(
-      #     code: 'acme.com',
-      #     client_id: 'project_01DG5TGK363GRVXP3ZS40WNGEZ'
-      #   )
-      #   => #<WorkOS::Profile:0x00007fb6e4193d20
-      #         @id="prof_01DRA1XNSJDZ19A31F183ECQW5",
-      #         @email="demo@workos-okta.com",
-      #         @first_name="WorkOS",
-      #         @connection_type="OktaSAML",
-      #         @last_name="Demo",
-      #         @idp_id="00u1klkowm8EGah2H357",
-      #         @access_token="01DVX6QBS3EG6FHY2ESAA5Q65X"
-      #        >
-      #
-      # @return [WorkOS::Profile]
+      # @return [WorkOS::ProfileAndToken]
       sig do
         params(
           code: String,
-          project_id: T.nilable(String),
           client_id: T.nilable(String),
-        ).returns(WorkOS::Profile)
+        ).returns(WorkOS::ProfileAndToken)
       end
-      def profile(code:, project_id: nil, client_id: nil)
-        if project_id
-          warn '[DEPRECATION] `project_id` is deprecated.
-          Please use `client_id` instead.'
-          client_id = project_id
-        end
-
+      def profile_and_token(code:, client_id: nil)
         body = {
           client_id: client_id,
           client_secret: WorkOS.key!,
@@ -135,65 +110,9 @@ module WorkOS
         }
 
         response = client.request(post_request(path: '/sso/token', body: body))
-        check_and_raise_profile_error(response: response)
+        check_and_raise_profile_and_token_error(response: response)
 
-        WorkOS::Profile.new(response.body)
-      end
-
-      # Promote a DraftConnection created via the WorkOS.js embed such that the
-      # Enterprise users can begin signing into your application.
-      #
-      # @param [String] token The Draft Connection token that's been provided to
-      # you by the WorkOS.js
-      #
-      # @example
-      #   WorkOS::SSO.promote_draft_connection(
-      #     token: 'draft_conn_429u59js',
-      #   )
-      #   => true
-      #
-      # @return [Bool] - returns `true` if successful, `false` otherwise.
-      # @see https://github.com/workos-inc/ruby-idp-link-example
-      sig { params(token: String).returns(T::Boolean) }
-      def promote_draft_connection(token:)
-        request = post_request(
-          auth: true,
-          path: "/draft_connections/#{token}/activate",
-        )
-
-        response = client.request(request)
-
-        response.is_a? Net::HTTPSuccess
-      end
-
-      # Create a Connection
-      #
-      # @param [String] source The Draft Connection token that's been provided
-      # to you by WorkOS.js
-      #
-      # @example
-      #   WorkOS::SSO.create_connection(source: 'draft_conn_429u59js')
-      #   => #<WorkOS::Connection:0x00007fb6e4193d20
-      #         @id="conn_02DRA1XNSJDZ19A31F183ECQW9",
-      #         @name="Foo Corp",
-      #         @connection_type="OktaSAML",
-      #         @domains=
-      #          [{:object=>"connection_domain",
-      #            :id=>"domain_01E6PK9N3XMD8RHWF7S66380AR",
-      #            :domain=>"example.com"}]>
-      #
-      # @return [WorkOS::Connection]
-      sig { params(source: String).returns(WorkOS::Connection) }
-      def create_connection(source:)
-        request = post_request(
-          auth: true,
-          path: '/connections',
-          body: { source: source },
-        )
-
-        response = execute_request(request: request)
-
-        WorkOS::Connection.new(response.body)
+        WorkOS::ProfileAndToken.new(response.body)
       end
 
       # Retrieve connections.
@@ -203,6 +122,8 @@ module WorkOS
       #  provider descriptor.
       # @option options [String] domain The domain of the connection to be
       #  retrieved.
+      # @option options [String] organization_id The id of the organization
+      #  of the connections to be retrieved.
       # @option options [String] limit Maximum number of records to return.
       # @option options [String] before Pagination cursor to receive records
       #  before a provided Connection ID.
@@ -213,7 +134,7 @@ module WorkOS
       sig do
         params(
           options: T::Hash[Symbol, String],
-        ).returns(T::Array[T::Hash[String, T.nilable(String)]])
+        ).returns(WorkOS::Types::ListStruct)
       end
       def list_connections(options = {})
         response = execute_request(
@@ -224,7 +145,15 @@ module WorkOS
           ),
         )
 
-        JSON.parse(response.body)['data']
+        parsed_response = JSON.parse(response.body)
+        connections = parsed_response['data'].map do |connection|
+          ::WorkOS::Connection.new(connection.to_json)
+        end
+
+        WorkOS::Types::ListStruct.new(
+          data: connections,
+          list_metadata: parsed_response['listMetadata'],
+        )
       end
 
       # Get a Connection
@@ -282,11 +211,17 @@ module WorkOS
         params(
           domain: T.nilable(String),
           provider: T.nilable(String),
+          connection: T.nilable(String),
         ).void
       end
-      def validate_domain_and_provider(domain:, provider:)
-        if [domain, provider].all?(&:nil?)
-          raise ArgumentError, 'Either domain or provider is required.'
+      def validate_authorization_url_arguments(
+        domain:,
+        provider:,
+        connection:
+      )
+        if [domain, provider, connection].all?(&:nil?)
+          raise ArgumentError, 'Either connection, domain, or ' \
+            'provider is required.'
         end
 
         return unless provider && !PROVIDERS.include?(provider)
@@ -296,10 +231,10 @@ module WorkOS
       end
 
       sig { params(response: Net::HTTPResponse).void }
-      def check_and_raise_profile_error(response:)
+      def check_and_raise_profile_and_token_error(response:)
         begin
           body = JSON.parse(response.body)
-          return if body['profile']
+          return if body['access_token'] && body['profile']
 
           message = body['message']
           request_id = response['x-request-id']

data/lib/workos/types/connection_struct.rb

@@ -10,6 +10,9 @@ module WorkOS
       const :name, String
       const :connection_type, String
       const :domains, T::Array[T.untyped]
+      const :organization_id, String
+      const :state, String
+      const :status, String
     end
   end
 end

data/lib/workos/types/directory_group_struct.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+# typed: strict
+
+module WorkOS
+  module Types
+    # This DirectoryGroupStruct acts as a typed interface
+    # for the DirectoryGroup class
+    class DirectoryGroupStruct < T::Struct
+      const :id, String
+      const :name, String
+    end
+  end
+end

data/lib/workos/types/directory_struct.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# typed: strict
+
+module WorkOS
+  module Types
+    # This DirectoryStruct acts as a typed interface
+    # for the Directory class
+    class DirectoryStruct < T::Struct
+      const :id, String
+      const :name, String
+      const :domain, String
+      const :type, String
+      const :state, String
+    end
+  end
+end

data/lib/workos/types/directory_user_struct.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+# typed: strict
+
+module WorkOS
+  module Types
+    # The DirectoryUserStruct acts as a typed interface
+    # for the DirectoryUser class
+    class DirectoryUserStruct < T::Struct
+      const :id, String
+      const :idp_id, String
+      const :emails, T::Array[T.untyped]
+      const :first_name, T.nilable(String)
+      const :last_name, T.nilable(String)
+      const :username, T.nilable(String)
+      const :state, T.nilable(String)
+      const :raw_attributes, T::Hash[Symbol, Object]
+    end
+  end
+end

data/lib/workos/types/intent_enum.rb

@@ -8,6 +8,7 @@ module WorkOS
     class Intent < T::Enum
       enums do
         SSO = new('sso')
+        DSYNC = new('dsync')
       end
     end
   end

data/lib/workos/types.rb

@@ -6,11 +6,14 @@ module WorkOS
   # so we're using Sorbet throughout this Ruby gem.
   module Types
     require_relative 'types/connection_struct'
+    require_relative 'types/directory_struct'
+    require_relative 'types/directory_group_struct'
     require_relative 'types/intent_enum'
     require_relative 'types/list_struct'
     require_relative 'types/organization_struct'
     require_relative 'types/passwordless_session_struct'
     require_relative 'types/profile_struct'
     require_relative 'types/provider_enum'
+    require_relative 'types/directory_user_struct'
   end
 end

data/lib/workos/version.rb

@@ -2,5 +2,5 @@
 # typed: strong
 
 module WorkOS
-  VERSION = '0.10.0'
+  VERSION = '1.0.0'
 end

data/lib/workos.rb

@@ -32,11 +32,16 @@ module WorkOS
   autoload :AuditTrail, 'workos/audit_trail'
   autoload :Connection, 'workos/connection'
   autoload :DirectorySync, 'workos/directory_sync'
+  autoload :Directory, 'workos/directory'
+  autoload :DirectoryGroup, 'workos/directory_group'
   autoload :Organization, 'workos/organization'
+  autoload :Organizations, 'workos/organizations'
   autoload :Passwordless, 'workos/passwordless'
   autoload :Portal, 'workos/portal'
   autoload :Profile, 'workos/profile'
+  autoload :ProfileAndToken, 'workos/profile_and_token'
   autoload :SSO, 'workos/sso'
+  autoload :DirectoryUser, 'workos/directory_user'
 
   # Errors
   autoload :APIError, 'workos/errors'

data/sorbet/rbi/gems/addressable.rbi

@@ -0,0 +1,199 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/addressable/all/addressable.rbi
+#
+# addressable-2.7.0
+
+module Addressable
+end
+module Addressable::VERSION
+end
+module Addressable::IDNA
+  def self.lookup_unicode_combining_class(codepoint); end
+  def self.lookup_unicode_compatibility(codepoint); end
+  def self.lookup_unicode_composition(unpacked); end
+  def self.lookup_unicode_lowercase(codepoint); end
+  def self.punycode_adapt(delta, numpoints, firsttime); end
+  def self.punycode_basic?(codepoint); end
+  def self.punycode_decode(punycode); end
+  def self.punycode_decode_digit(codepoint); end
+  def self.punycode_delimiter?(codepoint); end
+  def self.punycode_encode(unicode); end
+  def self.punycode_encode_digit(d); end
+  def self.to_ascii(input); end
+  def self.to_unicode(input); end
+  def self.unicode_compose(unpacked); end
+  def self.unicode_compose_pair(ch_one, ch_two); end
+  def self.unicode_decompose(unpacked); end
+  def self.unicode_decompose_hangul(codepoint); end
+  def self.unicode_downcase(input); end
+  def self.unicode_normalize_kc(input); end
+  def self.unicode_sort_canonical(unpacked); end
+end
+class Addressable::IDNA::PunycodeBadInput < StandardError
+end
+class Addressable::IDNA::PunycodeBigOutput < StandardError
+end
+class Addressable::IDNA::PunycodeOverflow < StandardError
+end
+class Addressable::URI
+  def +(uri); end
+  def ==(uri); end
+  def ===(uri); end
+  def absolute?; end
+  def authority; end
+  def authority=(new_authority); end
+  def basename; end
+  def default_port; end
+  def defer_validation; end
+  def display_uri; end
+  def domain; end
+  def dup; end
+  def empty?; end
+  def eql?(uri); end
+  def extname; end
+  def fragment; end
+  def fragment=(new_fragment); end
+  def freeze; end
+  def hash; end
+  def host; end
+  def host=(new_host); end
+  def hostname; end
+  def hostname=(new_hostname); end
+  def inferred_port; end
+  def initialize(options = nil); end
+  def inspect; end
+  def ip_based?; end
+  def join!(uri); end
+  def join(uri); end
+  def merge!(uri); end
+  def merge(hash); end
+  def normalize!; end
+  def normalize; end
+  def normalized_authority; end
+  def normalized_fragment; end
+  def normalized_host; end
+  def normalized_password; end
+  def normalized_path; end
+  def normalized_port; end
+  def normalized_query(*flags); end
+  def normalized_scheme; end
+  def normalized_site; end
+  def normalized_user; end
+  def normalized_userinfo; end
+  def omit!(*components); end
+  def omit(*components); end
+  def origin; end
+  def origin=(new_origin); end
+  def password; end
+  def password=(new_password); end
+  def path; end
+  def path=(new_path); end
+  def port; end
+  def port=(new_port); end
+  def query; end
+  def query=(new_query); end
+  def query_values(return_type = nil); end
+  def query_values=(new_query_values); end
+  def relative?; end
+  def remove_composite_values; end
+  def replace_self(uri); end
+  def request_uri; end
+  def request_uri=(new_request_uri); end
+  def route_from(uri); end
+  def route_to(uri); end
+  def scheme; end
+  def scheme=(new_scheme); end
+  def self.convert_path(path); end
+  def self.encode(uri, return_type = nil); end
+  def self.encode_component(component, character_class = nil, upcase_encoded = nil); end
+  def self.escape(uri, return_type = nil); end
+  def self.form_encode(form_values, sort = nil); end
+  def self.form_unencode(encoded_value); end
+  def self.heuristic_parse(uri, hints = nil); end
+  def self.ip_based_schemes; end
+  def self.join(*uris); end
+  def self.normalize_component(component, character_class = nil, leave_encoded = nil); end
+  def self.normalize_path(path); end
+  def self.normalized_encode(uri, return_type = nil); end
+  def self.parse(uri); end
+  def self.port_mapping; end
+  def self.unencode(uri, return_type = nil, leave_encoded = nil); end
+  def self.unencode_component(uri, return_type = nil, leave_encoded = nil); end
+  def self.unescape(uri, return_type = nil, leave_encoded = nil); end
+  def self.unescape_component(uri, return_type = nil, leave_encoded = nil); end
+  def site; end
+  def site=(new_site); end
+  def split_path(path); end
+  def tld; end
+  def tld=(new_tld); end
+  def to_hash; end
+  def to_s; end
+  def to_str; end
+  def user; end
+  def user=(new_user); end
+  def userinfo; end
+  def userinfo=(new_userinfo); end
+  def validate; end
+end
+class Addressable::URI::InvalidURIError < StandardError
+end
+module Addressable::URI::CharacterClasses
+end
+class Addressable::Template
+  def ==(template); end
+  def eql?(template); end
+  def expand(mapping, processor = nil, normalize_values = nil); end
+  def extract(uri, processor = nil); end
+  def freeze; end
+  def generate(params = nil, recall = nil, options = nil); end
+  def initialize(pattern); end
+  def inspect; end
+  def join_values(operator, return_value); end
+  def keys; end
+  def match(uri, processor = nil); end
+  def named_captures; end
+  def names; end
+  def normalize_keys(mapping); end
+  def normalize_value(value); end
+  def ordered_variable_defaults; end
+  def parse_template_pattern(pattern, processor = nil); end
+  def partial_expand(mapping, processor = nil, normalize_values = nil); end
+  def pattern; end
+  def source; end
+  def to_regexp; end
+  def transform_capture(mapping, capture, processor = nil, normalize_values = nil); end
+  def transform_partial_capture(mapping, capture, processor = nil, normalize_values = nil); end
+  def variable_defaults; end
+  def variables; end
+end
+class Addressable::Template::InvalidTemplateValueError < StandardError
+end
+class Addressable::Template::InvalidTemplateOperatorError < StandardError
+end
+class Addressable::Template::TemplateOperatorAbortedError < StandardError
+end
+class Addressable::Template::MatchData
+  def [](key, len = nil); end
+  def captures; end
+  def initialize(uri, template, mapping); end
+  def inspect; end
+  def keys; end
+  def mapping; end
+  def names; end
+  def post_match; end
+  def pre_match; end
+  def string; end
+  def template; end
+  def to_a; end
+  def to_s; end
+  def uri; end
+  def values; end
+  def values_at(*indexes); end
+  def variables; end
+end

data/sorbet/rbi/gems/ast.rbi

@@ -0,0 +1,49 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ast/all/ast.rbi
+#
+# ast-2.4.2
+
+module AST
+end
+class AST::Node
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def assign_properties(properties); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def deconstruct; end
+  def dup; end
+  def eql?(other); end
+  def fancy_type; end
+  def hash; end
+  def initialize(type, children = nil, properties = nil); end
+  def inspect(indent = nil); end
+  def original_dup; end
+  def to_a; end
+  def to_ast; end
+  def to_s(indent = nil); end
+  def to_sexp(indent = nil); end
+  def to_sexp_array; end
+  def type; end
+  def updated(type = nil, children = nil, properties = nil); end
+end
+class AST::Processor
+  include AST::Processor::Mixin
+end
+module AST::Processor::Mixin
+  def handler_missing(node); end
+  def process(node); end
+  def process_all(nodes); end
+end
+module AST::Sexp
+  def s(type, *children); end
+end

data/sorbet/rbi/gems/codecov.rbi

@@ -0,0 +1,37 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/codecov/all/codecov.rbi
+#
+# codecov-0.2.15
+
+module Codecov
+end
+class SimpleCov::Formatter::Codecov
+  def black(str); end
+  def build_params(ci); end
+  def create_report(report); end
+  def detect_ci; end
+  def display_header; end
+  def file_network; end
+  def file_to_codecov(file); end
+  def format(result, disable_net_blockers = nil); end
+  def green(str); end
+  def gzip_report(report); end
+  def handle_report_response(report); end
+  def net_blockers(switch); end
+  def red(str); end
+  def result_to_codecov(result); end
+  def result_to_codecov_coverage(result); end
+  def result_to_codecov_messages(result); end
+  def result_to_codecov_report(result); end
+  def retry_request(req, https); end
+  def shortened_filename(file); end
+  def upload_to_codecov(ci, report); end
+  def upload_to_v2(url, report, query, query_without_token); end
+  def upload_to_v4(url, report, query, query_without_token); end
+end

data/sorbet/rbi/gems/crack.rbi

@@ -0,0 +1,62 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: strict
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/crack/all/crack.rbi
+#
+# crack-0.4.5
+
+module Crack
+end
+module Crack::Util
+  def snake_case(str); end
+  def to_xml_attributes(hash); end
+  extend Crack::Util
+end
+class Crack::JSON
+  def self.convert_json_to_yaml(json); end
+  def self.format_dates(output, date_starts, date_ends); end
+  def self.parse(json); end
+  def self.parser_exceptions; end
+  def self.unescape(str); end
+end
+class REXMLUtiliyNodeString < String
+  def attributes; end
+  def attributes=(arg0); end
+end
+class REXMLUtilityNode
+  def add_node(node); end
+  def attributes; end
+  def attributes=(arg0); end
+  def children; end
+  def children=(arg0); end
+  def initialize(name, normalized_attributes = nil); end
+  def inner_html; end
+  def name; end
+  def name=(arg0); end
+  def self.available_typecasts; end
+  def self.available_typecasts=(obj); end
+  def self.typecasts; end
+  def self.typecasts=(obj); end
+  def to_hash; end
+  def to_html; end
+  def to_s; end
+  def type; end
+  def type=(arg0); end
+  def typecast_value(value); end
+  def undasherize_keys(params); end
+  def unnormalize_xml_entities(value); end
+end
+class Crack::REXMLParser
+  def self.parse(xml); end
+end
+class Crack::XML
+  def self.parse(xml); end
+  def self.parser; end
+  def self.parser=(parser); end
+end
+class Crack::ParseError < StandardError
+end