appwrite 10.1.2 → 11.0.0.pre.rc.4

data/lib/appwrite/services/account.rb

@@ -31,6 +31,56 @@ module Appwrite
         end
 
         
+        # Use this endpoint to allow a new user to register a new account in your
+        # project. After the user registration completes successfully, you can use
+        # the
+        # [/account/verfication](https://appwrite.io/docs/references/cloud/client-web/account#createVerification)
+        # route to start verifying the user email address. To allow the new user to
+        # login to their new account, you need to create a new [account
+        # session](https://appwrite.io/docs/references/cloud/client-web/account#createEmailSession).
+        #
+        # @param [String] user_id User ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        # @param [String] email User email.
+        # @param [String] password New user password. Must be between 8 and 256 chars.
+        # @param [String] name User name. Max length: 128 chars.
+        #
+        # @return [User]
+        def create(user_id:, email:, password:, name: nil)
+            api_path = '/account'
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if email.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "email"')
+            end
+
+            if password.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "password"')
+            end
+
+            api_params = {
+                userId: user_id,
+                email: email,
+                password: password,
+                name: name,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::User
+            )
+        end
+
+        
         # Update currently logged in user account email address. After changing user
         # address, the user confirmation status will get reset. A new confirmation
         # email is not sent automatically however you can use the send confirmation
@@ -76,7 +126,7 @@ module Appwrite
         
         # Get the list of identities for the currently logged in user.
         #
-        # @param [String] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: userId, provider, providerUid, providerEmail, providerAccessTokenExpiry
+        # @param [Array] queries Array of query strings generated using the Query class provided by the SDK. [Learn more about queries](https://appwrite.io/docs/queries). Maximum of 100 queries are allowed, each 4096 characters long. You may filter on the following attributes: userId, provider, providerUid, providerEmail, providerAccessTokenExpiry
         #
         # @return [IdentityList]
         def list_identities(queries: nil)
@@ -129,6 +179,34 @@ module Appwrite
         end
 
         
+        # Use this endpoint to create a JSON Web Token. You can use the resulting JWT
+        # to authenticate on behalf of the current user when working with the
+        # Appwrite server-side API and SDKs. The JWT secret is valid for 15 minutes
+        # from its creation and will be invalid if the user will logout in that time
+        # frame.
+        #
+        #
+        # @return [Jwt]
+        def create_jwt()
+            api_path = '/account/jwt'
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Jwt
+            )
+        end
+
+        
         # Get the list of latest security activity logs for the currently logged in
         # user. Each log returns user IP address, location and date and time of log.
         #
@@ -156,6 +234,227 @@ module Appwrite
         end
 
         
+        # 
+        #
+        # @param [] mfa Enable or disable MFA.
+        #
+        # @return [User]
+        def update_mfa(mfa:)
+            api_path = '/account/mfa'
+
+            if mfa.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "mfa"')
+            end
+
+            api_params = {
+                mfa: mfa,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PATCH',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::User
+            )
+        end
+
+        
+        # 
+        #
+        # @param [AuthenticationFactor] factor Factor used for verification.
+        #
+        # @return [MfaChallenge]
+        def create2_fa_challenge(factor:)
+            api_path = '/account/mfa/challenge'
+
+            if factor.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "factor"')
+            end
+
+            api_params = {
+                factor: factor,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::MfaChallenge
+            )
+        end
+
+        
+        # 
+        #
+        # @param [String] challenge_id ID of the challenge.
+        # @param [String] otp Valid verification token.
+        #
+        # @return []
+        def update_challenge(challenge_id:, otp:)
+            api_path = '/account/mfa/challenge'
+
+            if challenge_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "challengeId"')
+            end
+
+            if otp.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "otp"')
+            end
+
+            api_params = {
+                challengeId: challenge_id,
+                otp: otp,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PUT',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+        end
+
+        
+        # 
+        #
+        #
+        # @return [MfaFactors]
+        def list_factors()
+            api_path = '/account/mfa/factors'
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::MfaFactors
+            )
+        end
+
+        
+        # 
+        #
+        # @param [AuthenticatorType] type Type of authenticator.
+        #
+        # @return [MfaType]
+        def add_authenticator(type:)
+            api_path = '/account/mfa/{type}'
+                .gsub('{type}', type)
+
+            if type.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "type"')
+            end
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::MfaType
+            )
+        end
+
+        
+        # 
+        #
+        # @param [AuthenticatorType] type Type of authenticator.
+        # @param [String] otp Valid verification token.
+        #
+        # @return [User]
+        def verify_authenticator(type:, otp:)
+            api_path = '/account/mfa/{type}'
+                .gsub('{type}', type)
+
+            if type.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "type"')
+            end
+
+            if otp.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "otp"')
+            end
+
+            api_params = {
+                otp: otp,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PUT',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::User
+            )
+        end
+
+        
+        # 
+        #
+        # @param [AuthenticatorType] type Type of authenticator.
+        # @param [String] otp Valid verification token.
+        #
+        # @return [User]
+        def delete_authenticator(type:, otp:)
+            api_path = '/account/mfa/{type}'
+                .gsub('{type}', type)
+
+            if type.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "type"')
+            end
+
+            if otp.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "otp"')
+            end
+
+            api_params = {
+                otp: otp,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'DELETE',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::User
+            )
+        end
+
+        
         # Update currently logged in user account name.
         #
         # @param [String] name User name. Max length: 128 chars.
