mosquito-transport-js 0.3.2 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.3.2",
+  "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;
@@ -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; }
@@ -124,10 +125,21 @@ 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 } : {})
         },
         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.js

@@ -12,7 +12,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";
@@ -189,7 +188,7 @@ export class MosquitoTransport {
             let res;
 
             if (uglify) {
-                res = parse(await deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey));
+                res = await deserializeE2E(args, serverE2E_PublicKey, clientPrivateKey);
             } else res = args;
 
             callback?.(...res || [], ...typeof emitable === 'function' ? [async function () {
@@ -197,7 +196,7 @@ export class MosquitoTransport {
                 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);
@@ -231,7 +230,7 @@ export class MosquitoTransport {
                 const hasEmitable = typeof lastEmit === 'function';
                 const mit = 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';
@@ -243,14 +242,14 @@ export class MosquitoTransport {
                         let res;
 
                         if (uglify) {
-                            res = parse(await deserializeE2E(args, serverE2E_PublicKey, privateKey));
+                            res = await deserializeE2E(args, serverE2E_PublicKey, privateKey);
                         } else res = args;
 
                         lastEmit(...res || []);
                     }] : []
                 );
 
-                resolve((promise && result) ? uglify ? parse(await 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);
             }

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";
@@ -178,10 +178,9 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
             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 ? await deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -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 ? await deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+        const r = uglify ? await deserializeE2E(data, serverE2E_PublicKey, privateKey) : data;
 
         resolve({
             user: parseToken(r.result.token),
@@ -276,10 +274,9 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
             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 ? 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";
@@ -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 ? 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);
@@ -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 ? 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 });
@@ -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 ? 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;
@@ -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;
@@ -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(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 = {