react-native-mosquito-transport 0.0.19 → 0.0.21

package/src/products/database/accessor.js

@@ -1,317 +1,814 @@
-import { IS_RAW_OBJECT, objToUniqueString, queryEntries, shuffleArray, sortArrayByObjectKey } from "../../helpers/peripherals";
+import { niceHash, shuffleArray, sortArrayByObjectKey } from "../../helpers/peripherals";
 import { awaitStore, updateCacheStore } from "../../helpers/utils";
-import { CacheStore } from "../../helpers/variables";
-import { confirmFilterDoc } from "./validator";
+import { CacheStore, Scoped } from "../../helpers/variables";
+import { assignExtractionFind, CompareBson, confirmFilterDoc, defaultBSON, downcastBSON, validateCollectionName, validateFilter } from "./validator";
 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";
+import cloneDeep from "lodash.clonedeep";
+import { BSONRegExp, ObjectId, Timestamp } from "bson";
+import { niceGuard, Validator } from "guard-object";
+import { TIMESTAMP } from "../..";
+import { decrementDatabaseSize, incrementDatabaseSize } from "./counter";
+import { serializeToBase64 } from "./bson";
 
 export const listenQueryEntry = (callback, { accessId, builder, config, processId }) => {
-    let lastObj = '';
+    const { projectUrl, dbName, dbUrl, path } = builder;
     const { episode = 0 } = config || {};
 
-    const l = DatabaseRecordsListener.listenTo(accessId, async (dispatchId) => {
-        const cache = await getRecord(builder, accessId);
-        if (
-            cache &&
-            !isEqual(lastObj, cache[episode]) &&
-            dispatchId === processId
-        ) callback(cache[episode]);
-        lastObj = cache[episode];
+    const nodeID = `${projectUrl}${dbName}${dbUrl}${path}`;
+
+    if (!Scoped.ActiveDatabaseListeners[nodeID])
+        Scoped.ActiveDatabaseListeners[nodeID] = {};
+    Scoped.ActiveDatabaseListeners[nodeID][processId] = Date.now();
+
+    const listener = DatabaseRecordsListener.listenTo('d', async (dispatchId) => {
+        if (dispatchId !== processId) return;
+        const cache = await getRecord(builder, config, accessId);
+        if (cache) callback(cache[episode]);
     });
 
     return () => {
-        lastObj = undefined;
-        l();
-    }
-}
+        listener();
+        if (Scoped.ActiveDatabaseListeners[nodeID]?.[processId]) {
+            delete Scoped.ActiveDatabaseListeners[nodeID][processId];
+
+            if (!Object.keys(Scoped.ActiveDatabaseListeners[nodeID]).length)
+                delete Scoped.ActiveDatabaseListeners[nodeID];
+        }
+    };
+};
+
+export const insertRecord = async (builder, config, accessId, value) => {
+    builder = builder && cloneDeep(builder);
+    config = config && cloneDeep(config);
+    value = value && cloneDeep(value);
 
-export const insertRecord = async (builder, accessId, query, value) => {
     await awaitStore();
-    const { projectUrl, dbUrl = DEFAULT_DB_URL, dbName = DEFAULT_DB_NAME, path } = builder,
-        { extraction, excludeFields, returnOnly } = query?.config,
-        kaf = `${objToUniqueString(extraction || {})},${(excludeFields || []).join(',')},${(returnOnly || []).join(',')}`,
-        colData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', kaf], []);
-
-    // TODO:
-    (Array.isArray(value) ? value : [value]).forEach(e => {
-        const b4DocIndex = colData.findIndex(v => v?._id === e?._id);
+    const { projectUrl, dbUrl, dbName, path, command } = builder;
+    const entityId = await generateRecordID({}, config);
+    const colData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', entityId], { config, command, listing: [] });
+    const trackedData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'record', accessId]);
+
+    const newList = value ? Array.isArray(value) ? value : [value] : [];
+
+    const { tracks, ignore, registeredOn } = trackedData || {};
+    const trackedList = [...tracks || []];
+    const ignoreList = [...ignore || []];
+
+    const addSet = (arr, _id) => {
+        const dex = arr.findIndex(v => CompareBson.equal(v, _id));
+        if (dex === -1) arr.push(_id);
+    }
+
+    const deleteSet = (arr, _id) => {
+        const dex = arr.findIndex(v => CompareBson.equal(v, _id));
+        if (dex !== -1) arr.splice(dex, 1);
+    }
+
+    newList.forEach(e => {
+        const b4DocIndex = colData.listing.findIndex(v => CompareBson.equal(v._id, e._id));
         if (b4DocIndex === -1) {
-            colData.push(e);
-        } else colData[b4DocIndex] = e;
+            colData.listing.push(e);
+            incrementDatabaseSize(projectUrl, e);
+        } else {
+            decrementDatabaseSize(projectUrl, colData.listing[b4DocIndex]);
+            incrementDatabaseSize(projectUrl, e);
+            colData.listing[b4DocIndex] = e;
+        }
+        addSet(trackedList, e._id);
+    });
+
+    (tracks || []).forEach(e => {
+        if (newList.findIndex(v => CompareBson.equal(v._id, e)) === -1) {
+            if (colData.listing.findIndex(v => CompareBson.equal(v._id, e)) === -1) {
+                deleteSet(trackedList, e);
+                deleteSet(ignoreList, e);
+            } else addSet(ignoreList, e);
+        } else deleteSet(ignoreList, e);
     });
 
-    setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', kaf], [...colData]);
+    setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', entityId], colData);
     setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'record', accessId], {
-        query,
+        command,
         result: value,
-        registeredOn: Date.now()
+        tracks: [...trackedList],
+        ignore: [...ignoreList],
+        registeredOn: registeredOn || Date.now(),
+        updatedOn: Date.now()
     });
     updateCacheStore();
