Merge pull request #725 from appwrite/feat-ssr

feat: ssr

Author: abnegate

.github/workflows/tests.yml

@@ -13,7 +13,7 @@ jobs:
       fail-fast: false
       matrix:
         php-version: ['8.1']
-        sdk: [Android11Java8, Android11Java11, Android12Java8, Android12Java11, CLINode16, CLINode18, DartBeta, DartStable, Deno1193, Deno1303, DotNet60, DotNet70, FlutterStable, FlutterBeta, Go112, Go118, KotlinJava8, KotlinJava11, KotlinJava17, Node12, Node14, Node16, PHP74, PHP80, Python38, Python39, Python310, Ruby27, Ruby30, Ruby31, AppleSwift55, Swift55, WebChromium, WebNode]
+        sdk: [Android11Java8, Android11Java11, Android12Java8, Android12Java11, CLINode16, CLINode18, DartBeta, DartStable, Deno1193, Deno1303, DotNet60, DotNet70, FlutterStable, FlutterBeta, Go112, Go118, KotlinJava8, KotlinJava11, KotlinJava17, Node16, Node18, Node20, PHP74, PHP80, Python38, Python39, Python310, Ruby27, Ruby30, Ruby31, AppleSwift55, Swift55, WebChromium, WebNode]
 
     steps:
       - name: Checkout repository

templates/deno/src/client.ts.twig

@@ -61,78 +61,79 @@ export class Client {
         return this;
     }
 
