mosquito-transport-js 0.2.3 → 0.2.5

package/TODO

@@ -1,3 +1,4 @@
 - fix local cache query on sqlite and fs
 - fix and add all mongodb query and update operator
-- reauthenticate
+- reauthenticate
+- change `Object` in d.ts to [key: string]: any

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mosquito-transport-js",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Javascript web sdk for mosquito-transport (https://github.com/deflexable/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -33,11 +33,16 @@
     "@types/lodash": "^4.14.194",
     "buffer": "^6.0.3",
     "crypto-js": "^4.2.0",
+    "fast-json-stable-stringify": "^2.1.0",
+    "guard-object": "^1.0.6",
     "json-buffer": "^3.0.1",
-    "lodash": "^4.17.21",
+    "lodash.get": "^4.4.2",
+    "lodash.isequal": "^4.5.0",
+    "lodash.set": "^4.3.2",
+    "lodash.unset": "^4.5.2",
     "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/utils.js

@@ -1,7 +1,7 @@
 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; }
@@ -20,7 +20,7 @@ export const updateCacheStore = () => {
         );
 
         if (io) {
-            io.ouput(txt);
+            io.output(txt);
         } else if (cacheProtocol === CACHE_PROTOCOL.LOCAL_STORAGE) {
             window.localStorage.setItem(CACHE_STORAGE_PATH, txt);
         }

package/src/helpers/values.js

