mosquito-transport-js 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Javascript web sdk for mosquito-transport (https://github.com/deflexable/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -10,7 +10,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/BrainBehindx/mosquito-transport-js.git"
+    "url": "git+https://github.com/brainbehindx/mosquito-transport-js.git"
   },
   "keywords": [
     "mosquito-transport",
@@ -25,9 +25,9 @@
   "author": "Anthony Onabanjo <deflexable@gmail.com> (https://github.com/deflexable)",
   "license": "MIT",
   "bugs": {
-    "url": "https://github.com/BrainBehindx/mosquito-transport-js/issues"
+    "url": "https://github.com/brainbehindx/mosquito-transport-js/issues"
   },
-  "homepage": "https://github.com/BrainBehindx/mosquito-transport-js#readme",
+  "homepage": "https://github.com/brainbehindx/mosquito-transport-js#readme",
   "dependencies": {
     "@types/crypto-js": "^4.2.1",
     "@types/lodash": "^4.14.194",
@@ -37,7 +37,7 @@
     "lodash": "^4.17.21",
     "set-large-timeout": "^1.0.1",
     "socket.io-client": "^4.6.2",
-    "subscription-listener": "^1.1.1",
+    "subscription-listener": "^1.1.2",
     "tweetnacl": "^1.0.3"
   },
   "devDependencies": {

package/src/helpers/EngineApi.js

@@ -14,7 +14,6 @@ const apis = {
     _twitterSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._twitterSignin(baseApi)) : '_twitterSignin'}`,
     _githubSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._githubSignin(baseApi)) : '_githubSignin'}`,
     _signOut: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._signOut(baseApi)) : '_signOut'}`,
-    _invalidateToken: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._invalidateToken(baseApi)) : '_invalidateToken'}`,
     _refreshAuthToken: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._refreshAuthToken(baseApi)) : '_refreshAuthToken'}`,
     _downloadFile: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._downloadFile(baseApi)) : '_downloadFile'}`,
     _uploadFile: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._uploadFile(baseApi)) : '_uploadFile'}`,

package/src/helpers/utils.js

@@ -1,13 +1,14 @@
 import { ServerReachableListener, StoreReadyListener } from "./listeners";
 import { CACHE_PROTOCOL, CACHE_STORAGE_PATH, DEFAULT_CACHE_PASSWORD } from "./values";
 import { CacheStore, Scoped } from "./variables";
-import { decryptString, encryptString, niceTry, serializeE2E } from "./peripherals";
+import { decryptString, encryptString, serializeE2E } from "./peripherals";
 
 export const updateCacheStore = () => {
     try { window } catch (_) { return; }
     const {
         cachePassword = DEFAULT_CACHE_PASSWORD,
-        cacheProtocol = CACHE_PROTOCOL.LOCAL_STORAGE
+        cacheProtocol = CACHE_PROTOCOL.LOCAL_STORAGE,
+        io
     } = Scoped.ReleaseCacheData;
 
     clearTimeout(Scoped.cacheStorageReducer);
@@ -18,7 +19,9 @@ export const updateCacheStore = () => {
             cachePassword
         );
 
-        if (cacheProtocol === CACHE_PROTOCOL.LOCAL_STORAGE) {
+        if (io) {
+            io.ouput(txt);
+        } else if (cacheProtocol === CACHE_PROTOCOL.LOCAL_STORAGE) {
             window.localStorage.setItem(CACHE_STORAGE_PATH, txt);
         }
     }, 500);
@@ -28,17 +31,20 @@ export const releaseCacheStore = async (builder) => {
     try { window } catch (_) { return; }
     const {
         cachePassword = DEFAULT_CACHE_PASSWORD,
-        cacheProtocol = CACHE_PROTOCOL.LOCAL_STORAGE
+        cacheProtocol = CACHE_PROTOCOL.LOCAL_STORAGE,
+        io
     } = builder;
 
     let txt;
 
-    if (cacheProtocol === CACHE_PROTOCOL.LOCAL_STORAGE) {
+    if (io) {
+        txt = await io.input();
+    } else if (cacheProtocol === CACHE_PROTOCOL.LOCAL_STORAGE) {
         txt = window.localStorage.getItem(CACHE_STORAGE_PATH);
     }
 
     const j = JSON.parse(decryptString(txt || '', cachePassword, cachePassword) || '{}');
-    
+
     Object.entries(j).forEach(([k, v]) => {
         CacheStore[k] = v;
     });

package/src/helpers/values.js

@@ -37,8 +37,8 @@ export const WRITE_OPS = {
     $MAX: '$max',
     $MIN: '$min',
     $MUL: '$mul',
-    $RENAME: '$rename'
-    // $SET_ON_INSERT: '$setOnInsert'
+    $RENAME: '$rename',
+    $SET_ON_INSERT: '$setOnInsert'
 };
 export const WRITE_OPS_LIST = Object.values(WRITE_OPS);
 

package/src/helpers/variables.js

@@ -5,6 +5,7 @@ export const Scoped = {
     IS_TOKEN_READY: {},
     InitializedProject: {},
     ReleaseCacheData: undefined,
+    IsStoreReady: false,
     AuthJWTToken: {},
     cacheStorageReducer: undefined,
     TokenRefreshTimer: {},

package/src/index.d.ts

@@ -25,9 +25,26 @@ interface mtimestamp { $timestamp: 'now' }
 export const TIMESTAMP: mtimestamp;
 export function DOCUMENT_EXTRACTION(path: string): { $dynamicValue: number };
 
+interface ReleaseCacheOption_IO {
+    /**
+     * This password will be used to encrypt data stored locally
+     */
+    cachePassword?: string;
+    io: {
+        /**
+         * feeds mosquito-transport data
+         */
+        input: () => string;
+        /**
+         * emits mosquito-transport internal data
+         */
+        output: (data: string) => void;
+    }
+}
+
 interface ReleaseCacheOption {
     /**
-     * This password will be used to securely store your data locally
+     * This password will be used to encrypt data stored locally
      */
     cachePassword?: string;
     /**
@@ -61,7 +78,7 @@ interface BatchWriteConfig extends WriteConfig {
 
 export class MosquitoTransport {
     constructor(config: MTConfig);
-    static releaseCache(option?: ReleaseCacheOption): void;
+    static releaseCache(option?: ReleaseCacheOption | ReleaseCacheOption_IO): void;
     getDatabase(dbName?: string, dbUrl?: string): GetDatabase;
     collection(path: string): MTCollection;
     auth(): MTAuth;
@@ -273,6 +290,7 @@ interface DocumentFind {
     $or?: any[];
     $text?: {
         $search: string;
+        $field: string;
         $language?: string;
         $caseSensitive?: boolean;
         $diacriticSensitive?: boolean;
@@ -302,8 +320,11 @@ interface MTAuth {
     listenVerifiedStatus: (callback?: (verified?: boolean) => void, onError?: (error?: ErrorResponse) => void) => () => void;
     listenAuthToken: (callback: (token: string) => void) => () => void;
     getAuthToken: () => Promise<string>;
-    listenAuth: (callback: (auth: AuthData) => void) => () => void;
-    getAuth: () => Promise<AuthData>;
+    getRefreshToken: () => Promise<string>;
+    getRefreshTokenData: () => Promise<RefreshTokenData>;
+    parseToken: () => string;
+    listenAuth: (callback: (auth: TokenEventData) => void) => () => void;
+    getAuth: () => Promise<TokenEventData>;
     signOut: () => Promise<void>;
     forceRefreshToken: () => Promise<string>;
 }
@@ -324,14 +345,35 @@ interface AuthData {
     signupMethod: 'google' | 'apple' | 'custom' | 'github' | 'twitter' | 'facebook' | string;
     currentAuthMethod: 'google' | 'apple' | 'custom' | 'github' | 'twitter' | 'facebook' | string;
     joinedOn: number;
-    encryptionKey: string;
     uid: string;
     claims: Object;
     emailVerified: boolean;
+    tokenID: string;
+    disabled: boolean;
+    entityOf: string;
     profile: {
         photo: string;
         name: string;
-    }
+    },
+    exp: number;
+    aud: string;
+    iss: string;
+    sub: string;
+}
+
+interface RefreshTokenData {
+    uid: string;
+    tokenID: string;
+    isRefreshToken: true;
+}
+
+interface TokenEventData extends AuthData {
+    tokenManager: TokenManager | null;
+}
+
+interface TokenManager {
+    refreshToken: string;
+    accessToken: string;
 }
 
 declare type Base64String = string;

package/src/index.js

@@ -306,8 +306,17 @@ const validateReleaseCacheProp = (prop) => {
                 throw `Invalid value supplied to cachePassword, value must be a string and greater than 0 characters`;
         } else if (k === 'cacheProtocol') {
             if (!cacheList.includes(`${v}`)) throw `unknown value supplied to ${k}, expected any of ${cacheList}`;
+        } else if (k === 'io') {
+            Object.entries(v).forEach(([k, v]) => {
+                if (k === 'input' || k === 'output') {
+                    if (typeof v !== 'function')
+                        throw `Invalid value supplied to "io.${k}", expected a function but got "${v}"`;
+                } else throw `Unexpected property named "io.${k}"`;
+            });
         } else throw `Unexpected property named ${k}`;
     });
+
+    if (!prop?.io && !prop?.cacheProtocol) throw 'You need to provide either "io" or "cacheProtocol"';
 }
 
 const validator = {

package/src/products/auth/accessor.js

@@ -2,8 +2,8 @@ import setLargeTimeout from "set-large-timeout";
 import { doSignOut } from ".";
 import EngineApi from "../../helpers/EngineApi";
 import { AuthTokenListener, TokenRefreshListener } from "../../helpers/listeners";
-import { decodeBinary, deserializeE2E, listenReachableServer, simplifyCaughtError } from "../../helpers/peripherals";
-import { awaitReachableServer, awaitStore, buildFetchInterface, simplifyError, updateCacheStore } from "../../helpers/utils";
+import { decodeBinary, deserializeE2E, listenReachableServer } from "../../helpers/peripherals";
+import { awaitStore, buildFetchInterface, simplifyError, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 
 export const listenToken = (callback, projectUrl) =>
@@ -15,6 +15,7 @@ export const listenToken = (callback, projectUrl) =>
 export const injectFreshToken = async (config, { token, refreshToken }) => {
     const { projectUrl } = config;
 
+    await awaitStore();
     CacheStore.AuthStore[projectUrl] = { token, refreshToken };
     Scoped.AuthJWTToken[projectUrl] = token;
     updateCacheStore();
@@ -102,7 +103,6 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
             if (isForceRefresh) Scoped.InitiatedForcedToken[projectUrl] = true;
             updateCacheStore();
             initTokenRefresher(builder);
-            invalidateToken(builder, token);
         } else reject(lostProcess.simpleError);
     } catch (e) {
         if (e.simpleError) {
@@ -128,23 +128,4 @@ const refreshToken = (builder, processRef, remainRetries = 7, initialRetries = 7
             }, projectUrl);
         }
     }
-});
-
-export const invalidateToken = async (builder, token) => {
-    try {
-        const { projectUrl, accessKey, uglify, serverE2E_PublicKey } = builder;
-        await awaitReachableServer(projectUrl);
-
-        const [reqBuilder] = buildFetchInterface({
-            body: { token },
-            accessKey,
-            uglify,
-            serverE2E_PublicKey
-        });
-
-        const r = await (await fetch(EngineApi._invalidateToken(projectUrl, uglify), reqBuilder)).json();
-        if (r.simpleError) throw r;
-    } catch (e) {
-        throw simplifyCaughtError(e).simpleError;
-    }
-}
+});

package/src/products/auth/index.js

@@ -105,6 +105,13 @@ export class MTAuth {
 
     listenAuthToken = (callback) => listenToken(callback, this.builder.projectUrl);
 
+    getRefreshToken = async () => {
+        await awaitStore();
+        return CacheStore.AuthStore[this.builder.projectUrl]?.refreshToken;
+    }
+    
+    parseToken = (token) => parseToken(token);
+
     getAuthToken = () => new Promise(resolve => {
         const l = listenToken(t => {
             l();

package/src/products/database/validator.js

@@ -202,12 +202,19 @@ const evaluateFilter = (data = {}, filter = {}) => {
                 } else logics.push(false);
             } else if ($ === $TEXT) {
                 if (commandSplit.slice(-1)[0].$ === '$search') {
-                    const { $caseSensitive, $localFields = [], $search } = dataObj.$text;
+                    const { $caseSensitive, $search, $field } = filter.$text;
 
                     if (typeof value !== 'string' || typeof $search !== 'string')
                         throw `$search must have a string value`;
+                    if (!$field) throw '"$field" is required inside "$text" operator when "disableCache=false"';
+                    const fieldArr = Array.isArray($field) ? $field : [$field];
 
-                    const searchTxt = $localFields.map(v => getLodash(dataObj, v || '')).map(v =>
+                    fieldArr.forEach(v => {
+                        if (typeof v !== 'string' || !v.trim())
+                            throw `invalid item inside "$field", expected a non-empty string but got "${v}"`;
+                    });
+
+                    const searchTxt = fieldArr.map(v => getLodash(dataObj, v || '')).map(v =>
                         `${typeof v === 'string' ? v :
                             Array.isArray(v) ? v.map(v => typeof v === 'string' ? v : '').join(' ').trim() : ''}`.trim()
                     ).join(' ').trim();