mosquito-transport-js 0.3.1 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Javascript web sdk for mosquito-transport (https://github.com/deflexable/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -32,9 +32,9 @@
     "bson": "^6.8.0",
     "buffer": "^6.0.3",
     "crypto-js": "^4.2.0",
+    "entity-serializer": "^1.0.0",
     "guard-object": "^1.1.3",
     "limit-task": "1.0.0",
-    "json-buffer": "^3.0.1",
     "lodash.clonedeep": "^4.5.0",
     "lodash.get": "^4.4.2",
     "lodash.set": "^4.3.2",
@@ -57,4 +57,4 @@
   "engines": {
     "node": ">=14"
   }
-}
+}

package/src/helpers/peripherals.js

@@ -5,6 +5,7 @@ import Utf8Encoder from 'crypto-js/enc-utf8.js';
 import naclPkg from 'tweetnacl-functional';
 import getLodash from "lodash.get";
 import e2e_worker from "./e2e_worker";
+import { deserialize, serialize } from "entity-serializer";
 
 const { encrypt, decrypt } = aes_pkg;
 const { box, randomBytes } = naclPkg;
@@ -103,52 +104,52 @@ export const decryptString = (txt, password, iv) => {
     return decrypt(txt, `${password || ''}${iv || ''}`).toString(Utf8Encoder);
 };
 
-export const serializeE2E = (data, auth_token, serverPublicKey) => {
-    const inputData = new Uint8Array(Buffer.from(JSON.stringify([data, auth_token]), 'utf8'));
+export const serializeE2E = async (data, auth_token, serverPublicKey) => {
+    const inputData = serialize([data, auth_token]);
 
     if (inputData.byteLength > 10240) {
         // dispatch to background thread
-        const { data, pair, nonce } = e2e_worker.encrypt(inputData, serverPublicKey);
-        const pubBase64 = Buffer.from(pair.publicKey).toString('base64'),
-            nonceBase64 = Buffer.from(nonce).toString('base64');
+        const { data, pair, nonce } = await e2e_worker.encrypt(inputData, serverPublicKey);
 
         return [
-            `${pubBase64}.${nonceBase64}.${Buffer.from(data).toString('base64')}`,
+            serialize([pair.publicKey, nonce, data]),
             [pair.secretKey, pair.publicKey]
         ];
     }
 
     const pair = box.keyPair(),
-        nonce = randomBytes(box.nonceLength),
-        pubBase64 = Buffer.from(pair.publicKey).toString('base64'),
-        nonceBase64 = Buffer.from(nonce).toString('base64');
+        nonce = randomBytes(box.nonceLength);
 
     return [
-        `${pubBase64}.${nonceBase64}.${Buffer.from(
-            box(
-                inputData,
-                nonce,
-                serverPublicKey,
-                pair.secretKey
+        serialize([
+            pair.publicKey,
+            nonce,
+            Buffer.from(
+                box(
+                    inputData,
+                    nonce,
+                    serverPublicKey,
+                    pair.secretKey
+                )
             )
-        ).toString('base64')}`,
+        ]),
         [pair.secretKey, pair.publicKey]
     ];
 };
 
