harperdb 3.2.0 → 3.3.0

package/node_modules/lmdb-store/test/threads.js

@@ -1,100 +1,100 @@
-'use strict';
-
-var assert = require('assert');
-const { Worker, isMainThread, parentPort } = require('worker_threads');
-var path = require('path');
-var numCPUs = require('os').cpus().length;
-
-var lmdb = require('..');
-const MAX_DB_SIZE = 256 * 1024 * 1024;
-if (isMainThread) {
-  var inspector = require('inspector')
-//  inspector.open(9331, null, true)
-
-  // The main thread
-
-  var env = new lmdb.Env();
-  env.open({
-    path: path.resolve(__dirname, './testdata'),
-    maxDbs: 10,
-    mapSize: MAX_DB_SIZE,
-    maxReaders: 126
-  });
-
-  var dbi = env.openDbi({
-    name: 'threads',
-    create: true
-  });
-
-  var workerCount = Math.min(numCPUs * 2, 20);
-  var value = Buffer.from('48656c6c6f2c20776f726c6421', 'hex');
-
-  // This will start as many workers as there are CPUs available.
-  var workers = [];
-  for (var i = 0; i < workerCount; i++) {
-    var worker = new Worker(__filename);
-    workers.push(worker);
-  }
-
-  var messages = [];
-
-  workers.forEach(function(worker) {
-    worker.on('message', function(msg) {
-      messages.push(msg);
-      // Once every worker has replied with a response for the value
-      // we can exit the test.
-      if (messages.length === workerCount) {
-        dbi.close();
-        env.close();
-        for (var i = 0; i < messages.length; i ++) {
-          assert(messages[i] === value.toString('hex'));
-        }
-        process.exit(0);
-      }
-    });
-  });
-
-  var txn = env.beginTxn();
-  for (var i = 0; i < workers.length; i++) {
-    txn.putBinary(dbi, 'key' + i, value);
-  }
-
-  txn.commit();
-
-  for (var i = 0; i < workers.length; i++) {
-    var worker = workers[i];
-    worker.postMessage({key: 'key' + i});
-  };
-
-} else {
-
-  // The worker process
-  var env = new lmdb.Env();
-  env.open({
-    path: path.resolve(__dirname, './testdata'),
-    maxDbs: 10,
-    mapSize: MAX_DB_SIZE,
-    maxReaders: 126,
-    readOnly: true
-  });
-
-  var dbi = env.openDbi({
-    name: 'threads'
-  });
-
-  process.on('message', function(msg) {
-    if (msg.key) {
-      var txn = env.beginTxn({readOnly: true});
-      var value = txn.getBinary(dbi, msg.key);
-      
-      if (value === null) {
-        parentPort.postMessage("");
-      } else {
-        parentPort.postMessage(value.toString('hex'));
-      }
-      
-      txn.abort();
-    }
-  });
-
-}
+'use strict';
+
+var assert = require('assert');
+const { Worker, isMainThread, parentPort } = require('worker_threads');
+var path = require('path');
+var numCPUs = require('os').cpus().length;
+
+var lmdb = require('..');
+const MAX_DB_SIZE = 256 * 1024 * 1024;
+if (isMainThread) {
+  var inspector = require('inspector')
+//  inspector.open(9331, null, true)
+
+  // The main thread
+
+  var env = new lmdb.Env();
+  env.open({
+    path: path.resolve(__dirname, './testdata'),
+    maxDbs: 10,
+    mapSize: MAX_DB_SIZE,
+    maxReaders: 126
+  });
+
+  var dbi = env.openDbi({
+    name: 'threads',
+    create: true
+  });
+
+  var workerCount = Math.min(numCPUs * 2, 20);
+  var value = Buffer.from('48656c6c6f2c20776f726c6421', 'hex');
+
+  // This will start as many workers as there are CPUs available.
+  var workers = [];
+  for (var i = 0; i < workerCount; i++) {
+    var worker = new Worker(__filename);
+    workers.push(worker);
+  }
+
+  var messages = [];
+
+  workers.forEach(function(worker) {
+    worker.on('message', function(msg) {
+      messages.push(msg);
+      // Once every worker has replied with a response for the value
+      // we can exit the test.
+      if (messages.length === workerCount) {
+        dbi.close();
+        env.close();
+        for (var i = 0; i < messages.length; i ++) {
+          assert(messages[i] === value.toString('hex'));
+        }
+        process.exit(0);
+      }
+    });
+  });
+
+  var txn = env.beginTxn();
+  for (var i = 0; i < workers.length; i++) {
+    txn.putBinary(dbi, 'key' + i, value);
+  }
+
+  txn.commit();
+
+  for (var i = 0; i < workers.length; i++) {
+    var worker = workers[i];
+    worker.postMessage({key: 'key' + i});
+  };
+
+} else {
+
+  // The worker process
+  var env = new lmdb.Env();
+  env.open({
+    path: path.resolve(__dirname, './testdata'),
+    maxDbs: 10,
+    mapSize: MAX_DB_SIZE,
+    maxReaders: 126,
+    readOnly: true
+  });
+
+  var dbi = env.openDbi({
+    name: 'threads'
+  });
+
+  process.on('message', function(msg) {
+    if (msg.key) {
+      var txn = env.beginTxn({readOnly: true});
+      var value = txn.getBinary(dbi, msg.key);
+      
+      if (value === null) {
+        parentPort.postMessage("");
+      } else {
+        parentPort.postMessage(value.toString('hex'));
+      }
+      
+      txn.abort();
+    }
+  });
+
+}

