react-native-mosquito-transport 0.0.19 → 0.0.21

package/.jshintignore

@@ -0,0 +1,4 @@
+node_modules/
+android/
+example/
+ios/

package/.jshintrc

@@ -0,0 +1,16 @@
+{
+    "undef": true,  // Warns on variables used before declaration
+    "esversion": 12,
+    "globals": {
+        "process": true,
+        "clearTimeout": true,
+        "setTimeout": true,
+        "console": true,
+        "Buffer": true,
+        "clearInterval": true,
+        "setInterval": true,
+        "AbortController": true,
+        "URLSearchParams": true,
+        "URL": true
+    }
+}

package/README.md

@@ -1 +1,75 @@
-# react-native-mosquito-transport
+# react-native-mosquito-transport
+
+React native javascript sdk for [mosquito-transport](https://github.com/brainbehindx/mosquito-transport).
+
+## Installation
+
+```sh
+npm install react-native-mosquito-transport --save
+```
+
+or using yarn
+
+```sh
+yarn add react-native-mosquito-transport
+```
+
+## Usage
+
+```js
+import RNMosquitoTransport from "react-native-mosquito-transport";
+
+RNMosquitoTransport.initializeCache({
+  cachePassword: "****",
+  cacheProtocol: "sqlite",
+});
+
+const mclient = new RNMosquitoTransport({
+  projectUrl: "http://localhost:3444",
+  accessKey: "SERVER_ACCESS_KEY",
+});
+```
+
+## Additional Documentations
+
+- [RNMosquitoTransport Constructor](#RNMosquitoTransportConstructor)
+  - [dbName](#dbName)
+  - [dbUrl](#dbUrl)
+  - [projectUrl](#projectUrl)
+  - [disableCache](#disableCache)
+  - [accessKey](#accessKey)
+  - [maxRetries](#maxRetries)
+  - [enableE2E_Encryption](#enableE2E_Encryption)
+  - [serverE2E_PublicKey](#serverE2E_PublicKey)
+  - [extraHeaders](#extraHeaders)
+  - [castBSON](#castBSON)
+- [RNMosquitoTransport Methods](#RNMosquitoTransportMethods)
+ - [initialCache](#initialCache)
+ - [getDatabase](#getDatabase)
+ - [collection](#collection)
+ - [auth](#auth)
+ - [storage](#storage)
+ - [fetchHttp](#fetchHttp)
+ - [listenReachableServer](#listenReachableServer)
+ - [getSocket](#getSocket)
+ - [batchWrite](#batchWrite)
+- [TIMESTAMP](#TIMESTAMP)
+- [AUTH_PROVIDER_ID](#AUTH_PROVIDER_ID)
+- [DOCUMENT_EXTRACTION](#DOCUMENT_EXTRACTION)
+- [GEO_JSON](#GEO_JSON)
+- [FIND_GEO_JSON](#FIND_GEO_JSON)
+- [DoNotEncrypt](#DoNotEncrypt)
+
+## RNMosquitoTransport Constructor
+
+### dbName
+
+
+### dbUrl
+
+
+### projectUrl
+
+this is the base url of 
+
+### disableCache

package/TODO

@@ -3,4 +3,11 @@
 - reauthenticate
 - change `Object` in d.ts to [key: string]: any
 - add `getServerTimeOffset` method
-- change null to undefined in `value`
+- change null to undefined in `value`
+- `provide functionality to add extra header to MT instance (all outgoing request)`
+- borrowToken
+- `add sqlite`
+- minimize extraction data
+- change `collection().onDisconnect()` to `collection().socket().onDisconnect()` and `collection().socket().onConnect()`
+- add `_foreign_doc` to d.ts
+- tree shake dependencies

package/ios/Mosquitodb.swift

@@ -95,11 +95,18 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
             
             var request = URLRequest(url: URL(string: url)!)
             request.httpMethod = "POST"
+
+            if let extraHeaders = options["extraHeaders"] as? [[String: String]] {
+                for (key, value) in extraHeaders {
+                    request.setValue(value, forHTTPHeaderField: key)
+                }
+            }
             request.setValue("application/json", forHTTPHeaderField: "Accept")
             request.setValue(authorization, forHTTPHeaderField: "Authorization")
             if options["authToken"] != nil {
                 request.setValue(options["authToken"] as? String, forHTTPHeaderField: "Mosquito-Token")
             }
+            request.setValue(options["createHash"] as? String, forHTTPHeaderField: "hash-upload");
             request.setValue("buffer/upload", forHTTPHeaderField: "Content-Type")
             request.setValue(destination, forHTTPHeaderField: "Mosquito-Destination")
             
@@ -187,6 +194,12 @@ class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
         
         var request = URLRequest(url: URL(string: url)!)
         request.httpMethod = "POST"
+
+        if let extraHeaders = options["extraHeaders"] as? [[String: String]] {
+            for (key, value) in extraHeaders {
+                request.setValue(value, forHTTPHeaderField: key)
+            }
+        }
         request.setValue(authorization, forHTTPHeaderField: "Authorization")
         if options["authToken"] != nil {
             request.setValue(options["authToken"] as? String, forHTTPHeaderField: "Mosquito-Token")
@@ -249,7 +262,7 @@ class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
                             "result": "{\"file\": \"\(dest)\"}"
                         ]
                     ])
-                }else{
+                } else {
                     let documentsURL = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
                     let urlName = mainOptions["urlName"] as! String
                     let destDir = documentsURL.appendingPathComponent("mosquito-transport")

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.19",
-  "description": "React native javascript sdk for mosquito-transport (https://github.com/deflexable/mosquito-transport)",
+  "version": "0.0.21",
+  "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
+  "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/deflexable/react-native-mosquito-transport.git"
+    "url": "git+https://github.com/brainbehindx/react-native-mosquito-transport.git"
   },
   "keywords": [
     "mosquito-transport",
@@ -22,23 +23,22 @@
   "author": "Anthony Onabanjo <deflexable@gmail.com> (https://github.com/deflexable)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/deflexable/react-native-mosquito-transport/issues"
+    "url": "https://github.com/brainbehindx/react-native-mosquito-transport/issues"
   },
-  "homepage": "https://github.com/deflexable/react-native-mosquito-transport#readme",
+  "homepage": "https://github.com/brainbehindx/react-native-mosquito-transport#readme",
   "dependencies": {
-    "@types/crypto-js": "^4.2.1",
-    "@types/lodash": "^4.14.194",
+    "@turf/turf": "^7.1.0",
+    "bson": "^6.8.0",
     "buffer": "^6.0.3",
     "crypto-js": "^4.2.0",
-    "fast-json-stable-stringify": "^2.1.0",
-    "guard-object": "^1.0.9",
-    "json-buffer": "^3.0.1",
+    "entity-serializer": "^1.0.2",
+    "guard-object": "^1.1.3",
+    "lodash.clonedeep": "^4.5.0",
     "lodash.get": "^4.4.2",
-    "lodash.isequal": "^4.5.0",
     "lodash.set": "^4.3.2",
     "lodash.unset": "^4.5.2",
     "react-native-get-random-values": "^1.9.0",
-    "set-large-timeout": "^1.0.1",
+    "simplify-error": "^1.0.1",
     "socket.io-client": "^4.6.2",
     "subscription-listener": "^1.1.2",
     "tweetnacl": "^1.0.3"
@@ -47,4 +47,4 @@
     "react": "*",
     "react-native": "*"
   }
-}
+}

package/src/helpers/engine_api.js

@@ -0,0 +1,39 @@
+import { encodeBinary } from './peripherals';
+
+const EngineApiBase = (baseApi, ugly, path) => {
+    const url = new URL(baseApi);
+    if (ugly) {
+        url.pathname = `/e2e/${encodeBinary(path)}`;
+    } else url.pathname = path;
+    return url.href;
+};
+
+const apis = {
+    _readDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_readDocument'),
+    _queryCollection: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_queryCollection'),
+    _documentCount: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_documentCount'),
+    _writeDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_writeDocument'),
+    _writeMapDocument: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_writeMapDocument'),
+    _customSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_customSignin'),
+    _customSignup: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_customSignup'),
+    _googleSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_googleSignin'),
+    _appleSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_appleSignin'),
+    _facebookSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_facebookSignin'),
+    _twitterSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_twitterSignin'),
+    _githubSignin: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_githubSignin'),
+    _signOut: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_signOut'),
+    _refreshAuthToken: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_refreshAuthToken'),
+    _uploadFile: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_uploadFile'),
+    _deleteFile: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_deleteFile'),
+    _deleteFolder: (baseApi, ugly) => EngineApiBase(baseApi, ugly, '_deleteFolder'),
+    staticStorage: (baseApi) => `${baseApi}/storage`,
+    _areYouOk: (baseApi) => `${baseApi}/_areYouOk`,
+    // static path
+    _listenCollection: (ugly) => ugly ? encodeBinary(apis._listenCollection()) : '_listenCollection',
+    _listenDocument: (ugly) => ugly ? encodeBinary(apis._listenDocument()) : '_listenDocument',
+    _startDisconnectWriteTask: (ugly) => ugly ? encodeBinary(apis._startDisconnectWriteTask()) : '_startDisconnectWriteTask',
+    _cancelDisconnectWriteTask: (ugly) => ugly ? encodeBinary(apis._cancelDisconnectWriteTask()) : '_cancelDisconnectWriteTask',
+    _listenUserVerification: (ugly) => ugly ? encodeBinary(apis._listenUserVerification()) : '_listenUserVerification'
+};
+
+export default { ...apis };

package/src/helpers/peripherals.js

@@ -3,129 +3,44 @@ import { ServerReachableListener } from "./listeners";
 import aes_pkg from 'crypto-js/aes.js';
 import Utf8Encoder from 'crypto-js/enc-utf8.js';
 import naclPkg from 'tweetnacl';
+import getLodash from "lodash.get";
+import { deserialize, serialize } from "entity-serializer";
 
 const { encrypt, decrypt } = aes_pkg;
 const { box, randomBytes } = naclPkg;
 
-export const simplifyError = (error, message) => ({
-    simpleError: { error, message }
-});
-
-export const simplifyCaughtError = (e) => e?.simpleError ? e : simplifyError('unexpected_error', `${e}`);
-
-export const everyEntrie = (obj, callback) => {
-    if (typeof obj !== 'object' || Array.isArray(obj)) return;
-    oEntries(obj).forEach(e => {
-        callback?.(e);
-    });
-}
-
-export const flatEntries = (obj) => oEntries(obj);
-
-export const flatRawEntries = () => oEntries(obj, false);
-
-export const oEntries = (obj, includeObj = true) => {
-    let o = [];
-
-    Object.entries(obj).forEach(e => {
-        o.push(e);
-        if (e[1] && typeof e[1] === 'object' && !Array.isArray(e[1])) {
-            o = [...o, ...oEntries(e[1])];
-        }
-    });
-
-    return o.filter(v => includeObj || typeof v[1] !== 'object' || Array.isArray(v[1]));
-}
-
-export const IS_RAW_OBJECT = (e) => e && typeof e === 'object' && !Array.isArray(e) && !(e instanceof Date);
-
-export const IS_WHOLE_NUMBER = (v) => typeof v === 'number' && !`${v}`.includes('.');
-
-export const IS_DECIMAL_NUMBER = (v) => typeof v === 'number' && `${v}`.includes('.');
-
-export const queryEntries = (obj, lastPath = '', exceptions = [], seperator = '.') => {
-    let o = [];
-    const isArraySeperator = Array.isArray(lastPath);
-
-    Object.entries(obj).forEach(([key, value]) => {
-        if (IS_RAW_OBJECT(value) && !exceptions.includes(key)) {
-            o = [
-                ...o,
-                ...queryEntries(
-                    value,
-                    isArraySeperator ? [...lastPath, key] : `${lastPath}${key}${seperator}`,
-                    exceptions,
-                    seperator
-                )
-            ];
-        } else o.push(isArraySeperator ? [[...lastPath, key], value] : [`${lastPath}${key}`, value]);
-    });
-
-    return o;
-}
-
-export const objToUniqueString = (obj) => {
-    const keys = [],
-        values = [];
-
-    if (Array.isArray(obj)) {
-        obj.forEach(e => {
-            if (IS_RAW_OBJECT(e)) {
-                queryEntries(e).map(([k, v]) => {
-                    keys.push(k);
-                    values.push(v);
-                });
-            } else keys.push(Array.isArray(e) ? JSON.stringify(e) : `${e}`);
-        });
-    } else if (!IS_RAW_OBJECT(obj))
-        return `${obj}`;
-    else
-        queryEntries(obj).map(([k, v]) => {
-            keys.push(k);
-            values.push(v);
-        });
-
-    return [
-        ...keys.sort(),
-        ...values.map(v => `${Array.isArray(v) ? JSON.stringify(v) : v}`).sort()
-    ].join(',');
-}
-
-export const cloneInstance = (v) => {
-    if (v && typeof v === 'object') {
-        return Array.isArray(v) ? [...v] : { ...v };
-    }
-    return v;
-}
-
 export const listenReachableServer = (callback, projectUrl) => {
     let lastValue;
     return ServerReachableListener.listenTo(projectUrl, t => {
         if (typeof t === 'boolean' && t !== lastValue) callback?.(t);
     }, true);
-}
+};
 
 export const prefixStoragePath = (path, prefix = 'file:///') => {
-    if (!path) return path;
+    let cleanedPath = path.replace(/^[^/]+:\/{1,3}/, '');
 
-    if (!path.startsWith('/') && !path.includes(':')) return prefix + path;
+    // Continuously remove any remaining protocol patterns until none are left
+    while (/^[^/]+:\/{1,3}/.test(cleanedPath)) {
+        cleanedPath = cleanedPath.replace(/^[^/]+:\/{1,3}/, '');
+    }
 
-    return prefix + path.split('/').filter((v, i) => i && v).join('/');
-}
+    // Remove any leading slashes after protocol removal
+    cleanedPath = cleanedPath.replace(/^\/+/, '');
 
-export const getUrlExtension = (url) => {
-    const r = url.split(/[#?]/)[0].split(".").pop().trim();
-    return r === url ? '' : r;
-}
+    return `${prefix}${cleanedPath}`;
+};
 
 export const niceTry = (promise) => new Promise(async resolve => {
-
     try {
         const r = await promise();
         resolve(r);
     } catch (e) { resolve(); }
 });
 
+export const normalizeRoute = (route = '') => route.split('').map((v, i, a) =>
+    ((!i && v === '/') || (i === a.length - 1 && v === '/') || (i && a[i - 1] === '/' && v === '/')) ? '' : v
+).join('');
+
 export const shuffleArray = (n) => {
     const array = [...n];
     let currentIndex = array.length, randomIndex;
@@ -143,56 +58,87 @@ export const shuffleArray = (n) => {
 }
 
 export function sortArrayByObjectKey(arr = [], key) {
-    return arr.slice(0).sort(function (a, b) {
+    return arr.sort(function (a, b) {
         const left = getLodash(a, key),
             right = getLodash(b, key);
 
         return (left > right) ? 1 : (left < right) ? -1 : 0;
     });
-}
+};
+
+export async function niceHash(str) {
+    try {
+        // Convert the string to a Uint8Array
+        const encoder = new TextEncoder();
+        const data = encoder.encode(str);
+
+        // Use the Web Crypto API to compute the hash
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+
+        // Convert the ArrayBuffer to a hex string for readability
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map(byte => byte.toString(16).padStart(2, '0')).join('');
+
+        // Convert to base64
+        return Buffer.from(hashHex, 'hex').toString('base64');
+    } catch (_) {
+        return str;
+    }
+};
+
+export const sameInstance = (var1, var2) => {
+    try {
+        return var1.constructor === var2.constructor &&
+            Object.getPrototypeOf(var1) === Object.getPrototypeOf(var2)
+    } catch (_) {
+        return false;
+    }
+};
 
 export const encryptString = (txt, password, iv) => {
     return encrypt(txt, `${password || ''}${iv || ''}`).toString();
-}
+};
 
 export const decryptString = (txt, password, iv) => {
     return decrypt(txt, `${password || ''}${iv || ''}`).toString(Utf8Encoder);
-}
+};
 
-export const serializeE2E = (data, auth_token, serverPublicKey) => {
+export const serializeE2E = async (data, auth_token, serverPublicKey) => {
     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(
-                Buffer.from(JSON.stringify([
-                    data,
-                    auth_token
-                ]), 'utf8'),
-                nonce,
-                Buffer.from(serverPublicKey, 'base64'),
-                pair.secretKey
+        serialize([
+            pair.publicKey,
+            nonce,
+            Buffer.from(
+                box(
+                    serialize([
+                        data,
+                        auth_token
+                    ]),
+                    nonce,
+                    serverPublicKey,
+                    pair.secretKey
+                )
             )
-        ).toString('base64')}`,
+        ]),
         [pair.secretKey, pair.publicKey]
     ];
-}
+};
 
-export const deserializeE2E = (data, serverPublicKey, clientPrivateKey) => {
-    const [binaryNonce, binaryData] = data.split('.'),
+export const deserializeE2E = async (data, serverPublicKey, clientPrivateKey) => {
+    const [binaryNonce, binaryData] = deserialize(data),
         baseArray = box.open(
-            Buffer.from(binaryData, 'base64'),
-            Buffer.from(binaryNonce, 'base64'),
-            Buffer.from(serverPublicKey, 'base64'),
+            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');
 export const decodeBinary = (s) => Buffer.from(s, 'base64').toString('utf8');

package/src/helpers/utils.js

@@ -3,14 +3,28 @@ import { ServerReachableListener, StoreReadyListener } from "./listeners";
 import { CACHE_PROTOCOL, CACHE_STORAGE_PATH, DEFAULT_CACHE_PASSWORD, LOCAL_STORAGE_PATH } from "./values";
 import { CacheStore, Scoped } from "./variables";
 import { decryptString, encryptString, niceTry, serializeE2E } from "./peripherals";
+import { deserializeBSON, serializeToBase64 } from "../products/database/bson";
+import { trySendPendingWrite } from "../products/database";
+import { deserialize } from "entity-serializer";
 
-export const updateCacheStore = () => {
-    const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE, io } = Scoped.ReleaseCacheData;
+export const updateCacheStore = (timer = 300) => {
+    const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE, io, promoteCache } = Scoped.ReleaseCacheData;
 
     clearTimeout(Scoped.cacheStorageReducer);
     Scoped.cacheStorageReducer = setTimeout(() => {
+        const { AuthStore, EmulatedAuth, PendingAuthPurge, DatabaseStore, PendingWrites, ...restStore } = CacheStore;
+
         const txt = encryptString(
-            JSON.stringify({ ...CacheStore }),
+            JSON.stringify({
+                AuthStore,
+                EmulatedAuth,
+                PendingAuthPurge,
+                ...promoteCache ? {
+                    DatabaseStore: serializeToBase64(DatabaseStore),
+                    PendingWrites: serializeToBase64(PendingWrites)
+                } : {},
+                ...promoteCache ? restStore : {}
+            }),
             cachePassword,
             cachePassword
         );
@@ -19,12 +33,14 @@ export const updateCacheStore = () => {
             io.output(txt);
         } else if (cacheProtocol === CACHE_PROTOCOL.ASYNC_STORAGE) {
             AsyncStorage.setItem(CACHE_STORAGE_PATH, txt);
+        } else if (cacheProtocol === CACHE_PROTOCOL.SQLITE) {
+            console.error('unsupported protocol "sqlite"');
         } else {
             const fs = require('react-native-fs');
             fs.writeFile(LOCAL_STORAGE_PATH(), txt, 'utf8');
         }
-    }, 500);
-}
+    }, timer);
+};
 
 export const releaseCacheStore = async (builder) => {
     const { cachePassword = DEFAULT_CACHE_PASSWORD, cacheProtocol = CACHE_PROTOCOL.ASYNC_STORAGE, io } = builder;
@@ -41,17 +57,26 @@ export const releaseCacheStore = async (builder) => {
     }
 
     const j = JSON.parse(decryptString(txt || '', cachePassword, cachePassword) || '{}');
+    const projectList = new Set([]);
 
     Object.entries(j).forEach(([k, v]) => {
-        CacheStore[k] = v;
+        if (['DatabaseStore', 'PendingWrites'].includes(k)) {
+            CacheStore[k] = deserializeBSON(v);
+        } else CacheStore[k] = v;
+        projectList.add(k);
     });
     Object.entries(CacheStore.AuthStore).forEach(([key, value]) => {
         Scoped.AuthJWTToken[key] = value?.token;
     });
+    projectList.forEach(projectUrl => {
+        if (Scoped.IS_CONNECTED[projectUrl])
+            trySendPendingWrite(projectUrl);
+    });
     Scoped.IsStoreReady = true;
     StoreReadyListener.dispatch('_', 'ready');
-    // TODO: commit pending write
-}
+};
+
+export const getPrefferTime = () => Date.now() + (Scoped.serverTimeOffset || 0);
 
 export const awaitStore = () => new Promise(resolve => {
     if (Scoped.IsStoreReady) {
@@ -92,26 +117,30 @@ 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, extraHeaders }) => {
     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 } : {})
+            ...(authToken && !uglify) ? { 'Mosquito-Token': authToken } : {},
+            ...extraHeaders
         },
         method: method || 'POST'
     }, keyPair];
 };
 
-export const simplifyError = (error, message) => ({
-    simpleError: { error, message }
-});
-
-export const validateRequestMethod = (method) => {
-    // TODO:
-}
+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;
+};