Socket
Socket
Sign inDemoInstall

zapier-async-storage

Package Overview
Dependencies
Maintainers
1
Versions
12
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

zapier-async-storage - npm Package Compare versions

Comparing version 0.3.5 to 0.3.6

build/drivers/indexeddb.js
build/drivers/memory.js

287

build/createInstance.js

@@ -15,6 +15,2 @@ 'use strict';

var _validateKey = require('./utils/validateKey');
var _validateKey2 = _interopRequireDefault(_validateKey);
var _getIndexedDB = require('./utils/getIndexedDB');

@@ -24,8 +20,12 @@

var _destroyDatabase = require('./utils/destroyDatabase');
var _constants = require('./constants');
var _destroyDatabase2 = _interopRequireDefault(_destroyDatabase);
var _indexeddb = require('./drivers/indexeddb');
var _constants = require('./constants');
var _indexeddb2 = _interopRequireDefault(_indexeddb);
var _memory = require('./drivers/memory');
var _memory2 = _interopRequireDefault(_memory);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

@@ -44,2 +44,4 @@

var memoryStorage = {};
if (!indexedDB) {

@@ -57,258 +59,85 @@ throw new Error('No indexedDB implementation found!');

var databaseReadyPromise = (0, _initStorage2.default)({ dbName: dbName, storeName: storeName, version: version, options: options });
var databaseReadyPromise = (0, _initStorage2.default)({ dbName: dbName, storeName: storeName, version: version, options: options }).then(function (dbInstance) {
return (0, _indexeddb2.default)(dbInstance);
}).catch(function (error) {
// `InvalidStateError` occurs in Firefox private mode. When this happens
// we need to use an in-memory storage solution instead of relying of
// IndexedDB.
if (error.name && error.name === 'InvalidStateError') {
return (0, _memory2.default)(memoryStorage);
}
// Retrieve an item from the desired object store under the provided key
function getItem(name, key) {
key = (0, _validateKey2.default)(key);
throw new Error(error);
});
var getItem = function getItem(key) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_ONLY);
var objectStore = transaction.objectStore(name);
var req = objectStore.get(key);
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(transaction);
};
req.onerror = function () {
return reject(transaction);
};
});
return dbInstance.getItem(storeName, key);
});
}
};
// Store an item in the provided store name under the provided key
function setItem(name, key, value) {
key = (0, _validateKey2.default)(key);
var setItem = function setItem(key, value) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_WRITE);
var objectStore = transaction.objectStore(name);
// Saving as `null` will result in a subsequent getItem returning `undefined`
// Make it `undefined` immediately so that there is consistency
if (value === null) {
value = undefined;
}
objectStore.put(value, key);
transaction.oncomplete = function () {
return resolve(value, key);
};
transaction.onabort = function () {
return reject(transaction);
};
transaction.onerror = function () {
return reject(transaction);
};
});
return dbInstance.setItem(storeName, key, value);
});
}
};
// Return all the items stored in the provided store name
function getCollection(name) {
var clear = function clear() {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_WRITE);
var objectStore = transaction.objectStore(name);
var req = objectStore.getAll();
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(req);
};
req.onerror = function () {
return reject(req);
};
});
return dbInstance.clear(storeName);
});
}
};
// Remove an item from the provided store name under the provided key
function removeItem(name, key) {
key = (0, _validateKey2.default)(key);
var close = function close() {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_WRITE);
var objectStore = transaction.objectStore(name);
objectStore.delete(key);
transaction.oncomplete = function () {
return resolve();
};
transaction.onabort = function () {
return reject(transaction);
};
transaction.onerror = function () {
return reject(transaction);
};
});
return dbInstance.close(dbName, options);
});
}
};
function clear(name) {
var getCollection = function getCollection() {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
try {
var transaction = dbInstance.transaction(name, 'readwrite');
var objectStore = transaction.objectStore(name);
var req = objectStore.clear();
var onError = function onError() {
var err = req.error ? req.error : req.transaction.error;
reject(err);
};
transaction.oncomplete = function () {
return resolve();
};
transaction.onabort = onError;
transaction.onerror = onError;
} catch (err) {
reject({
storeName: name,
error: err
});
}
});
return dbInstance.getCollection(storeName);
});
}
};
// Get the size of the provided store name
function length(name) {
var removeItem = function removeItem(key) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_ONLY);
var objectStore = transaction.objectStore(name);
var req = objectStore.count();
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(req);
};
req.onerror = function () {
return reject(req);
};
});
return dbInstance.removeItem(storeName, key);
});
}
};
// Return all of the keys in the object store
function keys(name) {
var length = function length() {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_ONLY);
var objectStore = transaction.objectStore(name);
try {
var req = objectStore.openCursor();
var storeKeys = [];
req.onsuccess = function () {
var cursor = req.result;
// If the cursor is empty, send back the keys
if (!cursor) {
resolve(storeKeys);
return;
}
// Otherwise keep going
storeKeys.push(cursor.key);
cursor.continue();
};
req.onerror = function () {
return reject(req.error);
};
} catch (e) {
reject(e);
}
});
return dbInstance.length(storeName);
});
}
};
function iterate(name, callback) {
var keys = function keys() {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, _constants.READ_ONLY);
var objectStore = transaction.objectStore(name);
try {
var req = objectStore.openCursor();
req.onsuccess = function () {
var cursor = req.result;
// If the cursor is empty, send back the keys
if (!cursor) {
resolve();
return;
}
// Otherwise keep going
callback(cursor.value, cursor.key, cursor);
cursor.continue();
};
req.onerror = function () {
return reject(req.error);
};
} catch (e) {
reject(e);
}
});
return dbInstance.keys(storeName);
});
}
};
// Kills the connection to the DB
function close() {
var iterate = function iterate(callback) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve) {
dbInstance.close();
if (options.enableLogging) {
console.info('Closed connection to: ', dbName);
}
resolve();
});
return dbInstance.iterate(storeName, callback);
});
}
};
// Destroys the database instance
function destroy() {
var destroy = function destroy() {
return databaseReadyPromise.then(function (dbInstance) {
dbInstance.close();
return (0, _destroyDatabase2.default)(dbName, options);
return dbInstance.destroy(dbName, options);
});
}
};
return {
isReady: databaseReadyPromise,
getItem: _lodash2.default.partial(getItem, storeName),
setItem: _lodash2.default.partial(setItem, storeName),
getCollection: _lodash2.default.partial(getCollection, storeName),
removeItem: _lodash2.default.partial(removeItem, storeName),
clear: _lodash2.default.partial(clear, storeName),
length: _lodash2.default.partial(length, storeName),
keys: _lodash2.default.partial(keys, storeName),
iterate: _lodash2.default.partial(iterate, storeName),
getItem: getItem,
setItem: setItem,
clear: clear,
close: close,
getCollection: getCollection,
removeItem: removeItem,
length: length,
keys: keys,
iterate: iterate,
destroy: destroy

@@ -315,0 +144,0 @@ };