-}
+};
 
-export const getRecord = async (builder, accessId) => {
+export const getRecord = async (builder, config, accessId) => {
     await awaitStore();
-    const { projectUrl, dbUrl = DEFAULT_DB_URL, dbName = DEFAULT_DB_NAME, path, command } = builder,
-        { config, find, findOne, sort, direction, limit, random } = command,
-        { extraction, excludeFields, returnOnly } = config || {},
-        kaf = `${objToUniqueString(extraction || {})},${(excludeFields || []).join(',')},${(returnOnly || []).join(',')}`,
-        colData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', kaf], []),
-        colRecord = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'record', accessId]);
+    const { projectUrl, dbUrl, dbName, path, command } = builder;
+    const { find, findOne, sort, direction, limit, random } = command;
+    const entityId = await generateRecordID({}, config);
+    const colData = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', entityId]);
+    const colRecord = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'record', accessId]);
 
     if (!colRecord) return null;
-    let choosenColData = colData.filter(v => confirmFilterDoc(v, findOne || find || {}));
+    let choosenColData = colData.listing.filter(v =>
+        !colRecord.ignore.includes(v._id) &&
+        confirmFilterDoc(v, findOne || find || {})
+    );
 
     if (random) {
         choosenColData = shuffleArray(choosenColData);
     } else if (sort) {
-        choosenColData = sortArrayByObjectKey(choosenColData, sort);
+        sortArrayByObjectKey(choosenColData, sort);
         if (
             direction === -1 ||
             direction === 'desc' ||
             direction === 'descending'
-        ) choosenColData = choosenColData.reverse();
+        ) choosenColData.reverse();
     }
 
     if (findOne) {
         choosenColData = choosenColData[0];
-    } else if (limit) choosenColData.filter((_, i) => i < limit);
+    } else if (limit) choosenColData.slice(0, limit);
 
     return [choosenColData, colRecord.result];
