mosquito-transport-js 0.3.2 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "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.1",
     "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;
@@ -104,51 +105,51 @@ export const decryptString = (txt, password, iv) => {
 };
 
 export const serializeE2E = async (data, auth_token, serverPublicKey) => {
-    const inputData = new Uint8Array(Buffer.from(JSON.stringify([data, auth_token]), 'utf8'));
+    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 = async (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,7 +117,7 @@ export const getReachableServer = (projectUrl) => new Promise(resolve => {
     }, true);
 });
 
-export const buildFetchInterface = async ({ body, accessKey, authToken, method, uglify, serverE2E_PublicKey }) => {
+export const buildFetchInterface = async ({ body, accessKey, authToken, method, uglify, serverE2E_PublicKey, extraHeaders }) => {
     if (!uglify) body = JSON.stringify({ ...body });
     const [plate, keyPair] = uglify ? await serializeE2E(body, authToken, serverE2E_PublicKey) : [undefined, []];
 
@@ -124,10 +125,22 @@ export const buildFetchInterface = async ({ body, accessKey, authToken, method,
         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 } : {})
+            ...(authToken && !uglify) ? { 'Mosquito-Token': authToken } : {},
+            ...extraHeaders
         },
         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

@@ -16,6 +16,12 @@ interface MTConfig {
      * this is the base64 public key for end-to-end encryption on the server
      */
     serverE2E_PublicKey?: string;
+    /**
+     * extra headers that will be appended to all outgoing request in this instance
+     */
+    extraHeaders?: {
+        [key: string]: string
+    };
     /**
      * true to deserialize BSON values to their Node.js closest equivalent types
      * 
@@ -54,6 +60,13 @@ export function FIND_GEO_JSON(coordinates: [latitude, longitude], offSetMeters:
 
 export const AUTH_PROVIDER_ID: auth_provider_id;
 
+/**
+ * useful for avoiding encrypting data and extra overhead
+ */
+export class DoNotEncrypt {
+    value: any;
+}
+
 interface auth_provider_id {
     GOOGLE: 'google.com';
     FACEBOOK: 'facebook.com';
@@ -436,14 +449,27 @@ interface TokenManager {
 
 declare type Base64String = string;
 
-interface ReqOptions {
-    awaitServer?: boolean;
+interface UploadOptions {
+    /**
+     * optionally create hash for this upload to save disk space
+     */
     createHash?: boolean;
+    /**
+     * wait for a reachable server before initiating the upload task
+     */
+    awaitServer?: boolean;
+}
+
+interface DownloadOptions {
+    /**
+     * wait for a reachable server before initiating the download task
+     */
+    awaitServer?: boolean;
 }
 
 interface MTStorage {
-    downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void) => () => void;
-    uploadFile: (file: Base64String | Blob | Buffer | File, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void, options?: ReqOptions) => () => void;
+    downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void, options?: DownloadOptions) => () => void;
+    uploadFile: (file: Base64String | Blob | File | Buffer, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void, options?: UploadOptions) => () => void;
     deleteFile: (path: string) => Promise<void>;
     deleteFolder: (folder: string) => Promise<void>;
 }
@@ -467,13 +493,13 @@ interface ErrorResponse {
 }
 
 /** @public */
-export declare type Sort = string | Exclude<SortDirection, {
+declare type Sort = string | Exclude<SortDirection, {
     $meta: string;
 }> | string[] | {
     [key: string]: SortDirection;
 } | Map<string, SortDirection> | [string, SortDirection][] | [string, SortDirection];
 
 /** @public */
-export declare type SortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending' | {
+declare type SortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending' | {
     $meta: string;
 };

package/src/index.js

@@ -1,4 +1,3 @@
-import './polyfill';
 import { deserializeE2E, listenReachableServer, serializeE2E } from "./helpers/peripherals";
 import { releaseCacheStore, awaitStore } from "./helpers/utils";
 import { CacheStore, Scoped } from "./helpers/variables";
@@ -12,7 +11,6 @@ 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";
@@ -46,7 +44,7 @@ export class MosquitoTransport {
             maxRetries: config.maxRetries || 3,
             uglify: config.enableE2E_Encryption
         };
-        const { projectUrl } = this.config;
+        const { projectUrl, extraHeaders } = this.config;
 
         this.config.secureUrl = projectUrl.startsWith('https');
         this.config.baseUrl = projectUrl.split('://')[1];
@@ -67,6 +65,7 @@ export class MosquitoTransport {
 
             const socket = io(`${this.config.wsPrefix}://${this.config.baseUrl}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
+                extraHeaders,
                 auth: {
                     _m_internal: true,
                     _from_base: true
@@ -154,7 +153,7 @@ export class MosquitoTransport {
 
     getSocket = (configOpts) => {
         const { disableAuth, authHandshake } = configOpts || {};
-        const { projectUrl, uglify, accessKey, serverE2E_PublicKey, wsPrefix } = this.config;
+        const { projectUrl, uglify, accessKey, serverE2E_PublicKey, wsPrefix, extraHeaders } = this.config;
 
         const restrictedRoute = [
             _listenCollection,
@@ -185,22 +184,23 @@ export class MosquitoTransport {
                 return;
             }
 
-            const [args, emitable] = [...arguments];
+            const [[args, not_encrypted], emitable] = [...arguments];
             let res;
 
             if (uglify) {
-                res = parse(await deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey));
+                res = await deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey);
             } else res = args;
+            const sortedArgs = discloseSocketArguments([res, not_encrypted]);
 
-            callback?.(...res || [], ...typeof emitable === 'function' ? [async function () {
-                const args = [...arguments];
+            callback?.(...sortedArgs, ...typeof emitable === 'function' ? [async function () {
+                const [args, not_encrypted] = encloseSocketArguments([...arguments]);
                 let res;
 
                 if (uglify) {
-                    res = (await serializeE2E(stringify(args), undefined, serverE2E_PublicKey))[0];
+                    res = (await serializeE2E(args, undefined, serverE2E_PublicKey))[0];
                 } else res = args;
 
-                emitable(res);
+                emitable([res, not_encrypted]);
             }] : []);
         };
 
@@ -229,28 +229,29 @@ export class MosquitoTransport {
 
                 const lastEmit = emittion.slice(-1)[0];
                 const hasEmitable = typeof lastEmit === 'function';
-                const mit = hasEmitable ? emittion.slice(0, -1) : emittion;
+                const [mit, not_encrypted] = encloseSocketArguments(hasEmitable ? emittion.slice(0, -1) : emittion);
 
-                const [reqBuilder, [privateKey]] = uglify ? await 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,
+                    [uglify ? reqBuilder : mit, not_encrypted],
                     ...hasEmitable ? [async function () {
-                        const [args] = [...arguments];
+                        const [[args, not_encrypted]] = [...arguments];
                         let res;
 
                         if (uglify) {
-                            res = parse(await deserializeE2E(args, serverE2E_PublicKey, privateKey));
+                            res = await deserializeE2E(args, serverE2E_PublicKey, privateKey);
                         } else res = args;
 
-                        lastEmit(...res || []);
+                        lastEmit(...discloseSocketArguments([res, not_encrypted]));
                     }] : []
                 );
-
-                resolve((promise && result) ? uglify ? parse(await deserializeE2E(result, serverE2E_PublicKey, privateKey))[0] : result[0] : undefined);
+                if (promise && result) {
+                    resolve(discloseSocketArguments([uglify ? await deserializeE2E(result[0], serverE2E_PublicKey, privateKey) : result[0], result[1]])[0]);
+                } else resolve();
             } catch (e) {
                 reject(e);
             }
@@ -263,9 +264,10 @@ export class MosquitoTransport {
 
             socket = io(`${wsPrefix}://${projectUrl.split('://')[1]}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
+                extraHeaders,
                 auth: uglify ? {
                     ugly: true,
-                    e2e: reqBuilder
+                    e2e: reqBuilder.toString('base64')
                 } : {
                     ...mtoken ? { mtoken } : {},
                     a_extras: authHandshake,
@@ -359,6 +361,31 @@ export class MosquitoTransport {
     }
 };
 
+class DoNotEncrypt {
+    constructor(value) {
+        this.value = value;
+    }
+};
+
+const encloseSocketArguments = (args) => {
+    const [encrypted, unencrypted] = [{}, {}];
+
+    args.forEach((v, i) => {
+        if (v instanceof DoNotEncrypt) {
+            unencrypted[i] = v.value;
+        } else encrypted[i] = v;
+    });
+    return [encrypted, unencrypted];
+}
+
+const discloseSocketArguments = (args = []) => {
+    return args.map((obj, i) => Object.entries(obj).map(v => i ? [v[0], new DoNotEncrypt(v[1])] : v)).flat()
+        .sort((a, b) => (a[0] * 1) - (b[0] * 1)).map((v, i) => {
+            if (v[0] * 1 !== i) throw 'corrupted socket arguments';
+            return v[1];
+        });
+}
+
 const validateReleaseCacheProp = (prop) => {
     const cacheList = [...Object.values(CACHE_PROTOCOL)];
 
@@ -426,6 +453,16 @@ const validator = {
     serverE2E_PublicKey: (v) => {
         if (typeof v !== 'string' || !v.trim())
             throw `Invalid value supplied to serverETE_PublicKey, value must be a non-empty string`;
+    },
+    extraHeaders: v => {
+        if (!Validator.OBJECT(v)) throw '"extraHeaders" must be an object';
+        const reservedHeaders = ['mtoken', 'mosquito-token', 'init-content-type', 'content-type', 'authorization', 'uglified'];
+
+        Object.entries(v).forEach(([k, v]) => {
+            if (typeof v !== 'string') throw `expected a string at extraHeaders.${k} but got "${v}"`;
+            if (reservedHeaders.includes(v.toLowerCase()))
+                throw `extraHeaders must not include any reserved props which are: ${reservedHeaders}`;
+        });
     }
 };
 
@@ -445,6 +482,7 @@ const validateMTConfig = (config, that) => {
 }
 
 export {
+    DoNotEncrypt,
     TIMESTAMP,
     DOCUMENT_EXTRACTION,
     FIND_GEO_JSON,

package/src/products/auth/accessor.js

@@ -2,7 +2,7 @@ import { doSignOut } from ".";
 import EngineApi from "../../helpers/engine_api";
 import { AuthTokenListener, TokenRefreshListener } from "../../helpers/listeners";
 import { decodeBinary, deserializeE2E, listenReachableServer } from "../../helpers/peripherals";
-import { awaitStore, buildFetchInterface, getPrefferTime, updateCacheStore } from "../../helpers/utils";
+import { awaitStore, buildFetchInterface, buildFetchResult, getPrefferTime, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { simplifyError } from "simplify-error";
 
@@ -75,8 +75,8 @@ export const initTokenRefresher = async (config, forceRefresh) => {
 };
 
 const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7, isForceRefresh) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
-    const lostProcess = simplifyError('process_lost', 'The token refresh process has been lost and replace with another one');
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
+    const lostProcess = simplifyError('process_lost', 'The token refresh process has been lost and replaced with another one');
 
     try {
         const { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
@@ -85,18 +85,22 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
             body: { token, r_token },
             accessKey,
             uglify,
-            serverE2E_PublicKey
+            serverE2E_PublicKey,
+            extraHeaders
         });
 
-        const r = await (await fetch(EngineApi._refreshAuthToken(projectUrl, uglify), reqBuilder)).json();
+        let data;
 
-        if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
-            reject(lostProcess.simpleError);
-            return;
+        try {
+            data = await buildFetchResult(await fetch(EngineApi._refreshAuthToken(projectUrl, uglify), reqBuilder), uglify);
+        } finally {
+            if (processRef !== Scoped.LastTokenRefreshRef[projectUrl]) {
+                reject(lostProcess.simpleError);
+                return;
+            }
         }
-        if (r.simpleError) throw r;
 
-        const f = uglify ? await deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+        const f = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         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";
@@ -66,7 +66,7 @@ export class MTAuth {
             socket = io(`${wsPrefix}://${baseUrl}`, {
                 transports: ['websocket', 'polling', 'flashsocket'],
                 auth: uglify ? {
-                    e2e: reqBuilder,
+                    e2e: reqBuilder.toString('base64'),
                     _m_internal: true
                 } : { mtoken, _m_internal: true },
                 transports: ['websocket', 'polling', 'flashsocket']
@@ -167,7 +167,7 @@ export class MTAuth {
 };
 
 const doCustomSignin = (builder, email, password) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
 
     try {
         await awaitStore();
@@ -175,13 +175,13 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
             body: { data: `${encodeBinary(email)}.${encodeBinary(password)}` },
             accessKey,
             serverE2E_PublicKey,
-            uglify
+            uglify,
+            extraHeaders
         });
 
-        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 ? await deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -195,7 +195,7 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
 });
 
 const doCustomSignup = (builder, email, password, name, metadata) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
 
     try {
         await awaitStore();
@@ -206,13 +206,13 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
             },
             accessKey,
             serverE2E_PublicKey,
-            uglify
+            uglify,
+            extraHeaders
         });
 
-        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 ? await deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -239,7 +239,7 @@ export const clearCacheForSignout = (builder) => {
 export const doSignOut = async (builder) => {
     await awaitStore();
 
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder,
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder,
         { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
 
     clearCacheForSignout(builder);
@@ -253,11 +253,11 @@ export const doSignOut = async (builder) => {
                 body: { token, r_token },
                 accessKey,
                 uglify,
-                serverE2E_PublicKey
+                serverE2E_PublicKey,
+                extraHeaders
             });
 
-            const r = await (await fetch(_signOut(projectUrl, uglify), reqBuilder)).json();
-            if (r.simpleError) throw r;
+            await buildFetchResult(await fetch(_signOut(projectUrl, uglify), reqBuilder), uglify);
         } catch (e) {
             throw simplifyCaughtError(e).simpleError;
         }
@@ -265,7 +265,7 @@ export const doSignOut = async (builder) => {
 };
 
 const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) => {
-    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify, extraHeaders } = builder;
 
     try {
         await awaitStore();
@@ -273,13 +273,13 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
             body: { token },
             accessKey,
             uglify,
-            serverE2E_PublicKey
+            serverE2E_PublicKey,
+            extraHeaders
         });
 
-        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 ? await 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";
@@ -130,7 +130,7 @@ const {
 } = EngineApi;
 
 const listenDocument = (callback, onError, builder, config) => {
-    const { projectUrl, wsPrefix, serverE2E_PublicKey, baseUrl, dbUrl, dbName, accessKey, path, disableCache, command, uglify, castBSON } = builder;
+    const { projectUrl, wsPrefix, serverE2E_PublicKey, baseUrl, dbUrl, dbName, accessKey, path, disableCache, command, uglify, extraHeaders, castBSON } = builder;
     const { find, findOne, sort, direction, limit } = command;
     const { disableAuth } = config || {};
     const shouldCache = !disableCache;
@@ -185,14 +185,14 @@ const listenDocument = (callback, onError, builder, config) => {
         const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
         const pureConfig = stripRequestConfig(config);
         const authObj = {
-            commands: {
+            commands: stripUndefined({
                 config: pureConfig && serializeToBase64(pureConfig),
                 path,
                 find: serializeToBase64(findOne || find),
                 sort,
                 direction,
                 limit
-            },
+            }),
             dbName,
             dbUrl
         };
@@ -201,7 +201,8 @@ const listenDocument = (callback, onError, builder, config) => {
 
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
-            auth: uglify ? { e2e: encPlate, _m_internal: true } : {
+            extraHeaders,
+            auth: uglify ? { e2e: encPlate.toString('base64'), _m_internal: true } : {
                 accessKey,
                 _body: authObj,
                 ...mtoken ? { mtoken } : {},
@@ -257,7 +258,7 @@ const listenDocument = (callback, onError, builder, config) => {
 };
 
 const initOnDisconnectionTask = (builder, value, type) => {
-    const { projectUrl, wsPrefix, baseUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, path, command, uglify } = builder;
+    const { projectUrl, wsPrefix, baseUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, path, extraHeaders, command, uglify } = builder;
     const { find } = command || {};
     const disableAuth = false;
 
@@ -277,20 +278,21 @@ const initOnDisconnectionTask = (builder, value, type) => {
 
         const mtoken = disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl];
         const authObj = {
-            commands: {
+            commands: stripUndefined({
                 path,
                 find: find && serializeToBase64(find),
                 value: value && serializeToBase64({ _: value }),
                 scope: type
-            },
+            }),
             dbName,
             dbUrl
         };
 
         socket = io(`${wsPrefix}://${baseUrl}`, {
             transports: ['websocket', 'polling', 'flashsocket'],
+            extraHeaders,
             auth: uglify ? {
-                e2e: (await serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey))[0],
+                e2e: (await serializeE2E({ accessKey, _body: authObj }, mtoken, serverE2E_PublicKey))[0].toString('base64'),
                 _m_internal: true
             } : {
                 ...mtoken ? { mtoken } : {},
@@ -337,7 +339,7 @@ const initOnDisconnectionTask = (builder, value, type) => {
 };
 
 const countCollection = async (builder, config) => {
-    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, uglify, path, disableCache, command = {} } = builder;
+    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, uglify, extraHeaders, path, disableCache, command = {} } = builder;
     const { find } = command;
     const { disableAuth } = config || {};
     const accessId = await generateRecordID({ ...builder, countDoc: true }, config);
@@ -357,8 +359,8 @@ const countCollection = async (builder, config) => {
 
         const finalize = (a, b) => {
             if (Validator.NUMBER(a)) {
-                reject(b);
-            } else resolve(a);
+                resolve(a);
+            } else reject(b);
         };
 
         try {
@@ -374,13 +376,13 @@ const countCollection = async (builder, config) => {
                 accessKey,
                 ...disableAuth ? {} : { authToken: Scoped.AuthJWTToken[projectUrl] },
                 serverE2E_PublicKey,
-                uglify
+                uglify,
+                extraHeaders
             });
 
-            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 ? await 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);
@@ -420,13 +422,17 @@ const stripRequestConfig = (config) => {
     return requestConfig.length ? Object.fromEntries(requestConfig) : undefined;
 };
 
+const stripUndefined = o => Object.fromEntries(
+    Object.entries(o).filter(v => v[1] !== undefined)
+);
+
 const transformBSON = (d, castBSON) => {
     if (castBSON) return d && deserializeBSON(serializeToBase64({ _: d }), true)._;
     return cloneDeep(d);
 };
 
 const findObject = async (builder, config) => {
-    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, path, disableCache, uglify, command, castBSON } = builder;
+    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, path, disableCache, uglify, extraHeaders, command, castBSON } = builder;
     const { find, findOne, sort, direction, limit, random } = command;
     const { retrieval = RETRIEVAL.DEFAULT, episode = 0, disableAuth, disableMinimizer } = config || {};
     const enableMinimizer = !disableMinimizer;
@@ -499,7 +505,7 @@ const findObject = async (builder, config) => {
 
             const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
-                    commands: {
+                    commands: stripUndefined({
                         config: pureConfig && serializeToBase64(pureConfig),
                         path,
                         find: serializeToBase64(findOne || find),
@@ -507,20 +513,20 @@ const findObject = async (builder, config) => {
                         direction,
                         limit,
                         random
-                    },
+                    }),
                     dbName,
                     dbUrl
                 },
                 accessKey,
                 authToken: disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl],
                 serverE2E_PublicKey,
-                uglify
+                uglify,
+                extraHeaders
             });
 
-            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 ? await 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 });
@@ -589,7 +595,7 @@ const commitData = async (builder, value, type, config) => {
         )._;
     }
 
-    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, path, find, disableCache, uglify } = builder;
+    const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, accessKey, maxRetries = 7, path, find, disableCache, uglify, extraHeaders } = builder;
     const { disableAuth, delivery = DELIVERY.DEFAULT, stepping } = config || {};
     const writeId = `${Date.now() + ++Scoped.PendingIte}`;
     const isBatchWrite = type === 'batchWrite';
@@ -636,29 +642,29 @@ const commitData = async (builder, value, type, config) => {
 
             const [reqBuilder, [privateKey]] = await buildFetchInterface({
                 body: {
-                    commands: {
+                    commands: stripUndefined({
                         value: value && serializeToBase64({ _: value }),
                         ...isBatchWrite ? { stepping } : {
                             path,
                             scope: type,
                             find: find && serializeToBase64(find)
                         }
-                    },
+                    }),
                     dbName,
                     dbUrl
                 },
                 accessKey,
                 serverE2E_PublicKey,
                 authToken: disableAuth ? undefined : Scoped.AuthJWTToken[projectUrl],
-                uglify
+                uglify,
+                extraHeaders
             });
 
-            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 ? await 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;
@@ -33,7 +33,7 @@ const buildFetchData = (data) => {
 }
 
 export const mfetch = async (input = '', init, config) => {
-    const { projectUrl, serverE2E_PublicKey, method, maxRetries = 7, disableCache, accessKey, uglify } = config;
+    const { projectUrl, serverE2E_PublicKey, method, maxRetries = 7, disableCache, accessKey, uglify, extraHeaders } = config;
     const { headers, body } = init || {};
 
     if (method !== 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) ? Buffer.from(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;
@@ -153,11 +153,12 @@ export const mfetch = async (input = '', init, config) => {
                 ...uglified ? { body: reqBuilder } : {},
                 cache: 'no-cache',
                 headers: {
+                    ...extraHeaders,
                     ...isBaseUrl ? {} : { 'content-type': 'application/json' },
                     ...rawHeader,
                     ...uglified ? {
                         uglified,
-                        'content-type': 'text/plain',
+                        'content-type': 'request/buffer',
                         ...initType ? { 'init-content-type': initType } : {}
                     } : {},
                     ...(disableAuth || !mtoken || uglified || isBaseUrl) ? {} : { mtoken },
@@ -170,7 +171,7 @@ export const mfetch = async (input = '', init, config) => {
             if (!isBaseUrl && simple) throw { simpleError: JSON.parse(simple) };
 
             const base64 = uglified ?
-                Buffer.from(await 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

@@ -12,6 +12,7 @@ export class MTStorage {
     }
 
     uploadFile = (file, destination, onComplete, onProgress, reqOptions) => {
+        const { awaitServer, createHash } = reqOptions || {};
         let hasCancelled = false,
             hasFinished = false,
             xhr;
@@ -44,7 +45,6 @@ export class MTStorage {
 
             const { projectUrl, accessKey, uglify } = this.builder;
             xhr = new XMLHttpRequest();
-            const { awaitServer, createHash } = reqOptions || {};
 
             if (awaitServer) await awaitReachableServer(projectUrl);
             await awaitRefreshToken(projectUrl);

package/src/polyfill.js

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