react-native-mosquito-transport 0.0.18 → 0.0.21

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;
+};

package/src/helpers/values.js

@@ -6,10 +6,7 @@ export const CACHE_STORAGE_PATH = encodeBinary('MOSQUITO_TRANSPORT_FREEZER'),
     LOCAL_STORAGE_PATH = () => {
         const fs = require('react-native-fs');
         return `${Platform.OS === 'android' ? fs.ExternalCachesDirectoryPath : fs.CachesDirectoryPath}/${encodeBinary('MOSQUITO_TRANSPORT_STORAGE')}`;
-    },
-    DEFAULT_DB_NAME = 'DEFAULT_DB',
-    DEFAULT_DB_URL = 'mongodb://127.0.0.1:27017',
-    DEFAULT_ENCRYPT_IV = '****';
+    };
 
 export const CACHE_PROTOCOL = {
     ASYNC_STORAGE: 'async-storage',
@@ -23,7 +20,8 @@ export const RETRIEVAL = {
     STICKY_RELOAD: 'sticky-reload',
     DEFAULT: 'default',
     CACHE_NO_AWAIT: 'cache-no-await',
-    NO_CACHE_NO_AWAIT: 'no-cache-no-await'
+    NO_CACHE_NO_AWAIT: 'no-cache-no-await',
+    NO_CACHE_AWAIT: 'no-cache-await'
 };
 
 export const DELIVERY = {
@@ -35,48 +33,11 @@ export const DELIVERY = {
     CACHE_NO_AWAIT: 'cache-no-await'
 };
 
-export const WRITE_OPS = {
-    $SET: '$set',
-    $PUSH: '$push',
-    $PULL: '$pull',
-    $UNSET: '$unset',
-    $INC: '$inc',
-    $MAX: '$max',
-    $MIN: '$min',
-    $MUL: '$mul',
-    $RENAME: '$rename',
-    $SET_ON_INSERT: '$setOnInsert'
-};
-export const WRITE_OPS_LIST = Object.values(WRITE_OPS);
-
-export const READ_OPS = {
-    $IN: '$in',
-    $ALL: '$all',
-    $NIN: '$nin',
-    $GT: '$gt',
-    $GTE: '$gte',
-    $LT: '$lt',
-    $LTE: '$lte',
-    $TEXT: '$text',
-    // $EQ: '$eq',
-    // $REGEX: '$regex',
-    // $EXISTS: '$exists',
-    $NEAR: '$near',
-    $TYPE: '$type',
-    $SIZE: '$size',
-    // $NE: '$ne'
-};
-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',
+    GOOGLE: 'google',
+    FACEBOOK: 'facebook',
     PASSWORD: 'password',
-    TWITTER: 'x.com',
-    GITHUB: 'github.com',
-    APPLE: 'apple.com'
+    TWITTER: 'x',
+    GITHUB: 'github',
+    APPLE: 'apple'
 };

package/src/helpers/variables.js

@@ -1,4 +1,6 @@
+
 export const Scoped = {
+    serverTimeOffset: undefined,
     PendingIte: 0,
     AnyProcessIte: 0,
     IS_CONNECTED: {},
@@ -19,16 +21,22 @@ export const Scoped = {
     PendingDbReadCollective: {
         pendingProcess: {},
         pendingResolution: {}
-    }
-}
+    },
+    ActiveDatabaseListeners: {},
+    OutgoingWrites: {},
+    /**
+     * @type {Promise<any> | undefined}
+     */
+    dispatchingWritesPromise: undefined
+};
 
 export const CacheStore = {
     DatabaseStore: {},
-    DatabaseRecords: {},
     DatabaseCountResult: {},
+    DatabaseStats: {},
     AuthStore: {},
+    PendingAuthPurge: {},
+    EmulatedAuth: {},
     PendingWrites: {},
     FetchedStore: {}
-}
-
-export const CacheConstant = { ...CacheStore };
+};

package/src/index.d.ts

