Merge pull request #5 from emeraldsanto/dev

Version 2.0.0

.gitignore

@@ -41,3 +41,6 @@ buck-out/
 \.buckd/
 *.keystore
 .vscode/settings.json
+
+# JEST
+coverage/

README.md

@@ -51,18 +51,16 @@ import EncryptedStorage from 'react-native-encrypted-storage';
 
 ```js
 const storeUserSession = async () => {
- const success = await EncryptedStorage.store('user_session', {
- username : 'emeraldsanto',
- age : 21,
- languages : ['fr', 'en', 'de'],
- token : 'ACCESS_TOKEN'
- });
-
- if (success === true) {
+ try {
+ await EncryptedStorage.setItem('user_session', {
+  username : 'emeraldsanto',
+  age : 21,
+  languages : ['fr', 'en', 'de'],
+  token : 'ACCESS_TOKEN'
+  });
+
  // Congrats! You've just stored your first value!
- } 
-
- else {
+ } catch (error) {
  // There was an error on the native side
  }
 }
@@ -72,10 +70,14 @@ const storeUserSession = async () => {
 
 ```js
 const retrieveUserSession = async () => {
- const session = await EncryptedStorage.retrieve("user_session");
+ try { 
+ const session = await EncryptedStorage.getItem("user_session");
 
- if (session !== undefined) {
- // Congrats! You've just retrieved your first value!
+ if (session !== null) {
+ // Congrats! You've just retrieved your first value!
+ }
+ } catch (error) {
+ // There was an error on the native side
  }
 }
 ```
@@ -84,12 +86,11 @@ const retrieveUserSession = async () => {
 
 ```js
 const removeUserSession = async () => {
- const success = await EncryptedStorage.remove('user_session');
-
- if (success === true) {
+ try {
+ await EncryptedStorage.removeItem('user_session');
  // Congrats! You've just removed your first value!
-  const previousValue = await EncryptedStorage.retrieve('user_session');
- console.log(previousValue); // undefined
+ } catch (error) {
+ // There was an error on the native side
  }
 }
 ```

android/build.gradle

@@ -14,7 +14,7 @@ import groovy.json.JsonSlurper
 
 def DEFAULT_COMPILE_SDK_VERSION = 28
 def DEFAULT_BUILD_TOOLS_VERSION = '28.0.3'
-def DEFAULT_MIN_SDK_VERSION = 16
+def DEFAULT_MIN_SDK_VERSION = 23
 def DEFAULT_TARGET_SDK_VERSION = 28
 
 def safeExtGet(prop, fallback) {
@@ -86,6 +86,7 @@ dependencies {
  //noinspection GradleDynamicVersion
  implementation 'com.facebook.react:react-native:+'
  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version" // From node_modules
+ implementation "androidx.security:security-crypto:1.0.0-alpha02"
 }
 
 def configureReactNativePom(def pom) {

android/src/main/java/com/emeraldsanto/encryptedstorage/RNEncryptedStorageModule.kt

@@ -1,8 +1,9 @@
 package com.emeraldsanto.encryptedstorage
 
-import android.content.Context
 import android.content.SharedPreferences
 import android.content.res.Resources
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKeys
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
@@ -18,15 +19,21 @@ class RNEncryptedStorageModule(context : ReactApplicationContext) : ReactContext
  private val sharedPreferences : SharedPreferences;
 
  init {
- this.sharedPreferences = context.getSharedPreferences(RNEncryptedStorageModule.SHARED_PREFERENCES_FILENAME, Context.MODE_PRIVATE)
+ this.sharedPreferences = EncryptedSharedPreferences.create(
+ RNEncryptedStorageModule.SHARED_PREFERENCES_FILENAME,
+ MasterKeys.getOrCreate(MasterKeys.AES256_GCM_SPEC),
+ context,
+ EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+ EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+ );
  }
 
  override fun getName(): String {
  return RNEncryptedStorageModule.NATIVE_MODULE_NAME
  }
 
  @ReactMethod
- fun store(key : String, value : String, promise : Promise) {
+ fun setItem(key : String, value : String, promise : Promise) {
  val editor = this.sharedPreferences.edit();
  editor.putString(key, value);
  val saved = editor.commit();
@@ -41,7 +48,7 @@ class RNEncryptedStorageModule(context : ReactApplicationContext) : ReactContext
  }
 
  @ReactMethod
- fun retrieve(key : String, promise : Promise) {
+ fun getItem(key : String, promise : Promise) {
  val value = this.sharedPreferences.getString(key, "");
 
  if (value.isNullOrEmpty()) {
@@ -54,7 +61,7 @@ class RNEncryptedStorageModule(context : ReactApplicationContext) : ReactContext
  }
 
  @ReactMethod
- fun remove(key : String, promise : Promise) {
+ fun removeItem(key : String, promise : Promise) {
  val editor = this.sharedPreferences.edit();
  editor.remove(key);
  val saved = editor.commit();

ios/RNEncryptedStorage.m

@@ -12,20 +12,20 @@
 @interface RCT_EXTERN_MODULE(RNEncryptedStorage, NSObject)
 
 RCT_EXTERN_METHOD(
- store: (NSString *)key
+ setItem: (NSString *)key
  value: (NSString *)value
  resolver: (RCTPromiseResolveBlock)resolve
  rejecter: (RCTPromiseRejectBlock)reject
 );
 
 RCT_EXTERN_METHOD(
- retrieve: (NSString *)key
+ getItem: (NSString *)key
  resolver: (RCTPromiseResolveBlock)resolve
  rejecter: (RCTPromiseRejectBlock)reject
 );
 
 RCT_EXTERN_METHOD(
- remove: (NSString *)key
+ removeItem: (NSString *)key
  resolver: (RCTPromiseResolveBlock)resolve
  rejecter: (RCTPromiseRejectBlock)reject
 );

ios/RNEncryptedStorage.swift

@@ -17,7 +17,7 @@ class RNEncryptedStorage: NSObject {
  return false;
  }
 
- @objc func store(_ key : String, value : String, resolver resolve : RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) -> Void {
+ @objc func setItem(_ key : String, value : String, resolver resolve : RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) -> Void {
  guard let dataFromValue = value.data(using: .utf8, allowLossyConversion: false) else {
  return reject("Error parsing value for key \(key)", nil, nil);
  }
@@ -44,7 +44,7 @@ class RNEncryptedStorage: NSObject {
  }
 
  @objc
- func retrieve(_ key : String, resolver resolve : RCTPromiseResolveBlock, rejecter reject : RCTPromiseRejectBlock) {
+ func getItem(_ key : String, resolver resolve : RCTPromiseResolveBlock, rejecter reject : RCTPromiseRejectBlock) {
  let retrieveQuery : [String : Any] = [
  kSecClass as String : kSecClassGenericPassword,
  kSecAttrAccount as String : key,
@@ -67,7 +67,7 @@ class RNEncryptedStorage: NSObject {
  }
 
  @objc
- func remove(_ key : String, resolver resolve : RCTPromiseResolveBlock, rejecter reject : RCTPromiseRejectBlock) {
+ func removeItem(_ key : String, resolver resolve : RCTPromiseResolveBlock, rejecter reject : RCTPromiseRejectBlock) {
  let removeQuery : [String : Any] = [
  kSecClass as String : kSecClassGenericPassword,
  kSecAttrAccount as String : key,

lib/EncryptedStorage.js

@@ -11,40 +11,51 @@ const EncryptedStorage = {
  * @param {string} key - A string that will be associated to the value for later retrieval.
  * @param {Object} value - The data to store.
  */
- store : async function(key, value) {
- try {
- await RNEncryptedStorage.store(key, JSON.stringify(value));
- return true;
- } catch (error) {
- return false;
- }
+ setItem: async function (key, value, cb) {
+ return new Promise(async (resolve, reject) => {
+ try {
+ await RNEncryptedStorage.setItem(key, value);
+ cb && cb(null);
+ resolve(null);
+ } catch (error) {
+ cb && cb(error);
+ reject(error);
+ }
+ });
  },
 
  /**
  * Retrieves data from the disk, using SharedPreferences or KeyChain, depending on the platform and returns it as the specified type.
  * @param {string} key - A string that is associated to a value.
  */
- retrieve : async function(key) {
- try {
- const savedValue = await RNEncryptedStorage.retrieve(key);
- return JSON.parse(savedValue);
- } catch (error) {
- return undefined;
- }
+ getItem: async function (key, cb) {
+ return new Promise(async (resolve, reject) => {
+ try {
+ const value = await RNEncryptedStorage.getItem(key);
+ cb && cb(null, value);
+ resolve(value);
+ } catch (error) {
+ cb && cb(error, null);
+ reject(error);
+ }
+ });
  },
 
  /**
  * Deletes data from the disk, using SharedPreferences or KeyChain, depending on the platform.
  * @param {string} key - A string that is associated to a value.
  */
- remove : async function(key) {
- try {
- await RNEncryptedStorage.remove(key);
- return true;
- } catch (error) {
- return false;
- }
+ removeItem: async function (key, cb) {
+ return new Promise(async (resolve, reject) => {
+ try {
+ await RNEncryptedStorage.removeItem(key);
+ cb && cb(null);
+ resolve(null);
+ } catch (error) {
+ reject(error);
+ }
+ }); 
  }
 }
 
-export default EncryptedStorage;
+module.exports = EncryptedStorage;

lib/EncryptedStorage.test.js

@@ -0,0 +1,130 @@
+const EncryptedStorage = require('./EncryptedStorage');
+const { NativeModules } = require('react-native');
+const { RNEncryptedStorage } = NativeModules;
+
+describe('lib/EncryptedStorage', () => {
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ describe('using Promises', () => {
+ describe('setItem(key, value)', () => {
+ it('should return no errors if it could store the value', async () => {
+ const storeError = await EncryptedStorage.setItem('key', 'value');
+ expect(storeError).toBe(null);
+ });
+
+ it('should reject with an error if it could not store the value', async () => {
+ RNEncryptedStorage.setItem.mockImplementationOnce(() => Promise.reject(new Error('Set error')));
+
+ try {
+ await EncryptedStorage.setItem('key', 'value');
+ } catch (error) {
+ expect(error.message).toBe('Set error');
+ }
+ });
+ });
+
+ describe('getItem(key)', () => {
+ it('should return the value if it could be retrieved succesfully', async () => {
+ const item = await EncryptedStorage.getItem('key');
+ expect(item).toEqual('{ "foo": 1 }');
+ });
+
+ it('should return null if no value was found for that key', async () => {
+ RNEncryptedStorage.getItem.mockImplementationOnce(() => Promise.resolve(undefined));
+
+ const item = await EncryptedStorage.getItem('key');
+ expect(item).toEqual(undefined);
+ });
+
+ it('should reject with an error if it could not retrieve the value', async () => {
+ RNEncryptedStorage.getItem.mockImplementationOnce(() => Promise.reject(new Error("Get error")));
+
+ try {
+ await EncryptedStorage.getItem('key');
+ } catch (error) {
+ expect(error.message).toBe('Get error');
+ }
+ });
+ }); 
+
+ describe('removeItem(key)', () => {
+ it('should return no error if it could removed the stored value', async () => {
+ const removeResult = await EncryptedStorage.removeItem('key');
+ expect(removeResult).toBe(null);
+ });
+
+ it('should throw an error if it could not retrieve the stored value', async () => {
+ RNEncryptedStorage.removeItem.mockImplementationOnce(() => Promise.reject(new Error("Remove error")));
+
+ try {
+ await EncryptedStorage.removeItem('key');
+ } catch (error) {
+ expect(error.message).toBe('Remove error');
+ }
+ });
+ });
+ });
+
+ describe('using callbacks', () => {
+ describe('setItem(key, value)', () => {
+ it('should return no errors if it could store the value', () => {
+ EncryptedStorage.setItem('key', 'value', err => {
+ expect(err).toBe(null);
+ });
+ });
+
+ it('should reject with an error if it could not store the value', () => {
+ RNEncryptedStorage.setItem.mockImplementationOnce(() => Promise.reject(new Error('Set error')));
+
+ EncryptedStorage.setItem('key', 'value', err => {
+ expect(err.message).toBe('Set error');
+ });
+ });
+ });
+
+ describe('getItem(key)', () => {
+ it('should return the value if it could be retrieved succesfully', () => {
+ EncryptedStorage.getItem('key', (err, value) => {
+ expect(err).toBe(null);
+ expect(value).toEqual('{ "foo": 1 }');
+ });
+ });
+
+ it('should return null if no value was found for that key', () => {
+ RNEncryptedStorage.getItem.mockImplementationOnce(() => Promise.resolve(undefined));
+
+ EncryptedStorage.getItem('key', (err, value) => {
+ expect(err).toBe(null);
+ expect(value).toBe(undefined);
+ });
+ });
+
+ it('should reject with an error if it could not retrieve the value', () => {
+ RNEncryptedStorage.getItem.mockImplementationOnce(() => Promise.reject(new Error("Get error")));
+
+ EncryptedStorage.getItem('key', (err, value) => {
+ expect(err.message).toEqual('Get error');
+ expect(value).toBe(undefined);
+ });
+ });
+ }); 
+
+ describe('removeItem(key)', () => {
+ it('should return no error if it could removed the stored value', () => {
+ EncryptedStorage.removeItem('key', err => {
+ expect(err).toBe(null);
+ });
+ });
+
+ it('should throw an error if it could not retrieve the stored value', () => {
+ RNEncryptedStorage.removeItem.mockImplementationOnce(() => Promise.reject(new Error("Remove error")));
+
+ EncryptedStorage.removeItem('key', err => {
+ expect(err.message).toBe('Remove error');
+ });
+ });
+ });
+ });
+});