node-appwrite 11.1.1 → 12.0.0

package/lib/services/storage.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 Storage extends Service {
 
@@ -54,7 +56,7 @@ class Storage extends Service {
      * @param {boolean} enabled
      * @param {number} maximumFileSize
      * @param {string[]} allowedFileExtensions
-     * @param {string} compression
+     * @param {Compression} compression
      * @param {boolean} encryption
      * @param {boolean} antivirus
      * @throws {AppwriteException}
@@ -152,7 +154,7 @@ class Storage extends Service {
      * @param {boolean} enabled
      * @param {number} maximumFileSize
      * @param {string[]} allowedFileExtensions
-     * @param {string} compression
+     * @param {Compression} compression
      * @param {boolean} encryption
      * @param {boolean} antivirus
      * @throws {AppwriteException}
@@ -292,6 +294,7 @@ class Storage extends Service {
      * @param {string} fileId
      * @param {InputFile} file
      * @param {string[]} permissions
+     * @param {CallableFunction} onProgress
      * @throws {AppwriteException}
      * @returns {Promise}
      */
@@ -323,8 +326,9 @@ class Storage extends Service {
             payload['permissions'] = permissions;
         }
 
-        const size = file.size;
 
+        const size = file.size;
+        
         const apiHeaders = {
             'content-type': 'multipart/form-data',
         };
@@ -342,118 +346,78 @@ class Storage extends Service {
             }
         }
 
-        let currentChunk = Buffer.from('');
-        let currentChunkSize = 0;
-        let currentChunkStart = 0;
-
-        const selfClient = this.client;
+        let currentChunk = 1;
+        let currentPosition = 0;
+        let uploadableChunk = new Uint8Array(client.CHUNK_SIZE);
+    
 
-        async function uploadChunk(lastUpload = false) {
-            if(chunksUploaded - 1 >= currentChunkStart / client.CHUNK_SIZE) {
+        const uploadChunk = async (lastUpload = false) => {
+            if(currentChunk <= chunksUploaded) {
                 return;
             }
-            
-            const start = currentChunkStart;
-            const end = currentChunkStart + currentChunkSize - 1;
 
-            if(!lastUpload || currentChunkStart !== 0) {
+            const start = ((currentChunk - 1) * client.CHUNK_SIZE);
+            let end = start + currentPosition - 1;
+
+            if(!lastUpload || currentChunk !== 1) {
                 apiHeaders['content-range'] = 'bytes ' + start + '-' + end + '/' + size;
             }
 
+            let uploadableChunkTrimmed;
+            
+            if(currentPosition + 1 >= client.CHUNK_SIZE) {
+                uploadableChunkTrimmed = uploadableChunk;
+            } else {
+                uploadableChunkTrimmed = new Uint8Array(currentPosition);
+                for(let i = 0; i <= currentPosition; i++) {
+                    uploadableChunkTrimmed[i] = uploadableChunk[i];
+                }
+            }
+
             if (id) {
                 apiHeaders['x-appwrite-id'] = id;
             }
 
-            payload['file'] = {
-                type: 'file',
-                file: currentChunk,
-                filename: file.filename,
-                size: currentChunkSize
-            };
+            payload['file'] = { type: 'file', file: new File([uploadableChunkTrimmed], file.filename), filename: file.filename };
 
-            response = await selfClient.call('post', apiPath, apiHeaders, payload);
+            response = await this.client.call('post', apiPath, apiHeaders, payload);
 
             if (!id) {
                 id = response['$id'];
             }
-            
+
             if (onProgress !== null) {
                 onProgress({
                     $id: response['$id'],
-                    progress: Math.min((start+client.CHUNK_SIZE) * client.CHUNK_SIZE, size) / size * 100,
+                    progress: Math.min((currentChunk) * client.CHUNK_SIZE, size) / size * 100,
                     sizeUploaded: end+1,
                     chunksTotal: response['chunksTotal'],
                     chunksUploaded: response['chunksUploaded']
                 });
             }
 
-            currentChunkStart += client.CHUNK_SIZE;
-        }
-
-        return await new Promise((resolve, reject) => {
-            const writeStream = new Stream.Writable();
-            writeStream._write = async (mainChunk, encoding, callback) => {
-                try {
-                    // Segment incoming chunk into up to 5MB chunks
-                    const mainChunkSize = Buffer.byteLength(mainChunk);
-                    const chunksCount = Math.ceil(mainChunkSize / client.CHUNK_SIZE);
-                    const chunks = [];
-
-                    for(let i = 0; i < chunksCount; i++) {
-                        const chunk = mainChunk.slice(i * client.CHUNK_SIZE, (i + 1) * client.CHUNK_SIZE);
-                        chunks.push(chunk);
-                    }
-
-                    for (const chunk of chunks) {
-                        const chunkSize = Buffer.byteLength(chunk);
-
-                        if(chunkSize + currentChunkSize == client.CHUNK_SIZE) {
-                            // Upload chunk
-                            currentChunk = Buffer.concat([currentChunk, chunk]);
-                            currentChunkSize = Buffer.byteLength(currentChunk);
-                            await uploadChunk();
-                            currentChunk = Buffer.from('');
-                            currentChunkSize = 0;
-                        } else if(chunkSize + currentChunkSize > client.CHUNK_SIZE) {
-                            // Upload chunk, put rest into next chunk
-                            const bytesToUpload = client.CHUNK_SIZE - currentChunkSize;
-                            const newChunkSection = chunk.slice(0, bytesToUpload);
-                            currentChunk = Buffer.concat([currentChunk, newChunkSection]);
-                            currentChunkSize = Buffer.byteLength(currentChunk);
-                            await uploadChunk();
-                            currentChunk = chunk.slice(bytesToUpload, undefined);
-                            currentChunkSize = chunkSize - bytesToUpload;
-                        } else {
-                            // Append into current chunk
-                            currentChunk = Buffer.concat([currentChunk, chunk]);
-                            currentChunkSize = chunkSize + currentChunkSize;
-                        }
-                    }
-
-                    callback();
-                } catch (e) {
-                    callback(e);
+            uploadableChunk = new Uint8Array(client.CHUNK_SIZE);
+            currentChunk++;
+            currentPosition = 0;
+        }
+
+        for await (const chunk of file.stream) {
+            for(const b of chunk) {
+                uploadableChunk[currentPosition] = b;
+
+                currentPosition++;
+                if(currentPosition >= client.CHUNK_SIZE) {
+                    await uploadChunk();
+                    currentPosition = 0;
                 }
             }
+        }
 
-            writeStream.on("finish", async () => {
-                if(currentChunkSize > 0) {
-                    try {
-                        await uploadChunk(true);
-                    } catch (e) {
-                        reject(e);
-                    }
-                }
-                
-                resolve(response);
-            });
+        if (currentPosition > 0) { // Check if there's any remaining data for the last chunk
+            await uploadChunk(true);
+        }
 
-            writeStream.on("error", (err) => {
-                reject(err);
-            });
-            
-            file.stream.pipe(writeStream);
-        });
+        return response;
 
     }
 
@@ -593,7 +557,7 @@ class Storage extends Service {
      * @param {string} fileId
      * @param {number} width
      * @param {number} height
-     * @param {string} gravity
+     * @param {ImageGravity} gravity
      * @param {number} quality
      * @param {number} borderWidth
      * @param {string} borderColor
@@ -601,7 +565,7 @@ class Storage extends Service {
      * @param {number} opacity
      * @param {number} rotation
      * @param {string} background
-     * @param {string} output
+     * @param {ImageFormat} output
      * @throws {AppwriteException}
      * @returns {Promise}
      */

package/lib/services/teams.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 Teams extends Service {
 

package/lib/services/users.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 Users extends Service {
 
@@ -197,7 +199,7 @@ class Users extends Service {
      *
      * Get identities for all users.
      *
-     * @param {string} queries
+     * @param {string[]} queries
      * @param {string} search
      * @throws {AppwriteException}
      * @returns {Promise}
@@ -220,7 +222,7 @@ class Users extends Service {
     }
 
     /**
-     * Delete Identity
+     * Delete identity
      *
      * Delete an identity by its unique ID.
      *
@@ -533,7 +535,7 @@ class Users extends Service {
      * @param {string} userId
      * @param {string} email
      * @param {string} password
-     * @param {string} passwordVersion
+     * @param {PasswordHash} passwordVersion
      * @param {string} name
      * @throws {AppwriteException}
      * @returns {Promise}
@@ -744,6 +746,161 @@ class Users extends Service {
         }, payload);
     }
 
+    /**
+     * Update MFA
+     *
+     * Enable or disable MFA on a user account.
+     *
+     * @param {string} userId
+     * @param {boolean} mfa
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMfa(userId, mfa) {
+        const apiPath = '/users/{userId}/mfa'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        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);
+    }
+
+    /**
+     * Delete Authenticator
+     *
+     * Delete an authenticator app.
+     *
+     * @param {string} userId
+     * @param {AuthenticatorType} type
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async deleteMfaAuthenticator(userId, type) {
+        const apiPath = '/users/{userId}/mfa/authenticators/{type}'.replace('{userId}', userId).replace('{type}', type);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof type === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "type"');
+        }
+
+
+        return await this.client.call('delete', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * List Factors
+     *
+     * List the factors available on the account to be used as a MFA challange.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async listMfaFactors(userId) {
+        const apiPath = '/users/{userId}/mfa/factors'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        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 by User ID.
+     * Before getting codes, they must be generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async getMfaRecoveryCodes(userId) {
+        const apiPath = '/users/{userId}/mfa/recovery-codes'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        return await this.client.call('get', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Regenerate MFA Recovery Codes
+     *
+     * Regenerate recovery codes that can be used as backup for MFA flow by User
+     * ID. Before regenerating codes, they must be first generated using
+     * [createMfaRecoveryCodes](/docs/references/cloud/client-web/account#createMfaRecoveryCodes)
+     * method.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateMfaRecoveryCodes(userId) {
+        const apiPath = '/users/{userId}/mfa/recovery-codes'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        return await this.client.call('put', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create MFA Recovery Codes
+     *
+     * Generate recovery codes used as backup for MFA flow for User ID. Recovery
+     * codes can be used as a MFA verification type in
+     * [createMfaChallenge](/docs/references/cloud/client-web/account#createMfaChallenge)
+     * method by client SDK.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createMfaRecoveryCodes(userId) {
+        const apiPath = '/users/{userId}/mfa/recovery-codes'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        return await this.client.call('patch', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Update name
      *
@@ -914,6 +1071,33 @@ class Users extends Service {
         }, payload);
     }
 
+    /**
+     * Create session
+     *
+     * Creates a session for a user. Returns an immediately usable session object.
+     * 
+     * If you want to generate a token for a custom authentication flow, use the
+     * [POST
+     * /users/{userId}/tokens](https://appwrite.io/docs/server/users#createToken)
+     * endpoint.
+     *
+     * @param {string} userId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createSession(userId) {
+        const apiPath = '/users/{userId}/sessions'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Delete user sessions
      *
@@ -995,6 +1179,224 @@ class Users extends Service {
         }, payload);
     }
 
+    /**
+     * List User Targets
+     *
+     * List the messaging targets that are associated with a user.
+     *
+     * @param {string} userId
+     * @param {string[]} queries
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async listTargets(userId, queries) {
+        const apiPath = '/users/{userId}/targets'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        if (typeof queries !== 'undefined') {
+            payload['queries'] = queries;
+        }
+
+        return await this.client.call('get', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create User Target
+     *
+     * Create a messaging target.
+     *
+     * @param {string} userId
+     * @param {string} targetId
+     * @param {MessagingProviderType} providerType
+     * @param {string} identifier
+     * @param {string} providerId
+     * @param {string} name
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createTarget(userId, targetId, providerType, identifier, providerId, name) {
+        const apiPath = '/users/{userId}/targets'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+        if (typeof providerType === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "providerType"');
+        }
+
+        if (typeof identifier === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "identifier"');
+        }
+
+
+        if (typeof targetId !== 'undefined') {
+            payload['targetId'] = targetId;
+        }
+
+        if (typeof providerType !== 'undefined') {
+            payload['providerType'] = providerType;
+        }
+
+        if (typeof identifier !== 'undefined') {
+            payload['identifier'] = identifier;
+        }
+
+        if (typeof providerId !== 'undefined') {
+            payload['providerId'] = providerId;
+        }
+
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Get User Target
+     *
+     * Get a user's push notification target by ID.
+     *
+     * @param {string} userId
+     * @param {string} targetId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async getTarget(userId, targetId) {
+        const apiPath = '/users/{userId}/targets/{targetId}'.replace('{userId}', userId).replace('{targetId}', targetId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+
+        return await this.client.call('get', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Update User target
+     *
+     * Update a messaging target.
+     *
+     * @param {string} userId
+     * @param {string} targetId
+     * @param {string} identifier
+     * @param {string} providerId
+     * @param {string} name
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updateTarget(userId, targetId, identifier, providerId, name) {
+        const apiPath = '/users/{userId}/targets/{targetId}'.replace('{userId}', userId).replace('{targetId}', targetId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+
+        if (typeof identifier !== 'undefined') {
+            payload['identifier'] = identifier;
+        }
+
+        if (typeof providerId !== 'undefined') {
+            payload['providerId'] = providerId;
+        }
+
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+
+        return await this.client.call('patch', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Delete user target
+     *
+     * Delete a messaging target.
+     *
+     * @param {string} userId
+     * @param {string} targetId
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async deleteTarget(userId, targetId) {
+        const apiPath = '/users/{userId}/targets/{targetId}'.replace('{userId}', userId).replace('{targetId}', targetId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof targetId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "targetId"');
+        }
+
+
+        return await this.client.call('delete', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
+    /**
+     * Create token
+     *
+     * Returns a token 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 [PUT
+     * /account/sessions/custom](https://appwrite.io/docs/references/cloud/client-web/account#updateCustomSession)
+     * endpoint to complete the login process.
+     *
+     * @param {string} userId
+     * @param {number} length
+     * @param {number} expire
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async createToken(userId, length, expire) {
+        const apiPath = '/users/{userId}/tokens'.replace('{userId}', userId);
+        let payload = {};
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+
+        if (typeof length !== 'undefined') {
+            payload['length'] = length;
+        }
+
+        if (typeof expire !== 'undefined') {
+            payload['expire'] = expire;
+        }
+
+        return await this.client.call('post', apiPath, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Update email verification
      *