react-native-mosquito-transport 0.0.38 → 0.0.39

package/TODO

@@ -21,4 +21,5 @@
 - switch to events package
 - serverTimeOffset
 - avoid sending cookies ✅
+- add timeout in fetchHttp
 <!-- - error: "refreshToken retry limit exceeded" <--- no need -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -31,7 +31,6 @@
     "buffer": "^6.0.3",
     "entity-serializer": "^1.0.3",
     "guard-object": "^1.1.4",
-    "lodash": "^4.17.21",
     "poke-object": "^1.0.1",
     "simplify-error": "^1.0.1",
     "socket.io-client": "^4.8.1",

package/src/helpers/basic_clone.js

@@ -0,0 +1,212 @@
+import { Buffer } from "buffer";
+import { Validator } from "guard-object";
+import { BSONError, BSONOffsetError, BSONRegExp, BSONRuntimeError, BSONSymbol, BSONValue, BSONVersionError, Binary, Code, DBRef, Decimal128, Double, Int32, Long, MaxKey, MinKey, ObjectId, Timestamp, UUID } from '../vendor/bson';
+
+const ErrorInstances = [
+    niceReturn(() => ReferenceError),
+    niceReturn(() => SyntaxError),
+    niceReturn(() => RangeError),
+    niceReturn(() => TypeError),
+    niceReturn(() => EvalError),
+    Error
+].filter(v => v);
+
+/**
+ * @template T
+ * @param {T} obj 
+ * @returns {T}
+ */
+export function basicClone(obj) {
+    if ([NaN, undefined, Infinity, null].includes(obj)) {
+        return obj;
+    }
+
+    if (typeof obj === 'bigint')
+        return BigInt(obj);
+
+    if (
+        ['number', 'string', 'boolean', 'function'].includes(typeof obj) ||
+        obj instanceof Promise
+    ) return obj;
+
+    for (const e of [Date, RegExp]) {
+        if (isDirectInstance(obj, e))
+            return new e(obj);
+    }
+
+    if (isDirectInstance(obj, ArrayBuffer))
+        return obj.slice(0);
+
+    if (
+        typeof SharedArrayBuffer !== 'undefined' &&
+        isDirectInstance(obj, SharedArrayBuffer)
+    ) return obj.slice(0);
+
+    if (Buffer.isBuffer(obj)) return Buffer.from(obj);
+
+    for (const instance of ErrorInstances) {
+        if (isDirectInstance(obj, instance)) {
+            const n = new instance(obj.message);
+            n.stack = obj.stack;
+            // n.name = obj.name;
+            return n;
+        }
+    }
+
+    for (const e of [Map, Set]) {
+        if (isDirectInstance(obj, e))
+            return new e([...obj].map(basicClone));
+    }
+
+    for (
+        const e of
+        [
+            Int8Array,
+            Uint8Array,
+            Uint8ClampedArray,
+            Int16Array,
+            Uint16Array,
+            Int32Array,
+            Uint32Array,
+            Float32Array,
+            Float64Array,
+            BigInt64Array,
+            BigUint64Array
+        ]
+    ) {
+        if (isDirectInstance(obj, e))
+            return new e(Buffer.from(obj));
+    }
+
+    if (isDirectInstance(obj, BSONOffsetError)) {
+        const n = new BSONOffsetError(obj.message, obj.offset);
+        // n.name = obj.name;
+        n.stack = obj.stack;
+        return n;
+    }
+
+    for (
+        const instance of
+        [
+            BSONRuntimeError,
+            BSONVersionError,
+            BSONError
+        ]
+    ) {
+        if (isDirectInstance(obj, instance)) {
+            const n = new instance(obj.message);
+            n.stack = obj.stack;
+            // n.name = obj.name;
+            return n;
+        }
+    }
+
+    if (
+        typeof Response !== 'undefined' &&
+        isDirectInstance(obj, Response)
+    ) return obj.clone();
+
+    if (
+        typeof Headers !== 'undefined' &&
+        isDirectInstance(obj, Headers)
+    ) return new Headers(obj);
+
+    if (
+        typeof Blob !== 'undefined' &&
+        isDirectInstance(obj, Blob)
+    ) return obj.slice(0, obj.size, obj.type);
+
+    if (isDirectInstance(obj, BSONRegExp))
+        return new BSONRegExp(obj.pattern, obj.options);
+
+    if (isDirectInstance(obj, BSONSymbol))
+        return new BSONSymbol(obj.value);
+
+    if (isDirectInstance(obj, Binary))
+        return new Binary(obj.buffer, obj.sub_type);
+
+    if (isDirectInstance(obj, Code))
+        return new Code(obj.code, obj.scope);
+
+    if (isDirectInstance(obj, DBRef))
+        return new DBRef(obj.collection, obj.oid, obj.db, obj.fields);
+
+    if (isDirectInstance(obj, Decimal128))
+        return new Decimal128(obj.bytes);
+
+    if (isDirectInstance(obj, Double))
+        return new Double(obj.value);
+
+    if (isDirectInstance(obj, Int32))
+        return new Int32(obj.value);
+
+    if (isDirectInstance(obj, Long))
+        return new Long(obj.low, obj.high, obj.unsigned);
+
+    if (isDirectInstance(obj, Timestamp))
+        return new Timestamp({ t: obj.t, i: obj.i });
+
+    if (isDirectInstance(obj, MaxKey))
+        return new MaxKey();
+
+    if (isDirectInstance(obj, MinKey))
+        return new MinKey();
+
+    if (isDirectInstance(obj, ObjectId))
+        return new ObjectId(obj.id);
+
+    if (isDirectInstance(obj, UUID)) return new UUID(obj);
+
+    if (isDirectInstance(obj, BSONValue)) return obj;
+
+    if (Validator.ARRAY(obj))
+        return [...obj.map(basicClone)];
+
+    if (Validator.OBJECT(obj)) {
+        const newObj = {};
+
+        for (const key in obj) {
+            if (obj.hasOwnProperty(key)) {
+                newObj[key] = basicClone(obj[key]);
+            }
+        }
+
+        return newObj;
+    }
+
+    if (ArrayBuffer.isView(obj)) return Buffer.from(obj);
+
+    if (obj instanceof Error) {
+        // general errors
+        try {
+            const n = new obj.constructor(obj.message);
+            n.stack = obj.stack;
+            return n;
+        } catch (error) {
+            const n = new Error(obj.message);
+            n.stack = obj.stack;
+            try {
+                n.name = obj.name;
+            } catch (_) { }
+            return n;
+        }
+    }
+
+    throw `${obj} cannot be cloned`;
+}
+
+/**
+ * @template T
+ * @param {unknown} obj
+ * @param {new (...args: any[]) => T} Class
+ * @returns {obj is T}
+ */
+function isDirectInstance(obj, Class) {
+    return typeof obj === "object" && obj !== null && obj.constructor === Class;
+}
+
+function niceReturn(func) {
+    try {
+        return func();
+    } catch (_) { }
+}

