volcano-sdk 0.28.0 → 0.30.0

data/lib/volcano/auth_state_notifications.rb

@@ -3,8 +3,8 @@
 module Volcano
   # Queues auth events under the state mutex and invokes subscribers outside it.
   module AuthStateNotifications
-    CALLBACK_FAILURES = [Exception].freeze
-    private_constant :CALLBACK_FAILURES
+    CALLBACK_FAILURE = Exception
+    private_constant :CALLBACK_FAILURE
 
     private
 
@@ -26,12 +26,14 @@ module Volcano
     end
 
     def drain_notifications
+      # @type var failure: Exception?
       failure = nil
       loop do
         notification = next_notification
         break unless notification
 
-        current_failure = notify(*notification)
+        callback_ids, event, session = notification
+        current_failure = notify(callback_ids, event, session)
         failure ||= current_failure
       end
       raise failure if failure
@@ -48,12 +50,13 @@ module Volcano
     end
 
     def notify(callback_ids, event, session)
+      # @type var failure: Exception?
       failure = nil
       callback_ids.each do |callback_id|
         @mutex.synchronize { @callbacks[callback_id] }&.call(event, session)
       rescue StandardError => e
         Warning.warn("Volcano auth-state callback failed (#{e.class})\n")
-      rescue *CALLBACK_FAILURES => e
+      rescue CALLBACK_FAILURE => e
         unsubscribe(callback_id)
         failure ||= e
       end

data/lib/volcano/auth_update_user.rb

@@ -2,7 +2,7 @@
 
 module Volcano
   # Current-user update behavior for the authentication facade.
-  class Auth
+  module AuthUpdateUser
     def update_user(password: nil, metadata: nil)
       profile_request do
         request_password = password&.dup&.freeze

data/lib/volcano/generated_transport.rb

@@ -52,7 +52,9 @@ module Volcano
       invoke do
         apis = @api_factory.call(authorization)
         body = Generated::ProjectLockLeaseRequest.new(ttl_seconds: ttl)
-        result = apis.locks.acquire_project_lock_with_http_info(key, token, request_id, body)
+        result = apis.locks.acquire_project_lock_with_http_info(
+          key, token, request_id, body, debug_return_type: 'Object'
+        )
         data, status, headers = result
         response(data, status, headers)
       end
@@ -63,7 +65,8 @@ module Volcano
         apis = @api_factory.call(authorization)
         data, status, headers = apis.locks.get_project_lock_with_http_info(
           key,
-          request_id
+          request_id,
+          debug_return_type: 'Object'
         )
         response(data, status, headers)
       end
@@ -85,7 +88,7 @@ module Volcano
         apis = @api_factory.call(authorization)
         body = Generated::ProjectLockLeaseRequest.new(ttl_seconds: ttl)
         result = apis.locks.renew_project_lock_with_http_info(
-          key, token, request_id, body
+          key, token, request_id, body, debug_return_type: 'Object'
         )
         data, status, headers = result
         response(data, status, headers)

data/lib/volcano/lock_response.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Volcano
+  # Validates lock response fields before creating public records.
+  module LockResponse
+    private
+
+    def parse_time(value)
+      return Time.iso8601(value) if value.is_a?(String)
+      return value if value.nil? || value.is_a?(Time)
+
+      raise Error::TransportError, 'invalid lock expiry'
+    rescue ArgumentError => e
+      raise Error::TransportError, 'invalid lock expiry', cause: e
+    end
+
+    def required_time(value)
+      parse_time(value) || raise(Error::TransportError, 'invalid lock expiry')
+    end
+
+    def lock_payload(body)
+      raise Error::TransportError, 'invalid lock response' unless body.is_a?(Hash)
+
+      body
+    end
+
+    def lock_held(value)
+      return true if value == true
+      return false if value == false
+
+      raise Error::TransportError, 'invalid lock held flag'
+    end
+
+    def required_fencing_token(value)
+      raise Error::TransportError, 'invalid lock fencing token' unless value.is_a?(Integer)
+
+      value
+    end
+
+    def optional_fencing_token(value)
+      return if value.nil?
+
+      required_fencing_token(value)
+    end
+  end
+end