-export const deserializeE2E = (data = '', serverPublicKey, clientPrivateKey) => {
-    const [binaryNonce, binaryData] = data.split('.').map(v => new Uint8Array(Buffer.from(v, 'base64')));
+export const deserializeE2E = async (data, serverPublicKey, clientPrivateKey) => {
+    const [binaryNonce, binaryData] = deserialize(data);
     let baseArray;
 
     if (binaryData.byteLength > 10240) {
         // dispatch to background thread
-        baseArray = e2e_worker.decrypt(binaryData, binaryNonce, serverPublicKey, clientPrivateKey);
+        baseArray = await e2e_worker.decrypt(binaryData, binaryNonce, serverPublicKey, clientPrivateKey);
     } else {
         baseArray = box.open(binaryData, binaryNonce, serverPublicKey, clientPrivateKey);
     }
 
     if (!baseArray) throw 'Decrypting e2e message failed';
-    return JSON.parse(Buffer.from(baseArray).toString('utf8'))[0];
+    return deserialize(baseArray);
 };
 
 export const encodeBinary = (s) => Buffer.from(s, 'utf8').toString('base64');

package/src/helpers/utils.js

@@ -4,6 +4,7 @@ import { CacheStore, Scoped } from "./variables";
 import { decryptString, encryptString, serializeE2E } from "./peripherals";
 import { deserializeBSON, serializeToBase64 } from "../products/database/bson";
 import { trySendPendingWrite } from "../products/database";
+import { deserialize } from "entity-serializer";
 
 export const updateCacheStore = (timer = 300) => {
     try { window } catch (_) { return; }
@@ -116,18 +117,29 @@ export const getReachableServer = (projectUrl) => new Promise(resolve => {
     }, true);
 });
 
-export const buildFetchInterface = ({ body, accessKey, authToken, method, uglify, serverE2E_PublicKey }) => {
+export const buildFetchInterface = async ({ body, accessKey, authToken, method, uglify, serverE2E_PublicKey }) => {
     if (!uglify) body = JSON.stringify({ ...body });
-    const [plate, keyPair] = uglify ? serializeE2E(body, authToken, serverE2E_PublicKey) : [undefined, []];
+    const [plate, keyPair] = uglify ? await serializeE2E(body, authToken, serverE2E_PublicKey) : [undefined, []];
 
     return [{
         body: uglify ? plate : body,
         cache: 'no-cache',
         headers: {
-            'Content-type': uglify ? 'text/plain' : 'application/json',
+            'Content-type': uglify ? 'request/buffer' : 'application/json',
             'Authorization': accessKey,
             ...((authToken && !uglify) ? { 'Mosquito-Token': authToken } : {})
         },
         method: method || 'POST'
     }, keyPair];
+};
+
+export const buildFetchResult = async (fetchRef, ugly) => {
+    if (ugly) {
+        const [data, simpleError] = deserialize(await fetchRef.arrayBuffer());
+        if (simpleError) throw simpleError;
+        return data;
+    }
+    const json = await fetchRef.json();
+    if (json.simpleError) throw json;
+    return json;
 };

package/src/index.d.ts

@@ -115,7 +115,7 @@ interface MTSocket {
         emitWithAck: (...args: any) => Promise<any>;
     });
     emit: (...args: any) => void;
-    emitWithAck: () => Promise<any>;
+    emitWithAck: (...args: any) => Promise<any>;
     on: (route: string, callback?: () => any) => void;
     once: (route: string, callback?: () => any) => void;
     destroy: () => void;

package/src/index.js

