Added CacheableImage.cacheFile() and CacheableImage.purge() static methods and tests.

Author: billmalarky

index.js

@@ -7,5 +7,7 @@
 'use strict';
 
 import imageCacheHoc from './lib/imageCacheHoc';
+import FileSystemFactory, { FileSystem } from './lib/FileSystem';
 
-export default imageCacheHoc;
+export default imageCacheHoc;
+export { FileSystemFactory, FileSystem }; // Allow access to FS logic for advanced users.

lib/FileSystem.js

@@ -120,12 +120,12 @@ export class FileSystem {
    *
    * Wrapper for https://github.com/wkh237/react-native-fetch-blob/wiki/File-System-Access-API#existspathstringpromise
    *
-   * @param path - local file path.
+   * @param path - local relative file path.
    * @returns {Promise} - boolean promise for if file exists at path or not.
    */
   exists(path) {
     this._validatePath(path);
-    return RNFetchBlob.fs.exists(this.baseFilePath + path);
+    return RNFetchBlob.fs.exists(pathLib.resolve(this.baseFilePath + path));
   }
 
   /**
@@ -304,6 +304,24 @@ export class FileSystem {
 
   }
 
+  /**
+   * Used to delete local files and directories
+   *
+   * @param path - local relative file path.
+   * @returns {Promise} - boolean promise for if deletion was successful.
+   */
+  async unlink(path) {
+    this._validatePath(path);
+
+    try {
+      await RNFetchBlob.fs.unlink(pathLib.resolve(this.baseFilePath + path));
+      return true;
+    } catch (error) {
+      return false;
+    }
+
+  }
+
 }
 
 /**

lib/imageCacheHoc.js

@@ -44,6 +44,49 @@ export default function imageCacheHoc(Image, options = {}) {
       })
     };
 
+    /**
+     *
+     * Manually cache a file.
+     * Can be used to pre-warm caches.
+     * If calling this method repeatedly to cache a long list of files,
+     * be sure to use a queue and limit concurrency so your app performance does not suffer.
+     *
+     * @param url {String} - url of file to download.
+     * @param permanent {Boolean} - whether the file should be saved to the tmp or permanent cache directory.
+     * @returns {Promise} promise that resolves to an object that contains cached file info.
+     */
+    static async cacheFile(url, permanent = false) {
+
+      const fileSystem = FileSystemFactory();
+      const localFilePath = await fileSystem.getLocalFilePathFromUrl(url, permanent);
+
+      return {
+        url: url,
+        cacheType: (permanent ? 'permanent' : 'cache'),
+        localFilePath
+      };
+
+    }
+
+    /**
+     *
+     * Delete all locally stored image files created by react-native-image-cache-hoc (cache AND permanent).
+     * Calling this method will cause a performance hit on your app until the local files are rebuilt.
+     *
+     * @returns {Promise} promise that resolves to an object that contains the flush results.
+     */
+    static async flush() {
+
+      const fileSystem = FileSystemFactory();
+      const results = await Promise.all([fileSystem.unlink('permanent'), fileSystem.unlink('cache')]);
+
+      return {
+        permanentDirFlushed: results[0],
+        cacheDirFlushed: results[1]
+      };
+
+    }
+
     constructor(props) {
       super(props);
 

tests/CacheableImage.test.js

@@ -88,6 +88,93 @@ describe('CacheableImage', function() {
 
   });
 
+  it('#cacheFile static method should work as expected for cache dir files.', () => {
+
+    // RNFetchBlob Mocks
+    const RNFetchBlob = require('react-native-fetch-blob');
+
+    // Mock that file does not exist on local fs.
+    RNFetchBlob.fs.exists
+      .mockReturnValue(false);
+
+    // Mock fetch result
+    RNFetchBlob.fetch
+      .mockReturnValue({
+        path: () => {
+          return '/this/is/path/to/file.jpg';
+        }
+      });
+
+    const CacheableImage = imageCacheHoc(Image);
+
+    return CacheableImage.cacheFile('https://i.redd.it/rc29s4bz61uz.png')
+      .then(result => {
+
+        result.should.deepEqual({
+          url: 'https://i.redd.it/rc29s4bz61uz.png',
+          cacheType: 'cache',
+          localFilePath: '/this/is/path/to/file.jpg'
+        });
+
+      });
+
+  });
+
+  it('#cacheFile static method should work as expected for permanent dir files.', () => {
+
+    // RNFetchBlob Mocks
+    const RNFetchBlob = require('react-native-fetch-blob');
+
+    // Mock that file does not exist on local fs.
+    RNFetchBlob.fs.exists
+      .mockReturnValue(false);
+
+    // Mock fetch result
+    RNFetchBlob.fetch
+      .mockReturnValue({
+        path: () => {
+          return '/this/is/path/to/file.jpg';
+        }
+      });
+
+    const CacheableImage = imageCacheHoc(Image);
+
+    return CacheableImage.cacheFile('https://i.redd.it/rc29s4bz61uz.png', true)
+      .then(result => {
+
+        result.should.deepEqual({
+          url: 'https://i.redd.it/rc29s4bz61uz.png',
+          cacheType: 'permanent',
+          localFilePath: '/this/is/path/to/file.jpg'
+        });
+
+      });
+
+  });
+
+  it('#flush static method should work as expected.', () => {
+
+    // RNFetchBlob Mocks
+    const RNFetchBlob = require('react-native-fetch-blob');
+
+    // Mock unlink to always be true.
+    RNFetchBlob.fs.unlink
+      .mockReturnValue(true);
+
+    const CacheableImage = imageCacheHoc(Image);
+
+    return CacheableImage.flush()
+      .then(result => {
+
+        result.should.deepEqual({
+          permanentDirFlushed: true,
+          cacheDirFlushed: true
+        });
+
+      });
+
+  });
+
   it('#constructor should initialize class object properties correctly.', () => {
 
     const CacheableImage = imageCacheHoc(Image);

tests/FileSystem.test.js

@@ -290,4 +290,42 @@ describe('lib/FileSystem', function() {
 
   });
 
+  it('#unlink should only accept valid paths.', () => {
+
+    const fileSystem = FileSystemFactory();
+
+    const badFileName = '/../../../../../bad-file-name.jpg';
+
+    return fileSystem.unlink(badFileName)
+      .then(() => {
+        throw new Error('Bad file path was accepted.');
+      })
+      .catch((error) => {
+        let resolvedPath = pathLib.resolve(mockData.basePath + badFileName);
+
+        error.should.deepEqual(new Error(resolvedPath + ' is not a valid file path.'));
+      });
+
+  });
+
+  it('#unlink should work as expected for valid paths.', () => {
+
+    // RNFetchBlob Mocks
+    const RNFetchBlob = require('react-native-fetch-blob');
+
+    // Mock unlink to be true.
+    RNFetchBlob.fs.unlink
+      .mockReturnValueOnce(true);
+
+    const fileSystem = FileSystemFactory();
+
+    const validPath = '/permanent/valid.jpg';
+
+    return fileSystem.unlink(validPath)
+      .then( result => {
+        result.should.be.true();
+      });
+
+  });
+
 });