data/lib/volcano/locks.rb

@@ -7,6 +7,7 @@ module Volcano
   # Acquires and releases project-scoped distributed locks.
   class Locks
     include LockAutoRenewal
+    include LockResponse
 
     def initialize(client, transport)
       @client = client
@@ -14,80 +15,103 @@ module Volcano
     end
 
     def get(key, request_id: nil)
-      payload = lock_request(:get_project_lock, 200, key: key, request_id: request_id)
-      LockState.new(
-        held: payload.fetch('held'),
-        expires_at: parse_time(payload['expires_at']),
-        fencing_token: payload['fencing_token']
-      )
+      payload = lock_payload(perform_request(200) do
+        @transport.get_project_lock(
+          authorization: @client.service_token, key: key, request_id: request_uuid(request_id, 'request_id')
+        )
+      end)
+      build_state(payload)
     end
 
     def acquire(key, ttl:, token: nil, request_id: nil)
       validate_ttl(ttl)
-      parameters = {
-        authorization: @client.service_token.dup.freeze, key: key.dup.freeze,
-        ttl: ttl, token: request_uuid(token, 'token'), request_id: request_uuid(request_id, 'request_id')
-      }.freeze
-      payload = acquire_payload(parameters)
-      build_lease(parameters[:key], parameters[:token], payload)
+      authorization = @client.service_token.dup.freeze
+      owned_key = key.dup.freeze
+      owned_token = request_uuid(token, 'token')
+      owned_request_id = request_uuid(request_id, 'request_id')
+      payload = acquire_payload(
+        authorization: authorization, key: owned_key, ttl: ttl, token: owned_token, request_id: owned_request_id
+      )
+      build_lease(owned_key, owned_token, payload)
     end
 
     def renew(key, lease, ttl:, request_id: nil)
       validate_ttl(ttl)
-      payload = lock_request(:renew_project_lock, 200, key: key, ttl: ttl,
-                                                       token: lease.token, request_id: request_id)
+      payload = lock_payload(perform_request(200) do
+        @transport.renew_project_lock(
+          authorization: @client.service_token, key: key, ttl: ttl,
+          token: lease.token, request_id: request_uuid(request_id, 'request_id')
+        )
+      end)
       build_lease(key, lease.token, payload)
     end
 
     def release(key, lease, request_id: nil)
-      lock_request(:release_project_lock, 204, key: key, token: lease.token, request_id: request_id)
+      perform_request(204) do
+        @transport.release_project_lock(
+          authorization: @client.service_token, key: key, token: lease.token,
+          request_id: request_uuid(request_id, 'request_id')
+        )
+      end
       nil
     end
 
     def force_release(key, request_id: nil)
-      lock_request(:force_release_project_lock, 204, key: key, request_id: request_id)
+      perform_request(204) do
+        @transport.force_release_project_lock(
+          authorization: @client.service_token, key: key, request_id: request_uuid(request_id, 'request_id')
+        )
+      end
       nil
     end
 
     private
 
-    def acquire_payload(parameters)
-      perform_request(:acquire_project_lock, 201, parameters)
+    def acquire_payload(authorization:, key:, ttl:, token:, request_id:)
+      lock_payload(perform_request(201) do
+        @transport.acquire_project_lock(authorization: authorization, key: key, ttl: ttl,
+                                        token: token, request_id: request_id)
+      end)
     rescue Error::TransportError, Error::ServerError => e
       raise unless e.status.nil? || e.status == 503
 
-      perform_request(:acquire_project_lock, 201, parameters)
-    end
-
-    def lock_request(operation, status, **parameters)
-      parameters[:authorization] = @client.service_token
-      parameters[:request_id] = request_uuid(parameters[:request_id], 'request_id')
-      perform_request(operation, status, parameters)
+      lock_payload(perform_request(201) do
+        @transport.acquire_project_lock(authorization: authorization, key: key, ttl: ttl,
+                                        token: token, request_id: request_id)
+      end)
     end
 
-    def perform_request(operation, status, parameters)
-      response = Transport.invoke { @transport.public_send(operation, **parameters) }
+    def perform_request(status, &)
+      response = Transport.invoke(&)
       Transport.body(response, status)
     end
 
     def request_uuid(value, name)
       return SecureRandom.uuid.freeze if value.nil?
 