package/node_modules/lmdb-store/util/ArrayLikeIterable.js

@@ -1,136 +1,136 @@
-const when = require('./when')
-const SKIP = {}
-if (!Symbol.asyncIterator) {
-	Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator')
-}
-
-class ArrayLikeIterable {
-	constructor(sourceArray) {
-		if (sourceArray) {
-			this[Symbol.iterator] = sourceArray[Symbol.iterator].bind(sourceArray)
-		}
-	}
-	map(func) {
-		let source = this
-		let result = new ArrayLikeIterable()
-		result[Symbol.iterator] = (async) => {
-			let iterator = source[Symbol.iterator](async)
-			return {
-				next(resolvedResult) {
-					let result
-					do {
-						let iteratorResult
-						if (resolvedResult) {
-							iteratorResult = resolvedResult
-							resolvedResult = null // don't go in this branch on next iteration
-						} else {
-							iteratorResult = iterator.next()
-							if (iteratorResult.then) {
-								return iteratorResult.then(iteratorResult => this.next(iteratorResult))
-							}
-						}
-						if (iteratorResult.done === true) {
-							this.done = true
-							return iteratorResult
-						}
-						result = func(iteratorResult.value)
-						if (result && result.then) {
-							return result.then(result =>
-								result == SKIP ?
-									this.next() :
-									{
-										value: result
-									})
-						}
-					} while(result == SKIP)
-					return {
-						value: result
-					}
-				},
-				return() {
-					return iterator.return()
-				},
-				throw() {
-					return iterator.throw()
-				}
-			}
-		}
-		return result
-	}
-	[Symbol.asyncIterator]() {
-		return this[Symbol.iterator](true)
-	}
-	filter(func) {
-		return this.map(element => func(element) ? element : SKIP)
-	}
-
-	forEach(callback) {
-		let iterator = this[Symbol.iterator]()
-		let result
-		while ((result = iterator.next()).done !== true) {
-			callback(result.value)
-		}
-	}
-	concat(secondIterable) {
-		let concatIterable = new ArrayLikeIterable()
-		concatIterable[Symbol.iterator] = (async) => {
-			let iterator = this[Symbol.iterator]()
-			let isFirst = true
-			let concatIterator = {
-				next() {
-					let result = iterator.next()
-					if (isFirst && result.done) {
-						isFirst = false
-						iterator = secondIterable[Symbol.iterator](async)
-						return iterator.next()
-					}
-					return result
-				},
-				return() {
-					return iterator.return()
-				},
-				throw() {
-					return iterator.throw()
-				}
-			}
-			return concatIterator
-		}
-		return concatIterable
-	}
-	toJSON() {
-		if (this.asArray && this.asArray.forEach) {
-			return this.asArray
-		}
-		throw new Error('Can not serialize async iteratables without first calling resolveJSON')
-		//return Array.from(this)
-	}
-	get asArray() {
-		if (this._asArray)
-			return this._asArray
-		let promise = new Promise((resolve, reject) => {
-			let iterator = this[Symbol.iterator](true)
-			let array = []
-			let iterable = this
-			function next(result) {
-				while (result.done !== true) {
-					if (result.then) {
-						return result.then(next)
-					} else {
-						array.push(result.value)
-					}
-					result = iterator.next()
-				}
-				array.iterable = iterable
-				resolve(iterable._asArray = array)
-			}
-			next(iterator.next())
-		})
-		promise.iterable = this
-		return this._asArray || (this._asArray = promise)
-	}
-	resolveData() {
-		return this.asArray
-	}
-}
-
-exports.ArrayLikeIterable = ArrayLikeIterable
+const when = require('./when')
+const SKIP = {}
+if (!Symbol.asyncIterator) {
+	Symbol.asyncIterator = Symbol.for('Symbol.asyncIterator')
+}
+
+class ArrayLikeIterable {
+	constructor(sourceArray) {
+		if (sourceArray) {
+			this[Symbol.iterator] = sourceArray[Symbol.iterator].bind(sourceArray)
+		}
+	}
+	map(func) {
+		let source = this
+		let result = new ArrayLikeIterable()
+		result[Symbol.iterator] = (async) => {
+			let iterator = source[Symbol.iterator](async)
+			return {
+				next(resolvedResult) {
+					let result
+					do {
+						let iteratorResult
+						if (resolvedResult) {
+							iteratorResult = resolvedResult
+							resolvedResult = null // don't go in this branch on next iteration
+						} else {
+							iteratorResult = iterator.next()
+							if (iteratorResult.then) {
+								return iteratorResult.then(iteratorResult => this.next(iteratorResult))
+							}
+						}
+						if (iteratorResult.done === true) {
+							this.done = true
+							return iteratorResult
+						}
+						result = func(iteratorResult.value)
+						if (result && result.then) {
+							return result.then(result =>
+								result == SKIP ?
+									this.next() :
+									{
+										value: result
+									})
+						}
+					} while(result == SKIP)
+					return {
+						value: result
+					}
+				},
+				return() {
+					return iterator.return()
+				},
+				throw() {
+					return iterator.throw()
+				}
+			}
+		}
+		return result
+	}
+	[Symbol.asyncIterator]() {
+		return this[Symbol.iterator](true)
+	}
+	filter(func) {
+		return this.map(element => func(element) ? element : SKIP)
+	}
+
+	forEach(callback) {
+		let iterator = this[Symbol.iterator]()
+		let result
+		while ((result = iterator.next()).done !== true) {
+			callback(result.value)
+		}
+	}
+	concat(secondIterable) {
+		let concatIterable = new ArrayLikeIterable()
+		concatIterable[Symbol.iterator] = (async) => {
+			let iterator = this[Symbol.iterator]()
+			let isFirst = true
+			let concatIterator = {
+				next() {
+					let result = iterator.next()
+					if (isFirst && result.done) {
+						isFirst = false
+						iterator = secondIterable[Symbol.iterator](async)
+						return iterator.next()
+					}
+					return result
+				},
+				return() {
+					return iterator.return()
+				},
+				throw() {
+					return iterator.throw()
+				}
+			}
+			return concatIterator
+		}
+		return concatIterable
+	}
+	toJSON() {
+		if (this.asArray && this.asArray.forEach) {
+			return this.asArray
+		}
+		throw new Error('Can not serialize async iteratables without first calling resolveJSON')
+		//return Array.from(this)
+	}
+	get asArray() {
+		if (this._asArray)
+			return this._asArray
+		let promise = new Promise((resolve, reject) => {
+			let iterator = this[Symbol.iterator](true)
+			let array = []
+			let iterable = this
+			function next(result) {
+				while (result.done !== true) {
+					if (result.then) {
+						return result.then(next)
+					} else {
+						array.push(result.value)
+					}
+					result = iterator.next()
+				}
+				array.iterable = iterable
+				resolve(iterable._asArray = array)
+			}
+			next(iterator.next())
+		})
+		promise.iterable = this
+		return this._asArray || (this._asArray = promise)
+	}
+	resolveData() {
+		return this.asArray
+	}
+}
+
+exports.ArrayLikeIterable = ArrayLikeIterable