-    withoutHeader(key: string, headers: Payload): Payload {
-        return Object.keys(headers).reduce((acc: Payload, cv: string) => {
-            if (cv === 'content-type') return acc;
-            acc[cv] = headers[cv];
-            return acc;
-        }, {})
-    }
+    async call(method: string, path: string = "", headers: Payload = {}, params: Payload = {}, responseType: string = "json") {
+        headers = {...this.headers, ...headers};
+        const url = new URL(this.endpoint + path);
 
-    async call(method: string, path: string = '', headers: Payload = {}, params: Payload = {}) {
-        headers = Object.assign({}, this.headers, headers);
+        let body: string | FormData | undefined = undefined;
 
-        let body;
-        const url = new URL(this.endpoint + path);
-        if (method.toUpperCase() === 'GET') {
-            url.search = new URLSearchParams(this.flatten(params)).toString();
-            body = null;
-        } else if (headers['content-type'].toLowerCase().startsWith('multipart/form-data')) {
-            headers = this.withoutHeader('content-type', headers);
+        if (method.toUpperCase() === "GET") {
+            url.search = new URLSearchParams(Client.flatten(params)).toString();
+        } else if (headers["content-type"]?.toLowerCase().startsWith("multipart/form-data")) {
+            delete headers["content-type"];
             const formData = new FormData();
-            const flatParams = this.flatten(params);
-            for (const key in flatParams) {
-                const value = flatParams[key];
 
-                if(value && value.type && value.type === 'file') {
+            const flatParams = Client.flatten(params);
+
+            for (const [key, value] of Object.entries(flatParams)) {
+                if (value && value.type && value.type === "file") {
                     formData.append(key, value.file, value.filename);
                 } else {
-                    formData.append(key, flatParams[key]);
+                    formData.append(key, value);
                 }
             }
+
             body = formData;
         } else {
             body = JSON.stringify(params);
         }
 
-        const options = {
-            method: method.toUpperCase(),
-            headers: headers,
-            body: body,
-        };
-
+        let response = undefined;
         try {
-            let response = await fetch(url.toString(), options);
-            const contentType = response.headers.get('content-type');
-
-            if (contentType && contentType.includes('application/json')) {
-                if (response.status >= 400) {
-                    let res = await response.json();
-                    throw new {{ spec.title | caseUcfirst}}Exception(res.message, res.status, res.type ?? "", res);
-                }
+            response = await fetch(url.toString(), {
+                method: method.toUpperCase(),
+                headers,
+                body
+            });
+        } catch (error) {
+            throw new {{spec.title | caseUcfirst}}Exception(error.message);
+        }
 
-                return response.json();
-            } else {
-                if (response.status >= 400) {
-                    let res = await response.text();
-                    throw new {{ spec.title | caseUcfirst}}Exception(res, response.status, "", null);
-                }
-                return response;
+        if (response.status >= 400) {
+            const text = await response.text();
+            let json = undefined;
+            try {
+                json = JSON.parse(text);
+            } catch (error) {
+                throw new {{spec.title | caseUcfirst}}Exception(text, response.status, "", text);
             }
-        } catch(error) {
-            throw new {{ spec.title | caseUcfirst}}Exception(error?.response?.message || error.message, error?.response?.code, error?.response?.type, error.response);
+            throw new {{spec.title | caseUcfirst}}Exception(json.message, json.code, json.type, json);
+        }
+
+        if (responseType === "arraybuffer") {
+            const data = await response.arrayBuffer();
+            return data;
+        }
+
+        const text = await response.text();
+        let json = undefined;
+        try {
+            json = JSON.parse(text);
+        } catch (error) {
+            return text;
         }
+        return json;
     }
 
-    flatten(data: Payload, prefix = '') {
+    static flatten(data: Payload, prefix = '') {
         let output: Payload = {};
 
         for (const key in data) {
             let value = data[key];
             let finalKey = prefix ? prefix + '[' + key +']' : key;
 
             if (Array.isArray(value)) {
-                output = { ...output, ...this.flatten(value, finalKey) }; // @todo: handle name collision here if needed
+                output = { ...output, ...Client.flatten(value, finalKey) }; // @todo: handle name collision here if needed
             }
             else {
                 output[finalKey] = value;

templates/deno/src/inputFile.ts.twig

@@ -19,6 +19,12 @@ export class InputFile {
         return new InputFile(stream, filename, size);
     };
 
+    static fromBlob = async (blob: Blob, filename: string) => {
+        const arrayBuffer = await blob.arrayBuffer();
+        const buffer = new Uint8Array(arrayBuffer);
+        return InputFile.fromBuffer(buffer, filename);
+    };
+
     static fromBuffer = (buffer: Uint8Array, filename: string): InputFile => {
         const stream = _bufferToString(buffer);
         const size = buffer.byteLength;

templates/node/base/requests/file.twig

@@ -1,7 +1,8 @@
 {% for parameter in method.parameters.all %}
 {% if parameter.type == 'file' %}
-        const size = {{ parameter.name | caseCamel | escapeKeyword }}.size;
 
+        const size = {{ parameter.name | caseCamel | escapeKeyword }}.size;
+        
         const apiHeaders = {
 {% for parameter in method.parameters.header %}
             '{{ parameter.name }}': ${{ parameter.name | caseCamel | escapeKeyword }},
@@ -28,117 +29,77 @@
 {% endif %}
 {% endfor %}
 
-        let currentChunk = Buffer.from('');
-        let currentChunkSize = 0;
-        let currentChunkStart = 0;
+        let currentChunk = 1;
+        let currentPosition = 0;
+        let uploadableChunk = new Uint8Array(client.CHUNK_SIZE);
+    
 
-        const selfClient = this.client;
-
-        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-{{spec.title | caseLower }}-id'] = id;
             }
 
-            payload['{{ parameter.name }}'] = {
-                type: 'file',
-                file: currentChunk,
-                filename: {{ parameter.name }}.filename,
-                size: currentChunkSize
-            };
+            payload['{{ parameter.name }}'] = { type: 'file', file: new File([uploadableChunkTrimmed], {{ parameter.name | caseCamel | escapeKeyword }}.filename), filename: {{ parameter.name | caseCamel | escapeKeyword }}.filename };
 
-            response = await selfClient.call('{{ method.method | caseLower }}', apiPath, apiHeaders, payload{% if method.type == 'location' %}, 'arraybuffer'{% endif %});
+            response = await this.client.call('{{ method.method | caseLower }}', apiPath, apiHeaders, payload{% if method.type == 'location' %}, 'arraybuffer'{% endif %});
 
             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;
+            uploadableChunk = new Uint8Array(client.CHUNK_SIZE);
+            currentChunk++;
+            currentPosition = 0;
         }
 
-        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);
+        for await (const chunk of {{ parameter.name | caseCamel | escapeKeyword }}.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);
-            });
-            
-            {{ parameter.name | caseCamel | escapeKeyword }}.stream.pipe(writeStream);
-        });
+        return response;
 {% endif %}
 {% endfor %}

templates/node/index.d.ts.twig

@@ -250,7 +250,7 @@ declare module "{{ language.params.npmPackage|caseDash }}" {
      * @throws {{ '{' }}{{ spec.title | caseUcfirst}}Exception}
      * @returns {Promise}
      */
-    {{ method.name | caseCamel }}{% if generics %}<{{generics}}>{% endif %}({% for parameter in method.parameters.all %}{{ parameter.name | caseCamel | escapeKeyword }}{% if not parameter.required or parameter.nullable %}?{% endif %}: {{ parameter | typeName }}{% if not loop.last %}, {% endif %}{% endfor %}): Promise<{% if method.type == 'location' %}Buffer{% else %}{% if method.responseModel and method.responseModel != 'any' %}{% if not spec.definitions[method.responseModel].additionalProperties %}Models.{% endif %}{{method.responseModel | caseUcfirst}}{% if generics_return %}<{{generics_return}}>{% endif %}{% else %}{% if method.method == 'delete' %}string{% else %}any{% endif %}{% endif %}{% endif %}>;
+    {{ method.name | caseCamel }}{% if generics %}<{{generics}}>{% endif %}({% for parameter in method.parameters.all %}{{ parameter.name | caseCamel | escapeKeyword }}{% if not parameter.required or parameter.nullable %}?{% endif %}: {{ parameter | typeName }}{% if not loop.last %}, {% endif %}{% endfor %}): Promise<{% if method.type == 'location' %}ArrayBuffer{% else %}{% if method.responseModel and method.responseModel != 'any' %}{% if not spec.definitions[method.responseModel].additionalProperties %}Models.{% endif %}{{method.responseModel | caseUcfirst}}{% if generics_return %}<{{generics_return}}>{% endif %}{% else %}{% if method.method == 'delete' %}string{% else %}any{% endif %}{% endif %}{% endif %}>;
 {% endfor %}
   }
 {% endfor %}