-      valid = value.is_a?(String) && value.match?(/\A[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\z/i)
-      raise ArgumentError, "#{name} must be a UUID string" unless valid
+      unless value.is_a?(String) && value.match?(/\A[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\z/i)
+        raise ArgumentError, "#{name} must be a UUID string"
+      end
 
       value.dup.freeze
     end
 
     def build_lease(key, token, payload)
       LockLease.new(
-        key: key, token: token, expires_at: parse_time(payload['expires_at']),
-        fencing_token: payload['fencing_token']
+        key: key, token: token, expires_at: required_time(payload['expires_at']),
+        fencing_token: required_fencing_token(payload['fencing_token'])
       )
     end
 
-    def parse_time(value)
-      value.is_a?(String) ? Time.iso8601(value) : value
+    def build_state(payload)
+      held = lock_held(payload['held'])
+      expiry = held ? required_time(payload['expires_at']) : parse_time(payload['expires_at'])
+      fencing = if held
+                  required_fencing_token(payload['fencing_token'])
+                else
+                  optional_fencing_token(payload['fencing_token'])
+                end
+      LockState.new(held: held, expires_at: expiry, fencing_token: fencing)
     end
   end
 end

data/lib/volcano/session.rb

@@ -9,79 +9,6 @@ module Volcano
   end
   private_constant :SESSION_USER_CODER
 
-  # Owns credential snapshots and preserves validated identity during refresh.
-  module SessionCredentials
-    def self.build(access_token, refresh_token)
-      raise ArgumentError, 'refresh_token requires access_token' if access_token.nil? && !refresh_token.nil?
-      return if access_token.nil?
-
-      Session.new(access_token: credential(access_token, :access_token),
-                  refresh_token: credential(refresh_token, :refresh_token))
-    end
-
-    def self.credential(value, name)
-      return if value.nil?
-
-      raise ArgumentError, "#{name} must be a non-empty string" unless value.is_a?(String) && !value.strip.empty?
-
-      value.dup.freeze
-    end
-    private_class_method :credential
-
-    def self.validate_refresh_source(current, verified: false)
-      return if verified || session_id(current.access_token)
-
-      raise Error::AuthenticationError, 'Cannot refresh supplied credentials without a session identifier'
-    end
-
-    def self.validate_refresh(current, refreshed)
-      return unless current
-
-      validate_refresh_session_id(current, refreshed)
-      return unless current.user_id && current.user_id != refreshed&.user_id
-
-      raise Error::AuthenticationError, 'Refreshed session belongs to a different user'
-    end
-
-    def self.validate_refresh_session_id(current, refreshed)
-      expected = session_id(current.access_token)
-      return unless expected && expected != session_id(refreshed&.access_token)
-
-      raise Error::AuthenticationError, 'Refreshed credentials belong to a different server session'
-    end
-    private_class_method :validate_refresh_session_id
-
-    # Untrusted continuity constraint, never authenticated user identity.
-    def self.session_id(access_token)
-      payload = token_payload(access_token)
-      return unless payload.is_a?(Hash)
-
-      value = payload['session_id']
-      value.downcase if value.is_a?(String) && value.match?(/\A[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\z/i)
-    end
-
-    def self.token_payload(access_token)
-      return unless access_token.is_a?(String)
-
-      parts = access_token.split('.')
-      return unless parts.length == 3
-
-      encoded = parts.fetch(1).tr('-_', '+/')
-      JSON.parse((encoded + ('=' * (-encoded.length % 4))).unpack1('m0'))
-    rescue ArgumentError, JSON::ParserError
-      nil
-    end
-    private_class_method :token_payload
-
-    def self.with_user(session, user)
-      user_id = (session.user_id || user.fetch('id')).dup.freeze
-      raise Error::AuthenticationError, 'Profile belongs to a different user' unless user['id'] == user_id
-
-      Session.new(**session.to_h, user_id: user_id, user: user)
-    end
-  end
-  private_constant :SessionCredentials
-
   # Local credentials; refresh credentials and user identity may be unknown.
   Session = Data.define(:access_token, :refresh_token, :user_id, :user) do
     def initialize(access_token:, refresh_token: nil, user_id: nil, user: nil)

data/lib/volcano/session_credentials.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+require_relative 'session'
+
+module Volcano
+  # Owns credential snapshots and preserves validated identity during refresh.
+  module SessionCredentials
+    def self.build(access_token, refresh_token)
+      raise ArgumentError, 'refresh_token requires access_token' if access_token.nil? && !refresh_token.nil?
+      return if access_token.nil?
+
+      Session.new(access_token: credential(access_token, :access_token),
+                  refresh_token: refresh_token.nil? ? nil : credential(refresh_token, :refresh_token))
+    end
+
+    def self.credential(value, name)
+      raise ArgumentError, "#{name} must be a non-empty string" unless value.is_a?(String) && !value.strip.empty?
+
+      value.dup.freeze
+    end
+    private_class_method :credential
+
+    def self.validate_refresh_source(current, verified: false)
+      return if verified || session_id(current.access_token)
+
+      raise Error::AuthenticationError, 'Cannot refresh supplied credentials without a session identifier'
+    end
+
+    def self.validate_refresh(current, refreshed)
+      return unless current
+
+      validate_refresh_session_id(current, refreshed)
+      return unless current.user_id && current.user_id != refreshed&.user_id
+
+      raise Error::AuthenticationError, 'Refreshed session belongs to a different user'
+    end
+
+    def self.validate_refresh_session_id(current, refreshed)
+      expected = session_id(current.access_token)
+      return unless expected && expected != session_id(refreshed&.access_token)
+
+      raise Error::AuthenticationError, 'Refreshed credentials belong to a different server session'
+    end
+    private_class_method :validate_refresh_session_id
+
+    # Untrusted continuity constraint, never authenticated user identity.
+    def self.session_id(access_token)
+      payload = token_payload(access_token)
+      return unless payload.is_a?(Hash)
+
+      value = payload['session_id']
+      value.downcase if value.is_a?(String) && value.match?(/\A[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}\z/i)
+    end
+
+    def self.token_payload(access_token)
+      return unless access_token.is_a?(String)
+
+      parts = access_token.split('.')
+      return unless parts.length == 3
+
+      encoded = parts.fetch(1).tr('-_', '+/')
+      JSON.parse(Base64.strict_decode64(encoded + ('=' * (-encoded.length % 4))))
+    rescue ArgumentError, JSON::ParserError
+      nil
+    end
+    private_class_method :token_payload
+
+    def self.with_user(session, user)
+      user_id = session.user_id || user.fetch('id')
+      raise Error::AuthenticationError, 'Profile has no valid user identifier' unless user_id.is_a?(String)
+
+      user_id = user_id.dup.freeze
+      raise Error::AuthenticationError, 'Profile belongs to a different user' unless user['id'] == user_id
+
+      Session.new(access_token: session.access_token, refresh_token: session.refresh_token,
+                  user_id: user_id, user: user)
+    end
+  end
+  private_constant :SessionCredentials
+end

data/lib/volcano/session_operations.rb

@@ -42,7 +42,9 @@ module Volcano
     def refresh(&)
       operation, owner = @mutex.synchronize do
         raise Error::SessionChangedError if @sign_out || @locally_cleared
-        next [@refresh, false] if @refresh && !@refresh.done
+
+        current = @refresh
+        next [current, false] if current && !current.done
 
         @refresh = Outcome.new(false)
         [@refresh, true]
@@ -51,11 +53,7 @@ module Volcano
     end
 
     def sign_out
-      operation, owner, preceding, pending = @mutex.synchronize do
-        first = @sign_out.nil?
-        @sign_out ||= Outcome.new(false)
-        [@sign_out, first, @refresh, @refresh && !@refresh.done]
-      end
+      operation, owner, preceding, pending = @mutex.synchronize { claim_sign_out }
       execute(operation, owner) do
         yield(preceding, pending)
       ensure
@@ -79,10 +77,19 @@ module Volcano
 
     private
 
+    def claim_sign_out
+      first = @sign_out.nil? == true
+      operation = @sign_out ||= Outcome.new(false)
+      current = @refresh
+      [operation, first, current, current && !current.done]
+    end
+
     def execute(operation, owner)
       return result(operation) unless owner
 
       completed = false
+      # @type var value: Object?
+      value = nil
       begin
         value = yield
         completed = true

data/lib/volcano/session_page_mapping.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Maps the internal wire response to immutable public session values.
+  module SessionPageMapping
+    private
+
+    def session_page(body)
+      raise TypeError, 'Expected a complete session page' unless body.is_a?(Hash)
+
+      sessions = body.fetch('sessions')
+      raise TypeError, 'Expected a complete session page' unless sessions.is_a?(Array)
+
+      SessionPage.new(
+        sessions: sessions.map { |attributes| auth_session(attributes) },
+        total: required_integer(body, 'total'), page: required_integer(body, 'page'),
+        limit: required_integer(body, 'limit'), total_pages: required_integer(body, 'total_pages')
+      )
+    rescue KeyError
+      raise TypeError, 'Expected a complete session page'
+    end
+
+    def auth_session(attributes)
+      raise TypeError, 'Expected a complete authentication session' unless attributes.is_a?(Hash)
+
+      build_auth_session(attributes)
+    rescue KeyError
+      raise TypeError, 'Expected a complete authentication session'
+    end
+
+    def build_auth_session(attributes)
+      AuthSession.new(
+        id: required_string(attributes, 'id'), user_id: required_string(attributes, 'user_id'),
+        provider: required_string(attributes, 'provider'), expires_at: required_time(attributes, 'expires_at'),
+        is_active: required_boolean(attributes, 'is_active'), is_current: required_boolean(attributes, 'is_current'),
+        user_agent: optional_string(attributes, 'user_agent'), ip_address: optional_string(attributes, 'ip_address'),
+        last_ip_address: optional_string(attributes, 'last_ip_address'),
+        last_activity_at: optional_time(attributes, 'last_activity_at'),
+        session_started_at: optional_time(attributes, 'session_started_at'),
+        created_at: optional_time(attributes, 'created_at'), updated_at: optional_time(attributes, 'updated_at')
+      )
+    end
+
+    def required_integer(body, name)
+      value = body.fetch(name)
+      raise TypeError, 'Expected a complete session page' unless value.is_a?(Integer)
+
+      value
+    end
+
+    def required_string(body, name)
+      value = body.fetch(name)
+      raise TypeError, 'Expected a complete authentication session' unless value.is_a?(String)
+
+      value
+    end
+
+    def required_time(body, name)
+      value = body.fetch(name)
+      raise TypeError, 'Expected a complete authentication session' unless value.is_a?(Time)
+
+      value
+    end
+
+    def required_boolean(body, name)
+      value = body.fetch(name)
+      unless value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        raise TypeError, 'Expected a complete authentication session'
+      end
+
+      value
+    end
+
+    def optional_string(body, name)
+      value = body[name]
+      raise TypeError, 'Expected a complete authentication session' unless value.nil? || value.is_a?(String)
+
+      value
+    end
+
+    def optional_time(body, name)
+      value = body[name]
+      raise TypeError, 'Expected a complete authentication session' unless value.nil? || value.is_a?(Time)
+
+      value
+    end
+  end
+  private_constant :SessionPageMapping
+end

data/lib/volcano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Volcano
-  VERSION = '0.28.0'
+  VERSION = '0.30.0'
 end

data/lib/volcano.rb

@@ -5,6 +5,7 @@ require_relative 'volcano/connection_string'
 require_relative 'volcano/models'
 require_relative 'volcano/user'
 require_relative 'volcano/session'
+require_relative 'volcano/session_credentials'
 require_relative 'volcano/function_response'
 require_relative 'volcano/durable_models'
 require_relative 'volcano/log_responses'
@@ -16,16 +17,21 @@ require_relative 'volcano/errors'
 require_relative 'volcano/redaction'
 require_relative 'volcano/transport'
 require_relative 'volcano/generated_transport'
-require_relative 'volcano/auth'
+require_relative 'volcano/auth_notification_dispatch'
+require_relative 'volcano/auth_session_binding'
 require_relative 'volcano/auth_sign_out'
 require_relative 'volcano/auth_refresh'
+require_relative 'volcano/auth_profile_fields'
+require_relative 'volcano/auth_get_user'
+require_relative 'volcano/auth_update_user'
+require_relative 'volcano/auth_email_change'
+require_relative 'volcano/auth_sessions'
+require_relative 'volcano/auth'
 require_relative 'volcano/auth_sign_up'
 require_relative 'volcano/sign_up_result'
 require_relative 'volcano/auth_anonymous'
 require_relative 'volcano/auth_confirm_email'
 require_relative 'volcano/auth_resend_confirmation'
-require_relative 'volcano/auth_email_change'
-require_relative 'volcano/auth_sessions'
 require_relative 'volcano/auth_oauth'
 require_relative 'volcano/auth_oauth_sign_in'
 require_relative 'volcano/auth_hosted'
@@ -33,8 +39,6 @@ require_relative 'volcano/auth_oauth_token'
 require_relative 'volcano/auth_oauth_api'
 require_relative 'volcano/auth_reset_password_for_email'
 require_relative 'volcano/auth_reset_password'
-require_relative 'volcano/auth_get_user'
-require_relative 'volcano/auth_update_user'
 require_relative 'volcano/database'
 require_relative 'volcano/function_resolution'
 require_relative 'volcano/functions'
@@ -50,6 +54,7 @@ require_relative 'volcano/lock_guard'
 require_relative 'volcano/lock_renewer'
 require_relative 'volcano/lock_session'
 require_relative 'volcano/lock_auto_renewal'
+require_relative 'volcano/lock_response'
 require_relative 'volcano/locks'
 require_relative 'volcano/realtime/protocol'
 require_relative 'volcano/realtime'
@@ -57,8 +62,10 @@ require_relative 'volcano/client'
 
 # Public namespace for the Volcano Ruby SDK.
 module Volcano
-  private_constant :GeneratedTransport, :LockAutoRenewal, :LockLeaseClock, :LockRenewer, :LockSession,
-                   :Redaction, :SessionOperations
+  private_constant :AuthRefresh, :AuthSignOut, :AuthProfile, :AuthProfileFields, :AuthUpdateUser, :AuthEmailChange,
+                   :AuthSessions,
+                   :GeneratedTransport, :LockAutoRenewal, :LockLeaseClock, :LockRenewer,
+                   :LockSession, :LockResponse, :Redaction, :SessionOperations
 
   Realtime.private_constant :Protocol, :ProtocolDispatch, :ProtocolPublicationDispatch, :ProtocolRecovery,
                             :ProtocolRecoveryDispatch, :ProtocolRecoveryPosition

data/sig/auth_oauth.rbs

@@ -0,0 +1,16 @@
+module Volcano
+  type oauth_api_input = session_input
+
+  class Auth
+    def list_linked_oauth_providers: () -> Array[LinkedOAuthProvider]
+    def link_oauth_provider: (String provider) -> String
+    def unlink_oauth_provider: (String provider) -> nil
+    def get_oauth_provider_token: (String provider) -> OAuthProviderTokenStatus
+    def refresh_oauth_provider_token: (String provider) -> OAuthProviderTokenStatus
+    def call_oauth_api: (String provider, endpoint: String, ?method: String, ?body: oauth_api_input) -> Object?
+    def sign_in_with_oauth: (String provider, redirect_to: String, state: String) -> String
+    def exchange_oauth_code: (code: String, redirect_to: String, state: String, expected_state: String) -> Session
+    def get_hosted_auth_url: (project_id: String, state: String, ?action: String) -> String
+    def adopt_hosted_auth_session: (Session session, state: String, expected_state: String) -> Session
+  end
+end

data/sig/auth_profile.rbs

@@ -0,0 +1,10 @@
+module Volcano
+  class Auth
+    def user: () -> User
+    def get_user: () -> User
+    def update_user: (?password: String?, ?metadata: session_user_input?) -> User
+    def request_email_change: (new_email: String) -> EmailChangeResult
+    def cancel_email_change: () -> nil
+    def confirm_email_change: (token: String) -> User
+  end
+end