node-appwrite 11.1.1 → 12.0.0

package/lib/services/account.js

@@ -5,6 +5,8 @@ const client = require('../client.js');
 const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
+const { File } = require('undici');
+const Query = require('../query.js');
 
 class Account extends Service {
 
@@ -31,6 +33,61 @@ class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Create account
+     *
+     * 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} userId
+     * @param {string} email
+     * @param {string} password
+     * @param {string} name
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async create(userId, email, password, name) {
+        const apiPath = '/account';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+
+        if (typeof password === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "password"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+
+        if (typeof password !== 'undefined') {
+            payload['password'] = password;
+        }
+
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Update email
      *
@@ -78,7 +135,7 @@ class Account extends Service {
      *
      * Get the list of identities for the currently logged in user.
      *
-     * @param {string} queries
+     * @param {string[]} queries
      * @throws {AppwriteException}
      * @returns {Promise}
      */
@@ -96,7 +153,7 @@ class Account extends Service {
     }
 
     /**
-     * Delete Identity
+     * Delete identity
      *
      * Delete an identity by its unique ID.
      *
@@ -117,6 +174,27 @@ class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Create JWT
+     *
+     * 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.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createJWT() {
+        const apiPath = '/account/jwt';
+        let payload = {};
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * List logs
      *
@@ -140,6 +218,266 @@ class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Update MFA
+     *
+     * Enable or disable MFA on an account.
+     *
+     * @param {boolean} mfa
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMFA(mfa) {
+        const apiPath = '/account/mfa';
+        let payload = {};
+        if (typeof mfa === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "mfa"');
+        }
+
+
+        if (typeof mfa !== 'undefined') {
+            payload['mfa'] = mfa;
+        }
+
+        return await this.client.call('patch', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Add Authenticator
+     *
+     * Add an authenticator app to be used as an MFA factor. Verify the
+     * authenticator using the [verify
+     * authenticator](/docs/references/cloud/client-web/account#verifyAuthenticator)
+     * method.
+     *
+     * @param {AuthenticatorType} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createMfaAuthenticator(type) {
+        const apiPath = '/account/mfa/authenticators/{type}'.replace('{type}', type);
+        let payload = {};
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Verify Authenticator
+     *
+     * Verify an authenticator app after adding it using the [add
+     * authenticator](/docs/references/cloud/client-web/account#addAuthenticator)
+     * method.
+     *
+     * @param {AuthenticatorType} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMfaAuthenticator(type, otp) {
+        const apiPath = '/account/mfa/authenticators/{type}'.replace('{type}', type);
+        let payload = {};
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        if (typeof otp === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "otp"');
+        }
+
+
+        if (typeof otp !== 'undefined') {
+            payload['otp'] = otp;
+        }
+
+        return await this.client.call('put', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete Authenticator
+     *
+     * Delete an authenticator for a user by ID.
+     *
+     * @param {AuthenticatorType} type
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async deleteMfaAuthenticator(type, otp) {
+        const apiPath = '/account/mfa/authenticators/{type}'.replace('{type}', type);
+        let payload = {};
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+        if (typeof otp === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "otp"');
+        }
+
+
+        if (typeof otp !== 'undefined') {
+            payload['otp'] = otp;
+        }
+
+        return await this.client.call('delete', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create 2FA Challenge
+     *
+     * Begin the process of MFA verification after sign-in. Finish the flow with
+     * [updateMfaChallenge](/docs/references/cloud/client-web/account#updateMfaChallenge)
+     * method.
+     *
+     * @param {AuthenticationFactor} factor
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createMfaChallenge(factor) {
+        const apiPath = '/account/mfa/challenge';
+        let payload = {};
+        if (typeof factor === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "factor"');
+        }
+
+
+        if (typeof factor !== 'undefined') {
+            payload['factor'] = factor;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create MFA Challenge (confirmation)
+     *
+     * Complete the MFA challenge by providing the one-time password. Finish the
+     * process of MFA verification by providing the one-time password. To begin
+     * the flow, use
+     * [createMfaChallenge](/docs/references/cloud/client-web/account#createMfaChallenge)
+     * method.
+     *
+     * @param {string} challengeId
+     * @param {string} otp
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMfaChallenge(challengeId, otp) {
+        const apiPath = '/account/mfa/challenge';
+        let payload = {};
+        if (typeof challengeId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "challengeId"');
+        }
+
+        if (typeof otp === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "otp"');
+        }
+
+
+        if (typeof challengeId !== 'undefined') {
+            payload['challengeId'] = challengeId;
+        }
+
+        if (typeof otp !== 'undefined') {
+            payload['otp'] = otp;
+        }
+
+        return await this.client.call('put', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * List Factors
+     *
+     * List the factors available on the account to be used as a MFA challange.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async listMfaFactors() {
+        const apiPath = '/account/mfa/factors';
+        let payload = {};
+
+        return await this.client.call('get', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get MFA Recovery Codes
+     *
+     * Get recovery codes that can be used as backup for MFA flow. Before getting
+     * codes, they must be generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method. An OTP challenge is required to read recovery codes.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async getMfaRecoveryCodes() {
+        const apiPath = '/account/mfa/recovery-codes';
+        let payload = {};
+
+        return await this.client.call('get', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create MFA Recovery Codes
+     *
+     * Generate recovery codes as backup for MFA flow. It's recommended to
+     * generate and show then immediately after user successfully adds their
+     * authehticator. Recovery codes can be used as a MFA verification type in
+     * [createMfaChallenge](/docs/references/cloud/client-web/account#createMfaChallenge)
+     * method.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createMfaRecoveryCodes() {
+        const apiPath = '/account/mfa/recovery-codes';
+        let payload = {};
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Regenerate MFA Recovery Codes
+     *
+     * Regenerate recovery codes that can be used as backup for MFA flow. Before
+     * regenerating codes, they must be first generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method. An OTP challenge is required to regenreate recovery codes.
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMfaRecoveryCodes() {
+        const apiPath = '/account/mfa/recovery-codes';
+        let payload = {};
+
+        return await this.client.call('patch', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Update name
      *
@@ -342,11 +680,10 @@ class Account extends Service {
      * @param {string} userId
      * @param {string} secret
      * @param {string} password
-     * @param {string} passwordAgain
      * @throws {AppwriteException}
      * @returns {Promise}
      */
-    async updateRecovery(userId, secret, password, passwordAgain) {
+    async updateRecovery(userId, secret, password) {
         const apiPath = '/account/recovery';
         let payload = {};
         if (typeof userId === 'undefined') {
@@ -361,10 +698,6 @@ class Account extends Service {
             throw new AppwriteException('Missing required parameter: "password"');
         }
 
-        if (typeof passwordAgain === 'undefined') {
-            throw new AppwriteException('Missing required parameter: "passwordAgain"');
-        }
-
 
         if (typeof userId !== 'undefined') {
             payload['userId'] = userId;
@@ -378,10 +711,6 @@ class Account extends Service {
             payload['password'] = password;
         }
 
-        if (typeof passwordAgain !== 'undefined') {
-            payload['passwordAgain'] = passwordAgain;
-        }
-
         return await this.client.call('put', apiPath, {
             'content-type': 'application/json',
         }, payload);
@@ -423,6 +752,180 @@ class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Create anonymous session
+     *
+     * 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).
+     *
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createAnonymousSession() {
+        const apiPath = '/account/sessions/anonymous';
+        let payload = {};
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create email password session
+     *
+     * 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
+     * @param {string} password
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createEmailPasswordSession(email, password) {
+        const apiPath = '/account/sessions/email';
+        let payload = {};
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+
+        if (typeof password === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "password"');
+        }
+
+
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+
+        if (typeof password !== 'undefined') {
+            payload['password'] = password;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update magic URL session
+     *
+     * 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} userId
+     * @param {string} secret
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMagicURLSession(userId, secret) {
+        const apiPath = '/account/sessions/magic-url';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof secret === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "secret"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof secret !== 'undefined') {
+            payload['secret'] = secret;
+        }
+
+        return await this.client.call('put', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update phone session
+     *
+     * 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} userId
+     * @param {string} secret
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updatePhoneSession(userId, secret) {
+        const apiPath = '/account/sessions/phone';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof secret === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "secret"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof secret !== 'undefined') {
+            payload['secret'] = secret;
+        }
+
+        return await this.client.call('put', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create session
+     *
+     * 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} userId
+     * @param {string} secret
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createSession(userId, secret) {
+        const apiPath = '/account/sessions/token';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof secret === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "secret"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof secret !== 'undefined') {
+            payload['secret'] = secret;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Get session
      *
@@ -447,11 +950,11 @@ class Account extends Service {
     }
 
     /**
-     * Update OAuth session (refresh tokens)
+     * Update session
      *
-     * 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.
+     * Use this endpoint to extend a session's length. Extending a session is
+     * useful when session expiry is short. If the session was created using an
+     * OAuth provider, this endpoint refreshes the access token from the provider.
      *
      * @param {string} sessionId
      * @throws {AppwriteException}
@@ -515,6 +1018,209 @@ class Account extends Service {
         }, payload);
     }
 
+    /**
+     * Create email token (OTP)
+     *
+     * 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} userId
+     * @param {string} email
+     * @param {boolean} phrase
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createEmailToken(userId, email, phrase) {
+        const apiPath = '/account/tokens/email';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+
+        if (typeof phrase !== 'undefined') {
+            payload['phrase'] = phrase;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create magic URL token
+     *
+     * 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} userId
+     * @param {string} email
+     * @param {string} url
+     * @param {boolean} phrase
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createMagicURLToken(userId, email, url, phrase) {
+        const apiPath = '/account/tokens/magic-url';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof email === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "email"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof email !== 'undefined') {
+            payload['email'] = email;
+        }
+
+        if (typeof url !== 'undefined') {
+            payload['url'] = url;
+        }
+
+        if (typeof phrase !== 'undefined') {
+            payload['phrase'] = phrase;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create OAuth2 token
+     *
+     * 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 authentication succeeds, `userId` and `secret` of a token will be
+     * appended to the success URL as query parameters. These can be used to
+     * create a new session using the [Create
+     * session](https://appwrite.io/docs/references/cloud/client-web/account#createSession)
+     * endpoint.
+     * 
+     * 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
+     * @param {string} success
+     * @param {string} failure
+     * @param {string[]} scopes
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createOAuth2Token(provider, success, failure, scopes) {
+        const apiPath = '/account/tokens/oauth2/{provider}'.replace('{provider}', provider);
+        let payload = {};
+        if (typeof provider === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "provider"');
+        }
+
+
+        if (typeof success !== 'undefined') {
+            payload['success'] = success;
+        }
+
+        if (typeof failure !== 'undefined') {
+            payload['failure'] = failure;
+        }
+
+        if (typeof scopes !== 'undefined') {
+            payload['scopes'] = scopes;
+        }
+
+        return await this.client.call('get', apiPath, {
+            'content-type': 'application/json',
+        }, payload, 'location');
+    }
+
+    /**
+     * Create phone token
+     *
+     * 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} userId
+     * @param {string} phone
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createPhoneToken(userId, phone) {
+        const apiPath = '/account/tokens/phone';
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof phone === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "phone"');
+        }
+
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        if (typeof phone !== 'undefined') {
+            payload['phone'] = phone;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Create email verification
      *