package/node_modules/lmdb-store/util/WeakValueMap.js

@@ -1,41 +1,41 @@
-// this provides a weak-valued map to ensure we only have a single instance of an object per id, but can still be GC-ed
-let WeakValueMap
-try {
-	let NativeWeakValueMap = require('weakvaluemap')
-	let allInstances = []
-	WeakValueMap = function() {
-		let map = new NativeWeakValueMap()
-		allInstances.push(map)
-		return map
-	}
-	WeakValueMap.getStatus = function() {
-		let mapStats = []
-		for (let map of allInstances) {
-			let size = 0
-			let count = 0
-			for (let key of map.keys()) {
-				let value = map.get(key)
-				size += value && value.approximateSize || 100
-				count++
-			}
-			if (count > 0) {
-				mapStats.push({
-					name: map.name,
-					size,
-					count
-				})
-			}
-		}
-		return mapStats
-	}
-} catch (error) {
-	console.warn('No weak value map available, this can be used for development, but weak value maps should be enabled for production use', error.toString())
-	WeakValueMap = Map
-	WeakValueMap.getStatus = function() {
-		return 'WeakValueMap failed to load'
-	}
-	WeakValueMap.prototype._keysAsArray = function() {
-		return Array.from(this.keys())
-	}
-}
+// this provides a weak-valued map to ensure we only have a single instance of an object per id, but can still be GC-ed
+let WeakValueMap
+try {
+	let NativeWeakValueMap = require('weakvaluemap')
+	let allInstances = []
+	WeakValueMap = function() {
+		let map = new NativeWeakValueMap()
+		allInstances.push(map)
+		return map
+	}
+	WeakValueMap.getStatus = function() {
+		let mapStats = []
+		for (let map of allInstances) {
+			let size = 0
+			let count = 0
+			for (let key of map.keys()) {
+				let value = map.get(key)
+				size += value && value.approximateSize || 100
+				count++
+			}
+			if (count > 0) {
+				mapStats.push({
+					name: map.name,
+					size,
+					count
+				})
+			}
+		}
+		return mapStats
+	}
+} catch (error) {
+	console.warn('No weak value map available, this can be used for development, but weak value maps should be enabled for production use', error.toString())
+	WeakValueMap = Map
+	WeakValueMap.getStatus = function() {
+		return 'WeakValueMap failed to load'
+	}
+	WeakValueMap.prototype._keysAsArray = function() {
+		return Array.from(this.keys())
+	}
+}
 exports.WeakValueMap = WeakValueMap

