Breaking: add promise support and throw if not operational

UPGRADING.md

@@ -37,6 +37,48 @@ This document describes breaking changes and how to upgrade. For a complete list
 
 </details>
 
+## Upcoming
+
+All methods that take a callback now also support promises. They return a promise if no callback is provided, the same as `levelup`.
+
+On any operation, `abstract-leveldown` now checks if it's open. If not, it will either throw an error (if the relevant API is synchronous) or asynchronously yield an error. For example:
+
+```js
+try {
+  db.iterator()
+} catch (err) {
+  // Error: Database is not open
+}
+```
+
+```js
+try {
+  await db.get('example')
+} catch (err) {
+  // Error: Database is not open
+}
+```
+
+```js
+db.get('example', function (err, value) {
+  // Error: Database is not open
+})
+```
+
+This may be a breaking change downstream because it changes error messages for implementations that had their own safety checks (which will now be ineffective because `abstract-leveldown` checks are performed first).
+
+Implementations that have additional methods, like `leveldown` that has an `approximateSize()` method which is not part of the `abstract-leveldown` interface, should add or align their own safety checks for consistency. Like so:
+
+```js
+LevelDOWN.prototype.approximateSize = function (start, end, callback) {
+  if (!this.isOperational()) {
+    throw new Error('Database is not open')
+  }
+
+  // ...
+}
+```
+
 ## 7.0.0
 
 Legacy range options have been removed ([Level/community#86](https://github.com/Level/community/issues/86)). If you previously did:

abstract-chained-batch.js

@@ -1,7 +1,11 @@
 'use strict'
 
+const { fromCallback } = require('catering')
+const { getCallback, getOptions } = require('./lib/common')
+
 const emptyOptions = Object.freeze({})
 const kLength = Symbol('length')
+const kPromise = Symbol('promise')
 
 function AbstractChainedBatch (db) {
   if (typeof db !== 'object' || db === null) {
@@ -30,6 +34,10 @@ AbstractChainedBatch.prototype._checkWritten = function () {
 }
 
 AbstractChainedBatch.prototype.put = function (key, value, options) {
+  if (!this.db.isOperational()) {
+    throw new Error('Database is not open')
+  }
+
   this._checkWritten()
 
   const err = this.db._checkKey(key) || this.db._checkValue(value)
@@ -49,6 +57,10 @@ AbstractChainedBatch.prototype._put = function (key, value, options) {
 }
 
 AbstractChainedBatch.prototype.del = function (key, options) {
+  if (!this.db.isOperational()) {
+    throw new Error('Database is not open')
+  }
+
   this._checkWritten()
 
   const err = this.db._checkKey(key)
@@ -66,6 +78,10 @@ AbstractChainedBatch.prototype._del = function (key, options) {
 }
 
 AbstractChainedBatch.prototype.clear = function () {
+  if (!this.db.isOperational()) {
+    throw new Error('Database is not open')
+  }
+
   this._checkWritten()
   this._clear()
   this[kLength] = 0
@@ -78,20 +94,20 @@ AbstractChainedBatch.prototype._clear = function () {
 }
 
 AbstractChainedBatch.prototype.write = function (options, callback) {
-  this._checkWritten()
+  callback = getCallback(options, callback)
+  callback = fromCallback(callback, kPromise)
+  options = getOptions(options)
 
-  if (typeof options === 'function') {
-    callback = options
-  }
-  if (typeof callback !== 'function') {
-    throw new Error('write() requires a callback argument')
-  }
-  if (typeof options !== 'object' || options === null) {
-    options = {}
+  if (!this.db.isOperational()) {
+    this._nextTick(callback, new Error('Database is not open'))
+    return callback[kPromise]
   }
 
+  this._checkWritten()
   this._written = true
   this._write(options, callback)
+
+  return callback[kPromise]
 }
 
 AbstractChainedBatch.prototype._write = function (options, callback) {

abstract-iterator.js

@@ -1,5 +1,8 @@
 'use strict'
 
+const { fromCallback } = require('catering')
+const kPromise = Symbol('promise')
+
 function AbstractIterator (db) {
   if (typeof db !== 'object' || db === null) {
     throw new TypeError('First argument must be an abstract-leveldown compliant store')
@@ -26,6 +29,11 @@ AbstractIterator.prototype.next = function (callback) {
     throw new Error('next() requires a callback argument')
   }
 
+  if (!this.db.isOperational()) {
+    this._nextTick(callback, new Error('Database is not open'))
+    return ret
+  }
+
   if (this._ended) {
     this._nextTick(callback, new Error('cannot call next() after end()'))
     return ret
@@ -50,9 +58,14 @@ AbstractIterator.prototype._next = function (callback) {
 }
 
 AbstractIterator.prototype.seek = function (target) {
+  if (!this.db.isOperational()) {
+    throw new Error('Database is not open')
+  }
+
   if (this._ended) {
     throw new Error('cannot call seek() after end()')
   }
+
   if (this._nexting) {
     throw new Error('cannot call seek() before next() has completed')
   }
@@ -64,28 +77,22 @@ AbstractIterator.prototype.seek = function (target) {
 AbstractIterator.prototype._seek = function (target) {}
 
 AbstractIterator.prototype.end = function (callback) {
-  let promise
+  callback = fromCallback(callback, kPromise)
 
-  if (callback === undefined) {
-    promise = new Promise(function (resolve, reject) {
-      callback = function (err) {
-        if (err) reject(err)
-        else resolve()
-      }
-    })
-  } else if (typeof callback !== 'function') {
-    throw new Error('end() requires a callback argument')
+  if (!this.db.isOperational()) {
+    this._nextTick(callback, new Error('Database is not open'))
+    return callback[kPromise]
   }
 
   if (this._ended) {
     this._nextTick(callback, new Error('end() already called on iterator'))
-    return promise
+    return callback[kPromise]
   }
 
   this._ended = true
   this._end(callback)
 
-  return promise
+  return callback[kPromise]
 }
 
 AbstractIterator.prototype._end = function (callback) {