react-native-mosquito-transport 0.0.33 → 0.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-mosquito-transport",
-  "version": "0.0.33",
+  "version": "0.0.34",
   "description": "React native javascript sdk for mosquito-transport (https://github.com/brainbehindx/mosquito-transport)",
   "main": "src/index.js",
   "type": "module",
@@ -40,8 +40,8 @@
   },
   "peerDependencies": {
     "react-native": "*",
-    "react-native-fs": "*",
-    "react-native-sha256": "*",
-    "react-native-get-random-values": "*"
+    "react-native-file-access": "*",
+    "react-native-get-random-values": "*",
+    "react-native-sha256": "*"
   }
 }

package/src/helpers/fs_manager.js

@@ -1,8 +1,8 @@
 import { Scoped } from "./variables";
 import { Platform } from "react-native";
-import { writeFile, mkdir, MainBundlePath, readFile, unlink, DocumentDirectoryPath, readdir } from "react-native-fs";
+import { Dirs, FileSystem } from "react-native-file-access";
 
-const PARENT_FOLDER = `${Platform.OS === 'android' ? DocumentDirectoryPath.split('/').slice(0, -1).join('/') : MainBundlePath}/mosquito_base`;
+const PARENT_FOLDER = `${Platform.OS === 'android' ? Dirs.DocumentDir.split('/').slice(0, -1).join('/') : Dirs.MainBundleDir}/mosquito_base`;
 
 /**
  * this method linearize read/write for individual access_id on the file system ensuring consistency across concurrent operations
@@ -46,22 +46,22 @@ export const getSystem = (builder) => {
     return {
         set: async (table, primary_key, value) => {
             const path = conjoin(table, primary_key);
-            await mkdir(path).catch(() => null);
+            await FileSystem.mkdir(path).catch(() => null);
             await Promise.all(Object.entries(value).map(([k, v]) =>
-                writeFile(joinPath(path, k), JSON.stringify(v), 'utf8')
+                FileSystem.writeFile(joinPath(path, k), JSON.stringify(v), 'utf8')
             ));
         },
-        delete: (table, primary_key) => unlink(conjoin(table, primary_key)),
+        delete: (table, primary_key) => FileSystem.unlink(conjoin(table, primary_key)),
         find: async (table, primary_key, extractions) => {
             const path = conjoin(table, primary_key);
 
             const value_map = await Promise.all(extractions.map(async node =>
-                [node, JSON.parse(await readFile(joinPath(path, node)), 'utf8')]
+                [node, JSON.parse(await FileSystem.readFile(joinPath(path, node)), 'utf8')]
             ));
             return Object.fromEntries(value_map);
         },
         list: async (table, extractions) => {
-            const names = await readdir(conjoin(table));
+            const names = await FileSystem.ls(conjoin(table));
             const list_data = await Promise.all(names.map(async primary_key => {
                 const obj = await system.find(table, primary_key, extractions)
                     .catch(() => null);
@@ -74,7 +74,7 @@ export const getSystem = (builder) => {
     };
 };
 
-function purifyFilepath(filename) {
+export function purifyFilepath(filename) {
     if (!filename || typeof filename !== 'string')
         throw `invalid filename:${filename}`;
 

package/src/helpers/peripherals.js

@@ -4,6 +4,7 @@ import naclPkg from 'tweetnacl';
 import getLodash from "lodash/get";
 import { deserialize, serialize } from "entity-serializer";
 import { sha256 } from 'react-native-sha256';
+import { purifyFilepath } from "./fs_manager";
 
 const { box, randomBytes } = naclPkg;
 
@@ -67,8 +68,7 @@ export function sortArrayByObjectKey(arr = [], key) {
 
 export async function niceHash(str = '') {
     const hash = Buffer.from(await sha256(str), 'hex').toString('base64');
-    if (hash.length > str.length) return encodeBinary(str);
-    return hash;
+    return purifyFilepath(hash);
 };
 
 export const sameInstance = (var1, var2) => {

package/src/products/database/accessor.js

@@ -69,10 +69,12 @@ export const getCountQuery = async (builder, access_id) => {
         return data && data.value;
     } else {
         return useFS(builder, access_id, 'dbQueryCount')(async fs => {
-            const { value } = await fs.find(DB_COUNT_QUERY(path), access_id, ['value']);
-            await fs.set(DB_COUNT_QUERY(path), access_id, { touched: Date.now() });
-            return value;
-        }).catch(() => undefined);
+            const data = await fs.find(DB_COUNT_QUERY(path), access_id, ['value']).catch(() => null);
+            if (data) {
+                await fs.set(DB_COUNT_QUERY(path), access_id, { touched: Date.now() });
+                return data.value;
+            }
+        });
     }
 }
 

package/src/products/http_callable/accessor.js

@@ -25,7 +25,7 @@ export const insertFetchResources = async (projectUrl, access_id, value) => {
         updateCacheStore(['FetchedStore', 'DatabaseStats']);
     } else {
         await useFS(FETCH_RESOURCES(projectUrl), access_id, 'httpFetch')(async fs => {
-            const b4Data = await fs.find('main', access_id, ['size']);
+            const b4Data = await fs.find('main', access_id, ['size']).catch(() => null);
 
             await fs.set('main', access_id, { value, size: dataSize, touched: Date.now() });
             incrementFetcherSize(projectUrl, dataSize - (b4Data?.size || 0));

package/src/products/http_callable/index.js

@@ -106,7 +106,7 @@ export const mfetch = async (input = '', init, config) => {
 
         await awaitStore();
         const resolveCache = (reqData) => {
-            finalize(buildFetchData(reqData), { fromCache: true });
+            finalize(buildFetchData(reqData, { fromCache: true }));
         };
 
         try {