react-native-mosquito-transport 0.0.14

package/src/products/auth/index.js

@@ -0,0 +1,279 @@
+import { io } from "socket.io-client";
+import EngineApi from "../../helpers/EngineApi";
+import { TokenRefreshListener } from "../../helpers/listeners";
+import { awaitReachableServer, awaitStore, buildFetchInterface, simplifyError, updateCacheStore } from "../../helpers/utils";
+import { CacheConstant, CacheStore, Scoped } from "../../helpers/variables";
+import { awaitRefreshToken, initTokenRefresher, injectFreshToken, listenToken, parseToken, triggerAuthToken } from "./accessor";
+import { deserializeE2E, encodeBinary, serializeE2E, simplifyCaughtError } from "../../helpers/peripherals";
+
+const {
+    _listenUserVerification,
+    _signOut,
+    _customSignin,
+    _customSignup,
+    _googleSignin
+} = EngineApi;
+
+export class MTAuth {
+    constructor(config) {
+        this.builder = { ...config };
+    }
+
+    customSignin = (email, password) => doCustomSignin(this.builder, email, password);
+
+    customSignup = (email, password, name, metadata) => doCustomSignup(this.builder, email, password, name, metadata);
+
+    googleSignin = (token) => doGoogleSignin(this.builder, token);
+
+    appleSignin() {
+
+    }
+
+    facebookSignin() {
+
+    }
+
+    twitterSignin() {
+
+    }
+
+    githubSignin() {
+
+    }
+
+    listenVerifiedStatus(callback, onError) {
+        const { projectUrl, serverE2E_PublicKey, uglify, baseUrl } = this.builder;
+
+        let socket, wasDisconnected, lastToken = Scoped.AuthJWTToken[projectUrl] || null, lastInitRef = 0;
+
+        const init = async () => {
+            const processID = ++lastInitRef;
+            await awaitRefreshToken(projectUrl);
+
+            if (!Scoped.AuthJWTToken[projectUrl]) {
+                onError?.(simplifyError('user_login_required', 'You must be signed-in to use this method').simpleError);
+                return;
+            }
+            if (processID !== lastInitRef) return;
+            const mtoken = Scoped.AuthJWTToken[projectUrl],
+                [reqBuilder, [privateKey]] = uglify ? serializeE2E({ mtoken }, undefined, serverE2E_PublicKey) : [null, []];
+
+            socket = io(`ws://${baseUrl}`, {
+                auth: uglify ? {
+                    e2e: reqBuilder,
+                    _m_internal: true
+                } : { mtoken, _m_internal: true }
+            });
+
+            socket.emit(_listenUserVerification(uglify));
+
+            socket.on("onVerificationChanged", ([err, verified]) => {
+                const fatal = err ? simplifyCaughtError(err).simpleError : undefined;
+                if (fatal) {
+                    onError?.(fatal);
+                } else {
+                    callback?.(uglify ? deserializeE2E(verified, serverE2E_PublicKey, privateKey) : verified);
+                }
+            });
+
+            socket.on('connect', () => {
+                if (wasDisconnected) socket.emit(_listenUserVerification(uglify));
+            });
+
+            socket.on('disconnect', () => {
+                wasDisconnected = true;
+            });
+        };
+
+        init();
+
+        const tokenListener = listenToken(t => {
+            if ((t || null) !== lastToken) {
+                socket?.close?.();
+                wasDisconnected = undefined;
+                init();
+            }
+            lastToken = t;
+        }, projectUrl);
+
+        return () => {
+            socket?.close?.();
+            tokenListener?.();
+        }
+    }
+
+    listenAuthToken = (callback) => listenToken(callback, this.builder.projectUrl);
+
+    getAuthToken = () => new Promise(resolve => {
+        const l = listenToken(t => {
+            l();
+            resolve(t || null);
+        }, this.builder.projectUrl);
+    });
+
+    listenAuth = (callback) => {
+        let lastTrig;
+
+        return listenToken((t, initToken) => {
+            const { refreshToken } = CacheStore.AuthStore[this.builder.projectUrl] || {};
+
+            if (
+                (!!t || null) !== lastTrig ||
+                initToken
+            ) callback(t ? {
+                ...parseToken(t),
+                tokenManager: {
+                    refreshToken,
+                    accessToken: t
+                }
+            } : null);
+
+            lastTrig = !!t || null;
+        }, this.builder.projectUrl);
+    }
+
+    getAuth = () => new Promise(resolve => {
+        const l = this.listenAuth(d => {
+            l();
+            resolve(d);
+        });
+    });
+
+    signOut = () => doSignOut(this.builder);
+
+    forceRefreshToken = () => initTokenRefresher(this.builder, true);
+}
+
+const doCustomSignin = (builder, email, password) => new Promise(async (resolve, reject) => {
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+
+    try {
+        await awaitStore();
+        const [reqBuilder, [privateKey]] = buildFetchInterface({
+            body: { _: `${encodeBinary(email)}.${encodeBinary(password)}` },
+            accessKey,
+            serverE2E_PublicKey,
+            uglify
+        });
+
+        const f = await (await fetch(_customSignin(projectUrl, uglify), reqBuilder)).json();
+        if (f.simpleError) throw f;
+
+        const r = uglify ? deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+
+        resolve({
+            user: parseToken(r.result.token),
+            token: r.result.token,
+            refreshToken: r.result.refreshToken
+        });
+        await injectFreshToken(builder, r.result);
+    } catch (e) {
+        reject(simplifyCaughtError(e).simpleError);
+    }
+});
+
+const doCustomSignup = (builder, email, password, name, metadata) => new Promise(async (resolve, reject) => {
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+
+    try {
+        await awaitStore();
+        const [reqBuilder, [privateKey]] = buildFetchInterface({
+            body: {
+                _: `${encodeBinary(email)}.${encodeBinary(password)}.${(encodeBinary(name || '').trim())}`,
+                metadata,
+            },
+            accessKey,
+            serverE2E_PublicKey,
+            uglify
+        });
+
+        const f = await (await fetch(_customSignup(projectUrl, uglify), reqBuilder)).json();
+        if (f.simpleError) throw f;
+
+        const r = uglify ? deserializeE2E(f.e2e, serverE2E_PublicKey, privateKey) : f;
+
+        resolve({
+            user: parseToken(r.result.token),
+            token: r.result.token,
+            refreshToken: r.result.refreshToken
+        });
+        await injectFreshToken(builder, r.result);
+    } catch (e) {
+        reject(simplifyCaughtError(e).simpleError);
+    }
+});
+
+export const doSignOut = async (builder) => {
+    await awaitStore();
+
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder,
+        { token, refreshToken: r_token } = CacheStore.AuthStore[projectUrl];
+
+    TokenRefreshListener.dispatch(projectUrl);
+    if (CacheStore.AuthStore[projectUrl]) delete CacheStore.AuthStore[projectUrl];
+    if (token) delete Scoped.AuthJWTToken[projectUrl];
+    Object.keys(CacheConstant).forEach(e => {
+        CacheStore[e] = CacheConstant[e];
+    });
+    triggerAuthToken(projectUrl);
+    updateCacheStore();
+    initTokenRefresher(builder);
+
+    if (token) {
+        TokenRefreshListener.dispatch(projectUrl, 'ready');
+        try {
+            await awaitReachableServer(projectUrl);
+
+            const [reqBuilder] = buildFetchInterface({
+                body: { token, r_token },
+                accessKey,
+                uglify,
+                serverE2E_PublicKey
+            });
+
+            const r = await (await fetch(_signOut(projectUrl, uglify), reqBuilder)).json();
+            if (r.simpleError) throw r;
+        } catch (e) {
+            throw simplifyCaughtError(e).simpleError;
+        }
+    }
+}
+
+const doGoogleSignin = (builder, token) => new Promise(async (resolve, reject) => {
+    const { projectUrl, serverE2E_PublicKey, accessKey, uglify } = builder;
+
+    try {
+        await awaitStore();
+        const [reqBuilder, [privateKey]] = buildFetchInterface({
+            body: { token },
+            accessKey,
+            uglify,
+            serverE2E_PublicKey
+        });
+
+        const r = await (await fetch(_googleSignin(projectUrl, uglify), reqBuilder)).json();
+        if (r.simpleError) throw r;
+
+        const f = uglify ? deserializeE2E(r.e2e, serverE2E_PublicKey, privateKey) : r;
+
+        resolve({
+            user: parseToken(f.result.token),
+            token: f.result.token,
+            refreshToken: f.result.refreshToken,
+            isNewUser: f.result.isNewUser
+        });
+        await injectFreshToken(builder, f.result);
+    } catch (e) {
+        reject(simplifyCaughtError(e).simpleError);
+    }
+});
+
+const doAppleSignin = async () => {
+
+}
+
+const validateEmailAndPassword = () => { }
+
+const getAuthState = async (projectUrl) => {
+
+}