@@ -1,10 +1,12 @@
 interface RNMTConfig {
     dbName?: string;
     dbUrl?: string;
-    heapMemory?: number;
     projectUrl: string;
     disableCache?: boolean;
     accessKey: string;
+    /**
+     * maximum numbers of attempts to retry sending a request
+     */
     maxRetries?: number;
     /**
      * setting this to true will encrypt all outgoing and incoming request. This enables end-to-end encryption using [Tweetnacl](https://github.com/dchest/tweetnacl-js) and to prevent request interception by browser extensions, network intermediaries or other hijacking tools
@@ -14,6 +16,18 @@ interface RNMTConfig {
      * this is the base64 public key for end-to-end encryption on the server
      */
     serverE2E_PublicKey?: string;
+    /**
+     * extra headers that will be appended to all outgoing request in this instance
+     */
+    extraHeaders?: {
+        [key: string]: string
+    };
+    /**
+     * true to deserialize BSON values to their Node.js closest equivalent types
+     * 
+     * @default true
+     */
+    castBSON?: boolean;
 }
 
 interface GetDatabase {
@@ -23,7 +37,7 @@ interface GetDatabase {
 interface mtimestamp { $timestamp: 'now' }
 
 export const TIMESTAMP: mtimestamp;
-export function DOCUMENT_EXTRACTION(path: string): { $dynamicValue: number };
+export function DOCUMENT_EXTRACTION(path: string): { $dynamicValue: string };
 
 type longitude = number;
 type latitude = number;
@@ -34,7 +48,7 @@ export function GEO_JSON(latitude: latitude, longitude: longitude): {
 };
 
 export function FIND_GEO_JSON(coordinates: [latitude, longitude], offSetMeters: number, centerMeters?: number): {
-    $near: {
+    $nearSphere: {
         $geometry: {
             type: "Point",
             coordinates: [longitude, latitude]
@@ -46,13 +60,20 @@ export function FIND_GEO_JSON(coordinates: [latitude, longitude], offSetMeters:
 
 export const AUTH_PROVIDER_ID: auth_provider_id;
 
+/**
+ * useful for avoiding encrypting data and extra overhead
+ */
+export class DoNotEncrypt {
+    value: any;
+}
+
 interface auth_provider_id {
-    GOOGLE: 'google.com';
-    FACEBOOK: 'facebook.com';
+    GOOGLE: 'google';
+    FACEBOOK: 'facebook';
     PASSWORD: 'password';
-    TWITTER: 'x.com';
-    GITHUB: 'github.com';
-    APPLE: 'apple.com';
+    TWITTER: 'x';
+    GITHUB: 'github';
+    APPLE: 'apple';
 }
 
 type auth_provider_id_values = auth_provider_id['GOOGLE'] |
@@ -76,7 +97,7 @@ interface ReleaseCacheOption_IO {
          * emits mosquito-transport internal data
          */
         output: (data: string) => void;
-    }
+    };
 }
 
 interface ReleaseCacheOption {
@@ -90,6 +111,17 @@ interface ReleaseCacheOption {
      * - reat-native-fs: uses [reat-native-fs](https://github.com/itinance/react-native-fs) for storing data, make sure you have this package installed before setting this as the value
      */
     cacheProtocol?: 'async-storage' | 'reat-native-fs';
+    /**
+     * the maximum database size
+     */
+    heapMemory?: number;
+    /**
+     * true to cache database and {@link RNMT.fetchHttp} data.
+     * the value only applies to in-memory storage protocol such as `io`, `async-storage` and `reat-native-fs`
+     * 
+     * @default false
+     */
+    promoteCache?: boolean;
 }
 
 interface RNMTSocket {
@@ -97,7 +129,7 @@ interface RNMTSocket {
         emitWithAck: (...args: any) => Promise<any>;
     });
     emit: (...args: any) => void;
-    emitWithAck: () => Promise<any>;
+    emitWithAck: (...args: any) => Promise<any>;
     on: (route: string, callback?: () => any) => void;
     once: (route: string, callback?: () => any) => void;
     destroy: () => void;
@@ -116,7 +148,7 @@ interface BatchWriteConfig extends WriteConfig {
 
 export default class RNMT {
     constructor(config: RNMTConfig);
-    static releaseCache(option?: ReleaseCacheOption | ReleaseCacheOption_IO): void;
+    static initializeCache(option?: ReleaseCacheOption | ReleaseCacheOption_IO): void;
     getDatabase(dbName?: string, dbUrl?: string): GetDatabase;
     collection(path: string): RNMTCollection;
     auth(): RNMTAuth;
@@ -244,7 +276,7 @@ interface WriteConfig {
     delivery?: Delievery;
 }
 
-type Retrieval = 'sticky' | 'sticky-no-await' | 'sticky-reload' | 'default' | 'cache-no-await' | 'no-cache-no-await';
+type Retrieval = 'sticky' | 'sticky-no-await' | 'sticky-reload' | 'default' | 'cache-no-await' | 'no-cache-no-await' | 'no-cache-await';
 
 interface GetConfig {
     excludeFields?: string | string[];
@@ -253,17 +285,19 @@ interface GetConfig {
     /**
      * This property determines how requested data is being access and handled
      * 
-     * - default: we try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we await for client->server connectivity, then try getting the data, return it and cache it for future need. ⚠️ This respect disableCache value
+     * - default: will try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we await for client->server connectivity, then try getting the data, return it and cache it for future need. ⚠️ This respect disableCache value
      * 
      * - sticky: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need. ⚠️ This does not respect disableCache value
      * 
-     * - sticky-no-await: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, we try to get fresh data from serve, we throw an error if server is not reachable else if server returns requested data, we return such data and cache it for future need. ⚠️ This does not respect disableCache value
+     * - sticky-no-await: if local data exists for the specified query, such data is returned and no-ops afterwards. If no local data is found, will try to get fresh data from serve, we throw an error if server is not reachable else if server returns requested data, we return such data and cache it for future need. ⚠️ This does not respect disableCache value
      * 
-     * - sticky-reload: if local data exists for the specified query, such data is returned, then we try getting fresh data from the server and caching it for future need. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need
+     * - sticky-reload: if local data exists for the specified query, such data is returned, then will try getting fresh data from the server and caching it for future need. If no local data is found, we await for client->server connectivity and try to get fresh data from serve, return the data and cache it for future need
      * 
-     * - cache-no-await: we try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we throw an error
+     * - cache-no-await: will try getting fresh data from server if server is reachable, else we check if local data exists and return it, if no local data exist we throw an error
      * 
-     * - no-cache-no-await: we try getting fresh data from server if server is reachable, else we throw an error
+     * - no-cache-no-await: will try getting fresh data from server if server is reachable, else we throw an error
+     * 
+     * - no-cache-await: will try getting fresh data from server when server is reachable and the result won't be cache
      * 
      * To learn and see more examples on this, Please visit https://brainbehindx.com/mosquito-transport/docs/reading_data/retrieval
      */
@@ -278,33 +312,31 @@ interface GetConfig {
      */
     episode?: 0 | 1;
     /**
-     * send authentication token along with this request
+     * disable sending authentication token along with this request
      * 
      * @default - false
      */
     disableAuth?: boolean;
     /**
-     * this reduces duplicate query calls with the same operation resultant to a single request call.
+     * this reduces redundant network calls for the same query operation to a single request call.
      * 
-     * - Example:
+     * @example
      * 
      * ```js
      * 
      * const mserver = new RNMT({ projectUrl: 'http..', accessKey: '..'});
-     * const minimizedUser = ['james', 'john', 'james', 'john'];
-     * const unminimizedUser = ['anthony', 'albert', 'anthony', 'albert'];
      * 
-     * // operation will be reduced to two request: james and john
+     * // operation will be reduced to only one request
      * 
-     * minimizedUser.forEach(e=> {
-     *   mserver.collection('user').findOne({ _id: e }).get();
-     * });
+     * for (let i = 0; i < 1000; i++) {
+     *     mserver.collection('user').findOne({ company: 'brainbehindx' }).get({ disableMinimizer: false });
+     * }
      * 
-     * // operation will not be reduced and therefore four request will be sent: anthony, albert, anthony, albert
+     * // operation will not be reduced and therefore 1000 network calls will be made
      * 
-     * unminimizedUser.forEach(e=> {
-     *   mserver.collection('user').findOne({ _id: e }).get();
-     * });
+     * for (let i = 0; i < 1000; i++) {
+     *     mserver.collection('user').findOne({ company: 'brainbehindx' }).get({ disableMinimizer: true });
+     * }
      * ```
      * defaults to false
      * 
@@ -318,8 +350,13 @@ interface GetConfigExtraction {
     sort: string;
     direction?: 'desc' | 'asc' | 1 | -1
     collection: string;
-    find?: DocumentFind;
-    findOne?: DocumentFind
+    find?: DocumentFind | DynamicValueExtraction<{ $dynamicValue: string }>;
+    findOne?: DocumentFind | DynamicValueExtraction<{ $dynamicValue: string }>;
+    returnOnly: string | string[]
+}
+
+interface DynamicValueExtraction<T> {
+    [key: string]: T
 }
 
 interface DocumentFind {
@@ -356,15 +393,16 @@ interface RNMTAuth {
     twitterSignin: () => Promise<SignupResult>;
     githubSignin: () => Promise<SignupResult>;
     listenVerifiedStatus: (callback?: (verified?: boolean) => void, onError?: (error?: ErrorResponse) => void) => () => void;
-    listenAuthToken: (callback: (token: string) => void) => () => void;
-    getAuthToken: () => Promise<string>;
-    getRefreshToken: () => Promise<string>;
-    getRefreshTokenData: () => Promise<RefreshTokenData>;
-    parseToken: () => string;
-    listenAuth: (callback: (auth: TokenEventData) => void) => () => void;
+    listenAuthToken: (callback: (token: string | null) => void) => () => void;
+    getAuthToken: () => Promise<string | null>;
+    getRefreshToken: () => Promise<string | undefined>;
+    getRefreshTokenData: () => Promise<RefreshTokenData | undefined>;
+    parseToken: (token: string) => AuthData | RefreshTokenData;
+    listenAuth: (callback: (auth: TokenEventData | null) => void) => () => void;
     getAuth: () => Promise<TokenEventData>;
     signOut: () => Promise<void>;
     forceRefreshToken: () => Promise<string>;
+    emulate: (projectUrl?: string) => Promise<void>;
 }
 
 interface SigninResult {
@@ -403,10 +441,14 @@ interface RefreshTokenData {
     uid: string;
     tokenID: string;
     isRefreshToken: true;
+    exp: number;
+    aud: string;
+    iss: string;
+    sub: string;
 }
 
 interface TokenEventData extends AuthData {
-    tokenManager: TokenManager | null;
+    tokenManager: TokenManager;
 }
 
 interface TokenManager {
@@ -414,9 +456,27 @@ interface TokenManager {
     accessToken: string;
 }
 
+interface UploadOptions {
+    /**
+     * optionally create hash for this upload to save disk space
+     */
+    createHash?: boolean;
+    /**
+     * wait for a reachable server before initiating the upload task
+     */
+    awaitServer?: boolean;
+}
+
+interface DownloadOptions {
+    /**
+     * wait for a reachable server before initiating the download task
+     */
+    awaitServer?: boolean;
+}
+
 interface RNMTStorage {
-    downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void) => () => void;
-    uploadFile: (file: string, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void) => () => void;
+    downloadFile: (link: string, onComplete?: (error?: ErrorResponse, filepath?: string) => void, destination?: string, onProgress?: (stats: DownloadProgressStats) => void, options?: DownloadOptions) => () => void;
+    uploadFile: (file: string, destination: string, onComplete?: (error?: ErrorResponse, downloadUrl?: string) => void, onProgress?: (stats: UploadProgressStats) => void, options?: UploadOptions) => () => void;
     deleteFile: (path: string) => Promise<void>;
     deleteFolder: (folder: string) => Promise<void>;
 }
@@ -440,13 +500,13 @@ interface ErrorResponse {
 }
 
 /** @public */
-export declare type Sort = string | Exclude<SortDirection, {
+declare type Sort = string | Exclude<SortDirection, {
     $meta: string;
 }> | string[] | {
     [key: string]: SortDirection;
 } | Map<string, SortDirection> | [string, SortDirection][] | [string, SortDirection];
 
 /** @public */
-export declare type SortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending' | {
+declare type SortDirection = 1 | -1 | 'asc' | 'desc' | 'ascending' | 'descending' | {
     $meta: string;
 };