package/src/helpers/utils.js

@@ -5,15 +5,15 @@ import { DatastoreParser } from "../products/database/bson";
 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";
+import { basicClone } from "./basic_clone";
 
 const { FILE_NAME, TABLE_NAME } = FS_PATH;
 
 const CacheKeys = Object.keys(CacheStore);
 
 const prefillDatastore = (obj, caller) => {
-    obj = cloneDeep(obj);
+    obj = basicClone(obj);
     breakDbMap(obj, (_projectUrl, _dbUrl, _dbName, _path, value) => {
         Object.entries(value.instance).forEach(([access_id, obj]) => {
             value.instance[access_id] = caller(obj);
@@ -28,7 +28,7 @@ const prefillDatastore = (obj, caller) => {
 };
 
 const prefillFetcher = (store, encode) => {
-    store = cloneDeep(store);
+    store = basicClone(store);
     Object.values(store).forEach(accessIdObj => {
         Object.values(accessIdObj).forEach(value => {
             value.data.buffer = encode ?
@@ -54,7 +54,7 @@ export const updateCacheStore = async (node) => {
     } = CacheStore;
 
     const minimizePendingWrite = () => {
-        const obj = cloneDeep(PendingWrites);
+        const obj = basicClone(PendingWrites);
         Object.values(obj).forEach(e => {
             Object.values(e).forEach(b => {
                 if ('editions' in b) delete b.editions;
@@ -187,7 +187,6 @@ export const buildFetchInterface = async ({ body, authToken, method, uglify, ser
 
     return [{
         body: uglify ? plate : body,
-        // cache: 'no-cache',
         headers: {
             ...extraHeaders,
             'Content-type': uglify ? 'request/buffer' : 'application/json',

package/src/index.js

@@ -12,10 +12,10 @@ import { io } from "socket.io-client";
 import { AUTH_PROVIDER_ID } from "./helpers/values";
 import EngineApi from './helpers/engine_api';
 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";
+import { basicClone } from './helpers/basic_clone';
 
 const {
     _listenCollection,
@@ -58,7 +58,7 @@ class RNMT {
             throw `initializeCache must be called before creating any ${this.constructor.name} instance`;
 
         if (!Scoped.InitializedProject[projectUrl]) {
-            Scoped.InitializedProject[projectUrl] = cloneDeep(this.config);
+            Scoped.InitializedProject[projectUrl] = basicClone(this.config);
             Scoped.LastTokenRefreshRef[projectUrl] = 0;
             triggerAuthToken(projectUrl);
             initTokenRefresher({ ...this.config }, true);
@@ -95,7 +95,7 @@ class RNMT {
 
             const manualCheckConnection = () => {
                 const ref = ++connectionIte;
-                fetch(_areYouOk(projectUrl), { cache: 'no-cache', credentials: 'omit' }).then(async r => {
+                fetch(_areYouOk(projectUrl), { credentials: 'omit' }).then(async r => {
                     if ((await r.json()).status === 'yes') {
                         if (ref === connectionIte) onConnect();
                     } else throw null;

package/src/products/auth/accessor.js

@@ -1,4 +1,3 @@
-import cloneDeep from "lodash/cloneDeep";
 import { doSignOut, revokeAuthIntance } from ".";
 import EngineApi from "../../helpers/engine_api";
 import { AuthTokenListener, TokenRefreshListener } from "../../helpers/listeners";
@@ -7,6 +6,7 @@ import { awaitStore, buildFetchInterface, buildFetchResult, getPrefferTime, upda
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { simplifyError } from "simplify-error";
 import { Validator } from "guard-object";
+import { basicClone } from "../../helpers/basic_clone";
 
 export const listenToken = (callback, projectUrl) =>
     AuthTokenListener.listenTo(projectUrl, (t, n) => {
@@ -40,10 +40,10 @@ export const injectEmulatedAuth = async (config, emulatedURL) => {
 
     if (emulatedURL === projectUrl) throw `auth instance for ${emulatedURL} cannot emulate itself`;
     if (depended) throw `Chain Emulation Error: this auth instance (${projectUrl}) cannot be emulated as other auth instance (${depended[0]}) is already emulating it`;
-    const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+    const thisAuthStore = basicClone(CacheStore.AuthStore[projectUrl]);
     revokeAuthIntance(config, thisAuthStore);
 
-    CacheStore.AuthStore[projectUrl] = cloneDeep(CacheStore.AuthStore[emulatedURL]);
+    CacheStore.AuthStore[projectUrl] = basicClone(CacheStore.AuthStore[emulatedURL]);
     Scoped.AuthJWTToken[projectUrl] = token;
     CacheStore.EmulatedAuth[projectUrl] = emulatedURL;
 
@@ -155,7 +155,7 @@ const refreshToken = (builder, processRef, remainRetries = 1, isForceRefresh) =>
             if (isForceRefresh) Scoped.InitiatedForcedToken[projectUrl] = true;
 
             getEmulatedLinks(projectUrl).forEach(v => {
-                CacheStore.AuthStore[v] = cloneDeep(CacheStore.AuthStore[projectUrl]);
+                CacheStore.AuthStore[v] = basicClone(CacheStore.AuthStore[projectUrl]);
                 Scoped.AuthJWTToken[v] = f.result.token;
 
                 triggerAuthToken(v, isInit);

package/src/products/auth/index.js

@@ -6,7 +6,7 @@ import { CacheStore, Scoped } from "../../helpers/variables";
 import { awaitRefreshToken, getEmulatedLinks, initTokenRefresher, injectEmulatedAuth, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
 import { deserializeE2E, encodeBinary, serializeE2E } from "../../helpers/peripherals";
 import { simplifyCaughtError, simplifyError } from "simplify-error";
-import cloneDeep from "lodash/cloneDeep";
+import { basicClone } from "../../helpers/basic_clone";
 
 const {
     _listenUserVerification,
@@ -171,7 +171,7 @@ const doCustomSignin = (builder, email, password) => new Promise(async (resolve,
 
     try {
         await awaitStore();
-        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+        const thisAuthStore = basicClone(CacheStore.AuthStore[projectUrl]);
 
         const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { data: `${encodeBinary(email)}.${encodeBinary(password)}` },
@@ -201,7 +201,7 @@ const doCustomSignup = (builder, email, password, name, metadata) => new Promise
 
     try {
         await awaitStore();
-        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+        const thisAuthStore = basicClone(CacheStore.AuthStore[projectUrl]);
 
         const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: {
@@ -285,7 +285,7 @@ export const purgePendingToken = async (nodeId) => {
     try {
         let isConnected;
         try {
-            isConnected = (await (await fetch(_areYouOk(projectUrl))).json(), { cache: 'no-cache', credentials: 'omit' }).status === 'yes';
+            isConnected = (await (await fetch(_areYouOk(projectUrl))).json(), { credentials: 'omit' }).status === 'yes';
         } catch (_) { }
 
         if (!isConnected)
@@ -312,7 +312,7 @@ const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) =
 
     try {
         await awaitStore();
-        const thisAuthStore = cloneDeep(CacheStore.AuthStore[projectUrl]);
+        const thisAuthStore = basicClone(CacheStore.AuthStore[projectUrl]);
 
         const [reqBuilder, [privateKey]] = await buildFetchInterface({
             body: { token },

package/src/products/database/accessor.js

@@ -3,7 +3,6 @@ import { awaitStore, updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
 import { assignExtractionFind, CompareBson, confirmFilterDoc, defaultBSON, downcastBSON, validateCollectionName, validateFilter } from "./validator";
 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 "./types";
@@ -11,6 +10,7 @@ import { docSize, incrementDatabaseSize } from "./counter";
 import { DatastoreParser, serializeToBase64 } from "./bson";
 import { FS_PATH, getSystem, useFS } from "../../helpers/fs_manager";
 import { grab, poke, unpoke } from "poke-object";
+import { basicClone } from "../../helpers/basic_clone";
 
 const { LIMITER_DATA, LIMITER_RESULT, DB_COUNT_QUERY } = FS_PATH;
 
@@ -77,9 +77,9 @@ export const getCountQuery = async (builder, access_id) => {
 }
 
 export const insertRecord = async (builder, config, accessIdWithoutLimit, value, episode = 0) => {
-    builder = builder && cloneDeep(builder);
-    config = config && cloneDeep(config);
-    value = value && cloneDeep(value);
+    builder = builder && basicClone(builder);
+    config = config && basicClone(config);
+    value = value && basicClone(value);
 
     await awaitStore();
     const { io } = Scoped.ReleaseCacheData;
@@ -155,7 +155,7 @@ export const insertRecord = async (builder, config, accessIdWithoutLimit, value,
     incrementDatabaseSize(builder, path, editionSizeOffset + resultSizeOffset);
 
     poke(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'instance', accessIdWithoutLimit], newData);
-    if (isEpisode) poke(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, `${limit}`], cloneDeep(newResultData));
+    if (isEpisode) poke(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, `${limit}`], basicClone(newResultData));
     updateCacheStore(['DatabaseStore', 'DatabaseStats']);
 };
 
@@ -167,7 +167,7 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
     const isEpisode = episode === 1;
 
     const transformData = (data) => {
-        data = cloneDeep(data);
+        data = basicClone(data);
         if (random) {
             data = shuffleArray(data);
         } else if (sort) {
@@ -221,7 +221,7 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
         const resultData = grab(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'episode', accessIdWithoutLimit, `${limit}`]);
         if (resultData) {
             resultData.touched = Date.now();
-            return [cloneDeep(resultData.data)];
+            return [basicClone(resultData.data)];
         }
         return null;
     }
@@ -242,8 +242,8 @@ export const getRecord = async (builder, accessIdWithoutLimit, episode = 0) => {
 };
 
 export const generateRecordID = (builder, config, removeLimit) => {
-    builder = builder && cloneDeep(builder);
-    config = config && cloneDeep(config);
+    builder = builder && basicClone(builder);
+    config = config && basicClone(config);
 
     const { command, path, countDoc } = builder;
     const { extraction, excludeFields, returnOnly } = config || {};
@@ -269,7 +269,7 @@ export const generateRecordID = (builder, config, removeLimit) => {
 };
 
 const arrangeCommands = (c, removeLimit) => {
-    c = cloneDeep(c);
+    c = basicClone(c);
     const sortFind = f => {
         ['$and', '$or', '$nor'].forEach(n => {
             if (f[n]) {
@@ -375,12 +375,12 @@ const WriteValidator = {
 export const validateWriteValue = ({ type, find, value }) => WriteValidator[type]({ find, value, type });
 
 export const addPendingWrites = async (builder, writeId, result) => {
-    builder = builder && cloneDeep(builder);
-    result = result && cloneDeep(result);
+    builder = builder && basicClone(builder);
+    result = result && basicClone(result);
     await awaitStore();
 
     const { projectUrl } = builder;
-    const pendingSnapshot = cloneDeep(result);
+    const pendingSnapshot = basicClone(result);
     const { editions, linearWrite, pathChanges } = await syncCache(builder, result);
 
     const isStaticWrite = !linearWrite.some(({ value, type }) => {
@@ -428,7 +428,7 @@ export const addPendingWrites = async (builder, writeId, result) => {
     }
 
     if (!wasShifted)
-        poke(CacheStore.PendingWrites, [projectUrl, writeId], cloneDeep({
+        poke(CacheStore.PendingWrites, [projectUrl, writeId], basicClone({
             builder: pureBuilder,
             snapshot: pendingSnapshot,
             editions,
@@ -453,7 +453,7 @@ const syncCache = async (builder, result) => {
             )
             : [{ ...result, find: builder.find, path: builder.path }];
 
-    const copiedWrite = cloneDeep(linearWrite);
+    const copiedWrite = basicClone(linearWrite);
 
     await Promise.all(linearWrite.map(async ({ value: writeObj, find, type, path }) => {
         WriteValidator[type]({ find, value: writeObj });
@@ -506,7 +506,7 @@ const syncCache = async (builder, result) => {
             const { extraction } = config || {};
 
             const logChanges = (d) => {
-                editions.push(cloneDeep([entityId, d, path]));
+                editions.push(basicClone([entityId, d, path]));
                 const [b4, af] = d;
                 const offset = docSize(af) - docSize(b4);
                 dataObj.size += offset;
@@ -518,7 +518,7 @@ const syncCache = async (builder, result) => {
             const accessExtraction = async obj => {
                 const buildAssignedExtraction = (data) => {
                     const d = (Array.isArray(extraction) ? extraction : [extraction]).map(thisExtraction => {
-                        const query = cloneDeep(thisExtraction);
+                        const query = basicClone(thisExtraction);
 
                         ['find', 'findOne'].forEach(n => {
                             if (query[n])
@@ -570,7 +570,7 @@ const syncCache = async (builder, result) => {
                     return findOne ? scrapDocs[0] : scrapDocs;
                 }));
 
-                return cloneDeep(Array.isArray(extraction) ? scrapedProjection : scrapedProjection[0]);
+                return basicClone(Array.isArray(extraction) ? scrapedProjection : scrapedProjection[0]);
             }
 
             if (['setOne', 'setMany'].includes(type)) {
@@ -582,7 +582,7 @@ const syncCache = async (builder, result) => {
 
                         if (instance_data.findIndex(v => CompareBson.equal(v._id, e._id)) === -1) {
                             const x = snipUpdate(obj);
-                            instance_data.push(cloneDeep(x));
+                            instance_data.push(basicClone(x));
                             logChanges([undefined, x]);
                         } else if (!duplicateSets[e._id]) {
                             console.warn(`document with _id=${e._id} already exist locally with ${type}() operation, skipping to online commit`);
@@ -824,7 +824,7 @@ const snipDocument = (data, find, config) => {
     if (!data || !config) return data;
     const { returnOnly, excludeFields } = config || {};
 
-    let output = cloneDeep(data);
+    let output = basicClone(data);
 
     if (returnOnly) {
         output = {};
@@ -967,7 +967,7 @@ const AtomicWriter = {
             : [grab(object, destStage.slice(0, -1).join('.')), sourceStage.slice(-1)[0], destStage.slice(-1)[0]];
 
         if (tipObj && tipSource in tipObj) {
-            tipObj[tipDest] = cloneDeep(tipObj[tipSource]);
+            tipObj[tipDest] = basicClone(tipObj[tipSource]);
             delete tipObj[tipSource];
         }
     },

package/src/products/database/bson.js

@@ -1,6 +1,6 @@
-import cloneDeep from "lodash/cloneDeep";
 import { deserialize, serialize } from "../../vendor/bson";
 import { Buffer } from "buffer";
+import { basicClone } from "../../helpers/basic_clone";
 
 export const deserializeBSON = (data, cast) => {
     if (typeof data === 'string')
@@ -18,7 +18,7 @@ export const serializeToBase64 = doc => Buffer.from(serialize(doc)).toString('ba
 
 export const DatastoreParser = {
     encode: (obj) => {
-        obj = cloneDeep(obj);
+        obj = basicClone(obj);
         const { command, config } = obj;
 
         const serializeQuery = (e) =>
@@ -37,7 +37,7 @@ export const DatastoreParser = {
         return obj;
     },
     decode: (obj, cast = true) => {
-        obj = cloneDeep(obj);
+        obj = basicClone(obj);
         const { command, config } = obj;
 
         const serializeQuery = (e) =>

package/src/products/database/index.js

@@ -11,8 +11,8 @@ import { DELIVERY, RETRIEVAL } from "../../helpers/values";
 import { ObjectId } from "../../vendor/bson";
 import { guardObject, Validator } from "guard-object";
 import { simplifyCaughtError } from "simplify-error";
-import cloneDeep from "lodash/cloneDeep";
 import { deserializeBSON, serializeToBase64 } from "./bson";
+import { basicClone } from "../../helpers/basic_clone";
 
 export class MTCollection {
     constructor(config) {
@@ -136,6 +136,8 @@ const {
 } = EngineApi;
 
 const listenDocument = (callback, onError, builder, config) => {
+    builder = basicClone(builder);
+    config = basicClone(config);
     const { projectUrl, wsPrefix, serverE2E_PublicKey, baseUrl, dbUrl, dbName, path, disableCache, command, uglify, extraHeaders, castBSON } = builder;
     const { find, findOne, sort, direction, limit } = command;
     const { disableAuth, episode } = config || {};
@@ -160,7 +162,7 @@ const listenDocument = (callback, onError, builder, config) => {
         const thisSnapshotId = serializeToBase64({ _: s });
         if (thisSnapshotId === lastSnapshot) return;
         lastSnapshot = thisSnapshotId;
-        callback?.(cloneDeep(transformBSON(s, castBSON)));
+        callback?.(basicClone(transformBSON(s, castBSON)));
     };
 
     if (shouldCache) {
@@ -255,6 +257,9 @@ const listenDocument = (callback, onError, builder, config) => {
 };
 
 const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
+    connectData = basicClone(connectData);
+    disconnectData = basicClone(disconnectData);
+    builder = basicClone(builder);
     const { projectUrl, wsPrefix, baseUrl, serverE2E_PublicKey, dbUrl, dbName, extraHeaders, uglify } = builder;
     const disableAuth = false;
 
@@ -344,6 +349,8 @@ const initOnDisconnectionTask = ({ builder, connectData, disconnectData }) => {
 };
 
 const countCollection = async (builder, config) => {
+    builder = basicClone(builder);
+    config = basicClone(config);
     const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, maxRetries = 1, uglify, extraHeaders, path, disableCache, command = {} } = builder;
     const { find } = command;
     const { disableAuth } = config || {};
@@ -445,10 +452,12 @@ const hydrateForeignDoc = ({ data, doc_holder }) => {
 
 const transformBSON = (d, castBSON) => {
     if (castBSON) return d && deserializeBSON(serializeToBase64({ _: d }), true)._;
-    return cloneDeep(d);
+    return basicClone(d);
 };
 
 const findObject = async (builder, config) => {
+    builder = basicClone(builder);
+    config = basicClone(config);
     const { projectUrl, serverE2E_PublicKey, dbUrl, dbName, maxRetries = 1, path, disableCache = false, uglify, extraHeaders, command, castBSON } = builder;
     const pureConfig = stripRequestConfig(config);
     validateFindObject(command);
@@ -476,8 +485,8 @@ const findObject = async (builder, config) => {
             const res = (instantProcess && a) ? transformBSON(a[0] || undefined, castBSON) : a;
 
             if (a) {
-                resolve(instantProcess ? cloneDeep(res) : a);
-            } else reject(instantProcess ? cloneDeep(b) : b);
+                resolve(instantProcess ? basicClone(res) : a);
+            } else reject(instantProcess ? basicClone(b) : b);
             if (hasFinalize || !instantProcess) return;
             hasFinalize = true;
 
@@ -498,8 +507,8 @@ const findObject = async (builder, config) => {
                 if (enableMinimizer) {
                     if (Scoped.PendingDbReadCollective[processAccessId]) {
                         Scoped.PendingDbReadCollective[processAccessId].push((a, b) => {
-                            if (a) resolve(cloneDeep(a.result));
-                            else reject(cloneDeep(b));
+                            if (a) resolve(basicClone(a.result));
+                            else reject(basicClone(b));
                         });
                         return;
                     }
@@ -596,7 +605,7 @@ const transformNullRecursively = obj => Object.fromEntries(
     )
 );
 
-const cleanBatchWrite = (value) => cloneDeep(value).map(v => {
+const cleanBatchWrite = (value) => basicClone(value).map(v => {
     if (Validator.OBJECT(v?.value)) {
         v.value = transformNullRecursively(v.value);
     } else if (Array.isArray(v?.value)) {
@@ -608,6 +617,8 @@ const cleanBatchWrite = (value) => cloneDeep(value).map(v => {
 });
 
 const commitData = async (builder, value, type, config) => {
+    builder = basicClone(builder);
+    config = basicClone(config);
     // transform undefined
     if (Validator.OBJECT(value)) {
         value = value && deserializeBSON(serializeToBase64({ _: transformNullRecursively(value) }))._;

package/src/products/http_callable/accessor.js

@@ -1,14 +1,14 @@
 import { updateCacheStore } from "../../helpers/utils";
 import { CacheStore, Scoped } from "../../helpers/variables";
-import cloneDeep from "lodash/cloneDeep";
 import { serialize } from "entity-serializer";
 import { incrementFetcherSize } from "./counter";
 import { FS_PATH, useFS } from "../../helpers/fs_manager";
+import { basicClone } from "../../helpers/basic_clone";
 
 const { FETCH_RESOURCES } = FS_PATH;
 
 export const insertFetchResources = async (projectUrl, access_id, value) => {
-    value = cloneDeep(value);
+    value = basicClone(value);
     const dataSize = serialize(value).byteLength;
 
     const { io } = Scoped.ReleaseCacheData;
@@ -41,7 +41,7 @@ export const getFetchResources = async (projectUrl, access_id) => {
         const record = CacheStore.FetchedStore[projectUrl]?.[access_id];
         if (record) record.touched = Date.now();
         updateCacheStore(['FetchedStore']);
-        return record && cloneDeep(record?.data);
+        return record && basicClone(record?.data);
     }
 
     const res = await useFS(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async fs => {

package/src/products/http_callable/index.js

@@ -6,14 +6,14 @@ import { Scoped } from "../../helpers/variables";
 import { awaitRefreshToken } from "../auth/accessor";
 import { simplifyCaughtError } from "simplify-error";
 import { guardObject, Validator } from "guard-object";
-import cloneDeep from "lodash/cloneDeep";
 import { serialize } from "entity-serializer";
 import { getFetchResources, insertFetchResources } from "./accessor";
+import { basicClone } from "../../helpers/basic_clone";
 
 const buildFetchData = (data, extras) => {
     const { ok, type, status, statusText, redirected, url, headers, size, buffer } = data;
 
-    const response = new Response(buffer, {
+    const response = new Response(Buffer.from(buffer), {
         headers: new Headers(headers),
         status,
         statusText,
@@ -86,9 +86,9 @@ export const mfetch = async (input = '', init, config) => {
     const callFetch = () => new Promise(async (resolve, reject) => {
         const retryProcess = ++retries;
 
-        const finalize = (a, b) => {
-            if (a) resolve(a);
-            else reject(b);
+        const finalize = (a, b, extras) => {
+            if (a) resolve(buildFetchData(a, extras));
+            else reject(basicClone(b));
             if (hasFinalize || retryProcess !== 1) return;
             hasFinalize = true;
 
@@ -99,14 +99,14 @@ export const mfetch = async (input = '', init, config) => {
                     delete Scoped.PendingFetchCollective[processReqId];
 
                 resolutionList.forEach(e => {
-                    e(a, b);
+                    e(a && buildFetchData(a, extras), b && basicClone(b));
                 });
             }
         };
 
         await awaitStore();
         const resolveCache = (reqData) => {
-            finalize(buildFetchData(reqData, { fromCache: true }));
+            finalize(reqData, undefined, { fromCache: true });
         };
 
         try {
@@ -114,8 +114,8 @@ export const mfetch = async (input = '', init, config) => {
                 if (enableMinimizer) {
                     if (Scoped.PendingFetchCollective[processReqId]) {
                         Scoped.PendingFetchCollective[processReqId].push((a, b) => {
-                            if (a) resolve(cloneDeep(a.result));
-                            else reject(cloneDeep(b));
+                            if (a) resolve(a);
+                            else reject(b);
                         });
                         return;
                     }
@@ -142,11 +142,10 @@ export const mfetch = async (input = '', init, config) => {
             const [reqBuilder, [privateKey]] = uglified ? await serializeE2E(body, mtoken, serverE2E_PublicKey) : [null, []];
 
             const f = await fetch(isLink ? input : `${projectUrl}/${normalizeRoute(input)}`, {
-                ...(!isBaseUrl || hasBody) ? { method: 'POST' } : {},
+                ...hasBody ? { method: 'POST' } : {},
                 credentials: 'omit',
                 ...init,
                 ...uglified ? { body: reqBuilder } : encodeBody ? { body: serialize(body) } : {},
-                cache: 'no-cache',
                 headers: {
                     ...extraHeaders,
                     ...rawHeader,
@@ -185,7 +184,7 @@ export const mfetch = async (input = '', init, config) => {
 
             if (shouldCache) insertFetchResources(projectUrl, reqId, resObj);
 
-            finalize(buildFetchData(resObj));
+            finalize(resObj);
         } catch (e) {
             let thisRecord;