node-appwrite 6.0.0 → 7.0.2

package/lib/services/functions.js

@@ -1,6 +1,8 @@
 const Service = require('../service.js');
 const AppwriteException = require('../exception.js');
+const InputFile = require('../inputFile.js');
 const client = require('../client.js');
+const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
 
@@ -319,7 +321,7 @@ class Functions extends Service {
      *
      * @param {string} functionId
      * @param {string} entrypoint
-     * @param {string} code
+     * @param {InputFile} code
      * @param {boolean} activate
      * @throws {AppwriteException}
      * @returns {Promise}
@@ -349,68 +351,124 @@ class Functions extends Service {
         }
 
         if (typeof code !== 'undefined') {
-            payload['code'] = code.toString();
+            payload['code'] = code;
         }
 
         if (typeof activate !== 'undefined') {
             payload['activate'] = activate.toString();
         }
 
-        const { size: size } = await promisify(fs.stat)(code);
+        const size = code.size;
 
-        if (size <= client.CHUNK_SIZE) {
-            payload['code'] = fs.createReadStream(code);
-                
-            return await this.client.call('post', path, {
-                'content-type': 'multipart/form-data',
-            }, payload);
-        } else {
-            let id = undefined;
-            let response = undefined;
+        const headers = {
+            'content-type': 'multipart/form-data',
+        };
+
+        let id = undefined;
+        let response = undefined;
 
-            let counter = 0;
-            const totalCounters = Math.ceil(size / client.CHUNK_SIZE);
+        let chunksUploaded = 0;
 
-            const headers = {
-                'content-type': 'multipart/form-data',
-            };
 
+        let currentChunk = Buffer.from('');
+        let currentChunkSize = 0;
+        let currentChunkStart = 0;
 
-            for (counter; counter < totalCounters; counter++) {
-                const start = (counter * client.CHUNK_SIZE);
-                const end = Math.min((((counter * client.CHUNK_SIZE) + client.CHUNK_SIZE) - 1), size);
+        const selfClient = this.client;
 
+        async function uploadChunk(lastUpload = false) {
+            if(chunksUploaded - 1 >= currentChunkStart / client.CHUNK_SIZE) {
+                return;
+            }
+            
+            const start = currentChunkStart;
+            const end = Math.min(((start + client.CHUNK_SIZE) - 1), size);
+
+            if(!lastUpload || currentChunkStart !== 0) {
                 headers['content-range'] = 'bytes ' + start + '-' + end + '/' + size;
+            }
 
-                if (id) {
-                    headers['x-appwrite-id'] = id;
-                }
+            if (id) {
+                headers['x-appwrite-id'] = id;
+            }
+
+            const stream = Stream.Readable.from(currentChunk);
+            payload['code'] = { type: 'file', file: stream, filename: code.filename };
 
-                const stream = fs.createReadStream(code, {
-                    start,
-                    end
+            response = await selfClient.call('post', path, headers, 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,
+                    sizeUploaded: end+1,
+                    chunksTotal: response['chunksTotal'],
+                    chunksUploaded: response['chunksUploaded']
                 });
-                payload['code'] = stream;
+            }
+
+            currentChunkStart += client.CHUNK_SIZE;
+        }
 
-                response = await this.client.call('post', path, headers, payload);
+        return await new Promise((resolve, reject) => {
+            const writeStream = new Stream.Writable();
+            writeStream._write = async (mainChunk, encoding, next) => {
+                // Segment incoming chunk into up to 5MB chunks
+                const mainChunkSize = Buffer.byteLength(mainChunk);
+                const chunksCount = Math.ceil(mainChunkSize / client.CHUNK_SIZE);
+                const chunks = [];
 
-                if (!id) {
-                    id = response['$id'];
+                for(let i = 0; i < chunksCount; i++) {
+                    const chunk = mainChunk.slice(i * client.CHUNK_SIZE, client.CHUNK_SIZE);
+                    chunks.push(chunk);
                 }
-                
-                if (onProgress !== null) {
-                    onProgress({
-                        $id: response['$id'],
-                        progress: Math.min((counter+1) * client.CHUNK_SIZE, size) / size * 100,
-                        sizeUploaded: end+1,
-                        chunksTotal: response['chunksTotal'],
-                        chunksUploaded: response['chunksUploaded']
-                    });
+
+                for (const chunk of chunks) {
+                    const chunkSize = Buffer.byteLength(chunk);
+
+                    if(chunkSize + currentChunkSize == client.CHUNK_SIZE) {
+                        // Upload chunk
+                        currentChunk = Buffer.concat([currentChunk, chunk]);
+                        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;
+                    }
                 }
+
+                next();
             }
 
-            return response;
-        }
+            writeStream.on("finish", async () => {
+                if(currentChunkSize > 0) {
+                    await uploadChunk(true);
+                }
+                
+                resolve(response);
+            });
+
+            writeStream.on("error", (err) => {
+                reject(err);
+            });
+            
+            code.stream.pipe(writeStream);
+        });
     }
 
     /**

package/lib/services/health.js

@@ -1,6 +1,8 @@
 const Service = require('../service.js');
 const AppwriteException = require('../exception.js');
+const InputFile = require('../inputFile.js');
 const client = require('../client.js');
+const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
 

package/lib/services/locale.js

@@ -1,6 +1,8 @@
 const Service = require('../service.js');
 const AppwriteException = require('../exception.js');
+const InputFile = require('../inputFile.js');
 const client = require('../client.js');
+const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
 

package/lib/services/storage.js

@@ -1,6 +1,8 @@
 const Service = require('../service.js');
 const AppwriteException = require('../exception.js');
+const InputFile = require('../inputFile.js');
 const client = require('../client.js');
+const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
 
@@ -331,7 +333,7 @@ class Storage extends Service {
      *
      * @param {string} bucketId
      * @param {string} fileId
-     * @param {string} file
+     * @param {InputFile} file
      * @param {string[]} read
      * @param {string[]} write
      * @throws {AppwriteException}
@@ -358,7 +360,7 @@ class Storage extends Service {
         }
 
         if (typeof file !== 'undefined') {
-            payload['file'] = file.toString();
+            payload['file'] = file;
         }
 
         if (typeof read !== 'undefined') {
@@ -369,68 +371,124 @@ class Storage extends Service {
             payload['write'] = write;
         }
 
-        const { size: size } = await promisify(fs.stat)(file);
+        const size = file.size;
 
-        if (size <= client.CHUNK_SIZE) {
-            payload['file'] = fs.createReadStream(file);
-                
-            return await this.client.call('post', path, {
-                'content-type': 'multipart/form-data',
-            }, payload);
-        } else {
-            let id = undefined;
-            let response = undefined;
-
-            let counter = 0;
-            const totalCounters = Math.ceil(size / client.CHUNK_SIZE);
-
-            const headers = {
-                'content-type': 'multipart/form-data',
-            };
-
-            if(fileId != 'unique()') {
-                try {
-                    response = await this.client.call('get', path + '/' + fileId, headers);
-                    counter = response.chunksUploaded;
-                } catch(e) {
-                }
+        const headers = {
+            'content-type': 'multipart/form-data',
+        };
+
+        let id = undefined;
+        let response = undefined;
+
+        let chunksUploaded = 0;
+
+        if(fileId != 'unique()') {
+            try {
+                response = await this.client.call('get', path + '/' + fileId, headers);
+                chunksUploaded = response.chunksUploaded;
+            } catch(e) {
             }
+        }
 
-            for (counter; counter < totalCounters; counter++) {
-                const start = (counter * client.CHUNK_SIZE);
-                const end = Math.min((((counter * client.CHUNK_SIZE) + client.CHUNK_SIZE) - 1), size);
+        let currentChunk = Buffer.from('');
+        let currentChunkSize = 0;
+        let currentChunkStart = 0;
 
+        const selfClient = this.client;
+
+        async function uploadChunk(lastUpload = false) {
+            if(chunksUploaded - 1 >= currentChunkStart / client.CHUNK_SIZE) {
+                return;
+            }
+            
+            const start = currentChunkStart;
+            const end = Math.min(((start + client.CHUNK_SIZE) - 1), size);
+
+            if(!lastUpload || currentChunkStart !== 0) {
                 headers['content-range'] = 'bytes ' + start + '-' + end + '/' + size;
+            }
 
-                if (id) {
-                    headers['x-appwrite-id'] = id;
-                }
+            if (id) {
+                headers['x-appwrite-id'] = id;
+            }
 
-                const stream = fs.createReadStream(file, {
-                    start,
-                    end
+            const stream = Stream.Readable.from(currentChunk);
+            payload['file'] = { type: 'file', file: stream, filename: file.filename };
+
+            response = await selfClient.call('post', path, headers, 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,
+                    sizeUploaded: end+1,
+                    chunksTotal: response['chunksTotal'],
+                    chunksUploaded: response['chunksUploaded']
                 });
-                payload['file'] = stream;
+            }
+
+            currentChunkStart += client.CHUNK_SIZE;
+        }
 
-                response = await this.client.call('post', path, headers, payload);
+        return await new Promise((resolve, reject) => {
+            const writeStream = new Stream.Writable();
+            writeStream._write = async (mainChunk, encoding, next) => {
+                // Segment incoming chunk into up to 5MB chunks
+                const mainChunkSize = Buffer.byteLength(mainChunk);
+                const chunksCount = Math.ceil(mainChunkSize / client.CHUNK_SIZE);
+                const chunks = [];
 
-                if (!id) {
-                    id = response['$id'];
+                for(let i = 0; i < chunksCount; i++) {
+                    const chunk = mainChunk.slice(i * client.CHUNK_SIZE, client.CHUNK_SIZE);
+                    chunks.push(chunk);
                 }
-                
-                if (onProgress !== null) {
-                    onProgress({
-                        $id: response['$id'],
-                        progress: Math.min((counter+1) * client.CHUNK_SIZE, size) / size * 100,
-                        sizeUploaded: end+1,
-                        chunksTotal: response['chunksTotal'],
-                        chunksUploaded: response['chunksUploaded']
-                    });
+
+                for (const chunk of chunks) {
+                    const chunkSize = Buffer.byteLength(chunk);
+
+                    if(chunkSize + currentChunkSize == client.CHUNK_SIZE) {
+                        // Upload chunk
+                        currentChunk = Buffer.concat([currentChunk, chunk]);
+                        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;
+                    }
                 }
+
+                next();
             }
 
-            return response;
-        }
+            writeStream.on("finish", async () => {
+                if(currentChunkSize > 0) {
+                    await uploadChunk(true);
+                }
+                
+                resolve(response);
+            });
+
+            writeStream.on("error", (err) => {
+                reject(err);
+            });
+            
+            file.stream.pipe(writeStream);
+        });
     }
 
     /**

package/lib/services/teams.js

@@ -1,6 +1,8 @@
 const Service = require('../service.js');
 const AppwriteException = require('../exception.js');
+const InputFile = require('../inputFile.js');
 const client = require('../client.js');
+const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
 

package/lib/services/users.js

@@ -1,6 +1,8 @@
 const Service = require('../service.js');
 const AppwriteException = require('../exception.js');
+const InputFile = require('../inputFile.js');
 const client = require('../client.js');
+const Stream = require('stream');
 const { promisify } = require('util');
 const fs = require('fs');
 
@@ -298,6 +300,37 @@ class Users extends Service {
         }, payload);
     }
 
+    /**
+     * Update Phone
+     *
+     * Update the user phone by its unique ID.
+     *
+     * @param {string} userId
+     * @param {string} number
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updatePhone(userId, number) {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof number === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "number"');
+        }
+
+        let path = '/users/{userId}/phone'.replace('{userId}', userId);
+        let payload = {};
+
+        if (typeof number !== 'undefined') {
+            payload['number'] = number;
+        }
+
+        return await this.client.call('patch', path, {
+            'content-type': 'application/json',
+        }, payload);
+    }
+
     /**
      * Get User Preferences
      *
@@ -466,7 +499,7 @@ class Users extends Service {
      * @throws {AppwriteException}
      * @returns {Promise}
      */
-    async updateVerification(userId, emailVerification) {
+    async updateEmailVerification(userId, emailVerification) {
         if (typeof userId === 'undefined') {
             throw new AppwriteException('Missing required parameter: "userId"');
         }
@@ -486,6 +519,37 @@ class Users extends Service {
             'content-type': 'application/json',
         }, payload);
     }
+
+    /**
+     * Update Phone Verification
+     *
+     * Update the user phone verification status by its unique ID.
+     *
+     * @param {string} userId
+     * @param {boolean} phoneVerification
+     * @throws {AppwriteException}
+     * @returns {Promise}
+     */
+    async updatePhoneVerification(userId, phoneVerification) {
+        if (typeof userId === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "userId"');
+        }
+
+        if (typeof phoneVerification === 'undefined') {
+            throw new AppwriteException('Missing required parameter: "phoneVerification"');
+        }
+
+        let path = '/users/{userId}/verification/phone'.replace('{userId}', userId);
+        let payload = {};
+
+        if (typeof phoneVerification !== 'undefined') {
+            payload['phoneVerification'] = phoneVerification;
+        }
+
+        return await this.client.call('patch', path, {
+            'content-type': 'application/json',
+        }, payload);
+    }
 }
 
 module.exports = Users;

package/package.json

@@ -2,7 +2,7 @@
   "name": "node-appwrite",
   "homepage": "https://appwrite.io/support",
   "description": "Appwrite is an open-source self-hosted backend server that abstract and simplify complex and repetitive development tasks behind a very simple REST API",
-  "version": "6.0.0",
+  "version": "7.0.2",
   "license": "BSD-3-Clause",
   "main": "./index.js",
   "types": "./index.d.ts",

package/docs/examples/database/get-document.md

@@ -1,20 +0,0 @@
-const sdk = require('node-appwrite');
-
-// Init SDK
-let client = new sdk.Client();
-
-let database = new sdk.Database(client);
-
-client
-    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
-    .setProject('5df5acd0d48c2') // Your project ID
-    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
-;
-
-let promise = database.getDocument('[COLLECTION_ID]', '[DOCUMENT_ID]');
-
-promise.then(function (response) {
-    console.log(response);
-}, function (error) {
-    console.log(error);
-});

package/docs/examples/users/update-verification.md

@@ -1,20 +0,0 @@
-const sdk = require('node-appwrite');
-
-// Init SDK
-let client = new sdk.Client();
-
-let users = new sdk.Users(client);
-
-client
-    .setEndpoint('https://[HOSTNAME_OR_IP]/v1') // Your API Endpoint
-    .setProject('5df5acd0d48c2') // Your project ID
-    .setKey('919c2d18fb5d4...a2ae413da83346ad2') // Your secret API key
-;
-
-let promise = users.updateVerification('[USER_ID]', false);
-
-promise.then(function (response) {
-    console.log(response);
-}, function (error) {
-    console.log(error);
-});