allow temporary databases and treat them like in-memory databases

Author: JoshuaWise

lib/database.js

@@ -5,23 +5,23 @@ const util = require('./util');
 const CPPDatabase = require('../build/better_sqlite3.node').Database;
 
 function Database(filenameGiven, options) {
+	if (filenameGiven == null) filenameGiven = '';
 	if (options == null) options = {};
 	if (typeof filenameGiven !== 'string') throw new TypeError('Expected first argument to be a string');
 	if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
 
 	let filename = filenameGiven.trim();
-	if (!filename) throw new TypeError('Database filename cannot be an empty string');
 	if (filename.toLowerCase().startsWith('file:')) throw new TypeError('URI filenames are reserved for internal use only');
 	if ('readOnly' in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
 
-	const anonymous = filename === ':memory:';
+	const anonymous = filename === '' || filename === ':memory:';
 	const memory = util.getBooleanOption(options, 'memory');
 	const readonly = util.getBooleanOption(options, 'readonly');
 	const fileMustExist = util.getBooleanOption(options, 'fileMustExist');
 	const timeout = 'timeout' in options ? options.timeout : 5000;
 
 	if (readonly && (memory || anonymous)) throw new TypeError('In-memory databases cannot be readonly');
-	if (anonymous && !memory && 'memory' in options) throw new TypeError('Option "memory" conflicts with :memory: filename');
+	if (anonymous && !memory && 'memory' in options) throw new TypeError('Option "memory" conflicts with non-existent filename');
 	if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
 	if (timeout > 0x7fffffff) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
 

test/10.database.open.js

@@ -3,18 +3,17 @@ const { existsSync } = require('fs');
 const Database = require('../.');
 
 describe('new Database()', function () {
-	it('should throw when file path is not a string', function () {
-		expect(() => new Database()).to.throw(TypeError);
-		expect(() => new Database(null)).to.throw(TypeError);
+	it('should throw when given invalid argument types', function () {
+		expect(() => new Database('', '')).to.throw(TypeError);
+		expect(() => new Database({}, '')).to.throw(TypeError);
+		expect(() => new Database({}, {})).to.throw(TypeError);
+		expect(() => new Database({})).to.throw(TypeError);
 		expect(() => new Database(0)).to.throw(TypeError);
 		expect(() => new Database(123)).to.throw(TypeError);
 		expect(() => new Database(new String(util.next()))).to.throw(TypeError);
 		expect(() => new Database(() => util.next())).to.throw(TypeError);
 		expect(() => new Database([util.next()])).to.throw(TypeError);
 	});
-	it('should throw when file path is empty', function () {
-		expect(() => new Database('')).to.throw(TypeError);
-	});
 	it('should throw when boolean options are provided as non-booleans', function () {
 		expect(() => new Database(util.next(), { readOnly: false })).to.throw(TypeError);
 		expect(() => new Database(util.next(), { readonly: undefined })).to.throw(TypeError);
@@ -26,6 +25,20 @@ describe('new Database()', function () {
 		expect(() => new Database(`file:${util.next()}`)).to.throw(TypeError);
 		expect(() => new Database(`file:${util.next()}?mode=memory&cache=shared`)).to.throw(TypeError);
 	});
+	it('should allow anonymous temporary databases to be created', function () {
+		for (const args of [[''], [], [null], [undefined], ['', { timeout: 2000 }]]) {
+			const db = new Database(...args);
+			expect(db.name).to.equal('');
+			expect(db.memory).to.be.true;
+			expect(db.readonly).to.be.false;
+			expect(db.open).to.be.true;
+			expect(db.inTransaction).to.be.false;
+			expect(existsSync('')).to.be.false;
+			expect(existsSync('null')).to.be.false;
+			expect(existsSync('undefined')).to.be.false;
+			expect(existsSync('[object Object]')).to.be.false;
+		}
+	});
 	it('should allow anonymous in-memory databases to be created', function () {
 		const db = new Database(':memory:');
 		expect(db.name).to.equal(':memory:');
@@ -57,7 +70,9 @@ describe('new Database()', function () {
 	});
 	it('should not allow conflicting in-memory options', function () {
 		expect(() => new Database(':memory:', { memory: false })).to.throw(TypeError);
+		expect(() => new Database('', { memory: false })).to.throw(TypeError);
 		(new Database(':memory:', { memory: true })).close();
+		(new Database('', { memory: true })).close();
 	});
 	it('should allow readonly database connections to be created', function () {
 		expect(existsSync(util.next())).to.be.false;
@@ -76,6 +91,7 @@ describe('new Database()', function () {
 		expect(existsSync(util.next())).to.be.false;
 		expect(() => new Database(util.current(), { memory: true, readonly: true })).to.throw(TypeError);
 		expect(() => new Database(':memory:', { readonly: true })).to.throw(TypeError);
+		expect(() => new Database('', { readonly: true })).to.throw(TypeError);
 		expect(existsSync(util.current())).to.be.false;
 	});
 	it('should accept the "fileMustExist" option', function () {