@@ -63,4 +63,13 @@ export const READ_OPS_LIST = Object.values(READ_OPS);
 
 export const Regexs = {
     LINK: () => /(\b(https?|ftp):\/\/[-A-Z0-9+&@#\/%?=~_|!:,.;]*[-A-Z0-9+&@#\/%=~_|])/ig
-}
+};
+
+export const AUTH_PROVIDER_ID = {
+    GOOGLE: 'google.com',
+    FACEBOOK: 'facebook.com',
+    PASSWORD: 'password',
+    TWITTER: 'x.com',
+    GITHUB: 'github.com',
+    APPLE: 'apple.com'
+};

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,6 +25,43 @@ interface mtimestamp { $timestamp: 'now' }
 export const TIMESTAMP: mtimestamp;
 export function DOCUMENT_EXTRACTION(path: string): { $dynamicValue: number };
 
+type longitude = number;
+type latitude = number;
+
+export function GEO_JSON(latitude: latitude, longitude: longitude): {
+    type: "Point",
+    coordinates: [longitude, latitude],
+};
+
+export function FIND_GEO_JSON(coordinates: [latitude, longitude], offSetMeters: number, centerMeters?: number): {
+    $near: {
+        $geometry: {
+            type: "Point",
+            coordinates: [longitude, latitude]
+        },
+        $minDistance: number | 0,
+        $maxDistance: number
+    }
+};
+
+export const AUTH_PROVIDER_ID: auth_provider_id;
+
+interface auth_provider_id {
+    GOOGLE: 'google.com';
+    FACEBOOK: 'facebook.com';
+    PASSWORD: 'password';
+    TWITTER: 'x.com';
+    GITHUB: 'github.com';
+    APPLE: 'apple.com';
+}
+
+type auth_provider_id_values = auth_provider_id['GOOGLE'] |
+    auth_provider_id['FACEBOOK'] |
+    auth_provider_id['PASSWORD'] |
+    auth_provider_id['GITHUB'] |
+    auth_provider_id['TWITTER'] |
+    auth_provider_id['APPLE'];
+
 interface ReleaseCacheOption_IO {
     /**
      * This password will be used to encrypt data stored locally
@@ -290,6 +327,7 @@ interface DocumentFind {
     $or?: any[];
     $text?: {
         $search: string;
+        $field: string;
         $language?: string;
         $caseSensitive?: boolean;
         $diacriticSensitive?: boolean;
@@ -319,8 +357,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>;
 }
@@ -338,17 +379,38 @@ interface SignupResult extends SigninResult {
 interface AuthData {
     email?: string;
     metadata: Object;
-    signupMethod: 'google' | 'apple' | 'custom' | 'github' | 'twitter' | 'facebook' | string;
-    currentAuthMethod: 'google' | 'apple' | 'custom' | 'github' | 'twitter' | 'facebook' | string;
+    signupMethod: auth_provider_id_values;
+    currentAuthMethod: auth_provider_id_values;
     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

@@ -5,12 +5,12 @@ import { MTAuth } from "./products/auth";
 import { MTCollection, batchWrite } from "./products/database";
 import { MTStorage } from "./products/storage";
 import { ServerReachableListener, TokenRefreshListener } from "./helpers/listeners";
-import { initTokenRefresher, listenTokenReady, triggerAuthToken } from "./products/auth/accessor";
+import { initTokenRefresher, listenToken, listenTokenReady, parseToken, triggerAuthToken } from "./products/auth/accessor";
 import { TIMESTAMP, DOCUMENT_EXTRACTION, FIND_GEO_JSON, GEO_JSON } from "./products/database/types";
 import { mfetch } from "./products/http_callable";
 import { io } from "socket.io-client";
 import { validateCollectionPath } from "./products/database/validator";
-import { CACHE_PROTOCOL, Regexs } from "./helpers/values";
+import { AUTH_PROVIDER_ID, CACHE_PROTOCOL, Regexs } from "./helpers/values";
 import { trySendPendingWrite } from "./products/database/accessor";
 import EngineApi from './helpers/EngineApi';
 import { parse, stringify } from 'json-buffer';
@@ -47,21 +47,42 @@ export class MosquitoTransport {
             triggerAuthToken(projectUrl);
             initTokenRefresher({ ...this.config }, true);
 
-            const socket = io(`${this.config.wsPrefix}://${projectUrl.split('://')[1]}`, {
-                transports: ['websocket', 'polling', 'flashsocket'],
-                auth: { _m_internal: true, _from_base: true }
-            });
+            const disconnectionGlich = {};
+            let socket, lastUid, lastSocketProcess = 0, hasInited;
 
-            socket.on('_signal_signout', () => {
-                this.auth().signOut();
-            });
+            listenToken((token, thisInited) => {
+                const user = token && parseToken(token);
 
-            socket.on('connect', () => {
-                ServerReachableListener.dispatch(projectUrl, true);
-            });
-            socket.on('disconnect', () => {
-                ServerReachableListener.dispatch(projectUrl, false);
-            });
+                const thisUid = (user?.uid || null);
+                if (lastUid === thisUid && (hasInited || !thisInited)) return;
+                if (!hasInited) hasInited = thisInited;
+                lastUid = thisUid;
+
+                if (lastSocketProcess) disconnectionGlich[lastSocketProcess] = true;
+                socket.close();
+
+                const thisProcess = ++lastSocketProcess;
+                socket = io(`${this.config.wsPrefix}://${projectUrl.split('://')[1]}`, {
+                    transports: ['websocket', 'polling', 'flashsocket'],
+                    auth: {
+                        _m_internal: true,
+                        _from_base: true,
+                        atoken: token
+                    }
+                });
+
+                socket.on('_signal_signout', () => {
+                    this.auth().signOut();
+                });
+
+                socket.on('connect', () => {
+                    ServerReachableListener.dispatch(projectUrl, true);
+                });
+                socket.on('disconnect', () => {
+                    if (!disconnectionGlich[thisProcess])
+                        ServerReachableListener.dispatch(projectUrl, false);
+                });
+            }, projectUrl);
 
             listenReachableServer(c => {
                 Scoped.IS_CONNECTED[projectUrl] = c;
@@ -300,26 +321,23 @@ export class MosquitoTransport {
 const validateReleaseCacheProp = (prop) => {
     const cacheList = [...Object.values(CACHE_PROTOCOL)];
 
-    if (prop?.io) {
-        Object.entries(prop).forEach(([k, v]) => {
-            if (k === 'input' || k === 'output') {
-                if (typeof v !== 'function')
-                    throw `Invalid value supplied to ${k}, expected a function but got "${v}"`;
-            } else if (k === 'cachePassword') {
-                if (typeof v !== 'string' || v.trim().length <= 0)
-                    throw `Invalid value supplied to cachePassword, value must be a string and greater than 0 characters`;
-            } else throw `Unexpected property named ${k}`;
-        });
-    } else {
-        Object.entries(prop).forEach(([k, v]) => {
-            if (k === 'cachePassword') {
-                if (typeof v !== 'string' || v.trim().length <= 0)
-                    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 throw `Unexpected property named ${k}`;
-        });
-    }
+    Object.entries(prop).forEach(([k, v]) => {
+        if (k === 'cachePassword') {
+            if (typeof v !== 'string' || v.trim().length <= 0)
+                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 = {
@@ -382,5 +400,6 @@ export {
     TIMESTAMP,
     DOCUMENT_EXTRACTION,
     FIND_GEO_JSON,
-    GEO_JSON
+    GEO_JSON,
+    AUTH_PROVIDER_ID
 };

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();

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();
@@ -112,6 +119,9 @@ export class MTAuth {
         }, this.builder.projectUrl);
     });
 
+    /**
+     * @type {import('../../index').RNMTAuth['listenAuth']}
+     */
     listenAuth = (callback) => {
         let lastTrig;
 

package/src/products/database/accessor.js

@@ -2,10 +2,10 @@ import { IS_RAW_OBJECT, objToUniqueString, queryEntries, shuffleArray, sortArray
 import { awaitStore, updateCacheStore } from "../../helpers/utils";
 import { CacheStore } from "../../helpers/variables";
 import { confirmFilterDoc } from "./validator";
-import getLodash from 'lodash/get';
-import setLodash from 'lodash/set';
-import unsetLodash from 'lodash/unset';
-import isEqual from 'lodash/isEqual';
+import getLodash from 'lodash.get';
+import setLodash from 'lodash.set';
+import unsetLodash from 'lodash.unset';
+import isEqual from 'lodash.isequal';
 import { DEFAULT_DB_NAME, DEFAULT_DB_URL, DELIVERY, RETRIEVAL, WRITE_OPS, WRITE_OPS_LIST } from "../../helpers/values";
 import { DatabaseRecordsListener } from "../../helpers/listeners";
 

package/src/products/database/index.js

@@ -8,7 +8,7 @@ import { addPendingWrites, generateRecordID, getRecord, insertRecord, listenQuer
 import { validateCollectionPath, validateFilter, validateReadConfig, validateWriteValue } from "./validator";
 import { awaitRefreshToken, listenToken } from "../auth/accessor";
 import { DEFAULT_DB_NAME, DEFAULT_DB_URL, DELIVERY, RETRIEVAL } from "../../helpers/values";
-import setLodash from 'lodash/set';
+import setLodash from 'lodash.set';
 
 export class MTCollection {
     constructor(config) {

package/src/products/database/validator.js

@@ -1,7 +1,7 @@
 import { IS_DECIMAL_NUMBER, IS_RAW_OBJECT, IS_WHOLE_NUMBER, queryEntries } from "../../helpers/peripherals";
 import { READ_OPS, READ_OPS_LIST, RETRIEVAL } from "../../helpers/values";
-import getLodash from 'lodash/get';
-import isEqual from 'lodash/isEqual';
+import getLodash from 'lodash.get';
+import isEqual from 'lodash.isequal';
 
 const dirn = ['desc', 'asc', 'ascending', 'descending'];