-}
+};
 
 export const generateRecordID = (builder, config) => {
-    const { command, path, countDoc } = builder,
-        { find, findOne, sort, direction, limit } = command || {},
-        { extraction, retrieval = RETRIEVAL.DEFAULT, delivery = DELIVERY.DEFAULT, excludeFields = [], returnOnly = [] } = config || {},
-        accessId = `collection:${path}->excludes:${(Array.isArray(excludeFields) ? excludeFields : [excludeFields]).filter(v => v !== undefined).join(',')}->includes:${(Array.isArray(returnOnly) ? returnOnly : [returnOnly]).filter(v => v !== undefined).join(',')}->${countDoc ? 'countDoc:yes->' : ''}sort:${sort || ''}->direction:${direction || ''}->limit:${limit || ''}->${findOne ? 'findOne' : 'find'}:${objToUniqueString(findOne || find || {})}:extraction:${objToUniqueString(extraction || {})}:retrieval:${retrieval}:delivery:${delivery}`;
+    builder = builder && cloneDeep(builder);
+    config = config && cloneDeep(config);
+
+    const { command, path, countDoc } = builder;
+    const { extraction, excludeFields, returnOnly } = config || {};
+
+    const recordObj = Object.fromEntries(
+        Object.entries({
+            path,
+            command,
+            countDoc,
+            extraction,
+            excludeFields,
+            returnOnly
+        }).filter(([_, v]) => v !== undefined)
+    );
+
+    if (command) recordObj.command = arrangeCommands(command);
+    if (extraction) {
+        if (Array.isArray(extraction)) recordObj.extraction = extraction.map(arrangeCommands);
+        else recordObj.extraction = arrangeCommands(extraction);
+    }
 
-    return accessId;
-}
+    return niceHash(serializeToBase64(recordObj));
+};
+
+const arrangeCommands = c => {
+    c = cloneDeep(c);
+    const sortFind = f => {
+        ['$and', '$or', '$nor'].forEach(n => {
+            if (f[n]) {
+                f[n] = f[n].map(v => sortObject(v));
+            }
+        });
+
+        return sortObject(f);
+    };
+    if (c.sort) c.direction = [-1, 'desc', 'descending'].includes(c.direction) ? 'desc' : 'asc';
+    if (c.find) c.find = sortFind(c.find);
+    if (c.findOne) c.findOne = sortFind(c.findOne);
+    return sortObject(c);
+};
+
+const sortObject = (o) => Object.fromEntries(
+    Object.entries(o).sort((a, b) => (a > b) ? 1 : (a < b) ? -1 : 0)
+);
+
+const recursiveFlat = (a) => {
+    return a.map(v => Array.isArray(v) ? recursiveFlat(v) : v).flat();
+};
+
+const recurseNonAtomicWrite = (obj, i, type) => {
+    if (!Validator.OBJECT(obj)) throw `expected a document but got ${obj}`;
+    Object.entries(obj).forEach(([k, v]) => {
+        if (!i) {
+            if (k === '_id') throw `avoid providing "_id" for ${type}() operation as _id only reference a single document`;
+            if (k === '_foreign_doc') throw '"_foreign_doc" is readonly';
+        }
+        if (k.includes('$') || k.includes('.')) {
+            if (!(k === '$timestamp' && v === 'now'))
+                throw `invalid property "${k}", ${type}() operation fields must not contain .$`;
+        }
+        if (Validator.OBJECT(v)) recurseNonAtomicWrite(v, i + 1, type);
+    });
+};
+
+const recurseAtomicWrite = (obj, i, type) => {
+    if (!Validator.OBJECT(obj)) throw `expected a document but got ${obj}`;
+    Object.entries(obj).forEach(([k, v]) => {
+        if (!i && !(k in AtomicWriter)) throw `Unknown update operator: ${k}`;
+        if (i === 1) {
+            if ((k === '_id' || k.startsWith('_id.')))
+                throw `avoid providing "_id" for ${type}() operation as _id only reference a single document`;
+
+            if (k === '_foreign_doc' || k.startsWith('_foreign_doc.'))
+                throw '"_foreign_doc" is readonly';
+        }
+        if (k.includes('.$')) throw `unsupported operation at "${k}"`;
+        if (!i || Validator.OBJECT(v)) recurseAtomicWrite(v, i + 1, type);
+    });
+};
+
+const WriteValidator = {
+    setOne: ({ value, type = 'setOne' }) => {
+        if (!Validator.OBJECT(value)) throw `expected a document but got ${value}`;
+        const { _id, ...rest } = value;
+
+        if (_id === undefined || JSON.stringify(_id) === 'null')
+            throw `_id requires a valid bson value but got ${_id}`;
+
+        recurseNonAtomicWrite(rest, 0, type);
+    },
+    setMany: ({ value }) => {
+        value.forEach(v => {
+            WriteValidator.setOne({ value: v, type: 'setMany' });
+        });
+    },
+    replaceOne: ({ find, value }) => {
+        validateFilter(find);
+        recurseNonAtomicWrite(value, 0, 'replaceOne');
+    },
+    putOne: ({ find, value }) => {
+        validateFilter(find);
+        recurseNonAtomicWrite(value, 0, 'putOne');
+    },
+    updateOne: ({ find, value }) => {
+        validateFilter(find);
+        recurseAtomicWrite(value, 0, 'updateOne');
+    },
+    updateMany: ({ find, value }) => {
+        validateFilter(find);
+        recurseAtomicWrite(value, 0, 'updateMany');
+    },
+    mergeOne: ({ find, value }) => {
+        validateFilter(find);
+        recurseAtomicWrite(value, 0, 'mergeOne');
+    },
+    mergeMany: ({ find, value }) => {
+        validateFilter(find);
+        recurseAtomicWrite(value, 0, 'mergeMany');
+    },
+    deleteOne: ({ find }) => {
+        validateFilter(find);
+    },
+    deleteMany: ({ find }) => {
+        validateFilter(find);
+    }
+};
+
+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);
     await awaitStore();
