react-native-mosquito-transport 0.0.36 → 0.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",

package/src/helpers/purger.js

@@ -12,7 +12,7 @@ const inlineFsData = (arr, access_id_node = 'access_id') =>
         return obj;
     });
 
-export const purgeRedundantRecords = async (data, builder) => {
+export const purgeRedundantRecords = async (data, builder, willPurge) => {
     const { io, maxLocalDatabaseSize = 10485760, maxLocalFetchHttpSize = 10485760 } = builder;
 
     /**
@@ -20,9 +20,15 @@ export const purgeRedundantRecords = async (data, builder) => {
      */
     const { _db_size, _fetcher_size, counters, database, fetchers } = data.DatabaseStats || {};
 
+    const shouldPurgeDb = Validator.POSITIVE_NUMBER(_db_size) && maxLocalDatabaseSize && _db_size >= maxLocalDatabaseSize;
+    const shouldPurgeFetcher = Validator.POSITIVE_NUMBER(_fetcher_size) && maxLocalFetchHttpSize && _fetcher_size >= maxLocalFetchHttpSize;
+
+    if (shouldPurgeDb) willPurge(['DatabaseStore', 'DatabaseCountResult', 'DatabaseStats']);
+    if (shouldPurgeFetcher) willPurge(['FetchedStore', 'DatabaseStats']);
+
     if (io) {
         const purgeDatabase = () => {
-            if (!Validator.POSITIVE_NUMBER(_db_size) || !maxLocalDatabaseSize || _db_size < maxLocalDatabaseSize) return;
+            if (!shouldPurgeDb) return;
             const DbListing = [];
 
             breakDbMap(data.DatabaseStore, (projectUrl, dbUrl, dbName, path, value) => {
@@ -98,7 +104,7 @@ export const purgeRedundantRecords = async (data, builder) => {
             });
         }
         const purgeFetcher = () => {
-            if (!Validator.POSITIVE_NUMBER(_fetcher_size) || !maxLocalFetchHttpSize || _fetcher_size < maxLocalFetchHttpSize) return;
+            if (!shouldPurgeFetcher) return;
             const redundantFetchRanking = Object.entries(data.FetchedStore).map(([projectUrl, access_id_Obj]) =>
                 Object.entries(access_id_Obj).map(([access_id, data]) => ({
                     access_id,
@@ -133,7 +139,7 @@ export const purgeRedundantRecords = async (data, builder) => {
         await Promise.allSettled([
             (async () => {
                 try {
-                    if (!Validator.POSITIVE_NUMBER(_db_size) || !maxLocalDatabaseSize || _db_size < maxLocalDatabaseSize) return;
+                    if (!shouldPurgeDb) return;
                     const instances = [];
 
                     [database, counters].forEach((map, i) => {
@@ -204,7 +210,7 @@ export const purgeRedundantRecords = async (data, builder) => {
             })(),
             (async () => {
                 try {
-                    if (!Validator.POSITIVE_NUMBER(_fetcher_size) || !maxLocalFetchHttpSize || _fetcher_size < maxLocalFetchHttpSize) return;
+                    if (!shouldPurgeFetcher) return;
 
                     const redundantFetchRanking = await Promise.all(
                         Object.entries(fetchers).map(async ([projectUrl]) => {

package/src/helpers/utils.js

@@ -2,10 +2,11 @@ import { ServerReachableListener, StoreReadyListener } from "./listeners";
 import { CacheStore, Scoped } from "./variables";
 import { serializeE2E } from "./peripherals";
 import { DatastoreParser } from "../products/database/bson";
-import { deserialize, serialize } from "entity-serializer";
+import { deserialize } from "entity-serializer";
 import { breakDbMap, purgeRedundantRecords } from "./purger";
 import { FS_PATH, getSystem } from "./fs_manager";
 import cloneDeep from "lodash/cloneDeep";
+import { Buffer } from "buffer";
 
 const { FILE_NAME, TABLE_NAME } = FS_PATH;
 
@@ -26,7 +27,20 @@ const prefillDatastore = (obj, caller) => {
     return obj;
 };
 
+const prefillFetcher = (store, encode) => {
+    store = cloneDeep(store);
+    Object.values(store).forEach(accessIdObj => {
+        Object.values(accessIdObj).forEach(value => {
+            value.data.buffer = encode ?
+                Buffer.from(value.data.buffer).toString('base64')
+                : Buffer.from(value.data.buffer, 'base64');
+        });
+    });
+    return store;
+}
+
 export const updateCacheStore = async (node) => {
+    node = node && node.filter((v, i, a) => a.indexOf(v) === i);
     const { io, promoteCache } = Scoped.ReleaseCacheData;
 
     const {
@@ -35,6 +49,7 @@ export const updateCacheStore = async (node) => {
         PendingAuthPurge,
         DatabaseStore,
         PendingWrites,
+        FetchedStore,
         ...restStore
     } = CacheStore;
 
@@ -55,7 +70,8 @@ export const updateCacheStore = async (node) => {
             PendingAuthPurge,
             ...promoteCache ? {
                 DatabaseStore: prefillDatastore(DatabaseStore, DatastoreParser.encode),
-                PendingWrites: minimizePendingWrite()
+                PendingWrites: minimizePendingWrite(),
+                FetchedStore: prefillFetcher(FetchedStore, true)
             } : {},
             ...promoteCache ? restStore : {}
         });
@@ -83,6 +99,7 @@ export const releaseCacheStore = async (builder) => {
     const { io } = builder;
 
     let data = {};
+    const tobePurged = [];
 
     try {
         if (io) {
@@ -93,6 +110,8 @@ export const releaseCacheStore = async (builder) => {
                     data.DatabaseStore,
                     r => DatastoreParser.decode(r, false)
                 );
+            if (data.FetchedStore)
+                data.FetchedStore = prefillFetcher(data.FetchedStore, false);
         } else {
             const query = await getSystem(FILE_NAME).list(TABLE_NAME, ['value']).catch(() => []);
             data = Object.fromEntries(
@@ -101,7 +120,9 @@ export const releaseCacheStore = async (builder) => {
                 )
             );
         }
-        await purgeRedundantRecords(data, builder);
+        await purgeRedundantRecords(data, builder, purgeNodes => {
+            tobePurged.push(...purgeNodes);
+        });
     } catch (e) {
         console.error('releaseCacheStore data err:', e);
     }
@@ -114,6 +135,9 @@ export const releaseCacheStore = async (builder) => {
     });
     Scoped.IsStoreReady = true;
     StoreReadyListener.dispatch('_', 'ready');
+    setTimeout(() => {
+        if (tobePurged.length) updateCacheStore(tobePurged);
+    }, 0);
 };
 
 export const getPrefferTime = () => Date.now() + (Scoped.serverTimeOffset || 0);

package/src/helpers/values.js

@@ -12,7 +12,6 @@ export const RETRIEVAL = {
 
 export const DELIVERY = {
     DEFAULT: 'default',
-    CACHE_AWAIT: 'cache-await', // TODO: remove
     CACHE_NO_AWAIT: 'cache-no-await',
     NO_CACHE_NO_AWAIT: 'no-cache-no-await',
     NO_CACHE_AWAIT: 'no-cache-await'

package/src/index.d.ts

@@ -1,3 +1,5 @@
+import { BSON } from "./vendor/bson";
+
 interface RNMTConfig {
     dbName?: string;
     dbUrl?: string;
@@ -75,6 +77,8 @@ export class DoNotEncrypt {
     value: any;
 }
 
+export { BSON }
+
 interface auth_provider_id {
     GOOGLE: 'google';
     FACEBOOK: 'facebook';
@@ -289,7 +293,7 @@ interface FetchHttpConfig {
     rawApproach?: boolean;
 }
 
-type Delievery = 'default' | 'no-cache' | 'no-await' | 'no-await-no-cache' | 'await-no-cache' | 'cache-no-await';
+type Delievery = 'default' | 'cache-no-await' | 'no-cache-no-await' | 'no-cache-await';
 
 interface WriteConfig {
     /**
@@ -297,21 +301,9 @@ interface WriteConfig {
      */
     disableAuth?: boolean;
 
-    DEFAULT: 'default',
-    CACHE_AWAIT: 'cache-await',
-    CACHE_NO_AWAIT: 'cache-no-await',
-    NO_CACHE_NO_AWAIT: 'no-cache-no-await',
-    NO_CACHE_AWAIT: 'no-cache-await'
-
     /**
      * This property determines how the write will be dispatch to the remote server
      *  TODO:
-     * 
-     * `default`: 
-     * `cache-await`: 
-     * `cache-no-await`: 
-     * `no-cache-no-await`: 
-     * `no-cache-await`: 
      */
     delivery?: Delievery;
 }

package/src/index.js

@@ -15,6 +15,7 @@ import { Validator } from 'guard-object';
 import cloneDeep from 'lodash/cloneDeep';
 import { Buffer } from 'buffer';
 import MTAuth, { purgePendingToken } from './products/auth';
+import { BSON } from "./vendor/bson";
 
 const {
     _listenCollection,
@@ -426,7 +427,7 @@ const validateReleaseCacheProp = (prop) => {
                         throw `Invalid value supplied to "io.${k}", expected a function but got "${v}"`;
                 } else throw `Unexpected property named "io.${k}"`;
             });
-            if (!v?.input && !v?.output) throw '"input" and "output" are required when "io" is provided';
+            if (!v?.input || !v?.output) throw '"input" and "output" are required when "io" is provided';
         } else if (k === 'promoteCache') {
             if (typeof v !== 'boolean') throw 'promoteCache should be a boolean';
         } else if (['maxLocalDatabaseSize', 'maxLocalFetchHttpSize'].includes(k)) {
@@ -507,7 +508,8 @@ export {
     DOCUMENT_EXTRACTION,
     FIND_GEO_JSON,
     GEO_JSON,
-    AUTH_PROVIDER_ID
+    AUTH_PROVIDER_ID,
+    BSON
 };
 
 export default RNMT;

package/src/products/database/accessor.js

@@ -6,7 +6,7 @@ import { DatabaseRecordsListener } from "../../helpers/listeners";
 import cloneDeep from "lodash/cloneDeep";
 import { BSONRegExp, ObjectId, Timestamp } from "../../vendor/bson";
 import { niceGuard, Validator } from "guard-object";
-import { TIMESTAMP } from "../..";
+import { TIMESTAMP } from "./types";
 import { docSize, incrementDatabaseSize } from "./counter";
 import { DatastoreParser, serializeToBase64 } from "./bson";
 import { FS_PATH, getSystem, useFS } from "../../helpers/fs_manager";
@@ -18,7 +18,7 @@ export const listenQueryEntry = (callback, { accessId, builder, config, processI
     const { projectUrl, dbName, dbUrl, path } = builder;
     const { episode = 0 } = config || {};
 
-    const nodeID = `${projectUrl}${dbName}${dbUrl}${path}`;
+    const nodeID = `${projectUrl}_${dbName}_${dbUrl}_${path}`;
 
     if (!Scoped.ActiveDatabaseListeners[nodeID])
         Scoped.ActiveDatabaseListeners[nodeID] = {};
@@ -379,12 +379,72 @@ export const addPendingWrites = async (builder, writeId, result) => {
     result = result && cloneDeep(result);
     await awaitStore();
 
+    const { projectUrl } = builder;
+    const pendingSnapshot = cloneDeep(result);
+    const { editions, linearWrite, pathChanges } = await syncCache(builder, result);
+
+    const isStaticWrite = !linearWrite.some(({ value, type }) => {
+        if (
+            [
+                'updateOne',
+                'updateMany',
+                'mergeOne',
+                'mergeMany'
+            ].includes(type)
+        ) {
+            const operators = Object.keys(value);
+            return ['$inc', '$min', '$max', '$mul', '$pop', '$pull', '$push', '$rename'].includes(operators);
+        }
+    });
+    const pureBuilder = {};
+
+    ['path', 'dbUrl', 'dbName', 'find', 'extraHeaders', 'maxRetries'].forEach(v => {
+        if (builder[v] !== undefined) pureBuilder[v] = builder[v];
+    });
+    pureBuilder.find = serializeToBase64({ _: pureBuilder.find });
+    pendingSnapshot.value = serializeToBase64({ _: pendingSnapshot.value });
+
+    let wasShifted;
+
+    if (isStaticWrite) {
+        // find previously matching pending write
+        const entries = Object.entries(CacheStore.PendingWrites[projectUrl] || {});
+
+        for (const [writeId, obj] of entries) {
+            if (!Scoped.OutgoingWrites[writeId]) {
+                if (
+                    niceGuard(
+                        { builder: obj.builder, snapshot: obj.snapshot },
+                        { builder: pureBuilder, snapshot: pendingSnapshot }
+                    )
+                ) {
+                    // shift it to the back
+                    obj.addedOn = Date.now();
+                    wasShifted = true;
+                    break;
+                }
+            }
+        }
+    }
+
+    if (!wasShifted)
+        poke(CacheStore.PendingWrites, [projectUrl, writeId], cloneDeep({
+            builder: pureBuilder,
+            snapshot: pendingSnapshot,
+            editions,
+            addedOn: Date.now()
+        }));
+
+    updateCacheStore(['DatabaseStore', 'PendingWrites', 'DatabaseStats']);
+    notifyDatabaseNodeChanges(builder, [...pathChanges]);
+};
+
+const syncCache = async (builder, result) => {
     const { io } = Scoped.ReleaseCacheData;
     const { projectUrl, dbUrl, dbName } = builder;
-    const editions = [];
     const duplicateSets = {};
+    const editions = [];
     const pathChanges = new Set([]);
-    const pendingSnapshot = cloneDeep(result);
 
     const linearWrite =
         result.type === 'batchWrite' ?
@@ -393,6 +453,8 @@ export const addPendingWrites = async (builder, writeId, result) => {
             )
             : [{ ...result, find: builder.find, path: builder.path }];
 
+    const copiedWrite = cloneDeep(linearWrite);
+
     await Promise.all(linearWrite.map(async ({ value: writeObj, find, type, path }) => {
         WriteValidator[type]({ find, value: writeObj });
         validateCollectionName(path);
@@ -638,138 +700,94 @@ export const addPendingWrites = async (builder, writeId, result) => {
         };
     }));
 
-    const isStaticWrite = !linearWrite.some(({ value, type }) => {
-        if (
-            [
-                'updateOne',
-                'updateMany',
-                'mergeOne',
-                'mergeMany'
-            ].includes(type)
-        ) {
-            const operators = Object.keys(value);
-            return ['$inc', '$min', '$max', '$mul', '$pop', '$pull', '$push', '$rename'].includes(operators);
-        }
-    });
-    const pureBuilder = {};
-
-    ['path', 'dbUrl', 'dbName', 'find', 'extraHeaders', 'maxRetries'].forEach(v => {
-        if (builder[v] !== undefined) pureBuilder[v] = builder[v];
-    });
-    pureBuilder.find = serializeToBase64({ _: pureBuilder.find });
-    pendingSnapshot.value = serializeToBase64({ _: pendingSnapshot.value });
-
-    let wasShifted;
+    return {
+        editions,
+        pathChanges: [...pathChanges],
+        linearWrite: copiedWrite
+    };
+}
 
-    if (isStaticWrite) {
-        // find previously matching pending write
-        const entries = Object.entries(CacheStore.PendingWrites[projectUrl] || {});
+export const removePendingWrite = async (builder, writeId, revert) => {
+    await awaitStore();
+    const { projectUrl } = builder;
+    const pendingData = grab(CacheStore.PendingWrites, [projectUrl, writeId]);
+    if (!pendingData) return;
 
-        for (const [writeId, obj] of entries) {
-            if (!Scoped.OutgoingWrites[writeId]) {
-                if (
-                    niceGuard(
-                        { builder: obj.builder, snapshot: obj.snapshot },
-                        { builder: pureBuilder, snapshot: pendingSnapshot }
-                    )
-                ) {
-                    // shift it to the front
-                    obj.addedOn = Date.now();
-                    wasShifted = true;
-                    break;
-                }
-            }
-        }
-    }
+    const pathChanges = revert ? await revertChanges(builder, pendingData.editions) : [];
 
-    if (!wasShifted)
-        poke(CacheStore.PendingWrites, [projectUrl, writeId], cloneDeep({
-            builder: pureBuilder,
-            snapshot: pendingSnapshot,
-            editions,
-            addedOn: Date.now()
-        }));
-
-    updateCacheStore(['DatabaseStore', 'PendingWrites', 'DatabaseStats']);
+    unpoke(CacheStore.PendingWrites, [projectUrl, writeId]);
+    updateCacheStore(['PendingWrites', 'DatabaseStore', 'DatabaseStats']);
     notifyDatabaseNodeChanges(builder, [...pathChanges]);
 };
 
-export const removePendingWrite = async (builder, writeId, revert) => {
-    await awaitStore();
-    const { projectUrl, dbUrl, dbName } = builder;
-    const pendingData = grab(CacheStore.PendingWrites, [projectUrl, writeId]);
+const revertChanges = async (builder, pendingData) => {
     const { io } = Scoped.ReleaseCacheData;
-
-    if (!pendingData) return;
+    const { projectUrl, dbUrl, dbName } = builder;
     const pathChanges = new Set([]);
 
-    if (revert) {
-        await Promise.all(pendingData.editions.map(async ([access_id, [b4Doc, afDoc], path]) => {
-            if (io) {
-                RevertMutation(grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]));
-            } else {
-                await useFS(builder, access_id, 'database')(async fs => {
-                    const colObj = await fs.find(LIMITER_DATA(path), access_id, ['value'])
-                        .then(v => DatastoreParser.decode(v.value))
-                        .catch(() => null);
-                    if (!colObj) return;
-                    RevertMutation(colObj);
-                    await fs.set(LIMITER_DATA(path), access_id, {
-                        value: DatastoreParser.encode(colObj),
-                        touched: Date.now(),
-                        size: colObj.size
-                    });
+    await Promise.all(pendingData.map(async ([access_id, [b4Doc, afDoc], path]) => {
+        if (io) {
+            RevertMutation(grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', access_id]));
+        } else {
+            await useFS(builder, access_id, 'database')(async fs => {
+                const colObj = await fs.find(LIMITER_DATA(path), access_id, ['value'])
+                    .then(v => DatastoreParser.decode(v.value))
+                    .catch(() => null);
+                if (!colObj) return;
+                RevertMutation(colObj);
+                await fs.set(LIMITER_DATA(path), access_id, {
+                    value: DatastoreParser.encode(colObj),
+                    touched: Date.now(),
+                    size: colObj.size
                 });
-            }
+            });
+        }
 
-            function RevertMutation(colObj) {
-                const colList = colObj?.data;
+        function RevertMutation(colObj) {
+            const colList = colObj?.data;
 
-                const updateSize = (b4, af) => {
-                    const offset = docSize(af) - docSize(b4);
-                    colObj.size += offset;
-                    incrementDatabaseSize(builder, path, offset);
-                }
+            const updateSize = (b4, af) => {
+                const offset = docSize(af) - docSize(b4);
+                colObj.size += offset;
+                incrementDatabaseSize(builder, path, offset);
+            }
 
-                if (colList) {
-                    if (afDoc) {
-                        const editedIndex = colList.findIndex(e => CompareBson.equal(e._id, afDoc._id));
-                        if (editedIndex !== -1) {
-                            if (
-                                serializeToBase64(afDoc) === serializeToBase64(colList[editedIndex])
-                            ) {
-                                if (b4Doc) {
-                                    colList[editedIndex] = b4Doc;
-                                    updateSize(afDoc, b4Doc);
-                                } else {
-                                    colList.splice(editedIndex, 1);
-                                    updateSize(afDoc, undefined);
-                                }
+            if (colList) {
+                if (afDoc) {
+                    const editedIndex = colList.findIndex(e => CompareBson.equal(e._id, afDoc._id));
+                    if (editedIndex !== -1) {
+                        if (
+                            serializeToBase64(afDoc) === serializeToBase64(colList[editedIndex])
+                        ) {
+                            if (b4Doc) {
+                                colList[editedIndex] = b4Doc;
+                                updateSize(afDoc, b4Doc);
+                            } else {
+                                colList.splice(editedIndex, 1);
+                                updateSize(afDoc, undefined);
                             }
                         }
-                    } else if (
-                        b4Doc &&
-                        colList.findIndex(e => CompareBson.equal(e._id, b4Doc._id)) === -1
-                    ) {
-                        colList.push(b4Doc);
-                        updateSize(undefined, b4Doc);
                     }
+                } else if (
+                    b4Doc &&
+                    colList.findIndex(e => CompareBson.equal(e._id, b4Doc._id)) === -1
+                ) {
+                    colList.push(b4Doc);
+                    updateSize(undefined, b4Doc);
                 }
-                pathChanges.add(path);
             }
-        }));
-    }
+            pathChanges.add(path);
+        }
+    }));
 
-    unpoke(CacheStore.PendingWrites, [projectUrl, writeId]);
-    updateCacheStore(['PendingWrites', 'DatabaseStore', 'DatabaseStats']);
-    notifyDatabaseNodeChanges(builder, [...pathChanges]);
-};
+    return [...pendingData];
+}
 
 const notifyDatabaseNodeChanges = (builder, changedCollections = []) => {
     const { projectUrl, dbName, dbUrl } = builder;
 
     changedCollections.forEach(path => {
-        const nodeID = `${projectUrl}${dbName}${dbUrl}${path}`;
+        const nodeID = `${projectUrl}_${dbName}_${dbUrl}_${path}`;
         Object.entries(Scoped.ActiveDatabaseListeners[nodeID] || {})
             .sort((a, b) => a[1] - b[1])
             .forEach(([processId]) => {

package/src/products/database/bson.js

@@ -1,4 +1,4 @@
-import { cloneDeep } from "lodash";
+import cloneDeep from "lodash/cloneDeep";
 import { deserialize, serialize } from "../../vendor/bson";
 import { Buffer } from "buffer";
 

package/src/products/database/index.js

@@ -721,44 +721,47 @@ const commitData = async (builder, value, type, config) => {
     return (await sendValue());
 };
 
-export const trySendPendingWrite = (projectUrl) => {
+export const trySendPendingWrite = async (projectUrl) => {
     if (Scoped.dispatchingWritesPromise[projectUrl]) return;
 
+    let resolveCallback;
     Scoped.dispatchingWritesPromise[projectUrl] = new Promise(async resolve => {
-        const sortedWrite = Object.entries(CacheStore.PendingWrites[projectUrl] || {})
-            .filter(([k]) => !Scoped.OutgoingWrites[k])
-            .sort((a, b) => a[1].addedOn - b[1].addedOn);
-        let resolveCounts = 0;
-
-        for (const [writeId, { snapshot, builder, attempts = 1 }] of sortedWrite) {
-            try {
-                await commitData(
-                    { ...Scoped.InitializedProject[projectUrl], ...builder, find: deserializeBSON(builder.find, true)._ },
-                    deserializeBSON(snapshot.value, true)._,
-                    snapshot.type,
-                    { ...snapshot.config, delivery: DELIVERY.NO_CACHE_NO_AWAIT }
-                );
+        resolveCallback = resolve;
+    });
+
+    const sortedWrite = Object.entries(CacheStore.PendingWrites[projectUrl] || {})
+        .filter(([k]) => !Scoped.OutgoingWrites[k])
+        .sort((a, b) => a[1].addedOn - b[1].addedOn);
+    let resolveCounts = 0;
 
+    for (const [writeId, { snapshot, builder, attempts = 1 }] of sortedWrite) {
+        try {
+            await commitData(
+                { ...Scoped.InitializedProject[projectUrl], ...builder, find: deserializeBSON(builder.find, true)._ },
+                deserializeBSON(snapshot.value, true)._,
+                snapshot.type,
+                { ...snapshot.config, delivery: DELIVERY.NO_CACHE_NO_AWAIT }
+            );
+
+            delete CacheStore.PendingWrites[projectUrl][writeId];
+            ++resolveCounts;
+        } catch (err) {
+            const { maxRetries } = builder;
+            if (err?.ack || !maxRetries || attempts >= maxRetries) {
                 delete CacheStore.PendingWrites[projectUrl][writeId];
                 ++resolveCounts;
-            } catch (err) {
-                const { maxRetries } = builder;
-                if (err?.ack || !maxRetries || attempts >= maxRetries) {
-                    delete CacheStore.PendingWrites[projectUrl][writeId];
-                    ++resolveCounts;
-                } else if (CacheStore.PendingWrites[projectUrl]?.[writeId]) {
-                    CacheStore.PendingWrites[projectUrl][writeId].attempts = attempts + 1;
-                }
+            } else if (CacheStore.PendingWrites[projectUrl]?.[writeId]) {
+                CacheStore.PendingWrites[projectUrl][writeId].attempts = attempts + 1;
             }
         }
-        resolve();
-        if (projectUrl in Scoped.dispatchingWritesPromise)
-            delete Scoped.dispatchingWritesPromise[projectUrl];
-        updateCacheStore(['PendingWrites']);
-
-        if (
-            (sortedWrite.length - resolveCounts) &&
-            await getReachableServer(projectUrl)
-        ) trySendPendingWrite(projectUrl);
-    });
+    }
+    resolveCallback();
+    if (Scoped.dispatchingWritesPromise[projectUrl])
+        delete Scoped.dispatchingWritesPromise[projectUrl];
+    updateCacheStore(['PendingWrites']);
+
+    if (
+        (sortedWrite.length - resolveCounts) &&
+        await getReachableServer(projectUrl)
+    ) trySendPendingWrite(projectUrl);
 };

package/src/products/database/types.js

@@ -1,4 +1,4 @@
-import { guardObject, GuardSignal, niceGuard } from "guard-object";
+import { niceGuard } from "guard-object";
 
 export const TIMESTAMP = { $timestamp: "now" };
 export const TIMESTAMP_OFFSET = (v) => ({ $timestamp_offset: v });
@@ -12,17 +12,13 @@ export const GEO_JSON = (lat, lng) => ({
     coordinates: [lng, lat],
 });
 
-export const FIND_GEO_JSON = (location, offSetMeters, centerMeters) => {
-    guardObject(GuardSignal.COORDINATE.LAT_LNG_INT).validate(location);
-
-    return {
-        $nearSphere: {
-            $geometry: {
-                type: "Point",
-                coordinates: location.slice(0).reverse()
-            },
-            $minDistance: centerMeters || 0,
-            $maxDistance: offSetMeters
-        }
-    };
-};
+export const FIND_GEO_JSON = (location, offSetMeters, centerMeters) => ({
+    $nearSphere: {
+        $geometry: {
+            type: "Point",
+            coordinates: location.slice(0).reverse()
+        },
+        $minDistance: centerMeters || 0,
+        $maxDistance: offSetMeters
+    }
+});

package/src/products/http_callable/accessor.js

@@ -40,6 +40,7 @@ export const getFetchResources = async (projectUrl, access_id) => {
     if (io) {
         const record = CacheStore.FetchedStore[projectUrl]?.[access_id];
         if (record) record.touched = Date.now();
+        updateCacheStore(['FetchedStore']);
         return record && cloneDeep(record?.data);
     }
 

package/src/products/http_callable/index.js

@@ -11,9 +11,9 @@ import { serialize } from "entity-serializer";
 import { getFetchResources, insertFetchResources } from "./accessor";
 
 const buildFetchData = (data, extras) => {
-    const { ok, type, status, statusText, redirected, url, headers, size, base64 } = data;
+    const { ok, type, status, statusText, redirected, url, headers, size, buffer } = data;
 
-    const response = new Response(Buffer.from(base64, 'base64'), {
+    const response = new Response(buffer, {
         headers: new Headers(headers),
         status,
         statusText,
@@ -146,7 +146,7 @@ export const mfetch = async (input = '', init, config) => {
                 credentials: 'omit',
                 ...init,
                 ...uglified ? { body: reqBuilder } : encodeBody ? { body: serialize(body) } : {},
-                // cache: 'no-cache',
+                cache: 'no-cache',
                 headers: {
                     ...extraHeaders,
                     ...rawHeader,
@@ -165,12 +165,12 @@ export const mfetch = async (input = '', init, config) => {
 
             if (!isLink && simple) throw { simpleError: JSON.parse(simple) };
 
-            const base64 = uglified ?
-                Buffer.from(await deserializeE2E(await f.arrayBuffer(), serverE2E_PublicKey, privateKey)).toString('base64') :
-                Buffer.from(await f.arrayBuffer()).toString('base64');
+            const buffer = uglified ?
+                Buffer.from(await deserializeE2E(await f.arrayBuffer(), serverE2E_PublicKey, privateKey)) :
+                Buffer.from(await f.arrayBuffer());
 
             const resObj = {
-                base64,
+                buffer,
                 type,
                 status,
                 statusText,