@@ -372,11 +671,10 @@ module Appwrite
         #
         # @param [String] user_id User ID.
         # @param [String] secret Valid reset token.
-        # @param [String] password New user password. Must be at least 8 chars.
-        # @param [String] password_again Repeat new user password. Must be at least 8 chars.
+        # @param [String] password New user password. Must be between 8 and 256 chars.
         #
         # @return [Token]
-        def update_recovery(user_id:, secret:, password:, password_again:)
+        def update_recovery(user_id:, secret:, password:)
             api_path = '/account/recovery'
 
             if user_id.nil?
@@ -391,15 +689,10 @@ module Appwrite
               raise Appwrite::Exception.new('Missing required parameter: "password"')
             end
 
-            if password_again.nil?
-              raise Appwrite::Exception.new('Missing required parameter: "passwordAgain"')
-            end
-
             api_params = {
                 userId: user_id,
                 secret: secret,
                 password: password,
-                passwordAgain: password_again,
             }
             
             api_headers = {
@@ -465,6 +758,205 @@ module Appwrite
         end
 
         
+        # Use this endpoint to allow a new user to register an anonymous account in
+        # your project. This route will also create a new session for the user. To
+        # allow the new user to convert an anonymous account to a normal account, you
+        # need to update its [email and
+        # password](https://appwrite.io/docs/references/cloud/client-web/account#updateEmail)
+        # or create an [OAuth2
+        # session](https://appwrite.io/docs/references/cloud/client-web/account#CreateOAuth2Session).
+        #
+        #
+        # @return [Session]
+        def create_anonymous_session()
+            api_path = '/account/sessions/anonymous'
+
+            api_params = {
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Session
+            )
+        end
+
+        
+        # Allow the user to login into their account by providing a valid email and
+        # password combination. This route will create a new session for the user.
+        # 
+        # A user is limited to 10 active sessions at a time by default. [Learn more
+        # about session
+        # limits](https://appwrite.io/docs/authentication-security#limits).
+        #
+        # @param [String] email User email.
+        # @param [String] password User password. Must be at least 8 chars.
+        #
+        # @return [Session]
+        def create_email_password_session(email:, password:)
+            api_path = '/account/sessions/email'
+
+            if email.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "email"')
+            end
+
+            if password.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "password"')
+            end
+
+            api_params = {
+                email: email,
+                password: password,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Session
+            )
+        end
+
+        
+        # Use this endpoint to create a session from token. Provide the **userId**
+        # and **secret** parameters from the successful response of authentication
+        # flows initiated by token creation. For example, magic URL and phone login.
+        #
+        # @param [String] user_id User ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        # @param [String] secret Valid verification token.
+        #
+        # @return [Session]
+        def update_magic_url_session(user_id:, secret:)
+            api_path = '/account/sessions/magic-url'
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if secret.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "secret"')
+            end
+
+            api_params = {
+                userId: user_id,
+                secret: secret,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'PUT',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Session
+            )
+        end
+
+        
+        # Allow the user to login to their account using the OAuth2 provider of their
+        # choice. Each OAuth2 provider should be enabled from the Appwrite console
+        # first. Use the success and failure arguments to provide a redirect URL's
+        # back to your app when login is completed.
+        # 
+        # If there is already an active session, the new session will be attached to
+        # the logged-in account. If there are no active sessions, the server will
+        # attempt to look for a user with the same email address as the email
+        # received from the OAuth2 provider and attach the new session to the
+        # existing user. If no matching user is found - the server will create a new
+        # user.
+        # 
+        # A user is limited to 10 active sessions at a time by default. [Learn more
+        # about session
+        # limits](https://appwrite.io/docs/authentication-security#limits).
+        # 
+        #
+        # @param [OAuthProvider] provider OAuth2 Provider. Currently, supported providers are: amazon, apple, auth0, authentik, autodesk, bitbucket, bitly, box, dailymotion, discord, disqus, dropbox, etsy, facebook, github, gitlab, google, linkedin, microsoft, notion, oidc, okta, paypal, paypalSandbox, podio, salesforce, slack, spotify, stripe, tradeshift, tradeshiftBox, twitch, wordpress, yahoo, yammer, yandex, zoho, zoom.
+        # @param [String] success URL to redirect back to your app after a successful login attempt.  Only URLs from hostnames in your project's platform list are allowed. This requirement helps to prevent an [open redirect](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) attack against your project API.
+        # @param [String] failure URL to redirect back to your app after a failed login attempt.  Only URLs from hostnames in your project's platform list are allowed. This requirement helps to prevent an [open redirect](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) attack against your project API.
+        # @param [] token Include token credentials in the final redirect, useful for server-side integrations, or when cookies are not available.
+        # @param [Array] scopes A list of custom OAuth2 scopes. Check each provider internal docs for a list of supported scopes. Maximum of 100 scopes are allowed, each 4096 characters long.
+        #
+        # @return []
+        def create_o_auth2_session(provider:, success: nil, failure: nil, token: nil, scopes: nil)
+            api_path = '/account/sessions/oauth2/{provider}'
+                .gsub('{provider}', provider)
+
+            if provider.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "provider"')
+            end
+
+            api_params = {
+                success: success,
+                failure: failure,
+                token: token,
+                scopes: scopes,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'GET',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+            )
+        end
+
+        
+        # Use this endpoint to create a session from token. Provide the **userId**
+        # and **secret** parameters from the successful response of authentication
+        # flows initiated by token creation. For example, magic URL and phone login.
+        #
+        # @param [String] user_id User ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        # @param [String] secret Secret of a token generated by login methods. For example, the `createMagicURLToken` or `createPhoneToken` methods.
+        #
+        # @return [Session]
+        def create_session(user_id:, secret:)
+            api_path = '/account/sessions/token'
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if secret.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "secret"')
+            end
+
+            api_params = {
+                userId: user_id,
+                secret: secret,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Session
+            )
+        end
+
+        
         # Use this endpoint to get a logged in user's session using a Session ID.
         # Inputting 'current' will return the current session being used.
         #
@@ -496,9 +988,8 @@ module Appwrite
         end
 
         
-        # Access tokens have limited lifespan and expire to mitigate security risks.
-        # If session was created using an OAuth provider, this route can be used to
-        # "refresh" the access token.
+        # Extend session's expiry to increase it's lifespan. Extending a session is
+        # useful when session length is short such as 5 minutes.
         #
         # @param [String] session_id Session ID. Use the string 'current' to update the current device session.
         #
@@ -587,6 +1078,153 @@ module Appwrite
         end
 
         
+        # Sends the user an email with a secret key for creating a session. If the
+        # provided user ID has not be registered, a new user will be created. Use the
+        # returned user ID and secret and submit a request to the [POST
+        # /v1/account/sessions/token](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+        # endpoint to complete the login process. The secret sent to the user's email
+        # is valid for 15 minutes.
+        # 
+        # A user is limited to 10 active sessions at a time by default. [Learn more
+        # about session
+        # limits](https://appwrite.io/docs/authentication-security#limits).
+        #
+        # @param [String] user_id User ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        # @param [String] email User email.
+        # @param [] phrase Toggle for security phrase. If enabled, email will be send with a randomly generated phrase and the phrase will also be included in the response. Confirming phrases match increases the security of your authentication flow.
+        #
+        # @return [Token]
+        def create_email_token(user_id:, email:, phrase: nil)
+            api_path = '/account/tokens/email'
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if email.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "email"')
+            end
+
+            api_params = {
+                userId: user_id,
+                email: email,
+                phrase: phrase,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Token
+            )
+        end
+
+        
+        # Sends the user an email with a secret key for creating a session. If the
+        # provided user ID has not been registered, a new user will be created. When
+        # the user clicks the link in the email, the user is redirected back to the
+        # URL you provided with the secret key and userId values attached to the URL
+        # query string. Use the query string parameters to submit a request to the
+        # [POST
+        # /v1/account/sessions/token](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+        # endpoint to complete the login process. The link sent to the user's email
+        # address is valid for 1 hour. If you are on a mobile device you can leave
+        # the URL parameter empty, so that the login completion will be handled by
+        # your Appwrite instance by default.
+        # 
+        # A user is limited to 10 active sessions at a time by default. [Learn more
+        # about session
+        # limits](https://appwrite.io/docs/authentication-security#limits).
+        # 
+        #
+        # @param [String] user_id Unique Id. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        # @param [String] email User email.
+        # @param [String] url URL to redirect the user back to your app from the magic URL login. Only URLs from hostnames in your project platform list are allowed. This requirement helps to prevent an [open redirect](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) attack against your project API.
+        # @param [] phrase Toggle for security phrase. If enabled, email will be send with a randomly generated phrase and the phrase will also be included in the response. Confirming phrases match increases the security of your authentication flow.
+        #
+        # @return [Token]
+        def create_magic_url_token(user_id:, email:, url: nil, phrase: nil)
+            api_path = '/account/tokens/magic-url'
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if email.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "email"')
+            end
+
+            api_params = {
+                userId: user_id,
+                email: email,
+                url: url,
+                phrase: phrase,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Token
+            )
+        end
+
+        
+        # Sends the user an SMS with a secret key for creating a session. If the
+        # provided user ID has not be registered, a new user will be created. Use the
+        # returned user ID and secret and submit a request to the [POST
+        # /v1/account/sessions/token](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+        # endpoint to complete the login process. The secret sent to the user's phone
+        # is valid for 15 minutes.
+        # 
+        # A user is limited to 10 active sessions at a time by default. [Learn more
+        # about session
+        # limits](https://appwrite.io/docs/authentication-security#limits).
+        #
+        # @param [String] user_id Unique Id. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
+        # @param [String] phone Phone number. Format this number with a leading '+' and a country code, e.g., +16175551212.
+        #
+        # @return [Token]
+        def create_phone_token(user_id:, phone:)
+            api_path = '/account/tokens/phone'
+
+            if user_id.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "userId"')
+            end
+
+            if phone.nil?
+              raise Appwrite::Exception.new('Missing required parameter: "phone"')
+            end
+
+            api_params = {
+                userId: user_id,
+                phone: phone,
+            }
+            
+            api_headers = {
+                "content-type": 'application/json',
+            }
+
+            @client.call(
+                method: 'POST',
+                path: api_path,
+                headers: api_headers,
+                params: api_params,
+                response_type: Models::Token
+            )
+        end
+
+        
         # Use this endpoint to send a verification message to your user email address
         # to confirm they are the valid owners of that address. Both the **userId**
         # and **secret** arguments will be passed as query parameters to the URL you