@@ -1,3 +1,4 @@
+import './polyfill';
 import { deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
 import { releaseCacheStore, awaitStore } from "./helpers/utils";
 import { CacheStore, Scoped } from "./helpers/variables";
@@ -11,10 +12,10 @@ import { mfetch } from "./products/http_callable";
 import { io } from "socket.io-client";
 import { AUTH_PROVIDER_ID, CACHE_PROTOCOL } from "./helpers/values";
 import EngineApi from './helpers/engine_api';
-import { parse, stringify } from 'json-buffer';
 import { Validator } from 'guard-object';
 import sendMessage from "./helpers/broadcaster";
 import cloneDeep from "lodash.clonedeep";
+import { Buffer } from "buffer";
 
 const {
     _listenCollection,
@@ -177,7 +178,7 @@ export class MosquitoTransport {
             tokenListener,
             clientPrivateKey;
 
-        const listenerCallback = (route, callback) => function () {
+        const listenerCallback = (route, callback) => async function () {
             if (reservedEventName.includes(route)) {
                 callback?.(...[...arguments]);
                 return;
@@ -187,15 +188,15 @@ export class MosquitoTransport {
             let res;
 
             if (uglify) {
-                res = parse(deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey));
+                res = await deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey);
             } else res = args;
 
-            callback?.(...res || [], ...typeof emitable === 'function' ? [function () {
+            callback?.(...res || [], ...typeof emitable === 'function' ? [async function () {
                 const args = [...arguments];
                 let res;
 
                 if (uglify) {
-                    res = serializeE2E(stringify(args), undefined, serverE2E_PublicKey)[0];
+                    res = (await serializeE2E(args, undefined, serverE2E_PublicKey))[0];
                 } else res = args;
 
                 emitable(res);
@@ -229,26 +230,26 @@ export class MosquitoTransport {
                 const hasEmitable = typeof lastEmit === 'function';
                 const mit = hasEmitable ? emittion.slice(0, -1) : emittion;
 
-                const [reqBuilder, [privateKey]] = uglify ? serializeE2E(stringify(mit), undefined, serverE2E_PublicKey) : [undefined, []];
+                const [reqBuilder, [privateKey]] = uglify ? await serializeE2E(mit, undefined, serverE2E_PublicKey) : [undefined, []];
 
                 if (hasEmitable && promise)
                     throw 'emitWithAck cannot have function in it argument';
 
                 const result = await thisSocket[promise ? 'emitWithAck' : 'emit'](route,
                     uglify ? reqBuilder : mit,
-                    ...hasEmitable ? [function () {
+                    ...hasEmitable ? [async function () {
                         const [args] = [...arguments];
                         let res;
 
                         if (uglify) {
-                            res = parse(deserializeE2E(args, serverE2E_PublicKey, privateKey));
+                            res = await deserializeE2E(args, serverE2E_PublicKey, privateKey);
                         } else res = args;
 
                         lastEmit(...res || []);
                     }] : []
                 );
 
-                resolve((promise && result) ? uglify ? parse(deserializeE2E(result, serverE2E_PublicKey, privateKey))[0] : result[0] : undefined);
+                resolve((promise && result) ? uglify ? (await deserializeE2E(result, serverE2E_PublicKey, privateKey))[0] : result[0] : undefined);
             } catch (e) {
                 reject(e);
             }
@@ -257,7 +258,7 @@ export class MosquitoTransport {
         const init = async () => {
             if (hasCancelled) return;
             const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
-            const [reqBuilder, [privateKey]] = uglify ? serializeE2E({ accessKey, a_extras: authHandshake }, mtoken, serverE2E_PublicKey) : [null, []];
+            const [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ accessKey, a_extras: authHandshake }, mtoken, serverE2E_PublicKey) : [null, []];
 
             socket = io(`${wsPrefix}://${projectUrl.split('://')[1]}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],

package/src/polyfill.js

@@ -0,0 +1,3 @@
+import { Buffer } from "buffer";
+
+if (!globalThis.Buffer) globalThis.Buffer = Buffer;

package/src/products/auth/accessor.js

@@ -81,7 +81,7 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
     try {
         const { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
 
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { token, r_token },
             accessKey,
             uglify,
@@ -96,7 +96,7 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
         }
         if (r.simpleError) throw r;
 
-        const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+        const f = uglify ? await deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
 
         if (CacheStore.AuthStore[projectUrl]) {
             CacheStore.AuthStore[projectUrl].token = f.result.token;

package/src/products/auth/index.js

@@ -1,7 +1,7 @@
 import { io } from "socket.io-client";
 import EngineApi from "../../helpers/engine_api";
 import { TokenRefreshListener } from "../../helpers/listeners";
-import { awaitReachableServer, awaitStore, buildFetchInterface, updateCacheStore } from "../../helpers/utils";
+import { awaitReachableServer, awaitStore, buildFetchInterface, buildFetchResult, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { awaitRefreshToken, initTokenRefresher, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
 import { deserializeE2E, encodeBinary, serializeE2E } from "../../helpers/peripherals";
@@ -61,7 +61,7 @@ export class MTAuth {
             }
             if (processID !== lastInitRef) return;
             const mtoken = Scoped.AuthJWTToken[projectUrl],
-                [reqBuilder, [privateKey]] = uglify ? serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
+                [reqBuilder, [privateKey]] = uglify ? await serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
 
             socket = io(`${wsPrefix}://${baseUrl}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
@@ -74,11 +74,11 @@ export class MTAuth {
 
             socket.emit(_listenUserVerification(uglify));
 
-            socket.on("onVerificationChanged", ([err, verified]) => {
+            socket.on("onVerificationChanged", async ([err, verified]) => {
                 if (err) {
                     onError?.(simplifyCaughtError(err).simpleError);
                 } else {
-                    callback?.(uglify ? deserializeE2E(verified, serverE2E_PublicKey, privateKey) : verified);
+                    callback?.(uglify ? await deserializeE2E(verified, serverE2E_PublicKey, privateKey) : verified);
                 }
             });
 
@@ -171,17 +171,16 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
 
     try {
         await awaitStore();
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { data: `${encodeBinary(email)}.${encodeBinary(password)}` },
             accessKey,
             serverE2E_PublicKey,
             uglify
         });
 
-        const f = await (await fetch(_customSignin(projectUrl, uglify), reqBuilder)).json();
-        if (f.simpleError) throw f;
+        const data = await buildFetchResult(await fetch(_customSignin(projectUrl, uglify), reqBuilder), uglify);
 
-        const r = uglify ? deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -199,7 +198,7 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
 
     try {
         await awaitStore();
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: {
                 data: `${encodeBinary(email)}.${encodeBinary(password)}.${(encodeBinary((name || '').trim()))}`,
                 metadata,
@@ -209,10 +208,9 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
             uglify
         });
 
-        const f = await (await fetch(_customSignup(projectUrl, uglify), reqBuilder)).json();
-        if (f.simpleError) throw f;
+        const data = await buildFetchResult(await fetch(_customSignup(projectUrl, uglify), reqBuilder), uglify);
 
-        const r = uglify ? deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -249,7 +247,7 @@ export const doSignOut = async (builder) => {
         try {
             await awaitReachableServer(projectUrl);
 
-            const [reqBuilder] = buildFetchInterface({
+            const [reqBuilder] = await buildFetchInterface({
                 body: { token, r_token },
                 accessKey,
                 uglify,
@@ -269,17 +267,16 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
 
     try {
         await awaitStore();
-        const [reqBuilder, [privateKey]] = buildFetchInterface({
+        const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { token },
             accessKey,
             uglify,
             serverE2E_PublicKey
         });
 
-        const r = await (await fetch(_googleSignin(projectUrl, uglify), reqBuilder)).json();
-        if (r.simpleError) throw r;
+        const data = await buildFetchResult(await fetch(_googleSignin(projectUrl, uglify), reqBuilder), uglify);
 
-        const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+        const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(f.result.token),

package/src/products/database/index.js

@@ -2,7 +2,7 @@ import { io } from "socket.io-client";
 import EngineApi from "../../helpers/engine_api";
 import { DatabaseRecordsListener } from "../../helpers/listeners";
 import { deserializeE2E, listenReachableServer, niceTry, serializeE2E } from "../../helpers/peripherals";
-import { awaitStore, buildFetchInterface, getReachableServer } from "../../helpers/utils";
+import { awaitStore, buildFetchInterface, buildFetchResult, getReachableServer } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { addPendingWrites, generateRecordID, getRecord, insertRecord, listenQueryEntry, removePendingWrite, validateWriteValue } from "./accessor";
 import { validateCollectionName, validateFilter, validateFindConfig, validateFindObject, validateListenFindConfig } from "./validator";
@@ -197,7 +197,7 @@ const listenDocument = (callback, onError, builder, config) => {
             dbUrl
         };
 
-        const [encPlate, [privateKey]] = uglify ? serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey) : ['', []];
+        const [encPlate, [privateKey]] = uglify ? await serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey) : ['', []];
 
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
@@ -218,7 +218,7 @@ const listenDocument = (callback, onError, builder, config) => {
                     onError(simplifyCaughtError(err).simpleError);
                 } else console.error('unhandled listen for:', { path, find }, ' error:', err);
             } else {
-                if (uglify) snapshot = deserializeE2E(snapshot, serverE2E_PublicKey, privateKey);
+                if (uglify) snapshot = await deserializeE2E(snapshot, serverE2E_PublicKey, privateKey);
                 snapshot = deserializeBSON(snapshot)._;
                 dispatchSnapshot(snapshot);
 
@@ -290,7 +290,7 @@ const initOnDisconnectionTask = (builder, value, type) => {
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
             auth: uglify ? {
-                e2e: serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey)[0],
+                e2e: (await serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey))[0],
                 _m_internal: true
             } : {
                 ...mtoken ? { mtoken } : {},
@@ -365,7 +365,7 @@ const countCollection = async (builder, config) => {
             if (!disableAuth && await getReachableServer(projectUrl))
                 await awaitRefreshToken(projectUrl);
 
-            const [reqBuilder, [privateKey]] = buildFetchInterface({
+            const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
                     commands: { path, find: serializeToBase64(find) },
                     dbName,
@@ -377,10 +377,9 @@ const countCollection = async (builder, config) => {
                 uglify
             });
 
-            const r = await (await fetch(_documentCount(projectUrl, uglify), reqBuilder)).json();
-            if (r.simpleError) throw r;
+            const data = await buildFetchResult(await fetch(_documentCount(projectUrl, uglify), reqBuilder), uglify);
 
-            const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+            const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
             if (!disableCache)
                 setLodash(CacheStore.DatabaseCountResult, [projectUrl, dbUrl, dbName, accessId], f.result);
@@ -497,7 +496,7 @@ const findObject = async (builder, config) => {
             if (!disableAuth && await getReachableServer(projectUrl))
                 await awaitRefreshToken(projectUrl);
 
-            const [reqBuilder, [privateKey]] = buildFetchInterface({
+            const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
                     commands: {
                         config: pureConfig && serializeToBase64(pureConfig),
@@ -517,10 +516,9 @@ const findObject = async (builder, config) => {
                 uglify
             });
 
-            const r = await (await fetch((findOne ? _readDocument : _queryCollection)(projectUrl, uglify), reqBuilder)).json();
-            if (r.simpleError) throw r;
+            const data = await buildFetchResult(await fetch((findOne ? _readDocument : _queryCollection)(projectUrl, uglify), reqBuilder), uglify);
 
-            const result = deserializeBSON((uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r).result)._;
+            const result = deserializeBSON((uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data).result)._;
 
             if (shouldCache) insertRecord(builder, config, accessId, result);
             finalize({ liveResult: result || null });
@@ -634,7 +632,7 @@ const commitData = async (builder, value, type, config) => {
             if (!disableAuth && await getReachableServer(projectUrl))
                 await awaitRefreshToken(projectUrl);
 
-            const [reqBuilder, [privateKey]] = buildFetchInterface({
+            const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
                     commands: {
                         value: value && serializeToBase64({ _: value }),
@@ -653,12 +651,11 @@ const commitData = async (builder, value, type, config) => {
                 uglify
             });
 
-            const r = await (await fetch((isBatchWrite ? _writeMapDocument : _writeDocument)(projectUrl, uglify), reqBuilder)).json();
-            if (r.simpleError) throw r;
+            const data = await buildFetchResult(await fetch((isBatchWrite ? _writeMapDocument : _writeDocument)(projectUrl, uglify), reqBuilder), uglify);
 
-            const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+            const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
-            finalize({ ...f }, undefined, { removeCache: true });
+            finalize({ ...f.statusData }, undefined, { removeCache: true });
         } catch (e) {
             if (e?.simpleError) {
                 console.error(`${type} error (${path}), ${e.simpleError?.message}`);

package/src/products/http_callable/index.js

@@ -7,7 +7,7 @@ import { awaitRefreshToken } from "../auth/accessor";
 import { simplifyCaughtError } from "simplify-error";
 import { guardObject, Validator } from "guard-object";
 import cloneDeep from "lodash.clonedeep";
-import { stringify } from "json-buffer";
+import { serialize } from "entity-serializer";
 
 const buildFetchData = (data) => {
     const { ok, type, status, statusText, redirected, url, headers, size, base64 } = data;
@@ -61,7 +61,7 @@ export const mfetch = async (input = '', init, config) => {
     if ('uglified' in rawHeader)
         throw '"uglified" in header is a reserved prop';
 
-    if (!input.startsWith(projectUrl) && !rawApproach)
+    if (isBaseUrl && !rawApproach)
         throw `please set { rawApproach: true } if you're trying to access different endpoint at "${input}"`;
 
     if (body !== undefined) {
@@ -74,15 +74,15 @@ export const mfetch = async (input = '', init, config) => {
         ) throw `"body" must be any of string, buffer, object, File, Blob`;
     }
 
-    const rawBody = stringify([(body instanceof File || body instanceof Blob) ? await body.arrayBuffer() : body]);
+    const rawBody = (body instanceof File || body instanceof Blob) ? Buffer.from(await body.arrayBuffer()) : body;
 
     const reqId = await niceHash(
-        JSON.stringify([
+        serialize([
             rawHeader,
             rawBody,
             !!disableAuth,
             input
-        ])
+        ]).toString('base64')
     );
 
     let retries = 0, hasFinalize;
@@ -145,7 +145,7 @@ export const mfetch = async (input = '', init, config) => {
             const mtoken = Scoped.AuthJWTToken[projectUrl];
             const initType = rawHeader['content-type'];
 
-            const [reqBuilder, [privateKey]] = uglified ? serializeE2E(rawBody, mtoken, serverE2E_PublicKey) : [null, []];
+            const [reqBuilder, [privateKey]] = uglified ? await serializeE2E(rawBody, mtoken, serverE2E_PublicKey) : [null, []];
 
             const f = await fetch(isBaseUrl ? input : `${projectUrl}/${normalizeRoute(input)}`, {
                 ...isBaseUrl ? {} : { method: 'POST' },
@@ -157,7 +157,7 @@ export const mfetch = async (input = '', init, config) => {
                     ...rawHeader,
                     ...uglified ? {
                         uglified,
-                        'content-type': 'text/plain',
+                        'content-type': 'request/buffer',
                         ...initType ? { 'init-content-type': initType } : {}
                     } : {},
                     ...(disableAuth || !mtoken || uglified || isBaseUrl) ? {} : { mtoken },
@@ -170,7 +170,7 @@ export const mfetch = async (input = '', init, config) => {
             if (!isBaseUrl && simple) throw { simpleError: JSON.parse(simple) };
 
             const base64 = uglified ?
-                Buffer.from(deserializeE2E(await f.text(), serverE2E_PublicKey, privateKey), 'base64') :
+                Buffer.from(await deserializeE2E(await f.arrayBuffer(), serverE2E_PublicKey, privateKey)).toString('base64') :
                 Buffer.from(await f.arrayBuffer()).toString('base64');
 
             const resObj = {

package/src/products/storage/index.js

@@ -105,7 +105,7 @@ const deleteContent = async (builder, path, isFolder) => {
     try {
         const r = await (await fetch(
             EngineApi[isFolder ? '_deleteFolder' : '_deleteFile'](projectUrl, uglify),
-            buildFetchInterface({ path }, accessKey, Scoped.AuthJWTToken[projectUrl], 'DELETE')
+            await buildFetchInterface({ path }, accessKey, Scoped.AuthJWTToken[projectUrl], 'DELETE')
         )).json();
         if (r.simpleError) throw r;
         if (r.status !== 'success') throw 'operation not successful';