react-native-onyx
Version:
State management for React Native
195 lines (194 loc) • 7.44 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const Logger = __importStar(require("../Logger"));
const platforms_1 = __importDefault(require("./platforms"));
const InstanceSync_1 = __importDefault(require("./InstanceSync"));
const MemoryOnlyProvider_1 = __importDefault(require("./providers/MemoryOnlyProvider"));
let provider = platforms_1.default;
let shouldKeepInstancesSync = false;
let finishInitalization;
const initPromise = new Promise((resolve) => {
finishInitalization = resolve;
});
/**
* Degrade performance by removing the storage provider and only using cache
*/
function degradePerformance(error) {
Logger.logHmmm(`Error while using ${provider.name}. Falling back to only using cache and dropping storage.\n Error: ${error.message}\n Stack: ${error.stack}\n Cause: ${error.cause}`);
console.error(error);
provider = MemoryOnlyProvider_1.default;
}
/**
* Runs a piece of code and degrades performance if certain errors are thrown
*/
function tryOrDegradePerformance(fn, waitForInitialization = true) {
const initialization = waitForInitialization ? initPromise : Promise.resolve();
return initialization
.then(() => fn())
.catch((error) => {
// catch the error if DB connection can not be established/DB can not be created
if (error instanceof Error && error.message.includes('IDBKeyVal store could not be created')) {
degradePerformance(error);
}
return Promise.reject(error);
});
}
const storage = {
/**
* Returns the storage provider currently in use
*/
getStorageProvider() {
return provider;
},
/**
* Classifies a write error using the active provider's own classifier. Synchronous and pure —
* never wrapped in tryOrDegradePerformance.
*/
classifyError: (error) => provider.classifyError(error),
/**
* Initializes all providers in the list of storage providers
* and enables fallback providers if necessary
*/
init() {
tryOrDegradePerformance(provider.init, false).finally(() => {
finishInitalization();
});
},
/**
* Get the value of a given key or return `null` if it's not available
*/
getItem: (key) => tryOrDegradePerformance(() => provider.getItem(key)),
/**
* Get multiple key-value pairs for the give array of keys in a batch
*/
multiGet: (keys) => tryOrDegradePerformance(() => provider.multiGet(keys)),
/**
* Sets the value for a given key. The only requirement is that the value should be serializable to JSON string
*/
setItem: (key, value) => tryOrDegradePerformance(() => {
const promise = provider.setItem(key, value);
if (shouldKeepInstancesSync) {
return promise.then(() => InstanceSync_1.default.setItem(key));
}
return promise;
}),
/**
* Stores multiple key-value pairs in a batch
*/
multiSet: (pairs) => tryOrDegradePerformance(() => {
const promise = provider.multiSet(pairs);
if (shouldKeepInstancesSync) {
return promise.then(() => InstanceSync_1.default.multiSet(pairs.map((pair) => pair[0])));
}
return promise;
}),
/**
* Merging an existing value with a new one
*/
mergeItem: (key, change, replaceNullPatches) => tryOrDegradePerformance(() => {
const promise = provider.mergeItem(key, change, replaceNullPatches);
if (shouldKeepInstancesSync) {
return promise.then(() => InstanceSync_1.default.mergeItem(key));
}
return promise;
}),
/**
* Multiple merging of existing and new values in a batch
* This function also removes all nested null values from an object.
*/
multiMerge: (pairs) => tryOrDegradePerformance(() => {
const promise = provider.multiMerge(pairs);
if (shouldKeepInstancesSync) {
return promise.then(() => InstanceSync_1.default.multiMerge(pairs.map((pair) => pair[0])));
}
return promise;
}),
/**
* Removes given key and its value
*/
removeItem: (key) => tryOrDegradePerformance(() => {
const promise = provider.removeItem(key);
if (shouldKeepInstancesSync) {
return promise.then(() => InstanceSync_1.default.removeItem(key));
}
return promise;
}),
/**
* Remove given keys and their values
*/
removeItems: (keys) => tryOrDegradePerformance(() => {
const promise = provider.removeItems(keys);
if (shouldKeepInstancesSync) {
return promise.then(() => InstanceSync_1.default.removeItems(keys));
}
return promise;
}),
/**
* Clears everything
*/
clear: () => tryOrDegradePerformance(() => {
if (shouldKeepInstancesSync) {
return InstanceSync_1.default.clear(() => provider.clear());
}
return provider.clear();
}),
/**
* Returns all available keys
*/
getAllKeys: () => tryOrDegradePerformance(() => provider.getAllKeys()),
/**
* Returns all key-value pairs from storage in a single batch operation
*/
getAll: () => tryOrDegradePerformance(() => provider.getAll()),
/**
* Gets the total bytes of the store
*/
getDatabaseSize: () => tryOrDegradePerformance(() => provider.getDatabaseSize()),
/**
* @param onStorageKeyChanged - Storage synchronization mechanism keeping all opened tabs in sync (web only)
*/
keepInstancesSync(onStorageKeyChanged) {
// If InstanceSync shouldn't be used, it means we're on a native platform and we don't need to keep instances in sync
if (!InstanceSync_1.default.shouldBeUsed)
return;
shouldKeepInstancesSync = true;
InstanceSync_1.default.init(onStorageKeyChanged, this);
},
};
exports.default = storage;