react-native-mosquito-transport 0.0.19 → 0.0.22

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,71 @@
-# 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";
+
+// uses sqlite to cache it data by default
+RNMosquitoTransport.initializeCache();
+
+const mclient = new RNMosquitoTransport({
+  projectUrl: "http://localhost:3444"
+});
+```
+
+## Additional Documentations
+
+- [RNMosquitoTransport Constructor](#RNMosquitoTransportConstructor)
+  - [dbName](#dbName)
+  - [dbUrl](#dbUrl)
+  - [projectUrl](#projectUrl)
+  - [disableCache](#disableCache)
+  - [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

@@ -1,6 +1,23 @@
-- fix local cache query on sqlite and fs
+- fix local cache query on sqlite ✅
 - fix and add all mongodb query and update operator
 - reauthenticate
 - change `Object` in d.ts to [key: string]: any
 - add `getServerTimeOffset` method
-- change null to undefined in `value`
+- change undefined to null 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
+- dynamic import for fs ✅
+- new URL() work around ✅
+- fetchHttp, default retrieval if has body ✅
+- native hashing
+- TextEncoder
+- native storage upload
+- lodashes ✅
+- switch to events package
+- serverTimeOffset
+<!-- - error: "refreshToken retry limit exceeded" <--- no need -->

package/ios/Mosquitodb.swift

@@ -88,18 +88,23 @@ class MosquitodbUploadTask: NSObject, URLSessionDataDelegate {
         let filepath = options["file"] as! String
         let url = options["url"] as! String
         let destination = options["destination"] as! String
-        let authorization = options["authorization"] as! String
         
         do {
             let rawData = try Data(contentsOf: URL(fileURLWithPath: filepath))
             
             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")
             
@@ -183,11 +188,15 @@ class MosquitodbDownloadTask: NSObject, URLSessionDownloadDelegate {
     func downloadFile(options: [String: Any], completion: @escaping ([Any]?)->()) -> Void {
         let processID = options["processID"] as! String
         let url = options["url"] as! String
-        let authorization = options["authorization"] as! String
         
         var request = URLRequest(url: URL(string: url)!)
         request.httpMethod = "POST"
-        request.setValue(authorization, forHTTPHeaderField: "Authorization")
+
+        if let extraHeaders = options["extraHeaders"] as? [[String: String]] {
+            for (key, value) in extraHeaders {
+                request.setValue(value, forHTTPHeaderField: key)
+            }
+        }
         if options["authToken"] != nil {
             request.setValue(options["authToken"] as? String, forHTTPHeaderField: "Mosquito-Token")
         }
@@ -249,7 +258,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.22",
+  "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,19 @@
   "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",
-    "lodash.get": "^4.4.2",
-    "lodash.isequal": "^4.5.0",
-    "lodash.set": "^4.3.2",
-    "lodash.unset": "^4.5.2",
+    "entity-serializer": "^1.0.2",
+    "guard-object": "^1.1.4",
+    "lodash": "^4.17.21",
     "react-native-get-random-values": "^1.9.0",
-    "set-large-timeout": "^1.0.1",
+    "react-native-hash": "^3.0.3",
+    "simplify-error": "^1.0.1",
     "socket.io-client": "^4.6.2",
     "subscription-listener": "^1.1.2",
     "tweetnacl": "^1.0.3"
@@ -46,5 +43,8 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*"
+  },
+  "devDependencies": {
+    "@types/react-native-sqlite-storage": "^6.0.5"
   }
-}
+}

package/src/helpers/engine_api.js

@@ -0,0 +1,34 @@
+import { encodeBinary } from './peripherals';
+
+const EngineApiBase = (baseApi, ugly, path) =>
+    ugly ? `${baseApi}/e2e/${encodeBinary(path)}` : `${baseApi}/${path}`;
+
+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

@@ -1,133 +1,46 @@
 import { Buffer } from "buffer";
 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";
+import { CONSTANTS, JSHash } from 'react-native-hash';
 
-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];
+    const array = n.slice(0);
     let currentIndex = array.length, randomIndex;
 
     while (currentIndex != 0) {
@@ -143,56 +56,65 @@ 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 const encryptString = (txt, password, iv) => {
-    return encrypt(txt, `${password || ''}${iv || ''}`).toString();
-}
+export async function niceHash(str = '') {
+    const hash = await JSHash(str, CONSTANTS.HashAlgorithms.md5);
+    if (hash.length > str.length) return encodeBinary(str);
+    return hash;
+};
 
-export const decryptString = (txt, password, iv) => {
-    return decrypt(txt, `${password || ''}${iv || ''}`).toString(Utf8Encoder);
-}
+export const sameInstance = (var1, var2) => {
+    try {
+        return var1.constructor === var2.constructor &&
+            Object.getPrototypeOf(var1) === Object.getPrototypeOf(var2)
+    } catch (_) {
+        return false;
+    }
+};
 
-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');