605

build/index.js

@@ -215,11 +215,2 @@ 'use strict';

function validateKey(key) {
if (!_.isString(key)) {
console.warn('Keys must be strings, converting ' + key + ' to a string.');
return String(key);
}
return key;
}
var destroyDatabase = function destroyDatabase(databaseName) {

@@ -232,315 +223,453 @@ var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

try {
var req = getIndexedDB().deleteDatabase(databaseName);
var req = getIndexedDB().deleteDatabase(databaseName);
req.onsuccess = function () {
if (enableLogging) {
console.info('Successfully removed IndexedDB: ', databaseName);
}
req.onsuccess = function () {
if (enableLogging) {
console.info('Successfully removed IndexedDB: ', databaseName);
}
resolve(true);
};
req.onerror = function (err) {
if (enableLogging) {
console.warn('Unable to delete IndexedDB: ', databaseName);
}
resolve(true);
};
req.onerror = function (evt) {
if (enableLogging) {
console.warn('Unable to delete IndexedDB: ', databaseName);
}
reject(err);
};
req.onblocked = function (err) {
if (enableLogging) {
console.warn('Blocked attempting to delete IndexedDB: ', databaseName);
}
// See https://mzl.la/2wCPech
evt.preventDefault();
reject(err);
};
} catch (err) {
reject(evt.target.error);
};
req.onblocked = function (evt) {
if (enableLogging) {
console.warn('Unable to initialize IndexedDB deletion: ', databaseName);
console.warn('Blocked attempting to delete IndexedDB: ', databaseName);
}
reject(err);
}
reject(evt);
};
});
};
var indexedDB = getIndexedDB();
function createInstance(_ref) {
var storeName = _ref.storeName,
_ref$version = _ref.version,
version = _ref$version === undefined ? DEFAULT_VERSION : _ref$version,
_ref$dbName = _ref.dbName,
dbName = _ref$dbName === undefined ? DEFAULT_DB_NAME : _ref$dbName,
_ref$options = _ref.options,
options = _ref$options === undefined ? {} : _ref$options;
if (!indexedDB) {
throw new Error('No indexedDB implementation found!');
function validateKey(key) {
if (!_.isString(key)) {
console.warn('Keys must be strings, converting ' + key + ' to a string.');
return String(key);
}
if (!storeName) {
throw new Error('No store name provided for Indexed DB instance.');
}
return key;
}
if (!dbName) {
throw new Error('No database name provided for Indexed DB instance.');
}
var databaseReadyPromise = initStorage({ dbName: dbName, storeName: storeName, version: version, options: options });
var createIndexedDBDriver = function createIndexedDBDriver(dbInstance) {
// Retrieve an item from the desired object store under the provided key
function getItem(name, key) {
var getItem = function getItem(name, key) {
key = validateKey(key);
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
var req = objectStore.get(key);
var req = objectStore.get(key);
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(transaction);
};
req.onerror = function () {
return reject(transaction);
};
});
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(transaction);
};
req.onerror = function () {
return reject(transaction);
};
});
}
};
// Store an item in the provided store name under the provided key
function setItem(name, key, value) {
var setItem = function setItem(name, key, value) {
key = validateKey(key);
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_WRITE);
var objectStore = transaction.objectStore(name);
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_WRITE);
var objectStore = transaction.objectStore(name);
// Saving as `null` will result in a subsequent getItem returning `undefined`
// Make it `undefined` immediately so that there is consistency
if (value === null) {
value = undefined;
}
// Saving as `null` will result in a subsequent getItem returning `undefined`
// Make it `undefined` immediately so that there is consistency
if (value === null) {
value = undefined;
}
objectStore.put(value, key);
objectStore.put(value, key);
transaction.oncomplete = function () {
return resolve(value, key);
};
transaction.onabort = function () {
return reject(transaction);
};
transaction.onerror = function () {
return reject(transaction);
};
});
transaction.oncomplete = function () {
return resolve(value, key);
};
transaction.onabort = function () {
return reject(transaction);
};
transaction.onerror = function () {
return reject(transaction);
};
});
}
};
// Return all the items stored in the provided store name
function getCollection(name) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_WRITE);
var objectStore = transaction.objectStore(name);
var getCollection = function getCollection(name) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_WRITE);
var objectStore = transaction.objectStore(name);
var req = objectStore.getAll();
var req = objectStore.getAll();
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(req);
};
req.onerror = function () {
return reject(req);
};
});
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(req);
};
req.onerror = function () {
return reject(req);
};
});
}
};
// Remove an item from the provided store name under the provided key
function removeItem(name, key) {
var removeItem = function removeItem(name, key) {
key = validateKey(key);
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_WRITE);
var objectStore = transaction.objectStore(name);
objectStore.delete(key);
transaction.oncomplete = function () {
return resolve();
};
transaction.onabort = function () {
return reject(transaction);
};
transaction.onerror = function () {
return reject(transaction);
};
});
};
var clear = function clear(name) {
return new Promise(function (resolve, reject) {
try {
var transaction = dbInstance.transaction(name, READ_WRITE);
var objectStore = transaction.objectStore(name);
objectStore.delete(key);
var req = objectStore.clear();
var onError = function onError() {
var err = req.error ? req.error : req.transaction.error;
reject(err);
};
transaction.oncomplete = function () {
return resolve();
};
transaction.onabort = function () {
return reject(transaction);
};
transaction.onerror = function () {
return reject(transaction);
};
});
transaction.onabort = onError;
transaction.onerror = onError;
} catch (err) {
reject({
storeName: name,
error: err
});
}
});
}
};
function clear(name) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
try {
var transaction = dbInstance.transaction(name, 'readwrite');
var objectStore = transaction.objectStore(name);
// Get the size of the provided store name
var length = function length(name) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
var req = objectStore.clear();
var req = objectStore.count();
var onError = function onError() {
var err = req.error ? req.error : req.transaction.error;
reject(err);
};
req.onsuccess = function () {
return resolve(req.result);
};
req.onabort = function () {
return reject(req);
};
req.onerror = function () {
return reject(req);
};
});
};
transaction.oncomplete = function () {
return resolve();
};
transaction.onabort = onError;
transaction.onerror = onError;
} catch (err) {
reject({
storeName: name,
error: err
});
}
});
// Return all of the keys in the object store
var keys = function keys(name) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
try {
var req = objectStore.openCursor();
var storeKeys = [];
req.onsuccess = function () {
var cursor = req.result;
// If the cursor is empty, send back the keys
if (!cursor) {
resolve(storeKeys);
return;
}
// Otherwise keep going
storeKeys.push(cursor.key);
cursor.continue();
};
req.onerror = function () {
return reject(req.error);
};
} catch (e) {
reject(e);
}
});
}
};
// Get the size of the provided store name
function length(name) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
var iterate = function iterate(name, callback) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
var req = objectStore.count();
try {
var req = objectStore.openCursor();
req.onsuccess = function () {
return resolve(req.result);
var cursor = req.result;
// If the cursor is empty, send back the keys
if (!cursor) {
resolve();
return;
}
// Otherwise keep going
callback(cursor.value, cursor.key, cursor);
cursor.continue();
};
req.onabort = function () {
return reject(req);
};
req.onerror = function () {
return reject(req);
return reject(req.error);
};
});
} catch (e) {
reject(e);
}
});
}
};
// Return all of the keys in the object store
function keys(name) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
// Kills the connection to the DB
var close = function close(dbName, options) {
return new Promise(function (resolve) {
dbInstance.close();
try {
var req = objectStore.openCursor();
var storeKeys = [];
if (options.enableLogging) {
console.info('Closed connection to: ', dbName);
}
req.onsuccess = function () {
var cursor = req.result;
resolve();
});
};
// If the cursor is empty, send back the keys
if (!cursor) {
resolve(storeKeys);
return;
}
// Destroys the database instance
var destroy = function destroy(dbName, options) {
dbInstance.close();
// Otherwise keep going
storeKeys.push(cursor.key);
cursor.continue();
};
return destroyDatabase(dbName, options);
};
req.onerror = function () {
return reject(req.error);
};
} catch (e) {
reject(e);
}
});
return {
getItem: getItem,
setItem: setItem,
getCollection: getCollection,
removeItem: removeItem,
clear: clear,
length: length,
keys: keys,
iterate: iterate,
close: close,
destroy: destroy
};
};
var createMemoryDriver = function createMemoryDriver(storage) {
var getItem = function getItem(storeName, key) {
var value = _.get(storage, [storeName, key]);
return Promise.resolve(value);
};
var setItem = function setItem(storeName, key, value) {
_.set(storage, [storeName, key], value);
return Promise.resolve(value);
};
var clear = function clear(storeName) {
storage[storeName] = {};
};
var close = function close() {
return Promise.resolve();
};
var getCollection = function getCollection(storeName) {
var store = _.get(storage, [storeName], {});
return _.values(store);
};
var removeItem = function removeItem(storeName, key) {
delete storage[storeName][key];
};
var length = function length(storeName) {
return _.size(storage[storeName]);
};
var keys = function keys(storeName) {
return _.keys(storage[storeName]);
};
var iterate = function iterate(storeName, callback) {
return _.map(storage[storeName], function (value, key) {
return callback(key, value);
});
};
var destroy = function destroy() {
storage = {};
return true;
};
return {
getItem: getItem,
setItem: setItem,
clear: clear,
close: close,
getCollection: getCollection,
removeItem: removeItem,
length: length,
keys: keys,
iterate: iterate,
destroy: destroy
};
};
var indexedDB = getIndexedDB();
function createInstance(_ref) {
var storeName = _ref.storeName,
_ref$version = _ref.version,
version = _ref$version === undefined ? DEFAULT_VERSION : _ref$version,
_ref$dbName = _ref.dbName,
dbName = _ref$dbName === undefined ? DEFAULT_DB_NAME : _ref$dbName,
_ref$options = _ref.options,
options = _ref$options === undefined ? {} : _ref$options;
var memoryStorage = {};
if (!indexedDB) {
throw new Error('No indexedDB implementation found!');
}
function iterate(name, callback) {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve, reject) {
var transaction = dbInstance.transaction(name, READ_ONLY);
var objectStore = transaction.objectStore(name);
if (!storeName) {
throw new Error('No store name provided for Indexed DB instance.');
}
try {
var req = objectStore.openCursor();
if (!dbName) {
throw new Error('No database name provided for Indexed DB instance.');
}
req.onsuccess = function () {
var cursor = req.result;
var databaseReadyPromise = initStorage({ dbName: dbName, storeName: storeName, version: version, options: options }).then(function (dbInstance) {
return createIndexedDBDriver(dbInstance);
}).catch(function (error) {
// `InvalidStateError` occurs in Firefox private mode. When this happens
// we need to use an in-memory storage solution instead of relying of
// IndexedDB.
if (error.name && error.name === 'InvalidStateError') {
return createMemoryDriver(memoryStorage);
}
// If the cursor is empty, send back the keys
if (!cursor) {
resolve();
return;
}
throw new Error(error);
});
// Otherwise keep going
callback(cursor.value, cursor.key, cursor);
cursor.continue();
};
var getItem = function getItem(key) {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.getItem(storeName, key);
});
};
req.onerror = function () {
return reject(req.error);
};
} catch (e) {
reject(e);
}
});
var setItem = function setItem(key, value) {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.setItem(storeName, key, value);
});
}
};
// Kills the connection to the DB
function close() {
var clear = function clear() {
return databaseReadyPromise.then(function (dbInstance) {
return new Promise(function (resolve) {
dbInstance.close();
return dbInstance.clear(storeName);
});
};
if (options.enableLogging) {
console.info('Closed connection to: ', dbName);
}
var close = function close() {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.close(dbName, options);
});
};
resolve();
});
var getCollection = function getCollection() {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.getCollection(storeName);
});
}
};
// Destroys the database instance
function destroy() {
var removeItem = function removeItem(key) {
return databaseReadyPromise.then(function (dbInstance) {
dbInstance.close();
return dbInstance.removeItem(storeName, key);
});
};
return destroyDatabase(dbName, options);
var length = function length() {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.length(storeName);
});
}
};
var keys = function keys() {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.keys(storeName);
});
};
var iterate = function iterate(callback) {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.iterate(storeName, callback);
});
};
var destroy = function destroy() {
return databaseReadyPromise.then(function (dbInstance) {
return dbInstance.destroy(dbName, options);
});
};
return {
isReady: databaseReadyPromise,
getItem: _.partial(getItem, storeName),
setItem: _.partial(setItem, storeName),
getCollection: _.partial(getCollection, storeName),
removeItem: _.partial(removeItem, storeName),
clear: _.partial(clear, storeName),
length: _.partial(length, storeName),
keys: _.partial(keys, storeName),
iterate: _.partial(iterate, storeName),
getItem: getItem,
setItem: setItem,
clear: clear,
close: close,
getCollection: getCollection,
removeItem: removeItem,
length: length,
keys: keys,
iterate: iterate,
destroy: destroy

@@ -547,0 +676,0 @@ };