package/src/products/database/accessor.js

@@ -0,0 +1,316 @@
+import { IS_RAW_OBJECT, objToUniqueString, queryEntries, shuffleArray, sortArrayByObjectKey } from "../../helpers/peripherals";
+import { awaitStore, updateCacheStore } from "../../helpers/utils";
+import { CacheStore } from "../../helpers/variables";
+import { confirmFilterDoc } from "./validator";
+import getLodash from 'lodash/get';
+import setLodash from 'lodash/set';
+import unsetLodash from 'lodash/unset';
+import isEqual from 'lodash/isEqual';
+import { DEFAULT_DB_NAME, DEFAULT_DB_URL, DELIVERY, RETRIEVAL, WRITE_OPS, WRITE_OPS_LIST } from "../../helpers/values";
+import { DatabaseRecordsListener } from "../../helpers/listeners";
+
+export const listenQueryEntry = (callback, { accessId, builder, config, processId }) => {
+    let lastObj = '';
+    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];
+    });
+
+    return () => {
+        lastObj = undefined;
+        l();
+    }
+}
+
+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], []);
+
+    (Array.isArray(value) ? value : [value]).forEach(e => {
+        const b4DocIndex = colData.findIndex(v => v._id === e._id);
+        if (b4DocIndex === -1) {
+            colData.push(e);
+        } else colData[b4DocIndex] = e;
+    });
+
+    setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'data', kaf], [...colData]);
+    setLodash(CacheStore.DatabaseStore, [projectUrl, dbUrl, dbName, path, 'record', accessId], {
+        query,
+        result: value,
+        registeredOn: Date.now()
+    });
+    updateCacheStore();
+}
+
+export const getRecord = async (builder, 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]);
+
+    if (!colRecord) return null;
+    let choosenColData = colData.filter(v => confirmFilterDoc(v, findOne || find || {}));
+
+    if (random) {
+        choosenColData = shuffleArray(choosenColData);
+    } else if (sort) {
+        choosenColData = sortArrayByObjectKey(choosenColData, sort);
+        if (
+            direction === -1 ||
+            direction === 'desc' ||
+            direction === 'descending'
+        ) choosenColData = choosenColData.reverse();
+    }
+
+    if (findOne) {
+        choosenColData = choosenColData[0];
+    } else if (limit) choosenColData.filter((_, i) => i < 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}`;
+
+    return accessId;
+}
+
+export const addPendingWrites = async (builder, writeId, 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;
+                    }
+                }
+                if (afDoc !== undefined)
+                    editionSet.push({ doc: afDoc, dex: docDex, docId: doc._id, b4Doc: { ...doc } });
+            });
+        }
+
+        if (!editionSet.length) {
+            let hasNoID;
+
+            if (type === 'putOne') {
+                const nDoc = deserializeNonAtomicWrite(writeObj),
+                    nId = nDoc?._id || find?._id;
+
+                if (nId) {
+                    editionSet.push({
+                        doc: { ...nDoc, _id: nId },
+                        dex: 'push',
+                        docId: nId
+                    });
+                } 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
+                    });
+                } else hasNoID = true;
+            }
+            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 }) => {
+
+            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);
+            }
+        });
+    });
+
+
+    setLodash(CacheStore.PendingWrites, [projectUrl, `${dbUrl}${dbName}${path}`, writeId], {
+        find,
+        value: writeObj,
+        type,
+        editions,
+        addedOn: Date.now()
+    });
+
+    updateCacheStore();
+    notifyDatabaseNodeChanges(builder);
+}
+
+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);
+                }
+            });
+        });
+
+    unsetLodash(CacheStore.PendingWrites, [projectUrl, `${dbUrl}${dbName}${path}`, writeId]);
+    updateCacheStore();
+    notifyDatabaseNodeChanges(builder);
+}
+
+export const trySendPendingWrite = () => {
+
+}
+
+const notifyDatabaseNodeChanges = (builder) => {
+
+}
+
+const deserializeNonAtomicWrite = (writeObj) => {
+    const bj = {};
+
+    queryEntries(writeObj, []).forEach(([segment, value]) => {
+        if (segment[0].startsWith('$'))
+            throw `unexpected field "${segment[0]}"`;
+
+        if (segment.slice(-1)[0] === '$timestamp' && value === 'now') {
+            segment.pop();
+            value = Date.now();
+        }
+
+        setLodash(bj, segment.join('.'), value);
+    });
+    return bj;
+}
+
+const deserializeAtomicWrite = (b4Doc, writeObj) => {
+    const afDoc = { ...b4Doc },
+        affectedObj = {};
+
+    queryEntries(writeObj, []).forEach(([segment, value]) => {
+        const [op, path] = [segment[0], segment.filter((_, i) => i)];
+
+        if (!WRITE_OPS_LIST.includes(op) || !path.length)
+            throw `MongoInvalidArgumentError: Update document requires atomic operators`;
+
+        if (
+            path.length > 1 &&
+            IS_RAW_OBJECT(writeObj[op][path[0]]) &&
+            !affectedObj[path[0]]
+        ) {
+            affectedObj[path[0]] = true;
+            afDoc[path[0]] = {};
+        }
+
+        const nodeValue = getLodash(b4Doc, path.join('.'));
+
+        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();
+            }
+
+            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;
+            }
+
+            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:
+            );
+        }
+    });
+
+    return afDoc;
+}