package/node_modules/lmdb-store/util/upgrade-lmdb.js

@@ -1,46 +1,46 @@
-const { renameSync, unlinkSync } = require('fs')
-const { extname } = require('path')
-
-exports.upgrade =  function(path, options, open) {
-	let upgradeModule
-	try {
-		upgradeModule = require('lmdb-store-0.9')
-	} catch (error) {
-		throw new Error('And invalid file format was encountered in the database, if you have an older database, you need to install package lmdb-store-0.9 to upgrade')
-	}
-	let { open: legacyOpen, Cursor: legacyCursor } = upgradeModule
-	let filePath = extname(path) ? path : path + '/data.mdb'
-	console.log('Upgrading', filePath, 'to LMDB 1.0 format')
-	let tempPath = filePath.replace(/([^\\\/]+)$/, 'temp-$1')
-	let maxDbs = options.maxDbs || 20
-	let sourceStore = legacyOpen(path, { maxDbs, encoding: 'binary' })
-	let targetStore = open(tempPath, { maxDbs, encoding: 'binary', mapSize: sourceStore.env.info().mapSize })
-	let targetTxn = targetStore.transaction(() => {
-		copyDB(sourceStore, targetStore)
-		function copyDB(sourceStore, targetStore) {
-			let sourceTxn = sourceStore.env.beginTxn({ readOnly: true })
-			let sourceDb = sourceStore.db
-			let cursor = new legacyCursor(sourceTxn, sourceDb)
-			let currentKey = cursor.goToFirst()
-			while(currentKey) {
-				let size = cursor.getCurrentBinaryUnsafe()
-				if (cursor.getCurrentIsDatabase()) {
-					copyDB(sourceStore.openDB(currentKey, {}), targetStore.openDB(currentKey))
-				} else {
-					targetStore.putSync(currentKey, sourceDb.unsafeBuffer.slice(0, size))
-				}
-				currentKey = cursor.goToNext()
-			}
-			cursor.close()
-			sourceTxn.abort()
-		}
-	})
-	sourceStore.close()
-	targetStore.close()
-	unlinkSync(filePath)
-	renameSync(tempPath, filePath)
-	try {
-		unlinkSync(tempPath + '-lock')
-	} catch (error) {}
-	console.log('Finished upgrading', filePath)
-}
+const { renameSync, unlinkSync } = require('fs')
+const { extname } = require('path')
+
+exports.upgrade =  function(path, options, open) {
+	let upgradeModule
+	try {
+		upgradeModule = require('lmdb-store-0.9')
+	} catch (error) {
+		throw new Error('And invalid file format was encountered in the database, if you have an older database, you need to install package lmdb-store-0.9 to upgrade')
+	}
+	let { open: legacyOpen, Cursor: legacyCursor } = upgradeModule
+	let filePath = extname(path) ? path : path + '/data.mdb'
+	console.log('Upgrading', filePath, 'to LMDB 1.0 format')
+	let tempPath = filePath.replace(/([^\\\/]+)$/, 'temp-$1')
+	let maxDbs = options.maxDbs || 20
+	let sourceStore = legacyOpen(path, { maxDbs, encoding: 'binary' })
+	let targetStore = open(tempPath, { maxDbs, encoding: 'binary', mapSize: sourceStore.env.info().mapSize })
+	let targetTxn = targetStore.transaction(() => {
+		copyDB(sourceStore, targetStore)
+		function copyDB(sourceStore, targetStore) {
+			let sourceTxn = sourceStore.env.beginTxn({ readOnly: true })
+			let sourceDb = sourceStore.db
+			let cursor = new legacyCursor(sourceTxn, sourceDb)
+			let currentKey = cursor.goToFirst()
+			while(currentKey) {
+				let size = cursor.getCurrentBinaryUnsafe()
+				if (cursor.getCurrentIsDatabase()) {
+					copyDB(sourceStore.openDB(currentKey, {}), targetStore.openDB(currentKey))
+				} else {
+					targetStore.putSync(currentKey, sourceDb.unsafeBuffer.slice(0, size))
+				}
+				currentKey = cursor.goToNext()
+			}
+			cursor.close()
+			sourceTxn.abort()
+		}
+	})
+	sourceStore.close()
+	targetStore.close()
+	unlinkSync(filePath)
+	renameSync(tempPath, filePath)
+	try {
+		unlinkSync(tempPath + '-lock')
+	} catch (error) {}
+	console.log('Finished upgrading', filePath)
+}

package/node_modules/lmdb-store/util/when.js

@@ -1,8 +1,8 @@
-module.exports = function when(promise, callback, errback) {
-  if (promise && promise.then) {
-    return errback ?
-      promise.then(callback, errback) :
-      promise.then(callback)
-  }
-  return callback(promise)
-}
+module.exports = function when(promise, callback, errback) {
+  if (promise && promise.then) {
+    return errback ?
+      promise.then(callback, errback) :
+      promise.then(callback)
+  }
+  return callback(promise)
+}