-    const { projectUrl, dbUrl = DEFAULT_DB_URL, dbName = DEFAULT_DB_NAME, path } = builder,
-        { value: writeObj, find, type } = result,
-        isAtomic = type === 'updateOne' ||
-            type === 'updateMany' ||
-            type === 'mergeOne' ||
-            type === 'mergeMany',
-        colObj = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data'], {});
-
-    let editions = [], duplicateSets = {};
-
-    Object.entries(colObj).forEach(([kaf, colList]) => {
-        let hasEndCommit, editionSet = [];
-
-        if (type === 'setOne' || type === 'setMany') {
-            (type === 'setOne' ? [writeObj] : writeObj).forEach(e => {
-                if (colList.findIndex(v => v._id === e._id) === -1) {
-                    editionSet.push({ doc: deserializeNonAtomicWrite(e), dex: 'push', docId: writeObj._id });
-                } else if (!duplicateSets[e._id])
-                    console.error(`document with _id=${e._id} already exist locally with ${type}() operation, will try committing it online`);
-                duplicateSets[e._id] = true;
-            });
-        } else {
-            colList.forEach((doc, docDex) => {
-                if (hasEndCommit) return;
-                let afDoc = undefined;
-
-                if (confirmFilterDoc(doc, find || {})) {
-                    if (type === 'deleteMany') {
-                        afDoc = null;
-                    } else if (type === 'deleteOne') {
-                        afDoc = null;
-                        hasEndCommit = true;
-                    } else if (isAtomic) {
-                        if ((deserializeAtomicWrite({}, { ...writeObj })?._id || find?._id) && type.endsWith('Many'))
-                            throw `avoid providing "_id" for ${type}() operation, use ${type.substring(0, type.length - 4)}One instead as _id only reference a single document`;
-
-                        afDoc = deserializeAtomicWrite({ ...doc }, { ...writeObj });
-                        if (type.endsWith('One')) hasEndCommit = true;
-                    } else {
-                        afDoc = deserializeNonAtomicWrite({ ...writeObj });
-                        hasEndCommit = true;
-                    }
+
+    const { projectUrl, dbUrl, dbName } = builder;
+    const editions = [];
+    const duplicateSets = {};
+    const pathChanges = new Set([]);
+
+    (
+        result.type === 'batchWrite' ?
+            result.value.map(({ scope, value, find, path }) =>
+                ({ type: scope, value, find, path })
+            )
+            : [{ ...result, path: builder.path }]
+    ).forEach(({ value: writeObj, find, type, path }) => {
+        WriteValidator[type]({ find, value: writeObj });
+        validateCollectionName(path);
+        pathChanges.add(path);
+        const colObj = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data'], {});
+
+        Object.entries(colObj).forEach(([entityId, { listing, config }]) => {
+            const { extraction } = config || {};
+
+            const logChanges = (d) => {
+                editions.push([entityId, d, path]);
+            };
+
+            const accessExtraction = obj => {
+                const buildAssignedExtraction = (data) => {
+                    const d = (Array.isArray(extraction) ? extraction : [extraction]).map(thisExtraction => {
+                        const query = cloneDeep(thisExtraction);
+
+                        ['find', 'findOne'].forEach(n => {
+                            if (query[n])
+                                query[n] = assignExtractionFind(data, query[n]);
+                        });
+                        return arrangeCommands(query);
+                    });
+                    if (Array.isArray(extraction)) return d;
+                    return d[0];
                 }
-                if (afDoc !== undefined)
-                    editionSet.push({ doc: afDoc, dex: docDex, docId: doc._id, b4Doc: { ...doc } });
-            });
-        }
+                const extractionResultant = buildAssignedExtraction(obj);
+                const extractionBinary = serializeToBase64({ _: extractionResultant });
+
+                const sameProjection = listing.find(({ _foreign_doc, ...restDoc }) =>
+                    extractionBinary === serializeToBase64({ _: buildAssignedExtraction(restDoc) })
+                );
 
-        if (!editionSet.length) {
-            let hasNoID;
+                if (sameProjection) return sameProjection._foreign_doc;
 
-            if (type === 'putOne') {
-                const nDoc = deserializeNonAtomicWrite(writeObj),
-                    nId = nDoc?._id || find?._id;
+                // if no matching extraction was found, proceed to scrapping other paths
+                const scrapedProjection = (Array.isArray(extractionResultant) ? extractionResultant : [extractionResultant]).map((query, i) => {
+                    const { sort, direction, limit, find, findOne, collection: path } = query;
+                    const scrapDocs = [];
 
-                if (nId) {
-                    editionSet.push({
-                        doc: { ...nDoc, _id: nId },
-                        dex: 'push',
-                        docId: nId
+                    listing.forEach(({ _foreign_doc }) => {
+                        _foreign_doc = (Array.isArray(_foreign_doc) ? _foreign_doc : [_foreign_doc])[i];
+
+                        recursiveFlat([_foreign_doc]).forEach(e => {
+                            if (e && confirmFilterDoc(e, find || findOne)) {
+                                scrapDocs.push(e);
+                            }
+                        });
                     });
-                } else hasNoID = true;
-            } else if (type === 'mergeOne' || type === 'mergeMany') {
-                const nDoc = deserializeAtomicWrite({}, writeObj),
-                    nId = nDoc?._id || find?._id;
-
-                if (nId && type === 'mergeMany')
-                    throw `avoid providing "_id" for mergeMany() operation, use mergeOne instead as _id only reference a single document`;
-                if (nId) {
-                    editionSet.push({
-                        doc: { ...nDoc, _id: nId },
-                        dex: 'push',
-                        docId: nId
+                    if (!scrapDocs.length) {
+                        const scrapYard = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data'], {});
+                        Object.values(scrapYard).forEach(v => {
+                            v.listing.forEach(doc => {
+                                if (confirmFilterDoc(doc, find || findOne)) {
+                                    scrapDocs.push(snipDocument(doc, find || findOne, config));
+                                }
+                            });
+                        });
+                    }
+                    if (sort) sortArrayByObjectKey(scrapDocs, sort);
+                    if ([-1, 'desc', 'descending'].includes(direction)) scrapDocs.reverse();
+                    if (limit) scrapDocs.splice(limit);
+
+                    return findOne ? scrapDocs[0] : scrapDocs;
+                });
+
+                return Array.isArray(extraction) ? scrapedProjection : scrapedProjection[0];
+            }
+
+            if (['setOne', 'setMany'].includes(type)) {
+                (type === 'setOne' ? [writeObj] : writeObj).forEach(e => {
+                    if (listing.findIndex(v => CompareBson.equal(v._id, e._id)) === -1) {
+                        const obj = deserializeNonAtomicWrite(e);
+
+                        if (extraction) obj._foreign_doc = accessExtraction(obj);
+                        listing.push(obj);
+                        logChanges([undefined, obj]);
+                    } else if (!duplicateSets[e._id])
+                        console.warn(`document with _id=${e._id} already exist locally with ${type}() operation, skipping to online commit`);
+                    duplicateSets[e._id] = true;
+                });
+                return;
+            }
+
+            if (['putOne', 'replaceOne'].includes(type)) {
+                const extras = createWriteFromFind(find);
+
+                for (let i = 0; i < listing.length; i++) {
+                    const doc = listing[i];
+                    if (confirmFilterDoc(doc, find)) {
+                        const obj = deserializeNonAtomicWrite({
+                            ...extras,
+                            ...writeObj,
+                            ...'_id' in extras ? {} : { _id: doc._id }
+                        });
+
+                        if (extraction) obj._foreign_doc = accessExtraction(obj);
+                        listing[i] = obj;
+                        logChanges([doc, obj]);
+                        return;
+                    }
+                }
+                if (type === 'putOne') {
+                    const obj = deserializeNonAtomicWrite({
+                        ...extras,
+                        ...writeObj,
+                        ...'_id' in extras ? {} : { _id: new ObjectId() }
                     });
-                } else hasNoID = true;
+
+                    if (extraction) obj._foreign_doc = accessExtraction(obj);
+                    listing.push(obj);
+                    logChanges([undefined, obj]);
+                }
+                return;
+            }
+
+            if (['deleteOne', 'deleteMany'].includes(type)) {
+                let deletions = 0;
+
+                for (let i = 0; i < listing.length; i++) {
+                    const dex = deletions + i;
+                    const doc = listing[dex];
+                    if (confirmFilterDoc(doc, find)) {
+                        listing.splice(dex, 1);
+                        logChanges([doc]);
+                        --deletions;
+                        if (type === 'deleteOne') return;
+                    }
+                }
+                return;
             }
-            if (hasNoID) console.error(`no data found locally and _id was not provided for ${type}() operation, skipping local and proceeding to online commit`);
-        }
-        editions.push([kaf, editionSet]);
-    });
 
-    editions.forEach(([kaf, list]) => {
-        list.forEach(({ doc, dex, docId }) => {
+            let founded;
+            for (let i = 0; i < listing.length; i++) {
+                const doc = listing[i];
+                if (confirmFilterDoc(doc, find)) {
+                    const obj = deserializeAtomicWrite(doc, deserializeWriteValue(writeObj), false, type);
 
-            if (dex === 'push') {
-                colObj[kaf].push({ ...doc });
-            } else if (doc === null) {
-                colObj[kaf] = colObj[kaf].filter(v => v._id !== docId);
-            } else {
-                colObj[kaf] = colObj[kaf].map(v => v._id === docId ? { ...doc } : v);
+                    if (extraction) obj._foreign_doc = accessExtraction(obj);
+                    listing[i] = obj;
+                    logChanges([doc, obj]);
+
+                    founded = true;
+                    if (type.endsWith('One')) return;
+                }
+            }
+
+            if (!founded && type.startsWith('merge')) {
+                const extras = createWriteFromFind(find);
+                const obj = {
+                    ...extras,
+                    ...deserializeAtomicWrite(
+                        { _id: '_id' in extras ? extras._id : new ObjectId() },
+                        deserializeWriteValue(writeObj),
+                        true,
+                        type
+                    )
+                };
+
+                if (extraction) obj._foreign_doc = accessExtraction(obj);
+                listing.push(obj);
+                logChanges([undefined, obj]);
             }
         });
     });
 
-
-    setLodash(CacheStore.PendingWrites, [projectUrl, `${dbUrl}${dbName}${path}`, writeId], {
-        find,
-        value: writeObj,
-        type,
+    setLodash(CacheStore.PendingWrites, [projectUrl, writeId], cloneDeep({
+        builder,
+        snapshot: result,
         editions,
         addedOn: Date.now()
-    });
+    }));
 
     updateCacheStore();
-    notifyDatabaseNodeChanges(builder);
-}
+    notifyDatabaseNodeChanges(builder, [...pathChanges]);
+};
 
 export const removePendingWrite = async (builder, writeId, revert) => {
     await awaitStore();
-    const { projectUrl, dbUrl = DEFAULT_DB_URL, dbName = DEFAULT_DB_NAME, path } = builder,
-        pObj = getLodash(CacheStore.PendingWrites, [projectUrl, `${dbUrl}${dbName}${path}`, writeId]),
-        colObj = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data']);
-
-    if (!pObj) return;
-
-    if (revert && colObj)
-        pObj.editions.forEach(([kaf, list]) => {
-            list.forEach(({ doc, dex, docId, b4Doc }) => {
-
-                if (dex === 'push') {
-                    colObj[kaf] = colObj[kaf].filter(v => v._id !== docId);
-                } else if (doc === null) {
-                    colObj[kaf] = [...colObj[kaf], b4Doc];
-                } else {
-                    colObj[kaf] = colObj[kaf].map(v => v._id === docId ? { ...b4Doc } : v);
+    const { projectUrl, dbUrl, dbName } = builder;
+    const pendingData = getLodash(CacheStore.PendingWrites, [projectUrl, writeId]);
+
+    if (!pendingData) return;
+    const pathChanges = new Set([]);
+
+    if (revert) {
+        pendingData.editions.forEach(([entityId, [b4Doc, afDoc], path]) => {
+            const colObj = getLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data']);
+            const colList = colObj?.[entityId]?.listing;
+
+            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;
+                            } else colList.splice(editedIndex, 1);
+                        }
+                    }
+                } else if (
+                    b4Doc &&
+                    colList.findIndex(e => CompareBson.equal(e._id, b4Doc._id)) === -1
+                ) {
+                    colList.push(b4Doc);
                 }
-            });
+            }
+            pathChanges.add(path);
         });
+    }
 
-    unsetLodash(CacheStore.PendingWrites, [projectUrl, `${dbUrl}${dbName}${path}`, writeId]);
+    unsetLodash(CacheStore.PendingWrites, [projectUrl, writeId]);
     updateCacheStore();
-    notifyDatabaseNodeChanges(builder);
-}
+    notifyDatabaseNodeChanges(builder, [...pathChanges]);
+};
+
+const notifyDatabaseNodeChanges = (builder, changedCollections = []) => {
+    const { projectUrl, dbName, dbUrl } = builder;
+
+    changedCollections.forEach(path => {
+        const nodeID = `${projectUrl}${dbName}${dbUrl}${path}`;
+        Object.entries(Scoped.ActiveDatabaseListeners[nodeID] || {})
+            .sort((a, b) => a[1] - b[1])
+            .forEach(([processId]) => {
+                DatabaseRecordsListener.dispatch('d', processId);
+            });
+    });
+};
 
-export const trySendPendingWrite = () => {
+const createWriteFromFind = (find) => {
+    let result = {};
 
-}
+    Object.entries(find).forEach(([k, v]) => {
+        if (['$and', '$or'].includes(k)) {
+            v.forEach(e => {
+                result = { ...result, ...createWriteFromFind(e) };
+            });
+        } else if (!k.startsWith('$')) {
+            if (Validator.OBJECT(v)) {
+                if (!Object.keys(v).some(v => v.startsWith('$'))) {
+                    result[k] = v;
+                } else if ('$eq' in v) {
+                    result[k] = v.$eq;
+                }
+            } else {
+                result[k] = v instanceof RegExp ? new BSONRegExp(v.source, v.flags) : v;
+            }
+        }
+    });
 
-const notifyDatabaseNodeChanges = (builder) => {
+    return result;
+};
 
-}
+const snipDocument = (data, find, config) => {
+    if (!data || !config) return data;
+    const { returnOnly, excludeFields } = config || {};
 
-const deserializeNonAtomicWrite = (writeObj) => {
-    const bj = {};
+    let output = { ...data };
 
-    queryEntries(writeObj, []).forEach(([segment, value]) => {
-        if (segment[0].startsWith('$'))
-            throw `unexpected field "${segment[0]}"`;
+    if (returnOnly) {
+        output = {};
+        (Array.isArray(returnOnly) ? returnOnly : [returnOnly]).filter(v => v).forEach(e => {
+            const thisData = getLodash(data, e);
+            if (thisData) setLodash(output, e, thisData);
+        });
+    } else if (excludeFields) {
+        (Array.isArray(excludeFields) ? excludeFields : [excludeFields]).filter(v => v).forEach(e => {
+            if (getLodash(data, e) && e !== '_id') unsetLodash(output, e);
+        });
+    }
 
-        if (segment.slice(-1)[0] === '$timestamp' && value === 'now') {
-            segment.pop();
-            value = Date.now();
+    getFindFields(find).forEach(field => {
+        if (!getLodash(output, field)) {
+            const mainData = getLodash(data, field);
+            if (mainData !== undefined) setLodash(output, field, mainData);
         }
+    });
 
-        setLodash(bj, segment.join('.'), value);
+    return output;
+};
+
+const getFindFields = (find) => {
+    const result = ['_id'];
+
+    Object.entries(find).forEach(([k, v]) => {
+        if (['$and', '$or', '$nor'].includes(k)) {
+            v.forEach(e => {
+                result.push(...getFindFields(e));
+            });
+        } else if (k === '$text') {
+            result.push(...Array.isArray(v.$field) ? v.$field : [v.$field]);
+        } else if (!k.startsWith('$')) {
+            result.push(k);
+        }
     });
-    return bj;
+
+    return result.filter((v, i, a) => a.findIndex(b => b === v) === i);
+};
+
+const deserializeWriteValue = (value) => {
+    if (!value) return value;
+
+    if (niceGuard(TIMESTAMP, value)) {
+        return Date.now();
+    } else if (Validator.OBJECT(value)) {
+        return Object.fromEntries(
+            Object.entries(value).map(([k, v]) =>
+                Validator.JSON(v) ? [k, deserializeWriteValue(v)] : [k, v]
+            )
+        );
+    } else if (Array.isArray(value)) {
+        return value.map(deserializeWriteValue);
+    } else return value;
 }
 
-const deserializeAtomicWrite = (b4Doc, writeObj) => {
-    const afDoc = { ...b4Doc },
-        affectedObj = {};
+const deserializeNonAtomicWrite = (writeObj) => deserializeWriteValue(writeObj);
+
+
+const deserializeAtomicWrite = (b4Doc, writeObj, isNew, type) => {
+    const resultantDoc = { ...b4Doc };
+
+    Object.entries(writeObj).forEach(([key, value]) => {
+        if (key in AtomicWriter) {
+            if (Validator.OBJECT(value)) {
+                Object.entries(value).forEach(([k, v]) => {
+                    AtomicWriter[key](k, v, resultantDoc, isNew, type);
+                });
+            } else throw `expected an object at ${key} but got ${value}`;
+        } else if (key.startsWith('$')) {
+            throw `Unknown update operator: ${key}`;
+        } else throw 'MongoInvalidArgumentError: Update document requires atomic operators';
+    });
 
-    queryEntries(writeObj, []).forEach(([segment, value]) => {
-        const [op, path] = [segment[0], segment.filter((_, i) => i)];
+    return resultantDoc;
+};
 
-        if (!WRITE_OPS_LIST.includes(op) || !path.length)
-            throw `MongoInvalidArgumentError: Update document requires atomic operators`;
+const AtomicWriter = {
+    $currentDate: (field, value, object) => {
+        const isDate = value === true || niceGuard({ $type: "date" }, value);
+        const isTimestamp = niceGuard({ $type: "timestamp" }, value);
 
         if (
-            path.length > 1 &&
-            IS_RAW_OBJECT(writeObj[op][path[0]]) &&
-            !affectedObj[path[0]]
-        ) {
-            affectedObj[path[0]] = true;
-            afDoc[path[0]] = {};
+            !isDate &&
+            !isTimestamp
+        ) throw `invalid value at $currentDate.${field}, expected any of boolean (true), { $type: "timestamp" } or { $type: "date" } but got ${value}`;
+        setLodash(object, field, isDate ? new Date() : new Timestamp({ t: Math.floor(Date.now() / 1000), i: 0 }));
+    },
+    $inc: (field, value, object) => {
+        const current = getLodash(object, field);
+        if (current === null) {
+            console.warn(`cannot use $inc operator on a null value at ${field}`);
+            return;
         }
+        const castedCurrent = downcastBSON(current);
+        const castedValue = downcastBSON(value);
 
-        const nodeValue = getLodash(b4Doc, path.join('.'));
+        if (!Validator.NUMBER(castedValue)) throw `expected a number at $inc.${field} but got ${value}`;
 
-        if (op === WRITE_OPS.$UNSET) {
-            unsetLodash(afDoc, path.join('.'));
-        } else {
-            if (
-                [WRITE_OPS.$MAX, WRITE_OPS.$MIN, WRITE_OPS.$INC, WRITE_OPS.$MUL].filter(v => v === op).length &&
-                isNaN(value)
-            ) throw `expected a number for "${op}" operation but got ${value}`;
-
-            if (path.slice(-1)[0] === '$timestamp' && value === 'now') {
-                const k = [WRITE_OPS.$SET, WRITE_OPS.$UNSET];
-                if (!k.includes(op))
-                    throw `invalid operator for updating timestamp, expected any of ${k}`;
-                path.pop();
-                value = Date.now();
+        setLodash(object, field, Validator.NUMBER(castedCurrent) ? defaultBSON(castedCurrent + castedValue, current) : value);
+    },
+    $min: (field, value, object) => {
+        const current = getLodash(object, field);
+        if (CompareBson.lesser(value, current)) {
+            setLodash(object, field, value);
+        }
+    },
+    $max: (field, value, object) => {
+        const current = getLodash(object, field);
+        if (CompareBson.greater(value, current)) {
+            setLodash(object, field, value);
+        }
+    },
+    $mul: (field, value, object) => {
+        const current = getLodash(object, field);
+        const castedValue = downcastBSON(value);
+        const castedCurrent = downcastBSON(current);
+
+        if (!Validator.NUMBER(castedValue))
+            throw `expected a number at $mul.${field} but got ${value}`;
+
+        setLodash(object, field, Validator.NUMBER(castedCurrent) ? defaultBSON(castedCurrent * castedValue, value) : 0);
+    },
+    $rename: (field, value, object) => {
+        if (!Validator.EMPTY_STRING(value))
+            throw `expected a non-empty string at $rename.${field} but got ${value}`;
+        const destStage = value.split('.');
+        const sourceStage = field.split('.');
+
+        sourceStage.forEach((e, i, a) => {
+            if (a.length !== destStage.length)
+                throw `dotnotation mismatch for ${value}`;
+            if (i !== a.length - 1) {
+                if (e !== destStage[i])
+                    throw `dotnotation mismatch at ${destStage[i]}, expected "${e}"`;
             }
+            if (!e) throw `empty node for ${field}`;
+        });
+        const [tipObj, tipSource, tipDest] = destStage.length === 1 ? [object, field, value]
+            : [getLodash(object, destStage.slice(0, -1).join('.')), sourceStage.slice(-1)[0], destStage.slice(-1)[0]];
 
-            if (op === WRITE_OPS.$RENAME) {
-                if (nodeValue === undefined) return;
-                if (typeof value !== 'string') throw `${op} operator expected a string value at ${path.join('.')}`;
-                unsetLodash(afDoc, path.join('.'));
-                path[path.length - 1] = value;
+        if (tipObj && tipSource in tipObj) {
+            tipObj[tipDest] = cloneDeep(tipObj[tipSource]);
+            delete tipObj[tipSource];
+        }
+    },
+    $set: (field, value, object) => {
+        setLodash(object, field, value === undefined ? null : value);
+    },
+    $setOnInsert: (field, value, object, isNew) => {
+        if (isNew) AtomicWriter.$set(field, value, object);
+    },
+    $unset: (field, _, object) => {
+        unsetLodash(object, field);
+    },
+    $addToSet: (field, value, object) => {
+        const current = getLodash(object, field);
+        if (Array.isArray(current)) {
+            if (
+                Validator.OBJECT(value) &&
+                Object.keys(value).length === 1 &&
+                '$each' in value
+            ) {
+                const { $each } = value;
+                if (!Array.isArray($each))
+                    throw `expected an array at "$addToSet.${field}.$each" but got ${$each}`;
+                $each.forEach(e => {
+                    if (!current.some(v => CompareBson.equal(v, e))) {
+                        current.push(e);
+                    }
+                });
+            } else if (!current.some(v => CompareBson.equal(v, value))) {
+                current.push(value);
             }
+        }
+    },
+    $pop: (field, value, object) => {
+        if (![1, -1].includes(value)) throw `expected 1 or -1 at "$pop.${field}" but got ${value}`;
+        const current = getLodash(object, field);
+        if (
+            Array.isArray(current) &&
+            current.length
+        ) current[value === 1 ? 'pop' : 'shift']();
+    },
+    $pull: (field, value, object) => {
+        // TODO: issues
+        const current = getLodash(object, field);
+        const isQueryObject = Validator.OBJECT(value);
 
-            setLodash(
-                afDoc,
-                path.join('.'),
-                op === WRITE_OPS.$SET ? value :
-                    op === WRITE_OPS.$INC ? (isNaN(nodeValue) ? value : nodeValue + value) :
-                        op === WRITE_OPS.$MAX ? (isNaN(nodeValue) ? value : value > nodeValue ? value : nodeValue) :
-                            op === WRITE_OPS.$MIN ? (isNaN(nodeValue) ? value : value < nodeValue ? value : nodeValue) :
-                                op === WRITE_OPS.$MUL ? (isNaN(nodeValue) ? 0 : value * nodeValue) :
-                                    op === WRITE_OPS.$PULL ? (Array.isArray(nodeValue) ? nodeValue.filter(v => !isEqual(v, value)) : [value]) :
-                                        op === WRITE_OPS.$PUSH ? (Array.isArray(nodeValue) ? [...nodeValue, value] : [value]) :
-                                            op === WRITE_OPS.$RENAME ? nodeValue :
-                                                null // TODO:
-            );
+        if (
+            Array.isArray(current) &&
+            current.length
+        ) {
+            const remainingCurrent = current.filter(v => {
+                const isThisObject = Validator.OBJECT(v);
+
+                try {
+                    if (
+                        confirmFilterDoc(
+                            isThisObject ? v : { __x_: v },
+                            (isThisObject && isQueryObject) ? value : { __x_: value }
+                        )
+                    ) {
+                        return false;
+                    }
+                } catch (_) { }
+                return true;
+            });
+            setLodash(object, field, remainingCurrent);
         }
-    });
+    },
+    $push: (field, value, object) => {
+        const current = getLodash(object, field);
+
+        if (Array.isArray(current)) {
+            if (Validator.OBJECT(value)) {
+                const { $each, $sort, $slice, $position, ...rest } = value;
+                if (Object.keys(rest).length)
+                    throw `unknown property "${Object.keys(rest)}" at $push.${field}`;
+
+                if ($position !== undefined) {
+                    if (Validator.INTEGER($position))
+                        throw '$position must have an integer value';
+                    if (!$each) throw '$position operator requires an $each operator';
+                }
+                if ($each !== undefined) {
+                    if (!Array.isArray($each))
+                        throw `expected an array at "$push.${field}.$each" but got ${$each}`;
+                    if ($position !== undefined) {
+                        current.splice($position, 0, ...$each);
+                    } else current.push(...$each);
+                }
+                if ($sort !== undefined) {
+                    if (!$each) throw '$sort operator requires an $each operator';
+                    if ([1, -1].includes($sort)) {
+                        current.sort();
+                        if ($sort === -1) current.reverse();
+                    } else if (Validator.OBJECT($sort)) {
+                        if (Object.keys($sort).length !== 1)
+                            throw 'number of object keys in a $sort must be one';
+
+                        Object.entries($sort).forEach(([k, v]) => {
+                            sortArrayByObjectKey(current, k);
+                            if (v === -1) current.reverse();
+                        });
+                    } else throw `expected either 1, -1 or an object at "$push.${field}.$sort" but got ${$sort}`;
+                }
+                if ($slice) {
+                    if (Validator.POSITIVE_INTEGER($slice))
+                        throw `$slice operator requires a positive integer but got ${$slice}`;
+                    current.splice($slice);
+                }
+            } else current.push(value);
+        }
+    },
+    $pullAll: (field, value, object) => {
+        if (!Array.isArray(value))
+            throw `expected an array at $pullAll.${field}`;
+
+        const current = getLodash(object, field);
 
-    return afDoc;
-}
+        if (Array.isArray(current)) {
+            const remainingCurrent = current.filter(v =>
+                !value.some(k => CompareBson.equal(v, k))
+            );
+            setLodash(object, field, remainingCurrent);
+        }
+    }
+};