react-native-mosquito-transport 0.0.19 → 0.0.21

package/src/products/http_callable/index.js

@@ -1,63 +1,85 @@
 import { Buffer } from "buffer";
-import { cloneInstance, deserializeE2E, listenReachableServer, objToUniqueString, serializeE2E, simplifyCaughtError } from "../../helpers/peripherals";
-import { awaitStore, getReachableServer, updateCacheStore, validateRequestMethod } from "../../helpers/utils";
-import { RETRIEVAL, Regexs } from "../../helpers/values";
+import { deserializeE2E, listenReachableServer, niceHash, normalizeRoute, serializeE2E } from "../../helpers/peripherals";
+import { awaitStore, getReachableServer, updateCacheStore } from "../../helpers/utils";
+import { RETRIEVAL } from "../../helpers/values";
 import { CacheStore, 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";
 
 const buildFetchData = (data) => {
-    const { ok, type, status, statusText, redirected, url, headers, base64, builderCred } = data;
-    const { uglified, encKey, serverKey } = builderCred;
-
-    const h = {
-        arrayBuffer: async () => Buffer.from(base64, 'base64'),
-        json: async () => JSON.parse(await h.text()),
-        text: async () => {
-            const txt = Buffer.from(base64, 'base64').toString('utf8');
-
-            if (uglified) {
-                const json = deserializeE2E(txt, serverKey, encKey);
-                return `${json}`;
-            } else return txt;
-        },
-        clone: () => ({ ...h }),
-        type,
+    const { ok, type, status, statusText, redirected, url, headers, size, base64 } = data;
+
+    const response = new Response(Buffer.from(base64, 'base64'), {
+        headers: new Headers(headers),
         status,
         statusText,
-        redirected,
         url,
-        ok,
-        headers: new Headers({ ...headers }),
-    };
-
-    return h;
-}
+        size
+    });
 
-export const mfetch = async (input = '', init = {}, config) => {
-    const { projectUrl, apiUrl, serverE2E_PublicKey, method, maxRetries = 7, disableCache, accessKey, uglify } = config;
-    validateRequestMethod(method);
-
-    const { retrieval = RETRIEVAL.DEFAULT, enableMinimizer, rawApproach } = method || {},
-        isBaseUrl = Regexs.LINK().test(input),
-        disableAuth = method?.disableAuth || isBaseUrl,
-        shouldCache = (retrieval === RETRIEVAL.DEFAULT ? !disableCache : true) &&
-            retrieval !== RETRIEVAL.NO_CACHE_NO_AWAIT,
-        reqId = objToUniqueString({
-            ...init,
-            jij: { disableAuth: !!disableAuth, url: input, projectUrl, retrieval }
+    Object.entries({ ok, type, url, redirected, size })
+        .forEach(([k, v]) => {
+            if (response[k] !== v)
+                Object.defineProperty(response, k, {
+                    value: v,
+                    writable: false
+                });
         });
 
-    if ('mtoken' in (init?.headers || {}))
+    return response;
+}
+
+export const mfetch = async (input = '', init, config) => {
+    const { projectUrl, serverE2E_PublicKey, method, maxRetries = 7, disableCache, accessKey, uglify, extraHeaders } = config;
+    const { headers, body } = init || {};
+
+    if (method !== undefined)
+        guardObject({
+            enableMinimizer: t => t === undefined || Validator.BOOLEAN(t),
+            rawApproach: t => t === undefined || Validator.BOOLEAN(t),
+            disableAuth: t => t === undefined || Validator.BOOLEAN(t),
+            retrieval: t => t === undefined || Object.values(RETRIEVAL).includes(t)
+        }).validate(method);
+
+    const { retrieval = RETRIEVAL.DEFAULT, enableMinimizer, rawApproach } = method || {};
+    const isBaseUrl = Validator.LINK(input);
+    const disableAuth = method?.disableAuth || isBaseUrl;
+    const shouldCache = (retrieval !== RETRIEVAL.DEFAULT || !disableCache) &&
+        retrieval !== RETRIEVAL.NO_CACHE_NO_AWAIT;
+    const uglified = !!(!isBaseUrl && uglify);
+
+    const rawHeader = Object.fromEntries(
+        [...new Headers(headers).entries()]
+    );
+
+    if ('mtoken' in rawHeader)
         throw '"mtoken" in header is a reserved prop';
 
-    if ('uglified' in (init?.headers || {}))
+    if ('uglified' in rawHeader)
         throw '"uglified" in header is a reserved prop';
 
-    if (input.startsWith(projectUrl) && !rawApproach)
-        throw `fetchHttp first argument can not starts with projectUrl:"${projectUrl}", please set {rawApproach: true} if you're trying to access this url as it is`;
-
-    if (!isBaseUrl && init.body && typeof init.body !== 'string')
-        throw `"body" must be a string value`;
+    // if (isBaseUrl && !rawApproach)
+    //     throw `please set { rawApproach: true } if you're trying to access different endpoint at "${input}"`;
+
+    if (body !== undefined) {
+        if (
+            typeof body !== 'string' &&
+            !Buffer.isBuffer(body) &&
+            !Validator.JSON(body)
+        ) throw `"body" must be any of string, buffer, object`;
+    }
+
+    const reqId = await niceHash(
+        serialize([
+            rawHeader,
+            body,
+            !!disableAuth,
+            input
+        ]).toString('base64')
+    );
 
     let retries = 0, hasFinalize;
 
@@ -72,7 +94,7 @@ export const mfetch = async (input = '', init = {}, config) => {
 
             if (enableMinimizer) {
                 (Scoped.PendingFetchCollective.pendingResolution[reqId] || []).forEach(e => {
-                    e(cloneInstance(a), b);
+                    e(a, b);
                 });
                 if (Scoped.PendingFetchCollective.pendingResolution[reqId])
                     delete Scoped.PendingFetchCollective.pendingResolution[reqId];
@@ -83,16 +105,15 @@ export const mfetch = async (input = '', init = {}, config) => {
         };
 
         await awaitStore();
-        const reqData = CacheStore.FetchedStore[reqId],
-            resolveCache = () => {
-                finalize({
-                    ...buildFetchData(reqData),
-                    fromCache: true
-                });
-            };
+        const reqData = CacheStore.FetchedStore[projectUrl]?.[reqId];
+        const resolveCache = () => {
+            finalize({
+                ...buildFetchData(reqData),
+                fromCache: true
+            });
+        };
 
         try {
-
             if (retryProcess === 1) {
                 if (enableMinimizer) {
                     if (Scoped.PendingFetchCollective.pendingProcess[reqId]) {
@@ -100,8 +121,8 @@ export const mfetch = async (input = '', init = {}, config) => {
                             Scoped.PendingFetchCollective.pendingResolution[reqId] = [];
 
                         Scoped.PendingFetchCollective.pendingResolution[reqId].push((a, b) => {
-                            if (a) resolve(a.result);
-                            else reject(b);
+                            if (a) resolve(cloneDeep(a.result));
+                            else reject(cloneDeep(b));
                         });
                         return;
                     }
@@ -117,53 +138,56 @@ export const mfetch = async (input = '', init = {}, config) => {
             if (!disableAuth && await getReachableServer(projectUrl))
                 await awaitRefreshToken(projectUrl);
 
-            const mtoken = Scoped.AuthJWTToken[projectUrl],
-                uglified = (!isBaseUrl && init?.body && typeof init?.body === 'string' && uglify),
-                initType = extractHeaderItem('content-type', init?.headers);
+            const mtoken = Scoped.AuthJWTToken[projectUrl];
+            const initType = rawHeader['content-type'];
 
-            const [reqBuilder, [privateKey]] = (uglified && isBaseUrl) ? serializeE2E(init.body, mtoken, serverE2E_PublicKey) : [null, []];
+            const [reqBuilder, [privateKey]] = uglified ? await serializeE2E(body, mtoken, serverE2E_PublicKey) : [null, []];
 
-            const f = await fetch(isBaseUrl ? input : `${apiUrl}/${input}`, {
+            const f = await fetch(isBaseUrl ? input : `${projectUrl}/${normalizeRoute(input)}`, {
                 ...isBaseUrl ? {} : { method: 'POST' },
                 ...init,
                 ...uglified ? { body: reqBuilder } : {},
                 cache: 'no-cache',
                 headers: {
-                    ...isBaseUrl ? {} : { 'Content-type': 'application/json' },
-                    ...init?.headers,
+                    ...extraHeaders,
+                    ...isBaseUrl ? {} : { 'content-type': 'application/json' },
+                    ...rawHeader,
                     ...uglified ? {
                         uglified,
-                        'Content-type': 'text/plain',
+                        'content-type': 'request/buffer',
                         ...initType ? { 'init-content-type': initType } : {}
                     } : {},
-                    ...((disableAuth || !mtoken || uglified || isBaseUrl) ? {} : { mtoken }),
+                    ...(disableAuth || !mtoken || uglified || isBaseUrl) ? {} : { mtoken },
                     ...isBaseUrl ? {} : { authorization: `Bearer ${accessKey}` }
                 }
-            }),
-                { ok, type, status, statusText, redirected, url, headers } = f,
-                simple = headers.get('simple_error');
+            });
+            const { ok, type, status, statusText, redirected, url, headers, size } = f;
+            const simple = headers.get('simple_error');
 
             if (!isBaseUrl && simple) throw { simpleError: JSON.parse(simple) };
 
-            const base64 = Buffer.from(await f.arrayBuffer()).toString('base64'),
-                resObj = {
-                    builderCred: {
-                        uglified,
-                        encKey: privateKey,
-                        serverKey: serverE2E_PublicKey
-                    },
-                    base64,
-                    type,
-                    status,
-                    statusText,
-                    redirected,
-                    url,
-                    ok,
-                    headers: headerObj(headers)
-                };
+            const base64 = uglified ?
+                Buffer.from(await deserializeE2E(await f.arrayBuffer(), serverE2E_PublicKey, privateKey)).toString('base64') :
+                Buffer.from(await f.arrayBuffer()).toString('base64');
+
+            const resObj = {
+                base64,
+                type,
+                status,
+                statusText,
+                redirected,
+                url,
+                ok,
+                size,
+                headers: Object.fromEntries(
+                    [...headers.entries()]
+                )
+            };
 
             if (shouldCache) {
-                CacheStore.FetchedStore[reqId] = { ...resObj };
+                if (!CacheStore.FetchedStore[projectUrl])
+                    CacheStore.FetchedStore[projectUrl] = {};
+                CacheStore.FetchedStore[projectUrl][reqId] = cloneDeep(resObj);
                 updateCacheStore();
             }
 
@@ -207,24 +231,5 @@ export const mfetch = async (input = '', init = {}, config) => {
         }
     });
 
-    const r = await callFetch();
-    return r;
-};
-
-const extractHeaderItem = (t = '', header) => {
-    let k;
-    Object.entries(header || {}).forEach(([key, value]) => {
-        if (key.toLowerCase() === t.toLowerCase()) k = value;
-    });
-    return k;
-}
-
-const headerObj = (header) => {
-    const h = {};
-
-    header.forEach((v, k) => {
-        h[k] = v;
-    });
-
-    return h;
-}
+    return await callFetch();
+};

package/src/products/storage/index.js

@@ -1,9 +1,10 @@
-import EngineApi from "../../helpers/EngineApi";
+import EngineApi from "../../helpers/engine_api";
 import { encodeBinary, prefixStoragePath } from "../../helpers/peripherals";
 import { Scoped } from "../../helpers/variables";
 import { DeviceEventEmitter, NativeEventEmitter, NativeModules, Platform } from 'react-native';
-import { awaitReachableServer, buildFetchInterface, simplifyError } from "../../helpers/utils";
+import { awaitReachableServer, buildFetchInterface } from "../../helpers/utils";
 import { awaitRefreshToken } from "../auth/accessor";
+import { simplifyError } from "simplify-error";
 
 const LINKING_ERROR =
     `The package 'react-native-mosquito-transport' doesn't seem to be linked. Make sure: \n\n` +
@@ -17,22 +18,23 @@ const RNMTModule = NativeModules.Mosquitodb || (
             throw new Error(LINKING_ERROR);
         },
     })
-),
-    emitter = Platform.OS === 'android' ?
-        DeviceEventEmitter : new NativeEventEmitter(RNMTModule);
+);
+const emitter = Platform.OS === 'android' ?
+    DeviceEventEmitter : new NativeEventEmitter(RNMTModule);
 
 export class MTStorage {
     constructor(config) {
         this.builder = { ...config };
     }
 
-    downloadFile(link = '', onComplete, destination, onProgress) {
+    downloadFile(link = '', onComplete, destination, onProgress, options) {
+        const { awaitServer } = options || {};
         let hasFinished, isPaused, hasCancelled;
 
-        const { projectUrl, accessKey, awaitStorage } = this.builder;
+        const { projectUrl, accessKey, extraHeaders } = this.builder;
 
-        if (destination && (!destination?.trim() || typeof destination !== 'string')) {
-            onComplete?.({ error: 'destination_invalid', message: 'destination is invalid in downloadFile()' });
+        if (destination && (typeof destination !== 'string' || !destination.trim())) {
+            onComplete?.({ error: 'destination_invalid', message: 'destination must be a non-empty string' });
             return () => { };
         }
         if (destination) destination = prefixStoragePath(destination?.trim());
@@ -46,57 +48,58 @@ export class MTStorage {
         }
         link = link.trim();
 
+        const processID = `${++Scoped.StorageProcessID}`;
         const init = async () => {
-            if (awaitStorage) await awaitReachableServer(projectUrl);
+            if (awaitServer) await awaitReachableServer(projectUrl);
             await awaitRefreshToken(projectUrl);
 
             if (hasCancelled) return;
 
-            const processID = `${++Scoped.StorageProcessID}`,
-                progressListener = emitter.addListener('mt-download-progress', ({ processID: ref, receivedBtyes, expectedBytes }) => {
-                    if (processID !== ref || hasFinished || hasCancelled) return;
-                    onProgress?.({
-                        receivedBtyes,
-                        expectedBytes,
-                        isPaused: !!isPaused,
-                        pause: () => {
-                            if (hasFinished || isPaused || hasCancelled) return;
-                            RNMTModule.pauseDownload(processID);
-                            isPaused = true;
-                        },
-                        resume: () => {
-                            if (hasFinished || !isPaused || hasCancelled) return;
-                            RNMTModule.pauseDownload(processID);
-                            isPaused = false;
-                        }
-                    });
-                }),
-                resultListener = emitter.addListener('mt-download-status', ({ processID: ref, error, errorDes, result }) => {
-                    if (processID !== ref) return;
-                    if (result)
-                        try {
-                            result = JSON.parse(result);
-                        } catch (e) { }
-
-                    const path = result?.file || undefined;
-
-                    if (!hasFinished && !hasCancelled)
-                        onComplete?.(path ? undefined : (result?.simpleError || { error, errorDes }), path);
-                    resultListener.remove();
-                    progressListener.remove();
-                    hasFinished = true;
+            const progressListener = emitter.addListener('mt-download-progress', ({ processID: ref, receivedBtyes, expectedBytes }) => {
+                if (processID !== ref || hasFinished || hasCancelled) return;
+                onProgress?.({
+                    receivedBtyes,
+                    expectedBytes,
+                    isPaused: !!isPaused,
+                    pause: () => {
+                        if (hasFinished || isPaused || hasCancelled) return;
+                        RNMTModule.pauseDownload(processID);
+                        isPaused = true;
+                    },
+                    resume: () => {
+                        if (hasFinished || !isPaused || hasCancelled) return;
+                        RNMTModule.resumeDownload(processID);
+                        isPaused = false;
+                    }
                 });
+            });
+            const resultListener = emitter.addListener('mt-download-status', ({ processID: ref, error, errorDes, result }) => {
+                if (processID !== ref) return;
+                if (result)
+                    try {
+                        result = JSON.parse(result);
+                    } catch (e) { }
+
+                const path = result?.file || undefined;
+
+                if (!hasFinished && !hasCancelled)
+                    onComplete?.(path ? undefined : (result?.simpleError || { error, message: errorDes }), path);
+                resultListener.remove();
+                progressListener.remove();
+                hasFinished = true;
+            });
 
             RNMTModule.downloadFile({
                 url: link,
                 authToken: Scoped.AuthJWTToken[projectUrl],
-                ...(destination ? {
+                ...destination ? {
                     destination: destination.substring('file://'.length),
-                    destinationDir: `${destination.substring('file://'.length)}`.split('/').filter((_, i, a) => i !== a.length - 1).join('/')
-                } : {}),
+                    destinationDir: `${destination.substring('file://'.length)}`.split('/').slice(0, -1).join('/')
+                } : {},
                 processID,
                 urlName: link.split('/').pop(),
-                authorization: `Bearer ${encodeBinary(accessKey)}`
+                authorization: `Bearer ${encodeBinary(accessKey)}`,
+                extraHeaders: extraHeaders || {},
             });
         }
 
@@ -112,60 +115,64 @@ export class MTStorage {
         }
     }
 
-    uploadFile(file = '', destination = '', onComplete, onProgress) {
+    uploadFile(file = '', destination = '', onComplete, onProgress, options) {
+        const { createHash, awaitServer } = options || {};
         let hasFinished, hasCancelled;
 
-        if (!file?.trim() || typeof file !== 'string') {
+        if (typeof file !== 'string' || !file.trim()) {
             onComplete?.({ error: 'file_path_invalid', message: 'file must be a non-empty string in uploadFile()' });
             return () => { };
         }
-        destination = destination?.trim();
-
-        const destErr = validateDestination(destination),
-            isAsset = (file.startsWith('ph://') || file.startsWith('content://'));
+        destination = destination?.trim?.();
 
-        file = isAsset ? file.trim() : prefixStoragePath(file.trim());
-
-        if (destErr) {
-            onComplete?.({ error: 'destination_invalid', message: destErr });
+        try {
+            validateDestination(destination);
+        } catch (error) {
+            onComplete?.({ error: 'destination_invalid', message: error });
             return () => { };
         }
 
-        const { projectUrl, accessKey, awaitStorage } = this.builder,
-            processID = `${++Scoped.StorageProcessID}`;
+        const isAsset = (file.startsWith('ph://') || file.startsWith('content://'));
+
+        file = isAsset ? file.trim() : prefixStoragePath(file.trim());
+
+        const { projectUrl, accessKey, uglify, extraHeaders } = this.builder;
+        const processID = `${++Scoped.StorageProcessID}`;
 
         const init = async () => {
-            if (awaitStorage) await awaitReachableServer(projectUrl);
+            if (awaitServer) await awaitReachableServer(projectUrl);
             await awaitRefreshToken(projectUrl);
 
             if (hasCancelled) return;
             const progressListener = emitter.addListener('mt-uploading-progress', ({ processID: ref, sentBtyes, totalBytes }) => {
                 if (processID !== ref || hasFinished || hasCancelled) return;
                 onProgress?.({ sentBtyes, totalBytes });
-            }),
-                resultListener = emitter.addListener('mt-uploading-status', ({ processID: ref, error, errorDes, result }) => {
-                    if (processID !== ref || hasFinished) return;
-                    if (result)
-                        try {
-                            result = JSON.parse(result);
-                        } catch (e) { }
-
-                    const downloadUrl = result?.downloadUrl || undefined;
-
-                    if (!hasFinished && !hasCancelled)
-                        onComplete?.(downloadUrl ? undefined : (result?.simpleError || { error, errorDes }), downloadUrl);
-                    resultListener.remove();
-                    progressListener.remove();
-                    hasFinished = true;
-                });
+            });
+            const resultListener = emitter.addListener('mt-uploading-status', ({ processID: ref, error, errorDes, result }) => {
+                if (processID !== ref || hasFinished) return;
+                if (result)
+                    try {
+                        result = JSON.parse(result);
+                    } catch (e) { }
+
+                const downloadUrl = result?.downloadUrl || undefined;
+
+                if (!hasFinished && !hasCancelled)
+                    onComplete?.(downloadUrl ? undefined : (result?.simpleError || { error, message: errorDes }), downloadUrl);
+                resultListener.remove();
+                progressListener.remove();
+                hasFinished = true;
+            });
 
             RNMTModule.uploadFile({
-                url: EngineApi._uploadFile(projectUrl),
+                url: EngineApi._uploadFile(projectUrl, uglify),
                 file: isAsset ? file : file.substring('file://'.length),
                 authToken: Scoped.AuthJWTToken[projectUrl],
+                createHash: createHash ? 'yes' : 'no',
                 destination,
                 processID,
-                authorization: `Bearer ${encodeBinary(accessKey)}`
+                authorization: `Bearer ${encodeBinary(accessKey)}`,
+                extraHeaders: extraHeaders || {}
             });
         }
 
@@ -186,12 +193,12 @@ export class MTStorage {
 }
 
 const deleteContent = async (builder, path, isFolder) => {
-    const { projectUrl, accessKey } = builder;
+    const { projectUrl, accessKey, uglify } = builder;
 
     try {
         const r = await (await fetch(
-            EngineApi[isFolder ? '_deleteFolder' : '_deleteFile'](projectUrl),
-            buildFetchInterface({ path }, accessKey, Scoped.AuthJWTToken[projectUrl], 'DELETE')
+            EngineApi[isFolder ? '_deleteFolder' : '_deleteFile'](projectUrl, uglify),
+            await buildFetchInterface({ path }, accessKey, Scoped.AuthJWTToken[projectUrl], 'DELETE')
         )).json();
         if (r.simpleError) throw r;
         if (r.status !== 'success') throw 'operation not successful';
@@ -202,16 +209,18 @@ const deleteContent = async (builder, path, isFolder) => {
 }
 
 const validateDestination = (t = '') => {
-    t = t.trim();
+    if (typeof t !== 'string' || !t.trim()) throw 'path must be a non-empty string';
+    if (t.startsWith(' ') || t.endsWith(' ')) throw 'path must be trimmed';
+    if (t.startsWith('./') || t.startsWith('../')) throw 'path must be absolute';
+    if (t.endsWith('/')) throw 'path must not end with "/"';
+    if ('?'.split('').some(v => t.includes(v)))
+        throw `path must not contain ?`;
 
-    if (!t || typeof t !== 'string') return `destination is required`;
-    if (t.startsWith('/') || t.endsWith('/')) return 'destination must neither start with "/" nor end with "/"';
-    let l = '', r;
+    t = t.trim();
+    let l = '';
 
     t.split('').forEach(e => {
-        if (e === '/' && l === '/') r = 'invalid destination path, "/" cannot be side by side';
+        if (e === '/' && l === '/') throw 'invalid destination path, "/" cannot be duplicated side by side';
         l = e;
     });
-
-    return r;
 };

package/src/helpers/EngineApi.js

@@ -1,33 +0,0 @@
-import { encodeBinary } from './peripherals';
-
-const apis = {
-    _readDocument: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._readDocument(baseApi)) : '_readDocument'}`,
-    _writeDocument: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._writeDocument(baseApi)) : '_writeDocument'}`,
-    _deleteCollection: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._deleteCollection(baseApi)) : '_deleteCollection'}`,
-    _queryCollection: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._queryCollection(baseApi)) : '_queryCollection'}`,
-    _writeMapDocument: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._writeMapDocument(baseApi)) : '_writeMapDocument'}`,
-    _customSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._customSignin(baseApi)) : '_customSignin'}`,
-    _customSignup: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._customSignup(baseApi)) : '_customSignup'}`,
-    _googleSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._googleSignin(baseApi)) : '_googleSignin'}`,
-    _appleSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._appleSignin(baseApi)) : '_appleSignin'}`,
-    _facebookSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._facebookSignin(baseApi)) : '_facebookSignin'}`,
-    _twitterSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._twitterSignin(baseApi)) : '_twitterSignin'}`,
-    _githubSignin: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._githubSignin(baseApi)) : '_githubSignin'}`,
-    _signOut: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._signOut(baseApi)) : '_signOut'}`,
-    _refreshAuthToken: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._refreshAuthToken(baseApi)) : '_refreshAuthToken'}`,
-    _downloadFile: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._downloadFile(baseApi)) : '_downloadFile'}`,
-    _uploadFile: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._uploadFile(baseApi)) : '_uploadFile'}`,
-    _deleteFile: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._deleteFile(baseApi)) : '_deleteFile'}`,
-    _deleteFolder: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._deleteFolder(baseApi)) : '_deleteFolder'}`,
-    staticStorage: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis.staticStorage(baseApi)) : 'storage'}`,
-    _documentCount: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._documentCount(baseApi)) : '_documentCount'}`,
-    _areYouOk: (baseApi, ugly) => `${baseApi}/${ugly ? encodeBinary(apis._areYouOk(baseApi)) : '_areYouOk'}`,
-    // static path
-    _listenCollection: (ugly) => `${ugly ? encodeBinary(apis._listenCollection()) : '_listenCollection'}`,
-    _listenDocument: (ugly) => `${ugly ? encodeBinary(apis._listenDocument()) : '_listenDocument'}`,
-    _startDisconnectWriteTask: (ugly) => `${ugly ? encodeBinary(apis._startDisconnectWriteTask()) : '_startDisconnectWriteTask'}`,
-    _cancelDisconnectWriteTask: (ugly) => `${ugly ? encodeBinary(apis._cancelDisconnectWriteTask()) : '_cancelDisconnectWriteTask'}`,
-    _listenUserVerification: (ugly) => `${ugly ? encodeBinary(apis._listenUserVerification()) : '_listenUserVerification'}`
-};
-
-export default { ...apis };