"use strict";
// Import external names locally
var Shared = require('./Shared'),
async = require('async'),
localforage = require('localforage'),
FdbCompress = require('./PersistCompress'),// jshint ignore:line
FdbCrypto = require('./PersistCrypto'),// jshint ignore:line
Db,
Collection,
CollectionDrop,
CollectionGroup,
CollectionInit,
DbInit,
DbDrop,
Persist,
Overload;//,
//DataVersion = '2.0';
/**
* The persistent storage class handles loading and saving data to browser
* storage.
* @class
* @constructor
*/
Persist = function () {
this.init.apply(this, arguments);
};
/**
* The local forage library.
*/
Persist.prototype.localforage = localforage;
/**
* The init method that can be overridden or extended.
* @param {Db} db The ForerunnerDB database instance.
*/
Persist.prototype.init = function (db) {
var self = this;
this._encodeSteps = [
function () { return self._encode.apply(self, arguments); }
];
this._decodeSteps = [
function () { return self._decode.apply(self, arguments); }
];
// Check environment
if (db.isClient()) {
this.mode('localforage');
localforage.config({
name: String(db.core().name()),
storeName: 'FDB'
});
}
};
Shared.addModule('Persist', Persist);
Shared.mixin(Persist.prototype, 'Mixin.ChainReactor');
Shared.mixin(Persist.prototype, 'Mixin.Common');
Db = Shared.modules.Db;
Collection = require('./Collection');
CollectionDrop = Collection.prototype.drop;
CollectionGroup = require('./CollectionGroup');
CollectionInit = Collection.prototype.init;
DbInit = Db.prototype.init;
DbDrop = Db.prototype.drop;
Overload = Shared.overload;
/**
* Gets / sets the auto flag which determines if the persistence module
* will automatically load data for collections the first time they are
* accessed and save data whenever it changes. This is disabled by
* default.
* @param {Boolean} val Set to true to enable, false to disable
* @returns {*}
*/
Shared.synthesize(Persist.prototype, 'auto', function (val) {
var self = this;
if (val !== undefined) {
if (val) {
// Hook db events
this._db.on('create', function () { self._autoLoad.apply(self, arguments); });
this._db.on('change', function () { self._autoSave.apply(self, arguments); });
if (this._db.debug()) {
console.log(this._db.logIdentifier() + ' Automatic load/save enabled');
}
} else {
// Un-hook db events
this._db.off('create', this._autoLoad);
this._db.off('change', this._autoSave);
if (this._db.debug()) {
console.log(this._db.logIdentifier() + ' Automatic load/save disabled');
}
}
}
return this.$super.call(this, val);
});
Persist.prototype._autoLoad = function (obj, objType, name) {
var self = this;
if (typeof obj.load === 'function') {
if (self._db.debug()) {
console.log(self._db.logIdentifier() + ' Auto-loading data for ' + objType + ':', name);
}
obj.load(function (err, data) {
if (err && self._db.debug()) {
console.log(self._db.logIdentifier() + ' Automatic load failed:', err);
}
self.emit('load', err, data);
});
} else {
if (self._db.debug()) {
console.log(self._db.logIdentifier() + ' Auto-load for ' + objType + ':', name, 'no load method, skipping');
}
}
};
Persist.prototype._autoSave = function (obj, objType, name) {
var self = this;
if (typeof obj.save === 'function') {
if (self._db.debug()) {
console.log(self._db.logIdentifier() + ' Auto-saving data for ' + objType + ':', name);
}
obj.save(function (err, data) {
if (err && self._db.debug()) {
console.log(self._db.logIdentifier() + ' Automatic save failed:', err);
}
self.emit('save', err, data);
});
}
};
/**
* Gets / sets the persistent storage mode (the library used
* to persist data to the browser - defaults to localForage).
* @param {String} type The library to use for storage. Defaults
* to localForage.
* @returns {*}
*/
Persist.prototype.mode = function (type) {
if (type !== undefined) {
this._mode = type;
return this;
}
return this._mode;
};
/**
* Sets - if Persist is load in "localforage" mode - a custom driver which applies to the rules
* given by localforage, given here: https://localforage.github.io/localForage/#driver-api-definedriver
* @param driver A local forage driver definition
* @param callback A possible callback, which is executed after the customdriver was initialized
*/
Persist.prototype.customdriver = function(driver, callback) {
if (this.mode() !== 'localforage') {
throw 'No interface ready to set custom driver!';
}
var driverName = driver._driver; // copying the drivername to avoid possible variable modification errors
localforage.defineDriver(driver).then(function() {
return localforage.setDriver(driverName);
})
.then(function() {
if (callback) {
callback(null);
}
})
.catch(function(err) {
callback(err);
});
};
/**
* Gets / sets the driver used when persisting data.
* @param {String} val Specify the driver type (LOCALSTORAGE,
* WEBSQL or INDEXEDDB)
* @returns {*}
*/
Persist.prototype.driver = function (val) {
if (val !== undefined) {
switch (val.toUpperCase()) {
case 'LOCALSTORAGE':
localforage.setDriver(localforage.LOCALSTORAGE);
break;
case 'WEBSQL':
localforage.setDriver(localforage.WEBSQL);
break;
case 'INDEXEDDB':
localforage.setDriver(localforage.INDEXEDDB);
break;
default:
throw('ForerunnerDB.Persist: The persistence driver you have specified is not found. Please use either IndexedDB, WebSQL or LocalStorage!');
}
return this;
}
return localforage.driver();
};
/**
* Starts a decode waterfall process.
* @param {*} val The data to be decoded.
* @param {Function} finished The callback to pass final data to.
*/
Persist.prototype.decode = function (val, finished) {
async.waterfall([function (callback) {
if (callback) { callback(false, val, {}); }
}].concat(this._decodeSteps), finished);
};
/**
* Starts an encode waterfall process.
* @param {*} val The data to be encoded.
* @param {Function} finished The callback to pass final data to.
*/
Persist.prototype.encode = function (val, finished) {
async.waterfall([function (callback) {
if (callback) { callback(false, val, {}); }
}].concat(this._encodeSteps), finished);
};
Shared.synthesize(Persist.prototype, 'encodeSteps');
Shared.synthesize(Persist.prototype, 'decodeSteps');
Persist.prototype.addStep = new Overload({
/**
* Adds an encode/decode step to the persistent storage system so
* that you can add custom functionality.
* @name addStep
* @method Persist.addStep
* @param {Function} obj The object to encode / decode.
*/
'object': function (obj) {
return this.$main.call(this, function objEncode () { obj.encode.apply(obj, arguments); }, function objDecode () { obj.decode.apply(obj, arguments); }, 0);
},
/**
* Adds an encode/decode step to the persistent storage system so
* that you can add custom functionality.
* @name addStep
* @method Persist.addStep
* @param {Function} encode The encode method called with the data from the
* previous encode step. When your method is complete it MUST call the
* callback method. If you provide anything other than false to the err
* parameter the encoder will fail and throw an error.
* @param {Function} decode The decode method called with the data from the
* previous decode step. When your method is complete it MUST call the
* callback method. If you provide anything other than false to the err
* parameter the decoder will fail and throw an error.
*/
'function, function': function (encode, decode) {
return this.$main.call(this, encode, decode, 0);
},
/**
* Adds an encode/decode step to the persistent storage system so
* that you can add custom functionality.
* @name addStep
* @method Persist.addStep
* @param {Function} encode The encode method called with the data from the
* previous encode step. When your method is complete it MUST call the
* callback method. If you provide anything other than false to the err
* parameter the encoder will fail and throw an error.
* @param {Function} decode The decode method called with the data from the
* previous decode step. When your method is complete it MUST call the
* callback method. If you provide anything other than false to the err
* parameter the decoder will fail and throw an error.
* @param {Number=} index Optional index to add the encoder step to. This
* allows you to place a step before or after other existing steps. If not
* provided your step is placed last in the list of steps. For instance if
* you are providing an encryption step it makes sense to place this last
* since all previous steps will then have their data encrypted by your
* final step.
*/
'function, function, number': function (encode, decode, index) {
return this.$main.call(this, encode, decode, index);
},
$main: function (encode, decode, index) {
if (index === 0 || index === undefined) {
this._encodeSteps.push(encode);
this._decodeSteps.unshift(decode);
} else {
// Place encoder step at index then work out correct
// index to place decoder step
this._encodeSteps.splice(index, 0, encode);
this._decodeSteps.splice(this._decodeSteps.length - index, 0, decode);
}
}
});
Persist.prototype.unwrap = function (dataStr) {
var parts = dataStr.split('::fdb::'),
data;
switch (parts[0]) {
case 'json':
data = this.jParse(parts[1]);
break;
case 'raw':
data = parts[1];
break;
default:
break;
}
};
/**
* Takes encoded data and decodes it for use as JS native objects and arrays.
* @param {String} val The currently encoded string data.
* @param {Object} meta Meta data object that can be used to pass back useful
* supplementary data.
* @param {Function} finished The callback method to call when decoding is
* completed.
* @private
*/
Persist.prototype._decode = function (val, meta, finished) {
var parts,
data;
if (val) {
parts = val.split('::fdb::');
switch (parts[0]) {
case 'json':
data = this.jParse(parts[1]);
break;
case 'raw':
data = parts[1];
break;
default:
break;
}
if (data) {
meta.foundData = true;
meta.rowCount = data.length || 0;
} else {
meta.foundData = false;
meta.rowCount = 0;
}
if (finished) {
finished(false, data, meta);
}
} else {
meta.foundData = false;
meta.rowCount = 0;
if (finished) {
finished(false, val, meta);
}
}
};
/**
* Takes native JS data and encodes it for for storage as a string.
* @param {Object} val The current un-encoded data.
* @param {Object} meta Meta data object that can be used to pass back useful
* supplementary data.
* @param {Function} finished The callback method to call when encoding is
* completed.
* @private
*/
Persist.prototype._encode = function (val, meta, finished) {
var data = val;
if (typeof val === 'object') {
val = 'json::fdb::' + this.jStringify(val);
} else {
val = 'raw::fdb::' + val;
}
if (data) {
meta.foundData = true;
meta.rowCount = data.length || 0;
} else {
meta.foundData = false;
meta.rowCount = 0;
}
if (finished) {
finished(false, val, meta);
}
};
/**
* Encodes passed data and then stores it in the browser's persistent
* storage layer.
* @param {String} key The key to store the data under in the persistent
* storage.
* @param {Object} data The data to store under the key.
* @param {Function=} callback The method to call when the save process
* has completed.
*/
Persist.prototype.save = function (key, data, callback) {
switch (this.mode()) {
case 'localforage':
this.encode(data, function (err, data, tableStats) {
if (err) {
return callback(err);
}
localforage.setItem(key, data, function (err) {
if (callback) {
if (err) {
callback(err);
return;
}
callback(false, data, tableStats);
}
});
});
break;
default:
if (callback) { callback('No data handler.'); }
break;
}
};
/**
* Loads and decodes data from the passed key.
* @param {String} key The key to retrieve data from in the persistent
* storage.
* @param {Function=} callback The method to call when the load process
* has completed.
*/
Persist.prototype.load = function (key, callback) {
var self = this;
switch (this.mode()) {
case 'localforage':
localforage.getItem(key, function (err, val) {
if (err) {
if (callback) { callback(err); }
return;
}
self.decode(val, callback);
});
break;
default:
if (callback) { callback('No data handler or unrecognised data type.'); }
break;
}
};
/**
* Deletes data in persistent storage stored under the passed key.
* @param {String} key The key to drop data for in the storage.
* @param {Function=} callback The method to call when the data is dropped.
*/
Persist.prototype.drop = function (key, callback) {
switch (this.mode()) {
case 'localforage':
localforage.removeItem(key, function (err) {
if (callback) { callback(err); }
});
break;
default:
if (callback) { callback('No data handler or unrecognised data type.'); }
break;
}
};
/**
* Determines the byte size of a String, also taking special chars into account.
* Inspired by http://codereview.stackexchange.com/questions/37512/count-byte-length-of-string
* @param {String} string String to get bytes size of
* @return {Number} Size in bytes of the input string
* @private
*/
Persist.prototype._calcSize = function (string) {
var iCount = 0,
stringPrep = String(string || ""),
stringLength = stringPrep.length,
iPartCount,
i;
for (i = 0; i < stringLength; i++) {
iPartCount = encodeURI(stringPrep[i]).split("%").length;
iCount += iPartCount === 1 ? 1 : iPartCount - 1;
}
return iCount;
};
/**
* Argument to the persistedSize callback function
* @typedef {Object} persistedSizeCallbackArg
* @property {number} total The total size of either the collection or the DB in byte
* @property {Array[]} collections per Array item: collection name and size as an Array tupel: collectionName, size
*/
/**
* Callback for persisted size functions
*
* @callback persistedSizeCallback
* @param {persistedSizeCallbackArg}
*/
/**
* determine byte size of a persisted object,
* either entire DB or specific collection
* @param {string|object} target either a string (collection name) or an object (DB)
* @param {persistedSizeCallback} callback method to call when size determination is done - mandatory for obtaining a result!
*/
Persist.prototype.persistedSize = function (target, callback) {
var self = this,
resultMap;
// mapping: {
// total: $totalsize
// collections: [
// [collection, bytesize]
// ....
// ]
// }
resultMap = {
total: 0,
collections: []
};
/**
* named helper function to map-reduce the total byte size of a persisted object
* and to log each collections individual size
* @param {String} value
* @param {String} key
* @private
*/
function _mapSizeCb (value, key) {
// cont only if collection contains content
if (value !== null) {
// Both key and value of the persisted storage obj count toward total size
var atomicTotal = self._calcSize(value) + self._calcSize(key);
// Make an entry: collection (key) is $total bytes
resultMap.collections.push([key, atomicTotal]);
// Count towards total size only if value != null
resultMap.total += atomicTotal;
}
}
switch (this.mode()) {
case 'localforage':
// In general: don't do any decoding (enc, compression),
// b/c only the "raw" size of the storage object is of interest
switch ((typeof target).toLowerCase()) {
case 'string':
// Collection name was provided
// Utilize localforages built-in Promise functionality (includes
// shim for IE) get collection + collection meta data for size
// determination
localforage.getItem(target).then(function (value) {
_mapSizeCb(value, target);
}).then(function () {
return localforage.getItem(target + "-metaData");
}).then(function (value) {
_mapSizeCb(value, target + "-metaData");
}).then(function () {
// done - report back
if (callback) {
callback(null, resultMap);
}
}).catch(function (err) {
console.error(JSON.stringify(err));
if (callback) {
callback(err);
}
});
break;
case 'object':
// DB object was provided
// determine size of DB
// by iterating over all key/value pairs
// filtering for this DB
// we want to measure all persisted collections of a DB
// independent of whether they're attached to the DB
// at runtime via db.collection(name)
localforage.iterate(function (value, key) {
if ((key.lastIndexOf(target.name(), 0) === 0) && value !== null) {
_mapSizeCb(value, key);
}
}).then(function () {
// done - report back
callback(null, resultMap);
}).catch(function (err) {
console.error(JSON.stringify(err));
if (callback) {
callback(err);
}
});
break;
default:
if (callback) {
callback("Couldn't determine target for size calculation - must be either a collection name (string) or a db reference (object)");
}
}
break;
default:
if (callback) {
callback('No data handler or unrecognised data type.');
}
break;
}
};
// Extend the Collection prototype with persist methods
Collection.prototype.drop = new Overload({
/**
* Drop collection and persistent storage.
* @name drop
* @method Collection.drop
*/
'': function () {
if (!this.isDropped()) {
this.drop(true);
}
},
/**
* Drop collection and persistent storage with callback.
* @name drop
* @method Collection.drop
* @param {Function} callback Callback method.
*/
'function': function (callback) {
if (!this.isDropped()) {
this.drop(true, callback);
}
},
/**
* Drop collection and optionally drop persistent storage.
* @name drop
* @method Collection.drop
* @param {Boolean} removePersistent True to drop persistent storage, false to keep it.
*/
'boolean': function (removePersistent) {
if (!this.isDropped()) {
// Remove persistent storage
if (removePersistent) {
if (this._name) {
if (this._db) {
// Drop the collection data from storage
this._db.persist.drop(this._db._name + '-' + this._name);
this._db.persist.drop(this._db._name + '-' + this._name + '-metaData');
}
} else {
throw('ForerunnerDB.Persist: Cannot drop a collection\'s persistent storage when no name assigned to collection!');
}
}
// Call the original method
CollectionDrop.call(this);
}
},
/**
* Drop collections and optionally drop persistent storage with callback.
* @name drop
* @method Collection.drop
* @param {Boolean} removePersistent True to drop persistent storage, false to keep it.
* @param {Function} callback Callback method.
*/
'boolean, function': function (removePersistent, callback) {
var self = this;
if (!this.isDropped()) {
// Remove persistent storage
if (removePersistent) {
if (this._name) {
if (this._db) {
// Drop the collection data from storage
this._db.persist.drop(this._db._name + '-' + this._name, function () {
self._db.persist.drop(self._db._name + '-' + self._name + '-metaData', callback);
});
return CollectionDrop.call(this);
} else {
if (callback) { callback('Cannot drop a collection\'s persistent storage when the collection is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot drop a collection\'s persistent storage when no name assigned to collection!'); }
}
} else {
// Call the original method
return CollectionDrop.call(this, callback);
}
}
}
});
/**
* Saves an entire collection's data to persistent storage.
* @param {Function=} callback The method to call when the save function
* has completed.
*/
Collection.prototype.save = function (callback) {
var self = this,
processSave;
if (self._name) {
if (self._db) {
processSave = function () {
// Save the collection data
self._db.persist.save(self._db._name + '-' + self._name, self._data, function (err, tableData, tableStats) {
if (err) {
if (callback) { callback(err); }
return;
}
self._db.persist.save(self._db._name + '-' + self._name + '-metaData', self.metaData(), function (err, metaData, metaStats) {
self.deferEmit('save', tableStats, metaStats, {
tableData: tableData,
metaData: metaData,
tableDataName: self._db._name + '-' + self._name,
metaDataName: self._db._name + '-' + self._name + '-metaData'
});
if (callback) {
// Defer till the next VM tick to give the VM some breathing room
// around the persistent data getting into storage.
setTimeout(function () {
callback(err, tableStats, metaStats, {
tableData: tableData,
metaData: metaData,
tableDataName: self._db._name + '-' + self._name,
metaDataName: self._db._name + '-' + self._name + '-metaData'
});
}, 1);
}
});
});
};
// Check for processing queues
if (self.isProcessingQueue()) {
// Hook queue complete to process save
self.on('queuesComplete', function () {
processSave();
});
} else {
// Process save immediately
processSave();
}
} else {
if (callback) { callback('Cannot save a collection that is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot save a collection with no assigned name!'); }
}
};
/**
* Determines the byte size of a persisted collection
* @param {persistedSizeCallback} callback The method to call when the size check is complete
*/
Collection.prototype.persistedSize = function (callback) {
var self = this;
if (self._name) {
if (self._db) {
self._db.persist.persistedSize(self._db._name + '-' + self._name, callback);
} else {
if (callback) {
callback('Cannot determine persisted size of a collection that is not attached to a database!');
}
}
} else {
if (callback) { callback('Cannot determine persisted size of a collection with no assigned name!'); }
}
};
/**
* Loads an entire collection's data from persistent storage.
* @param {Function=} callback The method to call when the load function
* has completed.
*/
Collection.prototype.load = function (callback) {
var self = this;
if (self._name) {
if (self._db) {
// Load the collection data
self._db.persist.load(self._db._name + '-' + self._name, function (err, data, tableStats) {
if (!err) {
// Remove all previous data
self.remove({}, function () {
// Now insert the new data
data = data || [];
self.insert(data, function () {
// Now load the collection's metadata
self._db.persist.load(self._db._name + '-' + self._name + '-metaData', function (err, data, metaStats) {
if (!err) {
if (data) {
self.metaData(data);
}
}
self.deferEmit('load', tableStats, metaStats);
if (callback) { callback(err, tableStats, metaStats); }
});
});
//self.setData(data);
});
} else {
self.deferEmit('load', tableStats);
if (callback) { callback(err); }
}
});
} else {
if (callback) { callback('Cannot load a collection that is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot load a collection with no assigned name!'); }
}
};
/**
* Gets the data that represents this collection for easy storage using
* a third-party method / plugin instead of using the standard persistent
* storage system.
* @param {Function} callback The method to call with the data response.
*/
Collection.prototype.saveCustom = function (callback) {
var self = this,
myData = {},
processSave;
if (self._name) {
if (self._db) {
processSave = function () {
self.encode(self._data, function (err, data, tableStats) {
if (!err) {
myData.data = {
name: self._db._name + '-' + self._name,
store: data,
tableStats: tableStats
};
self.encode(self._data, function (err, data, tableStats) {
if (!err) {
myData.metaData = {
name: self._db._name + '-' + self._name + '-metaData',
store: data,
tableStats: tableStats
};
callback(false, myData);
} else {
callback(err);
}
});
} else {
callback(err);
}
});
};
// Check for processing queues
if (self.isProcessingQueue()) {
// Hook queue complete to process save
self.on('queuesComplete', function () {
processSave();
});
} else {
// Process save immediately
processSave();
}
} else {
if (callback) { callback('Cannot save a collection that is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot save a collection with no assigned name!'); }
}
};
/**
* Loads custom data loaded by a third-party plugin into the collection.
* @param {Object} myData Data object previously saved by using saveCustom()
* @param {Function} callback A callback method to receive notification when
* data has loaded.
*/
Collection.prototype.loadCustom = function (myData, callback) {
var self = this;
if (self._name) {
if (self._db) {
if (myData.data && myData.data.store) {
if (myData.metaData && myData.metaData.store) {
self.decode(myData.data.store, function (err, data, tableStats) {
if (!err) {
if (data) {
// Remove all previous data
self.remove({});
self.insert(data);
self.decode(myData.metaData.store, function (err, data, metaStats) {
if (!err) {
if (data) {
self.metaData(data);
if (callback) { callback(err, tableStats, metaStats); }
}
} else {
callback(err);
}
});
}
} else {
callback(err);
}
});
} else {
callback('No "metaData" key found in passed object!');
}
} else {
callback('No "data" key found in passed object!');
}
} else {
if (callback) { callback('Cannot load a collection that is not attached to a database!'); }
}
} else {
if (callback) { callback('Cannot load a collection with no assigned name!'); }
}
};
// Override the DB init to instantiate the plugin
Db.prototype.init = function () {
DbInit.apply(this, arguments);
this.persist = new Persist(this);
};
Db.prototype.load = new Overload({
/**
* Loads an entire database's data from persistent storage.
* @name load
* @method Db.load
* @param {Function=} callback The method to call when the load function
* has completed.
*/
'function': function (callback) {
this.$main.call(this, undefined, callback);
},
/**
* Loads an entire database's data from persistent storage.
* @name load
* @method Db.load
* @param {Object} myData Custom data to load into the collection.
* @param {Function} callback The method to call when the load function
* has completed.
*/
'object, function': function (myData, callback) {
this.$main.call(this, myData, callback);
},
'$main': function (myData, callback) {
// Loop the collections in the database
var self = this,
obj,
keys,
keyCount,
loadCallback,
index;
obj = this._collection;
keys = Object.keys(obj);
keyCount = keys.length;
if (keyCount <= 0) {
return callback(false);
}
loadCallback = function (err) {
if (!err) {
keyCount--;
if (keyCount <= 0) {
self.deferEmit('load');
if (callback) { callback(false); }
}
} else {
if (callback) { callback(err); }
}
};
for (index in obj) {
if (obj.hasOwnProperty(index)) {
// Call the collection load method
if (!myData) {
obj[index].load(loadCallback);
} else {
obj[index].loadCustom(myData, loadCallback);
}
}
}
}
});
Db.prototype.save = new Overload({
/**
* Saves an entire database's data to persistent storage.
* @name save
* @method Db.save
* @param {Function=} callback The method to call when the save function
* has completed.
*/
'function': function (callback) {
this.$main.call(this, {}, callback);
},
/**
* Saves an entire database's data to persistent storage.
* @name save
* @method Db.save
* @param {Object} options The options object.
* @param {Function} callback The method to call when the save function
* has completed.
*/
'object, function': function (options, callback) {
this.$main.call(this, options, callback);
},
'$main': function (options, callback) {
// Loop the collections in the database
var self = this,
obj,
keys,
keyCount,
saveCallback,
index;
obj = this._collection;
keys = Object.keys(obj);
keyCount = keys.length;
if (keyCount <= 0) {
return callback(false);
}
saveCallback = function (err) {
if (!err) {
keyCount--;
if (keyCount <= 0) {
self.deferEmit('save');
if (callback) {
callback(false);
}
}
} else {
if (callback) {
callback(err);
}
}
};
for (index in obj) {
if (obj.hasOwnProperty(index)) {
// Call the collection save method
if (!options.custom) {
obj[index].save(saveCallback);
} else {
obj[index].saveCustom(saveCallback);
}
}
}
}
});
/**
* Determines the byte size of a persisted DB
* @param {persistedSizeCallback} callback The method to call when the size check is complete
*/
Db.prototype.persistedSize = function(callback) {
this.persist.persistedSize(this, callback);
};
Shared.finishModule('Persist');
module.exports = Persist;