43

build/utils/destroyDatabase.js

@@ -20,33 +20,28 @@ 'use strict';

try {
var req = (0, _getIndexedDB2.default)().deleteDatabase(databaseName);
var req = (0, _getIndexedDB2.default)().deleteDatabase(databaseName);
req.onsuccess = function () {
if (enableLogging) {
console.info('Successfully removed IndexedDB: ', databaseName);
}
req.onsuccess = function () {
if (enableLogging) {
console.info('Successfully removed IndexedDB: ', databaseName);
}
resolve(true);
};
req.onerror = function (err) {
if (enableLogging) {
console.warn('Unable to delete IndexedDB: ', databaseName);
}
resolve(true);
};
req.onerror = function (evt) {
if (enableLogging) {
console.warn('Unable to delete IndexedDB: ', databaseName);
}
reject(err);
};
req.onblocked = function (err) {
if (enableLogging) {
console.warn('Blocked attempting to delete IndexedDB: ', databaseName);
}
// See https://mzl.la/2wCPech
evt.preventDefault();
reject(err);
};
} catch (err) {
reject(evt.target.error);
};
req.onblocked = function (evt) {
if (enableLogging) {
console.warn('Unable to initialize IndexedDB deletion: ', databaseName);
console.warn('Blocked attempting to delete IndexedDB: ', databaseName);
}
reject(err);
}
reject(evt);
};
});

@@ -53,0 +48,0 @@ };

2

package.json
{
"name": "zapier-async-storage",
"version": "0.3.5",
"version": "0.3.6",
"description": "Minimalist wrapper for IndexedDB",

@@ -5,0 +5,0 @@ "main": "build/index.js",

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc