diff --git a/.eslintrc.js b/.eslintrc.js
index 2303c3d4..13e5647e 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,10 +1,12 @@
 module.exports = {
     "extends": "eslint:recommended",
     "env": {
-        "es2017": true,
+        "es2018": true,
         "node": true
     },
     "rules": {
+        "no-var": "error",
+        "prefer-const": "error",
         "indent": ["error", 4],
         "linebreak-style": ["error", "unix"],
         "semi": ["error", "always"],
diff --git a/.gitignore b/.gitignore
index 108a59ae..2a0aa3c1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,3 +30,4 @@ setup.sh
 package-lock.json
 yarn.lock
 prebuilds
+somefile
diff --git a/lib/sqlite3.d.ts b/lib/sqlite3.d.ts
index 15e66230..22af82ff 100644
--- a/lib/sqlite3.d.ts
+++ b/lib/sqlite3.d.ts
@@ -59,8 +59,9 @@ export const LIMIT_TRIGGER_DEPTH: number;
 export const LIMIT_WORKER_THREADS: number;
 
 export const cached: {
-    Database(filename: string, callback?: (this: Database, err: Error | null) => void): Database;
-    Database(filename: string, mode?: number, callback?: (this: Database, err: Error | null) => void): Database;
+    Database: {
+        create: (filename: string, mode?: number) => Promise<Database>
+    };
 };
 
 export interface RunResult extends Statement {
@@ -69,60 +70,50 @@ export interface RunResult extends Statement {
 }
 
 export class Statement extends events.EventEmitter {
-    bind(callback?: (err: Error | null) => void): this;
-    bind(...params: any[]): this;
+    readonly lastID: number;
+    readonly changes: number;
+    readonly sql: string;
+    static create(database: Database, sql: string): Promise<Statement>;
+    bind(): Promise<Statement>;
+    bind(...params: any[]): Promise<Statement>;
 
-    reset(callback?: (err: null) => void): this;
+    reset(): Promise<Statement>;
 
-    finalize(callback?: (err: Error) => void): Database;
+    finalize(): Promise<Database>;
 
-    run(callback?: (err: Error | null) => void): this;
-    run(params: any, callback?: (this: RunResult, err: Error | null) => void): this;
-    run(...params: any[]): this;
+    run(...params: any[]): Promise<Statement>;
 
-    get<T>(callback?: (err: Error | null, row?: T) => void): this;
-    get<T>(params: any, callback?: (this: RunResult, err: Error | null, row?: T) => void): this;
-    get(...params: any[]): this;
+    get<T>(...params: any[]): T;
 
-    all<T>(callback?: (err: Error | null, rows: T[]) => void): this;
-    all<T>(params: any, callback?: (this: RunResult, err: Error | null, rows: T[]) => void): this;
-    all(...params: any[]): this;
+    all<T>(...params: any): Promise<T[]>;
 
-    each<T>(callback?: (err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
-    each<T>(params: any, callback?: (this: RunResult, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
-    each(...params: any[]): this;
+    each<T>(...params: any[]): AsyncIterable<T>;
 }
 
 export class Database extends events.EventEmitter {
-    constructor(filename: string, callback?: (err: Error | null) => void);
-    constructor(filename: string, mode?: number, callback?: (err: Error | null) => void);
+    private constructor(filename: string);
+    private constructor(filename: string, mode?: number);
 
-    close(callback?: (err: Error | null) => void): void;
+    static create(filename: string, mode?: number): Promise<Database>;
 
-    run(sql: string, callback?: (this: RunResult, err: Error | null) => void): this;
-    run(sql: string, params: any, callback?: (this: RunResult, err: Error | null) => void): this;
-    run(sql: string, ...params: any[]): this;
+    close(): Promise<void>;
 
-    get<T>(sql: string, callback?: (this: Statement, err: Error | null, row: T) => void): this;
-    get<T>(sql: string, params: any, callback?: (this: Statement, err: Error | null, row: T) => void): this;
-    get(sql: string, ...params: any[]): this;
+    run(sql: string, ...params: any[]): Promise<Statement>;
 
-    all<T>(sql: string, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
-    all<T>(sql: string, params: any, callback?: (this: Statement, err: Error | null, rows: T[]) => void): this;
-    all(sql: string, ...params: any[]): this;
+    get<T>(sql: string, ...params: any[]): Promise<T>;
 
-    each<T>(sql: string, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
-    each<T>(sql: string, params: any, callback?: (this: Statement, err: Error | null, row: T) => void, complete?: (err: Error | null, count: number) => void): this;
-    each(sql: string, ...params: any[]): this;
+    all<T>(sql: string, ...params: any[]): Promise<T[]>;
 
-    exec(sql: string, callback?: (this: Statement, err: Error | null) => void): this;
+    each<T>(sql: string, ...params: any[]): Promise<AsyncIterable<T>>;
 
-    prepare(sql: string, callback?: (this: Statement, err: Error | null) => void): Statement;
-    prepare(sql: string, params: any, callback?: (this: Statement, err: Error | null) => void): Statement;
-    prepare(sql: string, ...params: any[]): Statement;
+    exec(sql: string): Promise<Database>;
 
-    serialize(callback?: () => void): void;
-    parallelize(callback?: () => void): void;
+    prepare(sql: string, ...params: any[]): Promise<Statement>;
+
+    serialize<T>(callback?: () => Promise<T>): Promise<T>;
+    parallelize<T>(callback?: () => Promise<T>): Promise<T>;
+
+    map<T>(sql: string, ...params: any[]): Promise<Record<string, T>>;
 
     on(event: "trace", listener: (sql: string) => void): this;
     on(event: "profile", listener: (sql: string, time: number) => void): this;
@@ -134,11 +125,158 @@ export class Database extends events.EventEmitter {
     configure(option: "busyTimeout", value: number): void;
     configure(option: "limit", id: number, value: number): void;
 
-    loadExtension(filename: string, callback?: (err: Error | null) => void): this;
+    loadExtension(filename: string): Promise<Database>;
 
-    wait(callback?: (param: null) => void): this;
+    wait(): Promise<Database>;
 
     interrupt(): void;
+
+    backup(path: string): Promise<Backup>
+    backup(filename: string, destDbName: string, sourceDbName: string, filenameIsDest: boolean): Promise<Backup>
+}
+
+/**
+ *
+ * A class for managing an sqlite3_backup object.  For consistency
+ * with other node-sqlite3 classes, it maintains an internal queue
+ * of calls.
+ *
+ * Intended usage from node:
+ *
+ *   var db = new sqlite3.Database('live.db');
+ *   var backup = db.backup('backup.db');
+ *   ...
+ *   // in event loop, move backup forward when we have time.
+ *   if (backup.idle) { backup.step(NPAGES); }
+ *   if (backup.completed) { ... success ... }
+ *   if (backup.failed)    { ... sadness ... }
+ *   // do other work in event loop - fine to modify live.db
+ *   ...
+ *
+ * Here is how sqlite's backup api is exposed:
+ *
+ *   - `sqlite3_backup_init`: This is implemented as
+ *     `db.backup(filename, [callback])` or
+ *     `db.backup(filename, destDbName, sourceDbName, filenameIsDest, [callback])`.
+ *   - `sqlite3_backup_step`: `backup.step(pages, [callback])`.
+ *   - `sqlite3_backup_finish`: `backup.finish([callback])`.
+ *   - `sqlite3_backup_remaining`: `backup.remaining`.
+ *   - `sqlite3_backup_pagecount`: `backup.pageCount`.
+ *
+ * There are the following read-only properties:
+ *
+ *   - `backup.completed` is set to `true` when the backup
+ *     succeeeds.
+ *   - `backup.failed` is set to `true` when the backup
+ *     has a fatal error.
+ *   - `backup.message` is set to the error string 
+ *     the backup has a fatal error.
+ *   - `backup.idle` is set to `true` when no operation
+ *     is currently in progress or queued for the backup.
+ *   - `backup.remaining` is an integer with the remaining
+ *     number of pages after the last call to `backup.step`
+ *     (-1 if `step` not yet called).
+ *   - `backup.pageCount` is an integer with the total number
+ *     of pages measured during the last call to `backup.step`
+ *     (-1 if `step` not yet called).
+ *
+ * There is the following writable property:
+ *
+ *   - `backup.retryErrors`: an array of sqlite3 error codes
+ *     that are treated as non-fatal - meaning, if they occur,
+ *     backup.failed is not set, and the backup may continue.
+ *     By default, this is `[sqlite3.BUSY, sqlite3.LOCKED]`.
+ *
+ * The `db.backup(filename, [callback])` shorthand is sufficient
+ * for making a backup of a database opened by node-sqlite3.  If
+ * using attached or temporary databases, or moving data in the
+ * opposite direction, the more complete (but daunting)
+ * `db.backup(filename, destDbName, sourceDbName, filenameIsDest, [callback])`
+ * signature is provided.
+ *
+ * A backup will finish automatically when it succeeds or a fatal
+ * error occurs, meaning it is not necessary to call `db.finish()`.
+ * By default, SQLITE_LOCKED and SQLITE_BUSY errors are not
+ * treated as failures, and the backup will continue if they
+ * occur.  The set of errors that are tolerated can be controlled
+ * by setting `backup.retryErrors`. To disable automatic
+ * finishing and stick strictly to sqlite's raw api, set
+ * `backup.retryErrors` to `[]`.  In that case, it is necessary
+ * to call `backup.finish()`.
+ *
+ * In the same way as node-sqlite3 databases and statements,
+ * backup methods can be called safely without callbacks, due
+ * to an internal call queue.  So for example this naive code
+ * will correctly back up a db, if there are no errors:
+ *
+ *   var backup = db.backup('backup.db');
+ *   backup.step(-1);
+ *   backup.finish();
+ *
+ */
+export class Backup extends events.EventEmitter {
+    /**
+     * `true` when the backup is idle and ready for `step()` to 
+     * be called, `false` when busy.
+     */
+    readonly idle: boolean
+
+    /**
+     * `true` when the backup has completed, `false` otherwise.
+     */
+    readonly completed: boolean
+
+    /**
+     * `true` when the backup has failed, `false` otherwise. `Backup.message`
+     * contains the error message.
+     */
+    readonly failed: boolean
+
+    /**
+     * Message failure string from sqlite3_errstr() if `Backup.failed` is `true`
+     */
+    readonly message: boolean
+
+    /**
+     * The number of remaining pages after the last call to `step()`, 
+     * or `-1` if `step()` has never been called.
+     */
+    readonly remaining: number
+
+    /**
+     * The total number of pages measured during the last call to `step()`, 
+     * or `-1` if `step()` has never been called.
+     */
+    readonly pageCount: number
+
+
+    /**
+     * An array of sqlite3 error codes that are treated as non-fatal - 
+     * meaning, if they occur, `Backup.failed` is not set, and the backup 
+     * may continue. By default, this is `[sqlite3.BUSY, sqlite3.LOCKED]`.
+     */
+    retryErrors: number[]
+
+    /**
+     * Asynchronously finalize the backup (required).
+     * 
+     * @param callback Called when the backup is finalized.
+     */
+    finish(): Promise<void>
+
+    /**
+     * Asynchronously perform an incremental segment of the backup.
+     * 
+     * Example:
+     * 
+     * ```
+     * backup.step(5)
+     * ```
+     * 
+     * @param nPages Number of pages to process (5 recommended).
+     * @param callback Called when the step is completed.
+     */
+    step(nPages: number,): Promise<void>
 }
 
 export function verbose(): sqlite3;
@@ -202,4 +340,4 @@ export interface sqlite3 {
     Statement: typeof Statement;
     Database: typeof Database;
     verbose(): this;
-}
\ No newline at end of file
+}
diff --git a/lib/sqlite3.js b/lib/sqlite3.js
index 430a2b88..77d37077 100644
--- a/lib/sqlite3.js
+++ b/lib/sqlite3.js
@@ -4,19 +4,9 @@ const EventEmitter = require('events').EventEmitter;
 module.exports = exports = sqlite3;
 
 function normalizeMethod (fn) {
-    return function (sql) {
-        let errBack;
+    return async function (sql) {
         const args = Array.prototype.slice.call(arguments, 1);
-
-        if (typeof args[args.length - 1] === 'function') {
-            const callback = args[args.length - 1];
-            errBack = function(err) {
-                if (err) {
-                    callback(err);
-                }
-            };
-        }
-        const statement = new Statement(this, sql, errBack);
+        const statement = await Statement.create(this, sql);
         return fn.call(this, statement, args);
     };
 }
@@ -27,30 +17,26 @@ function inherits(target, source) {
 }
 
 sqlite3.cached = {
-    Database: function(file, a, b) {
-        if (file === '' || file === ':memory:') {
-            // Don't cache special databases.
-            return new Database(file, a, b);
-        }
+    Database: {
+        create: async function(file, a, b) {
+            if (file === '' || file === ':memory:') {
+                // Don't cache special databases.
+                return Database.create(file, a, b);
+            }
 
-        let db;
-        file = path.resolve(file);
+            let db;
+            file = path.resolve(file);
 
-        if (!sqlite3.cached.objects[file]) {
-            db = sqlite3.cached.objects[file] = new Database(file, a, b);
-        }
-        else {
-            // Make sure the callback is called.
-            db = sqlite3.cached.objects[file];
-            const callback = (typeof a === 'number') ? b : a;
-            if (typeof callback === 'function') {
-                function cb() { callback.call(db, null); }
-                if (db.open) process.nextTick(cb);
-                else db.once('open', cb);
+            if (!sqlite3.cached.objects[file]) {
+                db = sqlite3.cached.objects[file] = await Database.create(file, a, b);
+            }
+            else {
+                // Make sure the callback is called.
+                db = sqlite3.cached.objects[file];
             }
-        }
 
-        return db;
+            return db;
+        },
     },
     objects: {}
 };
@@ -64,84 +50,104 @@ inherits(Database, EventEmitter);
 inherits(Statement, EventEmitter);
 inherits(Backup, EventEmitter);
 
-// Database#prepare(sql, [bind1, bind2, ...], [callback])
+Database.create = async function(filename, mode) {
+    const database = new Database(filename, mode);
+    return database.connect();
+};
+
+// Database#prepare(sql, [bind1, bind2, ...])
 Database.prototype.prepare = normalizeMethod(function(statement, params) {
     return params.length
-        ? statement.bind.apply(statement, params)
+        ? statement.bind(...params)
         : statement;
 });
 
-// Database#run(sql, [bind1, bind2, ...], [callback])
+// Database#run(sql, [bind1, bind2, ...])
 Database.prototype.run = normalizeMethod(function(statement, params) {
-    statement.run.apply(statement, params).finalize();
-    return this;
+    return statement.run(...params)
+        .then((result) => statement.finalize()
+            .then(() => result));
 });
 
-// Database#get(sql, [bind1, bind2, ...], [callback])
+// Database#get(sql, [bind1, bind2, ...])
 Database.prototype.get = normalizeMethod(function(statement, params) {
-    statement.get.apply(statement, params).finalize();
-    return this;
+    return statement.get(...params)
+        .then((result) => statement.finalize()
+            .then(() => result));
 });
 
-// Database#all(sql, [bind1, bind2, ...], [callback])
+// Database#all(sql, [bind1, bind2, ...])
 Database.prototype.all = normalizeMethod(function(statement, params) {
-    statement.all.apply(statement, params).finalize();
-    return this;
+    return statement.all(...params)
+        .then((result) => statement.finalize()
+            .then(() => result));
 });
 
-// Database#each(sql, [bind1, bind2, ...], [callback], [complete])
-Database.prototype.each = normalizeMethod(function(statement, params) {
-    statement.each.apply(statement, params).finalize();
-    return this;
+// Database#each(sql, [bind1, bind2, ...], [complete])
+Database.prototype.each = normalizeMethod(async function*(statement, params) {
+    try {
+        for await (const row of statement.each(...params)) {
+            yield row;
+        }
+    } finally {
+        await statement.finalize();
+    } 
 });
 
 Database.prototype.map = normalizeMethod(function(statement, params) {
-    statement.map.apply(statement, params).finalize();
-    return this;
+    return statement.map(...params)
+        .then((result) => statement.finalize()
+            .then(() => result));
 });
 
-// Database#backup(filename, [callback])
-// Database#backup(filename, destName, sourceName, filenameIsDest, [callback])
-Database.prototype.backup = function() {
+Backup.create = async function(...args) {
+    const backup = new Backup(...args);
+    return backup.initialize();
+};
+
+// Database#backup(filename)
+// Database#backup(filename, destName, sourceName, filenameIsDest)
+Database.prototype.backup = async function(...args) {
     let backup;
-    if (arguments.length <= 2) {
+    if (args.length <= 2) {
         // By default, we write the main database out to the main database of the named file.
         // This is the most likely use of the backup api.
-        backup = new Backup(this, arguments[0], 'main', 'main', true, arguments[1]);
+        backup = await Backup.create(this, arguments[0], 'main', 'main', true, arguments[1]);
     } else {
         // Otherwise, give the user full control over the sqlite3_backup_init arguments.
-        backup = new Backup(this, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
+        backup = await Backup.create(this, arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
     }
     // Per the sqlite docs, exclude the following errors as non-fatal by default.
     backup.retryErrors = [sqlite3.BUSY, sqlite3.LOCKED];
     return backup;
 };
 
-Statement.prototype.map = function() {
-    const params = Array.prototype.slice.call(arguments);
-    const callback = params.pop();
-    params.push(function(err, rows) {
-        if (err) return callback(err);
-        const result = {};
-        if (rows.length) {
-            const keys = Object.keys(rows[0]);
-            const key = keys[0];
-            if (keys.length > 2) {
-                // Value is an object
-                for (let i = 0; i < rows.length; i++) {
-                    result[rows[i][key]] = rows[i];
-                }
-            } else {
-                const value = keys[1];
-                // Value is a plain value
-                for (let i = 0; i < rows.length; i++) {
-                    result[rows[i][key]] = rows[i][value];
-                }
+Statement.create = async function(database, sql) {
+    const statement = new Statement(database, sql);
+    return statement.prepare();
+};
+
+Statement.prototype.map = async function(...args) {
+    const rows = await this.all(...args);
+    const result = {};
+    if (rows.length) {
+        const keys = Object.keys(rows[0]);
+        const key = keys[0];
+        if (keys.length > 2) {
+            // Value is an object
+            for (let i = 0; i < rows.length; i++) {
+                result[rows[i][key]] = rows[i];
+            }
+        } else {
+            const value = keys[1];
+            // Value is a plain value
+            for (let i = 0; i < rows.length; i++) {
+                result[rows[i][key]] = rows[i][value];
             }
         }
-        callback(err, result);
-    });
-    return this.all.apply(this, params);
+    }
+    
+    return result;
 };
 
 let isVerbose = false;
diff --git a/lib/trace.js b/lib/trace.js
index 1d84cb01..b6895dc2 100644
--- a/lib/trace.js
+++ b/lib/trace.js
@@ -1,31 +1,23 @@
 // Inspired by https://github.com/tlrobinson/long-stack-traces
 const util = require('util');
 
-function extendTrace(object, property, pos) {
+function extendTrace(object, property) {
     const old = object[property];
-    object[property] = function() {
-        const error = new Error();
-        const name = object.constructor.name + '#' + property + '(' +
-            Array.prototype.slice.call(arguments).map(function(el) {
-                return util.inspect(el, false, 0);
-            }).join(', ') + ')';
-
-        if (typeof pos === 'undefined') pos = -1;
-        if (pos < 0) pos += arguments.length;
-        const cb = arguments[pos];
-        if (typeof arguments[pos] === 'function') {
-            arguments[pos] = function replacement() {
-                const err = arguments[0];
-                if (err && err.stack && !err.__augmented) {
-                    err.stack = filter(err).join('\n');
-                    err.stack += '\n--> in ' + name;
-                    err.stack += '\n' + filter(error).slice(1).join('\n');
-                    err.__augmented = true;
-                }
-                return cb.apply(this, arguments);
-            };
-        }
-        return old.apply(this, arguments);
+    object[property] = function(...args) {
+        return old.apply(this, args).catch((err) => {
+            const error = new Error();
+            const name = object.constructor.name + '#' + property + '(' +
+                        Array.prototype.slice.call(arguments).map(function(el) {
+                            return util.inspect(el, false, 0);
+                        }).join(', ') + ')';
+            if (err && err.stack && !err.__augmented) {
+                err.stack = filter(err).join('\n');
+                err.stack += '\n--> in ' + name;
+                err.stack += '\n' + filter(error).slice(1).join('\n');
+                err.__augmented = true;
+            }
+            throw err;
+        });
     };
 }
 exports.extendTrace = extendTrace;
diff --git a/package.json b/package.json
index ab413ff4..59c780c6 100644
--- a/package.json
+++ b/package.json
@@ -68,7 +68,8 @@
   "scripts": {
     "install": "prebuild-install -r napi || node-gyp rebuild",
     "prebuild": "prebuild --runtime napi --all --verbose",
-    "rebuild": "node-gyp rebuild",
+    "rebuild": "node-gyp -j $(nproc) rebuild",
+    "rebuild:dev": "node-gyp -j $(nproc) rebuild --debug",
     "upload": "prebuild --verbose --prerelease",
     "test": "node test/support/createdb.js && mocha -R spec --timeout 480000"
   },
diff --git a/src/backup.cc b/src/backup.cc
index 0f971f5e..7a316bd0 100644
--- a/src/backup.cc
+++ b/src/backup.cc
@@ -13,6 +13,7 @@ Napi::Object Backup::Init(Napi::Env env, Napi::Object exports) {
     auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);
 
     auto t = DefineClass(env, "Backup", {
+        InstanceMethod("initialize", &Backup::Initialize, napi_default_method),
         InstanceMethod("step", &Backup::Step, napi_default_method),
         InstanceMethod("finish", &Backup::Finish, napi_default_method),
         InstanceAccessor("idle", &Backup::IdleGetter, nullptr),
@@ -62,16 +63,7 @@ template <class T> void Backup::Error(T* baton) {
     assert(backup->status != 0);
     EXCEPTION(Napi::String::New(env, backup->message), backup->status, exception);
 
-    Napi::Function cb = baton->callback.Value();
-
-    if (!cb.IsEmpty() && cb.IsFunction()) {
-        Napi::Value argv[] = { exception };
-        TRY_CATCH_CALL(backup->Value(), cb, 1, argv);
-    }
-    else {
-        Napi::Value argv[] = { Napi::String::New(env, "error"), exception };
-        EMIT_EVENT(backup->Value(), 2, argv);
-    }
+    baton->deferred.Reject(exception);
 }
 
 void Backup::CleanQueue() {
@@ -83,7 +75,6 @@ void Backup::CleanQueue() {
         // Fire error for all remaining items in the queue.
         EXCEPTION(Napi::String::New(env, "Backup is already finished"), SQLITE_MISUSE, exception);
         Napi::Value argv[] = { exception };
-        bool called = false;
 
         // Clear out the queue so that this object can get GC'ed.
         while (!queue.empty()) {
@@ -91,20 +82,7 @@ void Backup::CleanQueue() {
             queue.pop();
 
             std::unique_ptr<Baton> baton(call->baton);
-            Napi::Function cb = baton->callback.Value();
-
-            if (inited && !cb.IsEmpty() &&
-                cb.IsFunction()) {
-                TRY_CATCH_CALL(Value(), cb, 1, argv);
-                called = true;
-            }
-        }
-
-        // When we couldn't call a callback function, emit an error on the
-        // Backup object.
-        if (!called) {
-            Napi::Value info[] = { Napi::String::New(env, "error"), exception };
-            EMIT_EVENT(Value(), 2, info);
+            baton->deferred.Reject(exception);
         }
     }
     else while (!queue.empty()) {
@@ -161,18 +139,29 @@ Backup::Backup(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Backup>(info)
     auto destName = info[3].As<Napi::String>();
     auto filenameIsDest = info[4].As<Napi::Boolean>();
 
+    this->filename = filename.Utf8Value();
+    this->sourceName = sourceName.Utf8Value();
+    this->destName = destName.Utf8Value();
+    this->filenameIsDest = filenameIsDest.Value();
+
     info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("filename", filename));
     info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("sourceName", sourceName));
     info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("destName", destName));
     info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("filenameIsDest", filenameIsDest));
+}
 
-    auto* baton = new InitializeBaton(this->db, info[5].As<Napi::Function>(), this);
-    baton->filename = filename.Utf8Value();
-    baton->sourceName = sourceName.Utf8Value();
-    baton->destName = destName.Utf8Value();
-    baton->filenameIsDest = filenameIsDest.Value();
+Napi::Value Backup::Initialize(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    auto deferred = Napi::Promise::Deferred::New(env);
+    auto* baton = new InitializeBaton(this->db, deferred, this);
+
+    baton->filename = filename;
+    baton->sourceName = sourceName;
+    baton->destName = destName;
+    baton->filenameIsDest = filenameIsDest;
 
     this->db->Schedule(Work_BeginInitialize, baton);
+    return deferred.Promise();
 }
 
 void Backup::Work_BeginInitialize(Database::Baton* baton) {
@@ -224,13 +213,13 @@ void Backup::Work_AfterInitialize(napi_env e, napi_status status, void* data) {
     }
     else {
         backup->inited = true;
-        Napi::Function cb = baton->callback.Value();
-        if (!cb.IsEmpty() && cb.IsFunction()) {
-            Napi::Value argv[] = { env.Null() };
-            TRY_CATCH_CALL(backup->Value(), cb, 1, argv);
-        }
     }
+
     BACKUP_END();
+
+    if (backup->inited) {
+        baton->deferred.Resolve(baton->backup->Value());
+    }
 }
 
 Napi::Value Backup::Step(const Napi::CallbackInfo& info) {
@@ -238,12 +227,11 @@ Napi::Value Backup::Step(const Napi::CallbackInfo& info) {
     auto env = backup->Env();
 
     REQUIRE_ARGUMENT_INTEGER(0, pages);
-    OPTIONAL_ARGUMENT_FUNCTION(1, callback);
 
-    auto* baton = new StepBaton(backup, callback, pages);
+    auto* baton = new StepBaton(backup, pages);
     backup->GetRetryErrors(baton->retryErrorsSet);
     backup->Schedule(Work_BeginStep, baton);
-    return info.This();
+    return baton->deferred.Promise();
 }
 
 void Backup::Work_BeginStep(Baton* baton) {
@@ -291,12 +279,12 @@ void Backup::Work_AfterStep(napi_env e, napi_status status, void* data) {
         Error(baton.get());
     }
     else {
-        // Fire callbacks.
-        Napi::Function cb = baton->callback.Value();
-        if (!cb.IsEmpty() && cb.IsFunction()) {
-            Napi::Value argv[] = { env.Null(), Napi::Boolean::New(env, backup->status == SQLITE_DONE) };
-            TRY_CATCH_CALL(backup->Value(), cb, 2, argv);
-        }
+        baton->deferred.Resolve(
+            Napi::Boolean::New(
+                env,
+                backup->status == SQLITE_DONE
+            )
+        );
     }
 
     BACKUP_END();
@@ -306,11 +294,9 @@ Napi::Value Backup::Finish(const Napi::CallbackInfo& info) {
     auto* backup = this;
     auto env = backup->Env();
 
-    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
-
-    auto* baton = new Baton(backup, callback);
+    auto* baton = new Baton(backup);
     backup->Schedule(Work_BeginFinish, baton);
-    return info.This();
+    return baton->deferred.Promise();
 }
 
 void Backup::Work_BeginFinish(Baton* baton) {
@@ -331,13 +317,8 @@ void Backup::Work_AfterFinish(napi_env e, napi_status status, void* data) {
 
     backup->FinishAll();
 
-    // Fire callback in case there was one.
-    Napi::Function cb = baton->callback.Value();
-    if (!cb.IsEmpty() && cb.IsFunction()) {
-        TRY_CATCH_CALL(backup->Value(), cb, 0, NULL);
-    }
-
     BACKUP_END();
+    baton->deferred.Resolve(backup->Value());
 }
 
 void Backup::FinishAll() {
diff --git a/src/backup.h b/src/backup.h
index b894aca1..a150b7fc 100644
--- a/src/backup.h
+++ b/src/backup.h
@@ -98,16 +98,16 @@ class Backup : public Napi::ObjectWrap<Backup> {
     struct Baton {
         napi_async_work request = NULL;
         Backup* backup;
-        Napi::FunctionReference callback;
+        Napi::Promise::Deferred deferred;
 
-        Baton(Backup* backup_, Napi::Function cb_) : backup(backup_) {
+        Baton(Backup* backup_) :
+                backup(backup_),
+                deferred(Napi::Promise::Deferred::New(backup_->Env())) {
             backup->Ref();
-            callback.Reset(cb_, 1);
         }
         virtual ~Baton() {
             if (request) napi_delete_async_work(backup->Env(), request);
             backup->Unref();
-            callback.Reset();
         }
     };
 
@@ -117,8 +117,8 @@ class Backup : public Napi::ObjectWrap<Backup> {
         std::string sourceName;
         std::string destName;
         bool filenameIsDest;
-        InitializeBaton(Database* db_, Napi::Function cb_, Backup* backup_) :
-            Baton(db_, cb_), backup(backup_), filenameIsDest(true) {
+        InitializeBaton(Database* db_, Napi::Promise::Deferred deferred_, Backup* backup_) :
+            Baton(db_, deferred_), backup(backup_), filenameIsDest(true) {
             backup->Ref();
         }
         virtual ~InitializeBaton() override {
@@ -133,8 +133,8 @@ class Backup : public Napi::ObjectWrap<Backup> {
     struct StepBaton : Baton {
         int pages;
         std::set<int> retryErrorsSet;
-        StepBaton(Backup* backup_, Napi::Function cb_, int pages_) :
-            Baton(backup_, cb_), pages(pages_) {}
+        StepBaton(Backup* backup_, int pages_) :
+            Baton(backup_), pages(pages_) {}
         virtual ~StepBaton() override = default;
     };
 
@@ -170,6 +170,7 @@ class Backup : public Napi::ObjectWrap<Backup> {
     void RetryErrorSetter(const Napi::CallbackInfo& info, const Napi::Value& value);
 
 protected:
+    Napi::Value Initialize(const Napi::CallbackInfo& info);
     static void Work_BeginInitialize(Database::Baton* baton);
     static void Work_Initialize(napi_env env, void* data);
     static void Work_AfterInitialize(napi_env env, napi_status status, void* data);
@@ -189,6 +190,11 @@ class Backup : public Napi::ObjectWrap<Backup> {
     sqlite3* _otherDb = NULL;
     sqlite3* _destDb = NULL;
 
+    std::string filename;
+    std::string sourceName;
+    std::string destName;
+    bool filenameIsDest;
+
     bool inited = false;
     bool locked = true;
     bool completed = false;
diff --git a/src/database.cc b/src/database.cc
index d495ce98..10016cf7 100644
--- a/src/database.cc
+++ b/src/database.cc
@@ -17,6 +17,7 @@ Napi::Object Database::Init(Napi::Env env, Napi::Object exports) {
     auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable); 
 
     auto t = DefineClass(env, "Database", {
+        InstanceMethod("connect", &Database::Connect, napi_default_method),
         InstanceMethod("close", &Database::Close, napi_default_method),
         InstanceMethod("exec", &Database::Exec, napi_default_method),
         InstanceMethod("wait", &Database::Wait, napi_default_method),
@@ -48,25 +49,14 @@ void Database::Process() {
     if (!open && locked && !queue.empty()) {
         EXCEPTION(Napi::String::New(env, "Database handle is closed"), SQLITE_MISUSE, exception);
         Napi::Value argv[] = { exception };
-        bool called = false;
 
         // Call all callbacks with the error object.
         while (!queue.empty()) {
             auto call = std::unique_ptr<Call>(queue.front());
             queue.pop();
-            auto baton = std::unique_ptr<Baton>(call->baton);
-            Napi::Function cb = baton->callback.Value();
-            if (IS_FUNCTION(cb)) {
-                TRY_CATCH_CALL(this->Value(), cb, 1, argv);
-                called = true;
-            }
-        }
 
-        // When we couldn't call a callback function, emit an error on the
-        // Database object.
-        if (!called) {
-            Napi::Value info[] = { Napi::String::New(env, "error"), exception };
-            EMIT_EVENT(Value(), 2, info);
+            auto baton = std::unique_ptr<Baton>(call->baton);
+            baton->deferred.Reject(exception);
         }
         return;
     }
@@ -93,18 +83,11 @@ void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) {
 
     if (!open && locked) {
         EXCEPTION(Napi::String::New(env, "Database is closed"), SQLITE_MISUSE, exception);
-        Napi::Function cb = baton->callback.Value();
+        auto deferred = baton->deferred;
         // We don't call the actual callback, so we have to make sure that
         // the baton gets destroyed.
-        delete baton;
-        if (IS_FUNCTION(cb)) {
-            Napi::Value argv[] = { exception };
-            TRY_CATCH_CALL(Value(), cb, 1, argv);
-        }
-        else {
-            Napi::Value argv[] = { Napi::String::New(env, "error"), exception };
-            EMIT_EVENT(Value(), 2, argv);
-        }
+        // delete baton;
+        deferred.Reject(exception);
         return;
     }
 
@@ -124,29 +107,25 @@ Database::Database(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Database>(
         Napi::TypeError::New(env, "String expected").ThrowAsJavaScriptException();
         return;
     }
-    auto filename = info[0].As<Napi::String>().Utf8Value();
-
-    unsigned int pos = 1;
+    this->filename = info[0].As<Napi::String>().Utf8Value();
 
-    int mode;
-    if (info.Length() >= pos && info[pos].IsNumber() && OtherIsInt(info[pos].As<Napi::Number>())) {
-        mode = info[pos++].As<Napi::Number>().Int32Value();
+    if (info.Length() >= 1 && info[1].IsNumber() && OtherIsInt(info[1].As<Napi::Number>())) {
+        this->mode = info[1].As<Napi::Number>().Int32Value();
     }
     else {
-        mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
-    }
-
-    Napi::Function callback;
-    if (info.Length() >= pos && info[pos].IsFunction()) {
-        callback = info[pos++].As<Napi::Function>();
+        this->mode = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX;
     }
 
     info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("filename", info[0].As<Napi::String>(), napi_default));
     info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("mode", Napi::Number::New(env, mode), napi_default));
+}
 
-    // Start opening the database.
-    auto* baton = new OpenBaton(this, callback, filename.c_str(), mode);
+Napi::Value Database::Connect(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    auto deferred = Napi::Promise::Deferred::New(env);
+    auto* baton = new OpenBaton(this, deferred, filename.c_str(), mode);
     Work_BeginOpen(baton);
+    return deferred.Promise();
 }
 
 void Database::Work_BeginOpen(Baton* baton) {
@@ -187,21 +166,11 @@ void Database::Work_AfterOpen(napi_env e, napi_status status, void* data) {
     Napi::Value argv[1];
     if (baton->status != SQLITE_OK) {
         EXCEPTION(Napi::String::New(env, baton->message.c_str()), baton->status, exception);
-        argv[0] = exception;
+        baton->deferred.Reject(exception);
+        return;
     }
     else {
         db->open = true;
-        argv[0] = env.Null();
-    }
-
-    Napi::Function cb = baton->callback.Value();
-
-    if (IS_FUNCTION(cb)) {
-        TRY_CATCH_CALL(db->Value(), cb, 1, argv);
-    }
-    else if (!db->open) {
-        Napi::Value info[] = { Napi::String::New(env, "error"), argv[0] };
-        EMIT_EVENT(db->Value(), 2, info);
     }
 
     if (db->open) {
@@ -209,6 +178,7 @@ void Database::Work_AfterOpen(napi_env e, napi_status status, void* data) {
         EMIT_EVENT(db->Value(), 1, info);
         db->Process();
     }
+    baton->deferred.Resolve(db->Value());
 }
 
 Napi::Value Database::Open(const Napi::CallbackInfo& info) {
@@ -220,12 +190,12 @@ Napi::Value Database::Open(const Napi::CallbackInfo& info) {
 Napi::Value Database::Close(const Napi::CallbackInfo& info) {
     auto env = info.Env();
     auto* db = this;
-    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
 
-   auto* baton = new Baton(db, callback);
+    auto deferred = Napi::Promise::Deferred::New(env);
+    auto* baton = new Baton(db, deferred);
     db->Schedule(Work_BeginClose, baton, true);
 
-    return info.This();
+    return deferred.Promise();
 }
 
 void Database::Work_BeginClose(Baton* baton) {
@@ -270,24 +240,11 @@ void Database::Work_AfterClose(napi_env e, napi_status status, void* data) {
     Napi::Value argv[1];
     if (baton->status != SQLITE_OK) {
         EXCEPTION(Napi::String::New(env, baton->message.c_str()), baton->status, exception);
-        argv[0] = exception;
+        baton->deferred.Reject(exception);
+        return;
     }
     else {
         db->open = false;
-        // Leave db->locked to indicate that this db object has reached
-        // the end of its life.
-        argv[0] = env.Null();
-    }
-
-    Napi::Function cb = baton->callback.Value();
-
-    // Fire callbacks.
-    if (IS_FUNCTION(cb)) {
-        TRY_CATCH_CALL(db->Value(), cb, 1, argv);
-    }
-    else if (db->open) {
-        Napi::Value info[] = { Napi::String::New(env, "error"), argv[0] };
-        EMIT_EVENT(db->Value(), 2, info);
     }
 
     if (!db->open) {
@@ -295,42 +252,92 @@ void Database::Work_AfterClose(napi_env e, napi_status status, void* data) {
         EMIT_EVENT(db->Value(), 1, info);
         db->Process();
     }
+    baton->deferred.Resolve(env.Undefined());
 }
 
+
 Napi::Value Database::Serialize(const Napi::CallbackInfo& info) {
     auto env = this->Env();
     auto* db = this;
+
     OPTIONAL_ARGUMENT_FUNCTION(0, callback);
 
+    auto deferred = Napi::Promise::Deferred::New(env);
     bool before = db->serialize;
     db->serialize = true;
 
     if (!callback.IsEmpty() && callback.IsFunction()) {
-        TRY_CATCH_CALL(info.This(), callback, 0, NULL, info.This());
-        db->serialize = before;
-    }
-
-    db->Process();
+        auto result = callback.Call(Napi::Value(info.This()), {});
+        if (!result.IsPromise()) {
+            return deferred.Promise();
+        }
 
-    return info.This();
+        auto promise = result.As<Napi::Promise>();
+        auto thenFn = promise.Get("then").As<Napi::Function>();
+        auto catchFn = promise.Get("catch").As<Napi::Function>();
+        auto joinPromise = [db, deferred, before](const Napi::CallbackInfo& info) {
+            auto result = info[0];
+            db->serialize = before;
+            db->Process();
+            deferred.Resolve(result);
+        };
+        auto joinPromiseCatch = [db, deferred, before](const Napi::CallbackInfo& info) {
+            auto error = info[0];
+            db->serialize = before;
+            db->Process();
+            deferred.Reject(error);
+        };
+        auto thenCallback = Napi::Function::New(env, joinPromise, "native_joinPromise");
+        auto catchCallback = Napi::Function::New(env, joinPromiseCatch, "native_joinPromiseCatche");
+        thenFn.Call(promise, {thenCallback});
+        catchFn.Call(promise, {catchCallback});
+    } else {
+        deferred.Resolve(env.Undefined());
+    }
+
+    return deferred.Promise();
 }
 
 Napi::Value Database::Parallelize(const Napi::CallbackInfo& info) {
     auto env = this->Env();
     auto* db = this;
+
     OPTIONAL_ARGUMENT_FUNCTION(0, callback);
 
-    auto before = db->serialize;
+    auto deferred = Napi::Promise::Deferred::New(env);
+    bool before = db->serialize;
     db->serialize = false;
 
     if (!callback.IsEmpty() && callback.IsFunction()) {
-        TRY_CATCH_CALL(info.This(), callback, 0, NULL, info.This());
-        db->serialize = before;
-    }
-
-    db->Process();
+        auto result = callback.Call(Napi::Value(info.This()), {});
+        if (!result.IsPromise()) {
+            return deferred.Promise();
+        }
 
-    return info.This();
+        auto promise = result.As<Napi::Promise>();
+        auto thenFn = promise.Get("then").As<Napi::Function>();
+        auto catchFn = promise.Get("catch").As<Napi::Function>();
+        auto joinPromise = [db, deferred, before](const Napi::CallbackInfo& info) {
+            auto result = info[0];
+            db->serialize = before;
+            db->Process();
+            deferred.Resolve(result);
+        };
+        auto joinPromiseCatch = [db, deferred, before](const Napi::CallbackInfo& info) {
+            auto error = info[0];
+            db->serialize = before;
+            db->Process();
+            deferred.Reject(error);
+        };
+        auto thenCallback = Napi::Function::New(env, joinPromise, "native_joinPromise");
+        auto catchCallback = Napi::Function::New(env, joinPromiseCatch, "native_joinPromiseCatche");
+        thenFn.Call(promise, {thenCallback});
+        catchFn.Call(promise, {catchCallback});
+    } else {
+        deferred.Resolve(env.Undefined());
+    }
+
+    return deferred.Promise();
 }
 
 Napi::Value Database::Configure(const Napi::CallbackInfo& info) {
@@ -339,13 +346,13 @@ Napi::Value Database::Configure(const Napi::CallbackInfo& info) {
 
     REQUIRE_ARGUMENTS(2);
 
-    Napi::Function handle;
+    auto deferred = Napi::Promise::Deferred::New(env);
     if (info[0].StrictEquals( Napi::String::New(env, "trace"))) {    
-       auto* baton = new Baton(db, handle);
+        auto* baton = new Baton(db, deferred);
         db->Schedule(RegisterTraceCallback, baton);
     }
     else if (info[0].StrictEquals( Napi::String::New(env, "profile"))) {
-       auto* baton = new Baton(db, handle);
+        auto* baton = new Baton(db, deferred);
         db->Schedule(RegisterProfileCallback, baton);
     }
     else if (info[0].StrictEquals( Napi::String::New(env, "busyTimeout"))) {
@@ -353,7 +360,7 @@ Napi::Value Database::Configure(const Napi::CallbackInfo& info) {
             Napi::TypeError::New(env, "Value must be an integer").ThrowAsJavaScriptException();
             return env.Null();
         }
-       auto* baton = new Baton(db, handle);
+        auto* baton = new Baton(db, deferred);
         baton->status = info[1].As<Napi::Number>().Int32Value();
         db->Schedule(SetBusyTimeout, baton);
     }
@@ -369,11 +376,11 @@ Napi::Value Database::Configure(const Napi::CallbackInfo& info) {
         }
         int id = info[1].As<Napi::Number>().Int32Value();
         int value = info[2].As<Napi::Number>().Int32Value();
-        Baton* baton = new LimitBaton(db, handle, id, value);
+        Baton* baton = new LimitBaton(db, deferred, id, value);
         db->Schedule(SetLimit, baton);
     }
     else if (info[0].StrictEquals(Napi::String::New(env, "change"))) {
-       auto* baton = new Baton(db, handle);
+        auto* baton = new Baton(db, deferred);
         db->Schedule(RegisterUpdateCallback, baton);
     }
     else {
@@ -561,10 +568,11 @@ Napi::Value Database::Exec(const Napi::CallbackInfo& info) {
     REQUIRE_ARGUMENT_STRING(0, sql);
     OPTIONAL_ARGUMENT_FUNCTION(1, callback);
 
-    Baton* baton = new ExecBaton(db, callback, sql.c_str());
+    auto deferred = Napi::Promise::Deferred::New(env);
+    Baton* baton = new ExecBaton(db, deferred, sql.c_str());
     db->Schedule(Work_BeginExec, baton, true);
 
-    return info.This();
+    return deferred.Promise();
 }
 
 void Database::Work_BeginExec(Baton* baton) {
@@ -605,23 +613,12 @@ void Database::Work_AfterExec(napi_env e, napi_status status, void* data) {
     auto env = db->Env();
     Napi::HandleScope scope(env);
 
-    Napi::Function cb = baton->callback.Value();
-
     if (baton->status != SQLITE_OK) {
         EXCEPTION(Napi::String::New(env, baton->message.c_str()), baton->status, exception);
-
-        if (IS_FUNCTION(cb)) {
-            Napi::Value argv[] = { exception };
-            TRY_CATCH_CALL(db->Value(), cb, 1, argv);
-        }
-        else {
-            Napi::Value info[] = { Napi::String::New(env, "error"), exception };
-            EMIT_EVENT(db->Value(), 2, info);
-        }
+        baton->deferred.Reject(exception);
     }
-    else if (IS_FUNCTION(cb)) {
-        Napi::Value argv[] = { env.Null() };
-        TRY_CATCH_CALL(db->Value(), cb, 1, argv);
+    else {
+        baton->deferred.Resolve(db->Value());
     }
 
     db->Process();
@@ -631,12 +628,11 @@ Napi::Value Database::Wait(const Napi::CallbackInfo& info) {
     auto env = info.Env();
     auto* db = this;
 
-    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
-
-   auto* baton = new Baton(db, callback);
+    auto deferred = Napi::Promise::Deferred::New(env);
+    auto* baton = new Baton(db, deferred);
     db->Schedule(Work_Wait, baton, true);
 
-    return info.This();
+    return deferred.Promise();
 }
 
 void Database::Work_Wait(Baton* b) {
@@ -650,13 +646,9 @@ void Database::Work_Wait(Baton* b) {
     assert(baton->db->_handle);
     assert(baton->db->pending == 0);
 
-    Napi::Function cb = baton->callback.Value();
-    if (IS_FUNCTION(cb)) {
-        Napi::Value argv[] = { env.Null() };
-        TRY_CATCH_CALL(baton->db->Value(), cb, 1, argv);
-    }
-
     baton->db->Process();
+
+    baton->deferred.Resolve(baton->db->Value());
 }
 
 Napi::Value Database::LoadExtension(const Napi::CallbackInfo& info) {
@@ -664,12 +656,12 @@ Napi::Value Database::LoadExtension(const Napi::CallbackInfo& info) {
     auto* db = this;
 
     REQUIRE_ARGUMENT_STRING(0, filename);
-    OPTIONAL_ARGUMENT_FUNCTION(1, callback);
 
-    Baton* baton = new LoadExtensionBaton(db, callback, filename.c_str());
+    auto deferred = Napi::Promise::Deferred::New(env);
+    Baton* baton = new LoadExtensionBaton(db, deferred, filename.c_str());
     db->Schedule(Work_BeginLoadExtension, baton, true);
 
-    return info.This();
+    return deferred.Promise();
 }
 
 void Database::Work_BeginLoadExtension(Baton* baton) {
@@ -713,26 +705,16 @@ void Database::Work_AfterLoadExtension(napi_env e, napi_status status, void* dat
     auto env = db->Env();
     Napi::HandleScope scope(env);
 
-    Napi::Function cb = baton->callback.Value();
-
     if (baton->status != SQLITE_OK) {
         EXCEPTION(Napi::String::New(env, baton->message.c_str()), baton->status, exception);
 
-        if (IS_FUNCTION(cb)) {
-            Napi::Value argv[] = { exception };
-            TRY_CATCH_CALL(db->Value(), cb, 1, argv);
-        }
-        else {
-            Napi::Value info[] = { Napi::String::New(env, "error"), exception };
-            EMIT_EVENT(db->Value(), 2, info);
-        }
-    }
-    else if (IS_FUNCTION(cb)) {
-        Napi::Value argv[] = { env.Null() };
-        TRY_CATCH_CALL(db->Value(), cb, 1, argv);
+        baton->deferred.Reject(exception);
+        return;
     }
 
     db->Process();
+
+    baton->deferred.Resolve(db->Value());
 }
 
 void Database::RemoveCallbacks() {
diff --git a/src/database.h b/src/database.h
index 8ffd300d..4464263b 100644
--- a/src/database.h
+++ b/src/database.h
@@ -43,51 +43,47 @@ class Database : public Napi::ObjectWrap<Database> {
     struct Baton {
         napi_async_work request = NULL;
         Database* db;
-        Napi::FunctionReference callback;
+        Napi::Promise::Deferred deferred;
         int status;
         std::string message;
 
-        Baton(Database* db_, Napi::Function cb_) :
-                db(db_), status(SQLITE_OK) {
+        Baton(Database* db_, Napi::Promise::Deferred deferred_) :
+                db(db_), deferred(deferred_), status(SQLITE_OK) {
             db->Ref();
-            if (!cb_.IsUndefined() && cb_.IsFunction()) {
-                callback.Reset(cb_, 1);
-            }
         }
         virtual ~Baton() {
             if (request) napi_delete_async_work(db->Env(), request);
             db->Unref();
-            callback.Reset();
         }
     };
 
     struct OpenBaton : Baton {
         std::string filename;
         int mode;
-        OpenBaton(Database* db_, Napi::Function cb_, const char* filename_, int mode_) :
-            Baton(db_, cb_), filename(filename_), mode(mode_) {}
+        OpenBaton(Database* db_, Napi::Promise::Deferred deferred_, const char* filename_, int mode_) :
+            Baton(db_, deferred_), filename(filename_), mode(mode_) {}
         virtual ~OpenBaton() override = default;
     };
 
     struct ExecBaton : Baton {
         std::string sql;
-        ExecBaton(Database* db_, Napi::Function cb_, const char* sql_) :
-            Baton(db_, cb_), sql(sql_) {}
+        ExecBaton(Database* db_, Napi::Promise::Deferred deferred_, const char* sql_) :
+            Baton(db_, deferred_), sql(sql_) {}
         virtual ~ExecBaton() override = default;
     };
 
     struct LoadExtensionBaton : Baton {
         std::string filename;
-        LoadExtensionBaton(Database* db_, Napi::Function cb_, const char* filename_) :
-            Baton(db_, cb_), filename(filename_) {}
+        LoadExtensionBaton(Database* db_, Napi::Promise::Deferred deferred_, const char* filename_) :
+            Baton(db_, deferred_), filename(filename_) {}
         virtual ~LoadExtensionBaton() override = default;
     };
 
     struct LimitBaton : Baton {
         int id;
         int value;
-        LimitBaton(Database* db_, Napi::Function cb_, int id_, int value_) :
-            Baton(db_, cb_), id(id_), value(value_) {}
+        LimitBaton(Database* db_, Napi::Promise::Deferred deferred_, int id_, int value_) :
+            Baton(db_, deferred_), id(id_), value(value_) {}
         virtual ~LimitBaton() override = default;
     };
 
@@ -138,6 +134,7 @@ class Database : public Napi::ObjectWrap<Database> {
     WORK_DEFINITION(Close);
     WORK_DEFINITION(LoadExtension);
 
+    Napi::Value Connect(const Napi::CallbackInfo& info);
     void Schedule(Work_Callback callback, Baton* baton, bool exclusive = false);
     void Process();
 
@@ -169,6 +166,9 @@ class Database : public Napi::ObjectWrap<Database> {
 protected:
     sqlite3* _handle = NULL;
 
+    std::string filename;
+    int mode;
+
     bool open = false;
     bool closing = false;
     bool locked = false;
diff --git a/src/macros.h b/src/macros.h
index 3bcde83c..ca2cf46a 100644
--- a/src/macros.h
+++ b/src/macros.h
@@ -204,4 +204,4 @@ inline bool OtherIsInt(Napi::Number source) {
     backup->Process();                                                         \
     backup->db->Process();
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/statement.cc b/src/statement.cc
index fc49b90f..136a9c03 100644
--- a/src/statement.cc
+++ b/src/statement.cc
@@ -1,3 +1,5 @@
+#include <iostream>
+#include <string>
 #include <cstring>
 #include <napi.h>
 #include <uv.h>
@@ -15,6 +17,7 @@ Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
     auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);
 
     auto t = DefineClass(env, "Statement", {
+      InstanceMethod("prepare", &Statement::Prepare, napi_default_method),
       InstanceMethod("bind", &Statement::Bind, napi_default_method),
       InstanceMethod("get", &Statement::Get, napi_default_method),
       InstanceMethod("run", &Statement::Run, napi_default_method),
@@ -75,16 +78,7 @@ template <class T> void Statement::Error(T* baton) {
     assert(stmt->status != 0);
     EXCEPTION(Napi::String::New(env, stmt->message.c_str()), stmt->status, exception);
 
-    Napi::Function cb = baton->callback.Value();
-
-    if (IS_FUNCTION(cb)) {
-        Napi::Value argv[] = { exception };
-        TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);
-    }
-    else {
-        Napi::Value argv[] = { Napi::String::New(env, "error"), exception };
-        EMIT_EVENT(stmt->Value(), 2, argv);
-    }
+    baton->deferred.Reject(exception);
 }
 
 // { Database db, String sql, Array params, Function callback }
@@ -100,24 +94,31 @@ Statement::Statement(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Statemen
         Napi::TypeError::New(env, "SQL query expected").ThrowAsJavaScriptException();
         return;
     }
-    else if (length > 2 && !info[2].IsUndefined() && !info[2].IsFunction()) {
-        Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException();
-        return;
-    }
 
     this->db = Napi::ObjectWrap<Database>::Unwrap(info[0].As<Napi::Object>());
     this->db->Ref();
 
     auto sql = info[1].As<Napi::String>();
+    this->sql = sql.Utf8Value();
 
-    info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("sql", sql, napi_default));
-
+    info.This()
+        .As<Napi::Object>()
+        .DefineProperty(
+            Napi::PropertyDescriptor::Value(
+                "sql",
+                sql,
+                napi_default
+            )
+        );
+}
 
+Napi::Value Statement::Prepare(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
     Statement* stmt = this;
-
-    auto* baton = new PrepareBaton(this->db, info[2].As<Napi::Function>(), stmt);
-    baton->sql = std::string(sql.As<Napi::String>().Utf8Value().c_str());
-    this->db->Schedule(Work_BeginPrepare, baton);
+    auto* baton = new PrepareBaton(stmt->db, stmt);
+    baton->sql = sql;
+    stmt->db->Schedule(Work_BeginPrepare, baton);
+    return baton->deferred.Promise();
 }
 
 void Statement::Work_BeginPrepare(Database::Baton* baton) {
@@ -165,45 +166,41 @@ void Statement::Work_AfterPrepare(napi_env e, napi_status status, void* data) {
     }
     else {
         stmt->prepared = true;
-        if (!baton->callback.IsEmpty() && baton->callback.Value().IsFunction()) {
-            Napi::Function cb = baton->callback.Value();
-            Napi::Value argv[] = { env.Null() };
-            TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);
-        }
+        baton->deferred.Resolve(stmt->Value());
     }
 
     STATEMENT_END();
 }
 
-template <class T> std::unique_ptr<Values::Field>
+template <class T> std::shared_ptr<Values::Field>
                    Statement::BindParameter(const Napi::Value source, T pos) {
     if (source.IsString()) {
         std::string val = source.As<Napi::String>().Utf8Value();
-        return std::make_unique<Values::Text>(pos, val.length(), val.c_str());
+        return std::make_shared<Values::Text>(pos, val.length(), val.c_str());
     }
     else if (OtherInstanceOf(source.As<Object>(), "RegExp")) {
         std::string val = source.ToString().Utf8Value();
-        return std::make_unique<Values::Text>(pos, val.length(), val.c_str());
+        return std::make_shared<Values::Text>(pos, val.length(), val.c_str());
     }
     else if (source.IsNumber()) {
         if (OtherIsInt(source.As<Napi::Number>())) {
-            return std::make_unique<Values::Integer>(pos, source.As<Napi::Number>().Int32Value());
+            return std::make_shared<Values::Integer>(pos, source.As<Napi::Number>().Int32Value());
         } else {
-            return std::make_unique<Values::Float>(pos, source.As<Napi::Number>().DoubleValue());
+            return std::make_shared<Values::Float>(pos, source.As<Napi::Number>().DoubleValue());
         }
     }
     else if (source.IsBoolean()) {
-        return std::make_unique<Values::Integer>(pos, source.As<Napi::Boolean>().Value() ? 1 : 0);
+        return std::make_shared<Values::Integer>(pos, source.As<Napi::Boolean>().Value() ? 1 : 0);
     }
     else if (source.IsNull()) {
-        return std::make_unique<Values::Null>(pos);
+        return std::make_shared<Values::Null>(pos);
     }
     else if (source.IsBuffer()) {
         Napi::Buffer<char> buffer = source.As<Napi::Buffer<char>>();
-        return std::make_unique<Values::Blob>(pos, buffer.Length(), buffer.Data());
+        return std::make_shared<Values::Blob>(pos, buffer.Length(), buffer.Data());
     }
     else if (OtherInstanceOf(source.As<Object>(), "Date")) {
-        return std::make_unique<Values::Float>(pos, source.ToNumber().DoubleValue());
+        return std::make_shared<Values::Float>(pos, source.ToNumber().DoubleValue());
     }
     else if (source.IsObject()) {
         auto napiVal = Napi::String::New(source.Env(), "[object Object]");
@@ -213,25 +210,16 @@ template <class T> std::unique_ptr<Values::Field>
         }
 
         std::string val = napiVal.Utf8Value();
-        return std::make_unique<Values::Text>(pos, val.length(), val.c_str());
+        return std::make_shared<Values::Text>(pos, val.length(), val.c_str());
     }
     else {
         return NULL;
     }
 }
 
-template <class T> T* Statement::Bind(const Napi::CallbackInfo& info, int start, int last) {
-    auto env = info.Env();
-    Napi::HandleScope scope(env);
-
-    if (last < 0) last = info.Length();
-    Napi::Function callback;
-    if (last > start && info[last - 1].IsFunction()) {
-        callback = info[last - 1].As<Napi::Function>();
-        last--;
-    }
-
-    auto *baton = new T(this, callback);
+bool Statement::BindParameters(const Napi::CallbackInfo& info, Parameters& parameters) {
+    auto start = 0;
+    auto last = info.Length();
 
     if (start < last) {
         if (info[start].IsArray()) {
@@ -239,7 +227,7 @@ template <class T> T* Statement::Bind(const Napi::CallbackInfo& info, int start,
             int length = array.Length();
             // Note: bind parameters start with 1.
             for (int i = 0, pos = 1; i < length; i++, pos++) {
-                baton->parameters.emplace_back(BindParameter((array).Get(i), i + 1));
+                parameters.emplace_back(BindParameter((array).Get(i), i + 1));
             }
         }
         else if (!info[start].IsObject() || OtherInstanceOf(info[start].As<Object>(), "RegExp") 
@@ -247,7 +235,7 @@ template <class T> T* Statement::Bind(const Napi::CallbackInfo& info, int start,
             // Parameters directly in array.
             // Note: bind parameters start with 1.
             for (int i = start, pos = 1; i < last; i++, pos++) {
-                baton->parameters.emplace_back(BindParameter(info[i], pos));
+                parameters.emplace_back(BindParameter(info[i], pos));
             }
         }
         else if (info[start].IsObject()) {
@@ -259,20 +247,30 @@ template <class T> T* Statement::Bind(const Napi::CallbackInfo& info, int start,
                 Napi::Number num = name.ToNumber();
 
                 if (num.Int32Value() == num.DoubleValue()) {
-                    baton->parameters.emplace_back(
+                    parameters.emplace_back(
                         BindParameter((object).Get(name), num.Int32Value()));
                 }
                 else {
-                    baton->parameters.emplace_back(BindParameter((object).Get(name),
+                    parameters.emplace_back(BindParameter((object).Get(name),
                         name.As<Napi::String>().Utf8Value().c_str()));
                 }
             }
         }
         else {
-            return NULL;
+            return false;
         }
     }
+    return true;
+}
 
+template <class T> T* Statement::Bind(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    
+    // Napi::HandleScope scope(env);
+    auto *baton = new T(this);
+    bool bound = this->BindParameters(info, baton->parameters);
+
+    baton->bound = bound;
     return baton;
 }
 
@@ -334,7 +332,7 @@ Napi::Value Statement::Bind(const Napi::CallbackInfo& info) {
     Statement* stmt = this;
 
     auto baton = stmt->Bind<Baton>(info);
-    if (baton == NULL) {
+    if (!baton->bound) {
         Napi::TypeError::New(env, "Data type is not supported").ThrowAsJavaScriptException();
         return env.Null();
     }
@@ -342,6 +340,7 @@ Napi::Value Statement::Bind(const Napi::CallbackInfo& info) {
         stmt->Schedule(Work_BeginBind, baton);
         return info.This();
     }
+    return baton->deferred.Promise();
 }
 
 void Statement::Work_BeginBind(Baton* baton) {
@@ -369,11 +368,8 @@ void Statement::Work_AfterBind(napi_env e, napi_status status, void* data) {
     }
     else {
         // Fire callbacks.
-        Napi::Function cb = baton->callback.Value();
-        if (IS_FUNCTION(cb)) {
-            Napi::Value argv[] = { env.Null() };
-            TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);
-        }
+        auto deferred = baton->deferred;
+        deferred.Resolve(stmt->Value());
     }
 
     STATEMENT_END();
@@ -386,14 +382,13 @@ Napi::Value Statement::Get(const Napi::CallbackInfo& info) {
     Statement* stmt = this;
 
     Baton* baton = stmt->Bind<RowBaton>(info);
-    if (baton == NULL) {
-        Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();
-        return env.Null();
+    if (!baton->bound) {
+        baton->deferred.Reject(Napi::Error::New(env, "Data type is not supported").Value());
     }
     else {
         stmt->Schedule(Work_BeginGet, baton);
-        return info.This();
     }
+    return baton->deferred.Promise();
 }
 
 void Statement::Work_BeginGet(Baton* baton) {
@@ -435,18 +430,12 @@ void Statement::Work_AfterGet(napi_env e, napi_status status, void* data) {
         Error(baton.get());
     }
     else {
-        // Fire callbacks.
-        Napi::Function cb = baton->callback.Value();
-        if (IS_FUNCTION(cb)) {
-            if (stmt->status == SQLITE_ROW) {
-                // Create the result array from the data we acquired.
-                Napi::Value argv[] = { env.Null(), RowToJS(env, &baton->row) };
-                TRY_CATCH_CALL(stmt->Value(), cb, 2, argv);
-            }
-            else {
-                Napi::Value argv[] = { env.Null() };
-                TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);
-            }
+        auto deferred = baton->deferred;
+        if (stmt->status == SQLITE_ROW) {
+            Napi::Value result = RowToJS(env, &baton->row);
+            deferred.Resolve(result);
+        } else {
+            deferred.Resolve(env.Undefined());
         }
     }
 
@@ -458,14 +447,17 @@ Napi::Value Statement::Run(const Napi::CallbackInfo& info) {
     Statement* stmt = this;
 
     Baton* baton = stmt->Bind<RunBaton>(info);
-    if (baton == NULL) {
-        Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();
-        return env.Null();
+    if (!baton->bound) {
+        baton->deferred.Reject(
+            Napi::Error::New(env, "Data type is not supported").Value()
+        );
     }
     else {
+        auto test = Napi::String::New(env, "test string");
         stmt->Schedule(Work_BeginRun, baton);
-        return info.This();
     }
+
+    return baton->deferred.Promise();
 }
 
 void Statement::Work_BeginRun(Baton* baton) {
@@ -509,15 +501,9 @@ void Statement::Work_AfterRun(napi_env e, napi_status status, void* data) {
         Error(baton.get());
     }
     else {
-        // Fire callbacks.
-        Napi::Function cb = baton->callback.Value();
-        if (IS_FUNCTION(cb)) {
-            (stmt->Value()).Set(Napi::String::New(env, "lastID"), Napi::Number::New(env, baton->inserted_id));
-            (stmt->Value()).Set( Napi::String::New(env, "changes"), Napi::Number::New(env, baton->changes));
-
-            Napi::Value argv[] = { env.Null() };
-            TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);
-        }
+        (stmt->Value()).Set(Napi::String::New(env, "lastID"), Napi::Number::New(env, baton->inserted_id));
+        (stmt->Value()).Set(Napi::String::New(env, "changes"), Napi::Number::New(env, baton->changes));
+        baton->deferred.Resolve(stmt->Value());
     }
 
     STATEMENT_END();
@@ -528,14 +514,13 @@ Napi::Value Statement::All(const Napi::CallbackInfo& info) {
     Statement* stmt = this;
 
     Baton* baton = stmt->Bind<RowsBaton>(info);
-    if (baton == NULL) {
-        Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();
-        return env.Null();
+    if (!baton->bound) {
+        baton->deferred.Reject(Napi::Error::New(env, "Data type is not supported").Value());
     }
     else {
         stmt->Schedule(Work_BeginAll, baton);
-        return info.This();
     }
+    return baton->deferred.Promise();
 }
 
 void Statement::Work_BeginAll(Baton* baton) {
@@ -579,65 +564,86 @@ void Statement::Work_AfterAll(napi_env e, napi_status status, void* data) {
         Error(baton.get());
     }
     else {
-        // Fire callbacks.
-        Napi::Function cb = baton->callback.Value();
-        if (IS_FUNCTION(cb)) {
-            if (baton->rows.size()) {
-                // Create the result array from the data we acquired.
-                Napi::Array result(Napi::Array::New(env, baton->rows.size()));
-                auto it = static_cast<Rows::const_iterator>(baton->rows.begin());
-                decltype(it) end = baton->rows.end();
-                for (int i = 0; it < end; ++it, i++) {
-                    (result).Set(i, RowToJS(env, it->get()));
-                }
-
-                Napi::Value argv[] = { env.Null(), result };
-                TRY_CATCH_CALL(stmt->Value(), cb, 2, argv);
-            }
-            else {
-                // There were no result rows.
-                Napi::Value argv[] = {
-                    env.Null(),
-                    Napi::Array::New(env, 0)
-                };
-                TRY_CATCH_CALL(stmt->Value(), cb, 2, argv);
+        if (baton->rows.size()) {
+            // Create the result array from the data we acquired.
+            Napi::Array result(Napi::Array::New(env, baton->rows.size()));
+            auto it = static_cast<Rows::const_iterator>(baton->rows.begin());
+            decltype(it) end = baton->rows.end();
+            for (int i = 0; it < end; ++it, i++) {
+                (result).Set(i, RowToJS(env, it->get()));
             }
+            baton->deferred.Resolve(result);
+        }
+        else {
+            baton->deferred.Resolve(Napi::Array::New(env, 0));
         }
     }
 
     STATEMENT_END();
 }
 
-Napi::Value Statement::Each(const Napi::CallbackInfo& info) {
-    auto env = info.Env();
+Napi::Value Statement::InitEachIterator(EachBaton* eachBaton) {
     Statement* stmt = this;
+    auto env = stmt->Env();
+    auto iterable = Napi::Object::New(env);
+
+    iterable.Set(Napi::Symbol::WellKnown(env, "asyncIterator"), Napi::Function::New(env, [=](const Napi::CallbackInfo& info) {
+        auto iteratorObject = Napi::Object::New(env);
+
+        stmt->Schedule(Work_BeginEach, eachBaton);
+
+        auto next = Napi::Function::New(env, [=](const Napi::CallbackInfo& info) {
+            auto deferred = std::make_shared<Napi::Promise::Deferred>(Napi::Promise::Deferred::New(env));
+            NODE_SQLITE3_MUTEX_LOCK(&eachBaton->async->mutex)
+            if (!eachBaton->async->data.empty()) {
+                auto row = std::move(eachBaton->async->data.front());
+                eachBaton->async->data.pop_front();
+                auto result = Napi::Object::New(env);
+                result["done"] = Napi::Boolean::New(env, false);
+                result["value"] = RowToJS(env, row.get());
+                deferred.get()->Resolve(result);
+            } else if (eachBaton->async->completed) {
+                if (stmt->status != SQLITE_DONE) {
+                    EXCEPTION(Napi::String::New(env, stmt->message.c_str()), stmt->status, exception);
+                    deferred.get()->Reject(exception);
+                } else {
+                    auto result = Napi::Object::New(env);
+                    result["done"] = Napi::Boolean::New(env, true);
+                    deferred.get()->Resolve(result);
+                }
+            } else {
+                eachBaton->async->deferreds.emplace_back(deferred);
+            }
+            NODE_SQLITE3_MUTEX_UNLOCK(&eachBaton->async->mutex)
+            return deferred->Promise();
+        });
 
-    int last = info.Length();
+        iteratorObject["next"] = next.Get("bind").As<Napi::Function>().Call(next, {iteratorObject});
+        return iteratorObject;
+    }));
 
-    Napi::Function completed;
-    if (last >= 2 && info[last - 1].IsFunction() && info[last - 2].IsFunction()) {
-        completed = info[--last].As<Napi::Function>();
-    }
+    return iterable;
+}
+
+Napi::Value Statement::Each(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    Statement* stmt = this;
 
-    auto baton = stmt->Bind<EachBaton>(info, 0, last);
-    if (baton == NULL) {
+    auto* baton = stmt->Bind<EachBaton>(info);
+    if (!baton->bound) {
         Napi::Error::New(env, "Data type is not supported").ThrowAsJavaScriptException();
-        return env.Null();
-    }
-    else {
-        baton->completed.Reset(completed, 1);
-        stmt->Schedule(Work_BeginEach, baton);
-        return info.This();
+        return env.Undefined();
     }
+
+    return Statement::InitEachIterator(baton);
 }
 
+// TODO: Implement as async generator
 void Statement::Work_BeginEach(Baton* baton) {
     // Only create the Async object when we're actually going into
     // the event loop. This prevents dangling events.
     auto* each_baton = static_cast<EachBaton*>(baton);
     each_baton->async = new Async(each_baton->stmt, reinterpret_cast<uv_async_cb>(AsyncEach));
-    each_baton->async->item_cb.Reset(each_baton->callback.Value(), 1);
-    each_baton->async->completed_cb.Reset(each_baton->completed.Value(), 1);
 
     STATEMENT_BEGIN(Each);
 }
@@ -654,7 +660,8 @@ void Statement::Work_Each(napi_env e, void* data) {
         sqlite3_reset(stmt->_handle);
     }
 
-    if (stmt->Bind(baton->parameters)) {
+    auto bound = stmt->Bind(baton->parameters);
+    if (bound) {
         while (true) {
             sqlite3_mutex_enter(mtx);
             stmt->status = sqlite3_step(stmt->_handle);
@@ -665,7 +672,6 @@ void Statement::Work_Each(napi_env e, void* data) {
                 NODE_SQLITE3_MUTEX_LOCK(&async->mutex)
                 async->data.emplace_back(std::move(row));
                 NODE_SQLITE3_MUTEX_UNLOCK(&async->mutex)
-
                 uv_async_send(&async->watcher);
             }
             else {
@@ -695,54 +701,56 @@ void Statement::AsyncEach(uv_async_t* handle) {
     auto env = async->stmt->Env();
     Napi::HandleScope scope(env);
 
-    while (true) {
-        // Get the contents out of the data cache for us to process in the JS callback.
-        Rows rows;
-        NODE_SQLITE3_MUTEX_LOCK(&async->mutex)
-        rows.swap(async->data);
-        NODE_SQLITE3_MUTEX_UNLOCK(&async->mutex)
-
-        if (rows.empty()) {
-            break;
-        }
-
-        Napi::Function cb = async->item_cb.Value();
-        if (IS_FUNCTION(cb)) {
-            Napi::Value argv[2];
-            argv[0] = env.Null();
-
-            for(auto& row : rows) {
-                argv[1] = RowToJS(env,row.get());
-                async->retrieved++;
-                TRY_CATCH_CALL(async->stmt->Value(), cb, 2, argv);
-            }
-        }
+    NODE_SQLITE3_MUTEX_LOCK(&async->mutex)
+    while (!async->deferreds.empty() && !async->data.empty()) {
+        auto deferred = std::move(async->deferreds.front());
+        async->deferreds.pop_front();
+        auto row = std::move(async->data.front());
+        async->data.pop_front();
+        auto result = Napi::Object::New(env);
+        result["done"] = Napi::Boolean::New(env, false);
+        result["value"] = RowToJS(env, row.get());
+        deferred.get()->Resolve(result);
     }
 
-    Napi::Function cb = async->completed_cb.Value();
     if (async->completed) {
-        if (!cb.IsEmpty() &&
-                cb.IsFunction()) {
-            Napi::Value argv[] = {
-                env.Null(),
-                Napi::Number::New(env, async->retrieved)
-            };
-            TRY_CATCH_CALL(async->stmt->Value(), cb, 2, argv);
+        if (!async->deferreds.empty()) {
+            auto deferred = std::move(async->deferreds.front());
+            async->deferreds.pop_front();
+            if (async->stmt->status != SQLITE_DONE) {
+                EXCEPTION(Napi::String::New(env, async->stmt->message.c_str()), async->stmt->status, exception);
+                deferred.get()->Reject(exception);
+            } else {
+                auto result = Napi::Object::New(env);
+                result["done"] = Napi::Boolean::New(env, true);
+                deferred.get()->Resolve(result);
+            }
         }
         uv_close(reinterpret_cast<uv_handle_t*>(handle), CloseCallback);
     }
+    NODE_SQLITE3_MUTEX_UNLOCK(&async->mutex)
 }
 
 void Statement::Work_AfterEach(napi_env e, napi_status status, void* data) {
-    std::unique_ptr<EachBaton> baton(static_cast<EachBaton*>(data));
+    std::unique_ptr<RowBaton> baton(static_cast<RowBaton*>(data));
     auto* stmt = baton->stmt;
 
-    auto env = stmt->Env();
-    Napi::HandleScope scope(env);
-
-    if (stmt->status != SQLITE_DONE) {
-        Error(baton.get());
-    }
+    // auto env = stmt->Env();
+    // Napi::HandleScope scope(env);
+
+    // if (stmt->status == SQLITE_DONE) {
+    //     auto result = Napi::Object::New(e);
+    //     result["done"] = Napi::Boolean::New(e, true);
+    //     baton->deferred.Resolve(result);
+    // } else {
+    //     auto result = Napi::Object::New(e);
+    //     result["done"] = Napi::Boolean::New(e, false);
+    //     result["value"] = RowToJS(env, &baton->row).As<Napi::Object>();
+    //     Napi::Object json = env.Global().Get("JSON").As<Napi::Object>();
+    //     Napi::Function stringify = json.Get("stringify").As<Napi::Function>();
+    //     auto resultString = stringify.Call(json, {result}).As<Napi::String>().Utf8Value();
+    //     baton->deferred.Resolve(result);
+    // }
 
     STATEMENT_END();
 }
@@ -751,12 +759,10 @@ Napi::Value Statement::Reset(const Napi::CallbackInfo& info) {
     auto env = info.Env();
     Statement* stmt = this;
 
-    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
-
-    auto* baton = new Baton(stmt, callback);
+    auto* baton = new Baton(stmt);
     stmt->Schedule(Work_BeginReset, baton);
 
-    return info.This();
+    return baton->deferred.Promise();
 }
 
 void Statement::Work_BeginReset(Baton* baton) {
@@ -777,12 +783,7 @@ void Statement::Work_AfterReset(napi_env e, napi_status status, void* data) {
     auto env = stmt->Env();
     Napi::HandleScope scope(env);
 
-    // Fire callbacks.
-    Napi::Function cb = baton->callback.Value();
-    if (IS_FUNCTION(cb)) {
-        Napi::Value argv[] = { env.Null() };
-        TRY_CATCH_CALL(stmt->Value(), cb, 1, argv);
-    }
+    baton->deferred.Resolve(stmt->Value());
 
     STATEMENT_END();
 }
@@ -861,12 +862,11 @@ void Statement::GetRow(Row* row, sqlite3_stmt* stmt) {
 Napi::Value Statement::Finalize_(const Napi::CallbackInfo& info) {
     auto env = info.Env();
     Statement* stmt = this;
-    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
 
-    auto *baton = new Baton(stmt, callback);
+    auto *baton = new Baton(stmt);
     stmt->Schedule(Finalize_, baton);
 
-    return stmt->db->Value();
+    return baton->deferred.Promise();
 }
 
 void Statement::Finalize_(Baton* b) {
@@ -876,11 +876,7 @@ void Statement::Finalize_(Baton* b) {
 
     baton->stmt->Finalize_();
 
-    // Fire callback in case there was one.
-    Napi::Function cb = baton->callback.Value();
-    if (IS_FUNCTION(cb)) {
-        TRY_CATCH_CALL(baton->stmt->Value(), cb, 0, NULL);
-    }
+    baton->deferred.Resolve(baton->stmt->db->Value());
 }
 
 void Statement::Finalize_() {
@@ -903,7 +899,6 @@ void Statement::CleanQueue() {
         // Fire error for all remaining items in the queue.
         EXCEPTION(Napi::String::New(env, "Statement is already finalized"), SQLITE_MISUSE, exception);
         Napi::Value argv[] = { exception };
-        bool called = false;
 
         // Clear out the queue so that this object can get GC'ed.
         while (!queue.empty()) {
@@ -911,20 +906,7 @@ void Statement::CleanQueue() {
             queue.pop();
 
             auto baton = std::unique_ptr<Baton>(call->baton);
-            Napi::Function cb = baton->callback.Value();
-
-            if (prepared && !cb.IsEmpty() &&
-                cb.IsFunction()) {
-                TRY_CATCH_CALL(Value(), cb, 1, argv);
-                called = true;
-            }
-        }
-
-        // When we couldn't call a callback function, emit an error on the
-        // Statement object.
-        if (!called) {
-            Napi::Value info[] = { Napi::String::New(env, "error"), exception };
-            EMIT_EVENT(Value(), 2, info);
+            baton->deferred.Reject(exception);
         }
     }
     else while (!queue.empty()) {
diff --git a/src/statement.h b/src/statement.h
index c522c0fd..0b7fab86 100644
--- a/src/statement.h
+++ b/src/statement.h
@@ -69,9 +69,9 @@ namespace Values {
     typedef Field Null;
 }
 
-typedef std::vector<std::unique_ptr<Values::Field> > Row;
-typedef std::vector<std::unique_ptr<Row> > Rows;
-typedef Row Parameters;
+typedef std::vector<std::unique_ptr<Values::Field>> Row;
+typedef std::deque<std::unique_ptr<Row>> Rows;
+typedef std::vector<std::shared_ptr<Values::Field>> Parameters;
 
 
 
@@ -80,42 +80,69 @@ class Statement : public Napi::ObjectWrap<Statement> {
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
     static Napi::Value New(const Napi::CallbackInfo& info);
 
+    struct ParamsBaton {
+        Parameters parameters;
+
+        ParamsBaton() {}
+        virtual ~ParamsBaton() {}
+    };
+
     struct Baton {
         napi_async_work request = NULL;
         Statement* stmt;
-        Napi::FunctionReference callback;
+        Napi::Promise::Deferred deferred;
+        // TODO: get rid of this (unused)?
+        Napi::Reference<Napi::Promise> promise;
         Parameters parameters;
+        bool bound = false;
 
-        Baton(Statement* stmt_, Napi::Function cb_) : stmt(stmt_) {
+        Baton(Statement* stmt_) :
+                stmt(stmt_),
+                deferred(Napi::Promise::Deferred::New(stmt_->Env())),
+                promise(Napi::Persistent(deferred.Promise())) {
             stmt->Ref();
-            callback.Reset(cb_, 1);
+            promise.Ref();
         }
         virtual ~Baton() {
             parameters.clear();
             if (request) napi_delete_async_work(stmt->Env(), request);
             stmt->Unref();
-            callback.Reset();
+            promise.Unref();
         }
     };
 
+    class Worker : public Napi::AsyncWorker {
+        public:
+            Worker(Napi::Env& env, Baton* baton);
+            virtual ~Worker(){};
+
+            void Execute();
+            void OnOK();
+            void OnError(const Napi::Error& e);
+
+        private:
+            Baton* baton;
+    };
+
+
     struct RowBaton : Baton {
-        RowBaton(Statement* stmt_, Napi::Function cb_) :
-            Baton(stmt_, cb_) {}
+        RowBaton(Statement* stmt_) :
+            Baton(stmt_) {}
         Row row;
         virtual ~RowBaton() override = default;
     };
 
     struct RunBaton : Baton {
-        RunBaton(Statement* stmt_, Napi::Function cb_) :
-            Baton(stmt_, cb_), inserted_id(0), changes(0) {}
+        RunBaton(Statement* stmt_) :
+            Baton(stmt_), inserted_id(0), changes(0) {}
         sqlite3_int64 inserted_id;
         int changes;
         virtual ~RunBaton() override = default;
     };
 
     struct RowsBaton : Baton {
-        RowsBaton(Statement* stmt_, Napi::Function cb_) :
-            Baton(stmt_, cb_) {}
+        RowsBaton(Statement* stmt_) :
+            Baton(stmt_) {}
         Rows rows;
         virtual ~RowsBaton() override = default;
     };
@@ -123,21 +150,18 @@ class Statement : public Napi::ObjectWrap<Statement> {
     struct Async;
 
     struct EachBaton : Baton {
-        Napi::FunctionReference completed;
         Async* async; // Isn't deleted when the baton is deleted.
 
-        EachBaton(Statement* stmt_, Napi::Function cb_) :
-            Baton(stmt_, cb_) {}
-        virtual ~EachBaton() override {
-            completed.Reset();
-        }
+        EachBaton(Statement* stmt_) :
+            Baton(stmt_) {}
+        virtual ~EachBaton() override = default;
     };
 
     struct PrepareBaton : Database::Baton {
         Statement* stmt;
         std::string sql;
-        PrepareBaton(Database* db_, Napi::Function cb_, Statement* stmt_) :
-            Baton(db_, cb_), stmt(stmt_) {
+        PrepareBaton(Database* db_, Statement* stmt_) :
+            Baton(db_, Napi::Promise::Deferred::New(stmt_->Env())), stmt(stmt_) {
             stmt->Ref();
         }
         virtual ~PrepareBaton() override {
@@ -162,6 +186,7 @@ class Statement : public Napi::ObjectWrap<Statement> {
         uv_async_t watcher;
         Statement* stmt;
         Rows data;
+        std::deque<std::shared_ptr<Napi::Promise::Deferred>> deferreds;
         NODE_SQLITE3_MUTEX_t;
         bool completed;
         int retrieved;
@@ -202,21 +227,26 @@ class Statement : public Napi::ObjectWrap<Statement> {
     WORK_DEFINITION(Each)
     WORK_DEFINITION(Reset)
 
+    static void StepEach(Baton* baton);
+
     Napi::Value Finalize_(const Napi::CallbackInfo& info);
 
 protected:
+    Napi::Value Prepare(const Napi::CallbackInfo& info);                          \
     static void Work_BeginPrepare(Database::Baton* baton);
     static void Work_Prepare(napi_env env, void* data);
     static void Work_AfterPrepare(napi_env env, napi_status status, void* data);
 
+    Napi::Value InitEachIterator(EachBaton* baton);
     static void AsyncEach(uv_async_t* handle);
     static void CloseCallback(uv_handle_t* handle);
 
     static void Finalize_(Baton* baton);
     void Finalize_();
 
-    template <class T> inline std::unique_ptr<Values::Field> BindParameter(const Napi::Value source, T pos);
-    template <class T> T* Bind(const Napi::CallbackInfo& info, int start = 0, int end = -1);
+    bool BindParameters(const Napi::CallbackInfo& info, Parameters& parameters);
+    template <class T> inline std::shared_ptr<Values::Field> BindParameter(const Napi::Value source, T pos);
+    template <class T> T* Bind(const Napi::CallbackInfo& info);
     bool Bind(const Parameters &parameters);
 
     static void GetRow(Row* row, sqlite3_stmt* stmt);
@@ -229,6 +259,8 @@ class Statement : public Napi::ObjectWrap<Statement> {
 protected:
     Database* db;
 
+    std::string sql;
+
     sqlite3_stmt* _handle = NULL;
     int status = SQLITE_OK;
     bool prepared = false;
diff --git a/test/affected.test.js b/test/affected.test.js
index 031dc1b9..8f40c6ee 100644
--- a/test/affected.test.js
+++ b/test/affected.test.js
@@ -1,32 +1,33 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('query properties', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:');
-        db.run("CREATE TABLE foo (id INT, txt TEXT)", done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.run("CREATE TABLE foo (id INT, txt TEXT)");
     });
 
-    it('should return the correct lastID', function(done) {
-        var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-        var j = 1;
-        for (var i = 0; i < 5000; i++) {
-            stmt.run(i, "demo", function(err) {
-                if (err) throw err;
+    it('should return the correct lastID', async function() {
+        const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)");
+        let j = 1;
+        const promises = [];
+        for (let i = 0; i < 5000; i++) {
+            promises.push(stmt.run(i, "demo").then((result) => {
                 // Relies on SQLite's row numbering to be gapless and starting
                 // from 1.
-                assert.equal(j++, this.lastID);
-            });
+                assert.equal(j++, result.lastID);
+            }));
         }
-        db.wait(done);
+        await Promise.all(promises);
+        // TODO: this doesn't seem to work?
+        // await db.wait();
     });
 
-    it('should return the correct changes count', function(done) {
-        db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err) {
-            if (err) throw err;
-            assert.equal(2500, this.changes);
-            done();
-        });
+    it('should return the correct changes count', async function() {
+        const statement = await db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0");
+        await db.all("SELECT * FROM foo");
+        assert.equal(2500, statement.changes);
     });
 });
diff --git a/test/async_calls.test.js b/test/async_calls.test.js
index 9ce29a73..41eb75b7 100644
--- a/test/async_calls.test.js
+++ b/test/async_calls.test.js
@@ -1,17 +1,19 @@
-"use strict"
+"use strict";
 
-var sqlite3 = require('..');
+const sqlite3 = require('..');
 const assert = require("assert");
 const { createHook, executionAsyncId } = require("async_hooks");
 
 
-describe('async_hooks', function() {
+// TODO: What.. is this testing??
+describe.skip('async_hooks', function() {
+    /** @type {sqlite3.Database} */
     let db;
     let dbId;
     let asyncHook;
 
-    beforeEach(function() {
-        db = new sqlite3.Database(':memory:');
+    beforeEach(async function() {
+        db = await sqlite3.Database.create(':memory:');
 
         asyncHook = createHook({
             init(asyncId, type) {
@@ -22,12 +24,10 @@ describe('async_hooks', function() {
         }).enable();
     });
 
-    it('should support performance measuring with async hooks', function(done) {
-        db.run("DROP TABLE user", () => {
-            const cbId = executionAsyncId();
-            assert.strictEqual(cbId, dbId);
-            done();
-        });
+    it('should support performance measuring with async hooks', async function() {
+        await db.run("DROP TABLE user");
+        const cbId = executionAsyncId();
+        assert.strictEqual(cbId, dbId);
     });
 
     afterEach(function() {
@@ -39,4 +39,4 @@ describe('async_hooks', function() {
             db.close();
         }
     });
-});
\ No newline at end of file
+});
diff --git a/test/backup.test.js b/test/backup.test.js
index c05c298f..727f882f 100644
--- a/test/backup.test.js
+++ b/test/backup.test.js
@@ -1,28 +1,19 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
-var helper = require('./support/helper');
+const sqlite3 = require('..');
+const assert = require('assert');
+const helper = require('./support/helper');
 
 // Check that the number of rows in two tables matches.
-function assertRowsMatchDb(db1, table1, db2, table2, done) {
-    db1.get("SELECT COUNT(*) as count FROM " + table1, function(err, row) {
-        if (err) throw err;
-        db2.get("SELECT COUNT(*) as count FROM " + table2, function(err, row2) {
-            if (err) throw err;
-            assert.equal(row.count, row2.count);
-            done();
-        });
-    });
+async function assertRowsMatchDb(db1, table1, db2, table2) {
+    const row = await db1.get("SELECT COUNT(*) as count FROM " + table1);
+    const row2 = await db2.get("SELECT COUNT(*) as count FROM " + table2);
+    assert.equal(row.count, row2.count);
 }
 
 // Check that the number of rows in the table "foo" is preserved in a backup.
-function assertRowsMatchFile(db, backupName, done) {
-    var db2 = new sqlite3.Database(backupName, sqlite3.OPEN_READONLY, function(err) {
-        if (err) throw err;
-        assertRowsMatchDb(db, 'foo', db2, 'foo', function() {
-            db2.close(done);
-        });
-    });
+async function assertRowsMatchFile(db, backupName) {
+    const db2 = await sqlite3.Database.create(backupName, sqlite3.OPEN_READONLY);
+    await assertRowsMatchDb(db, 'foo', db2, 'foo');
+    await db2.close();
 }
 
 describe('backup', function() {
@@ -30,250 +21,183 @@ describe('backup', function() {
         helper.ensureExists('test/tmp');
     });
 
-    var db;
-    beforeEach(function(done) {
+    /** @type {sqlite3.Database} */
+    let db;
+    beforeEach(async function() {
         helper.deleteFile('test/tmp/backup.db');
         helper.deleteFile('test/tmp/backup2.db');
-        db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done);
-    });
-
-    afterEach(function(done) {
-        if (!db) { done(); }
-        db.close(done);
-    });
-
-    it ('output db created once step is called', function(done) {
-        var backup = db.backup('test/tmp/backup.db', function(err) {
-            if (err) throw err;
-            backup.step(1, function(err) {
-                if (err) throw err;
-                assert.fileExists('test/tmp/backup.db');
-                backup.finish(done);
-            });
-        });
-    });
-
-    it ('copies source fully with step(-1)', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            assert.fileExists('test/tmp/backup.db');
-            backup.finish(function(err) {
-                if (err) throw err;
-                assertRowsMatchFile(db, 'test/tmp/backup.db', done);
-            });
-        });
+        db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
     });
 
-    it ('backup db not created if finished immediately', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        backup.finish(function(err) {
-            if (err) throw err;
-            assert.fileDoesNotExist('test/tmp/backup.db');
-            done();
-        });
+    afterEach(async function() {
+        await (db && db.close());
     });
 
-    it ('error closing db if backup not finished', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        db.close(function(err) {
-            db = null;
-            if (!err) throw new Error('should have an error');
-            if (err.errno == sqlite3.BUSY) {
-                done();
-            }
-            else throw err;
-        });
+    it('output db created once step is called', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        await backup.step(1);
+        assert.fileExists('test/tmp/backup.db');
+        await backup.finish();
     });
 
-    it ('using the backup after finished is an error', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        backup.finish(function(err) {
-            if (err) throw err;
-            backup.step(1, function(err) {
-                if (!err) throw new Error('should have an error');
-                if (err.errno == sqlite3.MISUSE &&
-                    err.message === 'SQLITE_MISUSE: Backup is already finished') {
-                    done();
-                }
-                else throw err;
-            });
-        });
+    it('copies source fully with step(-1)', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        await backup.step(-1);
+        assert.fileExists('test/tmp/backup.db');
+        await backup.finish();
+        await assertRowsMatchFile(db, 'test/tmp/backup.db');
     });
 
-    it ('remaining/pageCount are available after call to step', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        backup.step(0, function(err) {
-            if (err) throw err;
-            assert.equal(typeof this.pageCount, 'number');
-            assert.equal(typeof this.remaining, 'number');
-            assert.equal(this.remaining, this.pageCount);
-            var prevRemaining = this.remaining;
-            var prevPageCount = this.pageCount;
-            backup.step(1, function(err) {
-                if (err) throw err;
-                assert.notEqual(this.remaining, prevRemaining);
-                assert.equal(this.pageCount, prevPageCount);
-                backup.finish(done);
-            });
-        });
+    it('backup db not created if finished immediately', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        await backup.finish();
+        assert.fileDoesNotExist('test/tmp/backup.db');
     });
 
-    it ('backup works if database is modified half-way through', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            backup.finish(function(err) {
-                if (err) throw err;
-                var db2 = new sqlite3.Database('test/tmp/backup.db', function(err) {
-                    if (err) throw err;
-                    var backup2 = db2.backup('test/tmp/backup2.db');
-                    backup2.step(1, function(err, completed) {
-                        if (err) throw err;
-                        assert.equal(completed, false);  // Page size for the test db
-                        // should not be raised to high.
-                        db2.exec("insert into foo(txt) values('hello')", function(err) {
-                            if (err) throw err;
-                            backup2.step(-1, function(err, completed) {
-                                if (err) throw err;
-                                assert.equal(completed, true);
-                                assertRowsMatchFile(db2, 'test/tmp/backup2.db', function() {
-                                    backup2.finish(function(err) {
-                                        if (err) throw err;
-                                        db2.close(done);
-                                    });
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
+    it('error closing db if backup not finished', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        try {
+            await db.close();
+        } catch (err) {
+            assert.equal(err.errno, sqlite3.BUSY);
+        } finally {
+            // Finish the backup so that the after hook succeeds
+            await backup.finish();
+        }
     });
 
-    (sqlite3.VERSION_NUMBER < 3026000 ? it.skip : it) ('can backup from temp to main', function(done) {
-        db.exec("CREATE TEMP TABLE space (txt TEXT)", function(err) {
-            if (err) throw err;
-            db.exec("INSERT INTO space(txt) VALUES('monkey')", function(err) {
-                if (err) throw err;
-                var backup = db.backup('test/tmp/backup.db', 'temp', 'main', true, function(err) {
-                    if (err) throw err;
-                    backup.step(-1, function(err) {
-                        if (err) throw err;
-                        backup.finish(function(err) {
-                            if (err) throw err;
-                            var db2 = new sqlite3.Database('test/tmp/backup.db', function(err) {
-                                if (err) throw err;
-                                db2.get("SELECT * FROM space", function(err, row) {
-                                    if (err) throw err;
-                                    assert.equal(row.txt, 'monkey');
-                                    db2.close(done);
-                                });
-                            });
-                        });
-                    });
-                });
-            });
-        });
+    it('using the backup after finished is an error', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        await backup.finish();
+        try {
+            await backup.step(1);
+            
+        } catch (err) {
+            assert.equal(err.errno, sqlite3.MISUSE);
+            assert.equal(err.message, 'SQLITE_MISUSE: Backup is already finished');
+        }
     });
 
-    (sqlite3.VERSION_NUMBER < 3026000 ? it.skip : it) ('can backup from main to temp', function(done) {
-        var backup = db.backup('test/support/prepare.db', 'main', 'temp', false, function(err) {
-            if (err) throw err;
-            backup.step(-1, function(err) {
-                if (err) throw err;
-                backup.finish(function(err) {
-                    if (err) throw err;
-                    assertRowsMatchDb(db, 'temp.foo', db, 'main.foo', done);
-                });
-            });
-        });
+    it('remaining/pageCount are available after call to step', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        await backup.step(0);
+        assert.equal(typeof backup.pageCount, 'number');
+        assert.equal(typeof backup.remaining, 'number');
+        assert.equal(backup.remaining, backup.pageCount);
+        const prevRemaining = backup.remaining;
+        const prevPageCount = backup.pageCount;
+        await backup.step(1);
+        assert.notEqual(backup.remaining, prevRemaining);
+        assert.equal(backup.pageCount, prevPageCount);
+        await backup.finish();
+    });
+
+    it('backup works if database is modified half-way through', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        await backup.step(-1);
+        await backup.finish();
+        const db2 = await sqlite3.Database.create('test/tmp/backup.db');
+        const backup2 = await db2.backup('test/tmp/backup2.db');
+        const completed = await backup2.step(1);
+        assert.equal(completed, false);  // Page size for the test db
+        // should not be raised to high.
+        await db2.exec("insert into foo(txt) values('hello')");
+        const completed2 = await backup2.step(-1);
+        assert.equal(completed2, true);
+        await assertRowsMatchFile(db2, 'test/tmp/backup2.db');
+        await backup2.finish();
+        await db2.close();
+    });
+
+    (sqlite3.VERSION_NUMBER < 3026000 ? it.skip : it) ('can backup from temp to main', async function() {
+        await db.exec("CREATE TEMP TABLE space (txt TEXT)");
+        await db.exec("INSERT INTO space(txt) VALUES('monkey')");
+        const backup = await db.backup('test/tmp/backup.db', 'temp', 'main', true);
+        await backup.step(-1);
+        await backup.finish();
+        const db2 = await sqlite3.Database.create('test/tmp/backup.db');
+        const row = await db2.get("SELECT * FROM space");
+        assert.equal(row.txt, 'monkey');
+        await db2.close();
+    });
+
+    (sqlite3.VERSION_NUMBER < 3026000 ? it.skip : it) ('can backup from main to temp', async function() {
+        const backup = await db.backup('test/support/prepare.db', 'main', 'temp', false);
+        await backup.step(-1);
+        await backup.finish();
+        await assertRowsMatchDb(db, 'temp.foo', db, 'main.foo');
+    });
+
+    it('cannot backup to a locked db', async function() {
+        const db2 = await sqlite3.Database.create('test/tmp/backup.db');
+        await db2.exec("PRAGMA locking_mode = EXCLUSIVE");
+        await db2.exec("BEGIN EXCLUSIVE");
+        const backup = await db.backup('test/tmp/backup.db');
+        try {
+            await backup.step(-1);
+        } catch (err) {
+            assert.equal(err.errno, sqlite3.BUSY);
+        } finally {
+            await backup.finish();
+        }
     });
 
-    it ('cannot backup to a locked db', function(done) {
-        var db2 = new sqlite3.Database('test/tmp/backup.db', function(err) {
-            db2.exec("PRAGMA locking_mode = EXCLUSIVE");
-            db2.exec("BEGIN EXCLUSIVE", function(err) {
-                if (err) throw err;
-                var backup = db.backup('test/tmp/backup.db');
-                backup.step(-1, function(stepErr) {
-                    db2.close(function(err) {
-                        if (err) throw err;
-                        if (stepErr.errno == sqlite3.BUSY) {
-                            backup.finish(done);
-                        }
-                        else throw stepErr;
-                    });
-                });
-            });
+    it('fuss-free incremental backups work', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
+        let timer;
+        let resolve;
+        const promise = new Promise((res) => {
+            resolve = res;
         });
-    });
-
-    it ('fuss-free incremental backups work', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
-        var timer;
-        function makeProgress() {
+        async function makeProgress() {
             if (backup.idle) {
-                backup.step(1);
+                await backup.step(1);
             }
             if (backup.completed || backup.failed) {
                 clearInterval(timer);
                 assert.equal(backup.completed, true);
                 assert.equal(backup.failed, false);
-                done();
+                resolve();
             }
         }
         timer = setInterval(makeProgress, 2);
+        await promise;
     });
 
-    it ('setting retryErrors to empty disables automatic finishing', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
+    it('setting retryErrors to empty disables automatic finishing', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
         backup.retryErrors = [];
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            db.close(function(err) {
-                db = null;
-                if (!err) throw new Error('should have an error');
-                assert.equal(err.errno, sqlite3.BUSY);
-                done();
-            });
-        });
+        await backup.step(-1);
+        try {
+            await db.close();
+        } catch (err) {
+            assert.equal(err.errno, sqlite3.BUSY);
+        } finally {
+            await backup.finish();
+        }
     });
 
-    it ('setting retryErrors enables automatic finishing', function(done) {
-        var backup = db.backup('test/tmp/backup.db');
+    it('setting retryErrors enables automatic finishing', async function() {
+        const backup = await db.backup('test/tmp/backup.db');
         backup.retryErrors = [sqlite3.OK];
-        backup.step(-1, function(err) {
-            if (err) throw err;
-            db.close(function(err) {
-                if (err) throw err;
-                db = null;
-                done();
-            });
-        });
-    });
-
-    it ('default retryErrors will retry on a locked/busy db', function(done) {
-        var db2 = new sqlite3.Database('test/tmp/backup.db', function(err) {
-            db2.exec("PRAGMA locking_mode = EXCLUSIVE");
-            db2.exec("BEGIN EXCLUSIVE", function(err) {
-                if (err) throw err;
-                var backup = db.backup('test/tmp/backup.db');
-                backup.step(-1, function(stepErr) {
-                    db2.close(function(err) {
-                        if (err) throw err;
-                        assert.equal(stepErr.errno, sqlite3.BUSY);
-                        assert.equal(backup.completed, false);
-                        assert.equal(backup.failed, false);
-                        backup.step(-1, function(err) {
-                            if (err) throw err;
-                            assert.equal(backup.completed, true);
-                            assert.equal(backup.failed, false);
-                            done();
-                        });
-                    });
-                });
-            });
-        });
+        await backup.step(-1);
+    });
+
+    it('default retryErrors will retry on a locked/busy db', async function() {
+        const db2 = await sqlite3.Database.create('test/tmp/backup.db');
+        await db2.exec("PRAGMA locking_mode = EXCLUSIVE");
+        await db2.exec("BEGIN EXCLUSIVE");
+        const backup = await db.backup('test/tmp/backup.db');
+        try {
+            await backup.step(-1);
+        } catch (err) {
+            assert.equal(err.errno, sqlite3.BUSY);
+        }
+        await db2.close();
+        assert.equal(backup.completed, false);
+        assert.equal(backup.failed, false);
+        await backup.step(-1);
+        assert.equal(backup.completed, true);
+        assert.equal(backup.failed, false);
     });
 });
diff --git a/test/blob.test.js b/test/blob.test.js
index 5c2b0d85..8e1e3112 100644
--- a/test/blob.test.js
+++ b/test/blob.test.js
@@ -1,54 +1,53 @@
-var sqlite3 = require('..'),
+const sqlite3 = require('..'),
     fs = require('fs'),
     assert = require('assert'),
     Buffer = require('buffer').Buffer;
 
 // lots of elmo
-var elmo = fs.readFileSync(__dirname + '/support/elmo.png');
+const elmo = fs.readFileSync(__dirname + '/support/elmo.png');
 
 describe('blob', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:');
-        db.run("CREATE TABLE elmos (id INT, image BLOB)", done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.run("CREATE TABLE elmos (id INT, image BLOB)");
     });
 
-    var total = 10;
-    var inserted = 0;
-    var retrieved = 0;
-
-
-    it('should insert blobs', function(done) {
-        for (var i = 0; i < total; i++) {
-            db.run('INSERT INTO elmos (id, image) VALUES (?, ?)', i, elmo, function(err) {
-                if (err) throw err;
-                inserted++;
-            });
+    const total = 10;
+    let inserted = 0;
+    let retrieved = 0;
+
+    it('should insert blobs', async function() {
+        const promises = [];
+        for (let i = 0; i < total; i++) {
+            promises.push(
+                db.run('INSERT INTO elmos (id, image) VALUES (?, ?)', i, elmo).then(() => {
+                    inserted++;
+                })
+            );
         }
-        db.wait(function() {
-            assert.equal(inserted, total);
-            done();
-        });
+        // TODO: fix wait
+        // await db.wait();
+        await Promise.all(promises);
+        assert.equal(inserted, total);
     });
 
-    it('should retrieve the blobs', function(done) {
-        db.all('SELECT id, image FROM elmos ORDER BY id', function(err, rows) {
-            if (err) throw err;
-            for (var i = 0; i < rows.length; i++) {
-                assert.ok(Buffer.isBuffer(rows[i].image));
-                assert.ok(elmo.length, rows[i].image);
-
-                for (var j = 0; j < elmo.length; j++) {
-                    if (elmo[j] !== rows[i].image[j]) {
-                        assert.ok(false, "Wrong byte");
-                    }
-                }
+    it('should retrieve the blobs', async function() {
+        const rows = await db.all('SELECT id, image FROM elmos ORDER BY id');
+        for (let i = 0; i < rows.length; i++) {
+            assert.ok(Buffer.isBuffer(rows[i].image));
+            assert.ok(elmo.length, rows[i].image);
 
-                retrieved++;
+            for (let j = 0; j < elmo.length; j++) {
+                if (elmo[j] !== rows[i].image[j]) {
+                    assert.ok(false, "Wrong byte");
+                }
             }
 
-            assert.equal(retrieved, total);
-            done();
-        });
+            retrieved++;
+        }
+
+        assert.equal(retrieved, total);
     });
 });
diff --git a/test/cache.test.js b/test/cache.test.js
index 9866dbf9..4e1e358c 100644
--- a/test/cache.test.js
+++ b/test/cache.test.js
@@ -1,41 +1,30 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+const sqlite3 = require('..');
+const assert = require('assert');
+const helper = require('./support/helper');
 
 describe('cache', function() {
     before(function() {
         helper.ensureExists('test/tmp');
     });
 
-    it('should cache Database objects while opening', function(done) {
-        var filename = 'test/tmp/test_cache.db';
+    it('should cache Database objects while opening', async function() {
+        const filename = 'test/tmp/test_cache.db';
         helper.deleteFile(filename);
-        var opened1 = false, opened2 = false;
-        var db1 = new sqlite3.cached.Database(filename, function(err) {
-            if (err) throw err;
-            opened1 = true;
-            if (opened1 && opened2) done();
-        });
-        var db2 = new sqlite3.cached.Database(filename, function(err) {
-            if (err) throw err;
-            opened2 = true;
-            if (opened1 && opened2) done();
-        });
+        const db1 = await sqlite3.cached.Database.create(filename);
+        const db2 = await sqlite3.cached.Database.create(filename);
         assert.equal(db1, db2);
     });
 
+    // TODO: Does this still make sense? Is this correctly implemented now?
     it('should cache Database objects after they are open', function(done) {
-        var filename = 'test/tmp/test_cache2.db';
+        const filename = 'test/tmp/test_cache2.db';
         helper.deleteFile(filename);
-        var db1, db2;
-        db1 = new sqlite3.cached.Database(filename, function(err) {
-            if (err) throw err;
+        sqlite3.cached.Database.create(filename).then((db1) => {
             process.nextTick(function() {
-                db2 = new sqlite3.cached.Database(filename, function(err) {
+                sqlite3.cached.Database.create(filename).then((db2)  =>{
+                    assert.equal(db1, db2);
                     done();
-
                 });
-                assert.equal(db1, db2);
             });
         });
     });
diff --git a/test/constants.test.js b/test/constants.test.js
index 7e1affdd..c56782e6 100644
--- a/test/constants.test.js
+++ b/test/constants.test.js
@@ -1,5 +1,5 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('constants', function() {
     it('should have the right OPEN_* flags', function() {
diff --git a/test/database_fail.test.js b/test/database_fail.test.js
index 8b936769..084f153e 100644
--- a/test/database_fail.test.js
+++ b/test/database_fail.test.js
@@ -1,153 +1,129 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('error handling', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
     });
 
     it('throw when calling Database() without new', function() {
         assert.throws(function() {
+            // @ts-expect-error Calling private constructor for test
             sqlite3.Database(':memory:');
         }, (/Class constructors cannot be invoked without 'new'/));
 
         assert.throws(function() {
+            // @ts-expect-error Calling private constructor for test
             sqlite3.Statement();
         }, (/Class constructors cannot be invoked without 'new'/));
     });
 
-    it('should error when calling Database#get on a missing table', function(done) {
-        db.get('SELECT id, txt FROM foo', function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
-        });
+    it('should error when calling Database#get on a missing table', async function() {
+        try {
+            await db.get('SELECT id, txt FROM foo');
+        } catch (err) {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+        }
+        new Error('Completed query without error, but expected error');
     });
 
-    it('Database#all prepare fail', function(done) {
-        db.all('SELECT id, txt FROM foo', function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
-        });
+    it('Database#all prepare fail', async function() {
+        try {
+            await db.all('SELECT id, txt FROM foo');
+        } catch (err) {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+        }
+        new Error('Completed query without error, but expected error');
     });
 
-    it('Database#run prepare fail', function(done) {
-        db.run('SELECT id, txt FROM foo', function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
-        });
+    it('Database#run prepare fail', async function() {
+        try {
+
+            await db.run('SELECT id, txt FROM foo');
+        } catch (err) {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+        }
+        new Error('Completed query without error, but expected error');
     });
 
-    it('Database#each prepare fail', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
-            assert.ok(false, "this should not be called");
-        }, function(err, num) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
+    it('Database#each prepare fail', async function() {
+        await assert.rejects(db.each('SELECT id, text FROM foo'), (err) => {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+            return true;
         });
     });
 
-    it('Database#each prepare fail without completion handler', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
+    it('Database#each prepare fail without completion handler', async function() {
+        await assert.rejects(db.each('SELECT id, txt FROM foo'), (err) => {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+            return true;
         });
     });
 
-    it('Database#get prepare fail with param binding', function(done) {
-        db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
-        });
+    it('Database#get prepare fail with param binding', async function() {
+        try {
+            await db.get('SELECT id, txt FROM foo WHERE id = ?', 1);
+        } catch (err) {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+        }
+        new Error('Completed query without error, but expected error');
     });
 
-    it('Database#all prepare fail with param binding', function(done) {
-        db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
-        });
+    it('Database#all prepare fail with param binding', async function() {
+        try {
+            await db.all('SELECT id, txt FROM foo WHERE id = ?', 1);
+        } catch (err) {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+        }
+        new Error('Completed query without error, but expected error');
     });
 
-    it('Database#run prepare fail with param binding', function(done) {
-        db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
-        });
+    it('Database#run prepare fail with param binding', async function() {
+        try {
+            await db.run('SELECT id, txt FROM foo WHERE id = ?', 1);
+        } catch (err) {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+        }
+        new Error('Completed query without error, but expected error');
     });
 
-    it('Database#each prepare fail with param binding', function(done) {
-        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
-            assert.ok(false, "this should not be called");
-        }, function(err, num) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
+    it('Database#each prepare fail with param binding', async function() {
+        await assert.rejects(db.each('SELECT id, txt FROM foo WHERE id = ?', 1), (err) => {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+            return true;
         });
     });
 
-    it('Database#each prepare fail with param binding without completion handler', function(done) {
-        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
-            if (err) {
-                assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
-                assert.equal(err.errno, sqlite3.ERROR);
-                assert.equal(err.code, 'SQLITE_ERROR');
-                done();
-            } else {
-                done(new Error('Completed query without error, but expected error'));
-            }
+    it('Database#each prepare fail with param binding without completion handler', async function() {
+        assert.rejects(db.each('SELECT id, txt FROM foo WHERE id = ?', 1), (err) => {
+            assert.equal(err.message, 'SQLITE_ERROR: no such table: foo');
+            assert.equal(err.errno, sqlite3.ERROR);
+            assert.equal(err.code, 'SQLITE_ERROR');
+            return true;
         });
     });
+
+    after(async function() {
+        await db.close();
+    });
 });
diff --git a/test/each.test.js b/test/each.test.js
index 27df32c8..541a0b55 100644
--- a/test/each.test.js
+++ b/test/each.test.js
@@ -1,39 +1,32 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('each', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database('test/support/big.db', sqlite3.OPEN_READONLY, done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create('test/support/big.db', sqlite3.OPEN_READONLY);
     });
 
-    it('retrieve 100,000 rows with Statement#each', function(done) {
-        var total = 100000;
-        var retrieved = 0;
+    it('retrieve 100,000 rows with Statement#each', async function() {
+        const total = 100000;
+        // var total = 10;
+        let retrieved = 0;
         
-
-        db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
-            if (err) throw err;
+        const iterable = await db.each('SELECT id, txt FROM foo LIMIT 0, ?', total);
+        for await (const _row of iterable) {
             retrieved++;
-            
-            if(retrieved === total) {
-                assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
-                done();
-            }
-        });
+        }
+        assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
     });
+ 
+    it('Statement#each with complete callback', async function() {
+        const total = 10000;
+        let retrieved = 0;
 
-    it('Statement#each with complete callback', function(done) {
-        var total = 10000;
-        var retrieved = 0;
-
-        db.each('SELECT id, txt FROM foo LIMIT 0, ?', total, function(err, row) {
-            if (err) throw err;
+        for await (const _row of await db.each('SELECT id, txt FROM foo LIMIT 0, ?', total)) {
             retrieved++;
-        }, function(err, num) {
-            assert.equal(retrieved, num);
-            assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
-            done();
-        });
+        }
+        assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
     });
 });
diff --git a/test/exec.test.js b/test/exec.test.js
index e3d55329..cb1d2fed 100644
--- a/test/exec.test.js
+++ b/test/exec.test.js
@@ -1,39 +1,37 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
+const sqlite3 = require('..');
+const assert = require('assert');
+const fs = require('fs');
 
 describe('exec', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
     });
 
-    it('Database#exec', function(done) {
-        var sql = fs.readFileSync('test/support/script.sql', 'utf8');
-        db.exec(sql, done);
+    it('Database#exec', async function() {
+        const sql = fs.readFileSync('test/support/script.sql', 'utf8');
+        await db.exec(sql);
     });
 
-    it('retrieve database structure', function(done) {
-        db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err, rows) {
-            if (err) throw err;
-            assert.deepEqual(rows, [
-                { type: 'index', name: 'grid_key_lookup' },
-                { type: 'index', name: 'grid_utfgrid_lookup' },
-                { type: 'index', name: 'images_id' },
-                { type: 'index', name: 'keymap_lookup' },
-                { type: 'index', name: 'map_index' },
-                { type: 'index', name: 'name' },
-                { type: 'table', name: 'grid_key' },
-                { type: 'table', name: 'grid_utfgrid' },
-                { type: 'table', name: 'images' },
-                { type: 'table', name: 'keymap' },
-                { type: 'table', name: 'map' },
-                { type: 'table', name: 'metadata' },
-                { type: 'view', name: 'grid_data' },
-                { type: 'view', name: 'grids' },
-                { type: 'view', name: 'tiles' }
-            ]);
-            done();
-        });
+    it('retrieve database structure', async function() {
+        const rows = await db.all("SELECT type, name FROM sqlite_master ORDER BY type, name");
+        assert.deepEqual(rows, [
+            { type: 'index', name: 'grid_key_lookup' },
+            { type: 'index', name: 'grid_utfgrid_lookup' },
+            { type: 'index', name: 'images_id' },
+            { type: 'index', name: 'keymap_lookup' },
+            { type: 'index', name: 'map_index' },
+            { type: 'index', name: 'name' },
+            { type: 'table', name: 'grid_key' },
+            { type: 'table', name: 'grid_utfgrid' },
+            { type: 'table', name: 'images' },
+            { type: 'table', name: 'keymap' },
+            { type: 'table', name: 'map' },
+            { type: 'table', name: 'metadata' },
+            { type: 'view', name: 'grid_data' },
+            { type: 'view', name: 'grids' },
+            { type: 'view', name: 'tiles' }
+        ]);
     });
 });
diff --git a/test/extension.test.js b/test/extension.test.js
index 36c350fa..f39e3fac 100644
--- a/test/extension.test.js
+++ b/test/extension.test.js
@@ -1,26 +1,21 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var exists = require('fs').existsSync || require('path').existsSync;
+const { join } = require('node:path');
+const sqlite3 = require('..');
+const { cwd } = require('node:process');
+const { exec: execCb } = require('node:child_process');
+const {promisify} = require('node:util');
 
-/*
+const exec = promisify(execCb);
 
-// disabled because this is not a generically safe test to run on all systems
+const uuidExtension = join(cwd(), 'test', 'support', 'uuid.c');
 
-var spatialite_ext = '/usr/local/lib/libspatialite.dylib';
 
-describe('loadExtension', function(done) {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+describe('loadExtension', function() {
+    before(async function() {
+        await exec(`gcc -g -fPIC -shared ${uuidExtension} -o ${uuidExtension}.so`);
     });
 
-    if (exists(spatialite_ext)) {
-        it('libspatialite', function(done) {
-            db.loadExtension(spatialite_ext, done);
-        });
-    } else {
-        it('libspatialite');
-    }
+    it('can load the uuid extension', async function() {
+        const db = await sqlite3.Database.create(':memory:');
+        await db.loadExtension(uuidExtension);
+    });
 });
-
-*/
\ No newline at end of file
diff --git a/test/fts-content.test.js b/test/fts-content.test.js
index c7095a9c..39a99707 100644
--- a/test/fts-content.test.js
+++ b/test/fts-content.test.js
@@ -1,13 +1,13 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
 
 describe('fts', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
     });
 
-    it('should create a new fts4 table', function(done) {
-        db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);', done);
+    it('should create a new fts4 table', async function() {
+        await db.exec('CREATE VIRTUAL TABLE t1 USING fts4(content="", a, b, c);');
     });
 });
diff --git a/test/interrupt.test.js b/test/interrupt.test.js
index 708f4caf..5ca531ba 100644
--- a/test/interrupt.test.js
+++ b/test/interrupt.test.js
@@ -1,80 +1,70 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('interrupt', function() {
-    it('should interrupt queries', function(done) {
-        var interrupted = false;
-        var saved = null;
+    it('should interrupt queries', async function() {
+        let interrupted = false;
+        let saved = null;
 
-        var db = new sqlite3.Database(':memory:', function() {
-            db.serialize();
-
-            var setup = 'create table t (n int);';
-            for (var i = 0; i < 8; i += 1) {
+        const db = await sqlite3.Database.create(':memory:');
+        await db.serialize(async () => {
+    
+            let setup = 'create table t (n int);';
+            for (let i = 0; i < 8; i += 1) {
                 setup += 'insert into t values (' + i + ');';
             }
-
-            db.exec(setup, function(err) {
-                if (err) {
-                    return done(err);
-                }
-
-                var query = 'select last.n ' +
-                    'from t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t as last';
-
-                db.each(query, function(err) {
-                    if (err) {
-                        saved = err;
-                    } else if (!interrupted) {
+    
+            await db.exec(setup);
+    
+            const query = 'select last.n ' +
+                'from t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t as last';
+    
+            try {
+                for await (const _row of await db.each(query)) {
+                    if (!interrupted) {
                         interrupted = true;
                         db.interrupt();
                     }
-                });
-
-                db.close(function() {
-                    if (saved) {
-                        assert.equal(saved.message, 'SQLITE_INTERRUPT: interrupted');
-                        assert.equal(saved.errno, sqlite3.INTERRUPT);
-                        assert.equal(saved.code, 'SQLITE_INTERRUPT');
-                        done();
-                    } else {
-                        done(new Error('Completed query without error, but expected error'));
-                    }
-                });
-            });
+                }
+            } catch (err) {
+                saved = err;
+            } finally {
+                await db.close();
+            }
+    
+            if (!saved) throw new Error('Completed query without error, but expected error');
+            assert.equal(saved.message, 'SQLITE_INTERRUPT: interrupted');
+            assert.equal(saved.errno, sqlite3.INTERRUPT);
+            assert.equal(saved.code, 'SQLITE_INTERRUPT');
         });
+        
     });
 
-    it('should throw if interrupt is called before open', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('should throw if interrupt is called before open', async function() {
+        // @ts-expect-error Calling private constructor for testing
+        const db = new sqlite3.Database(':memory:');
 
         assert.throws(function() {
             db.interrupt();
         }, (/Database is not open/));
-
-        db.close();
-        done();
     });
 
-    it('should throw if interrupt is called after close', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('should throw if interrupt is called after close', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        db.close(function() {
-            assert.throws(function() {
-                db.interrupt();
-            }, (/Database is not open/));
+        await db.close();
 
-            done();
-        });
+        assert.throws(function() {
+            db.interrupt();
+        }, (/Database is not open/));
     });
 
-    it('should throw if interrupt is called during close', function(done) {
-        var db = new sqlite3.Database(':memory:', function() {
-            db.close();
-            assert.throws(function() {
-                db.interrupt();
-            }, (/Database is closing/));
-            done();
-        });
+    it('should throw if interrupt is called during close', async function() {
+        const db = await sqlite3.Database.create(':memory:');
+        db.close();
+
+        assert.throws(function() {
+            db.interrupt();
+        }, (/Database is closing/));
     });
 });
diff --git a/test/issue-108.test.js b/test/issue-108.test.js
index 99343782..adddd600 100644
--- a/test/issue-108.test.js
+++ b/test/issue-108.test.js
@@ -1,28 +1,23 @@
-var sqlite3 = require('..'),
-    assert = require('assert');
+const sqlite3 = require('..');
 
 describe('buffer', function() {
-    var db;
+    /** @type {sqlite3.Database} */
+    let db;
     // before(function() {
     // });
 
-    it('should insert blobs', function(done) {
-        db = new sqlite3.Database(':memory:');
-        db.serialize(function () {
+    it('should insert blobs', async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.serialize(async function () {
 
-            db.run("CREATE TABLE lorem (info BLOB)");
-            var stmt = db.prepare("INSERT INTO lorem VALUES (?)");
+            await db.run("CREATE TABLE lorem (info BLOB)");
+            const stmt = await db.prepare("INSERT INTO lorem VALUES (?)");
 
-            stmt.on('error', function (err) {
-                throw err;
-            });
-
-            var buff = Buffer.alloc(2);
-            stmt.run(buff);
-            stmt.finalize();
+            const buff = Buffer.alloc(2);
+            await stmt.run(buff);
+            await stmt.finalize();
         });
 
-        db.close(done);
-
+        await db.close();
     });
 });
diff --git a/test/json.test.js b/test/json.test.js
index 6d7d32da..44d8c15a 100644
--- a/test/json.test.js
+++ b/test/json.test.js
@@ -1,4 +1,4 @@
-var sqlite3 = require('..');
+const sqlite3 = require('..');
 
 if( process.env.NODE_SQLITE3_JSON1 === 'no' ){
     describe('json', function() {
@@ -9,14 +9,15 @@ if( process.env.NODE_SQLITE3_JSON1 === 'no' ){
     });
 } else {
     describe('json', function() {
-        var db;
+        /** @type {sqlite3.Database} */
+        let db;
 
-        before(function(done) {
-            db = new sqlite3.Database(':memory:', done);
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
         });
 
-        it('should select JSON', function(done) {
-            db.run('SELECT json(?)', JSON.stringify({ok:true}), done);
+        it('should select JSON', async function() {
+            await db.run('SELECT json(?)', JSON.stringify({ok:true}));
         });
     });
 }
diff --git a/test/limit.test.js b/test/limit.test.js
index d79f2c8d..b1cca6f9 100644
--- a/test/limit.test.js
+++ b/test/limit.test.js
@@ -1,28 +1,32 @@
-var sqlite3 = require('..');
+const sqlite3 = require('..');
+const assert = require('node:assert');
 
 describe('limit', function() {
-    var db;
+    /** @type {sqlite3.Database} */
+    let db;
 
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
     });
 
-    it('should support applying limits via configure', function(done) {
+    it('should support applying limits via configure', async function() {
         db.configure('limit', sqlite3.LIMIT_ATTACHED, 0);
-        db.exec("ATTACH 'test/support/prepare.db' AS zing", function(err) {
-            if (!err) {
-                throw new Error('ATTACH should not succeed');
-            }
-            if (err.errno === sqlite3.ERROR &&
-                err.message === 'SQLITE_ERROR: too many attached databases - max 0') {
-                db.configure('limit', sqlite3.LIMIT_ATTACHED, 1);
-                db.exec("ATTACH 'test/support/prepare.db' AS zing", function(err) {
-                    if (err) throw err;
-                    db.close(done);
-                });
-            } else {
-                throw err;
-            }
-        });
+        let caught;
+        try {
+            await db.exec("ATTACH 'test/support/prepare.db' AS zing");
+        } catch (err) {
+            caught = err;
+        }
+
+        if (!caught) {
+            await db.close();
+            throw new Error('ATTACH should not succeed');
+        }
+
+        assert.strictEqual(caught.errno, sqlite3.ERROR);
+        assert.strictEqual(caught.message, 'SQLITE_ERROR: too many attached databases - max 0');
+        db.configure('limit', sqlite3.LIMIT_ATTACHED, 1);
+        await db.exec("ATTACH 'test/support/prepare.db' AS zing");
+        await db.close();
     });
 });
diff --git a/test/map.test.js b/test/map.test.js
index db190a7c..cb0d37a0 100644
--- a/test/map.test.js
+++ b/test/map.test.js
@@ -1,63 +1,53 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('map', function() {
-    it('test Database#map() with two columns', function(done) {
-        var count = 10;
-        var inserted = 0;
-
-        var db = new sqlite3.Database(':memory:');
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id INT, value TEXT)");
-
-            var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-            for (var i = 5; i < count; i++) {
-                stmt.run(i, 'Value for ' + i, function(err) {
-                    if (err) throw err;
-                    inserted++;
-                });
+    it('test Database#map() with two columns', async function() {
+        const count = 10;
+        let inserted = 0;
+
+        const db = await sqlite3.Database.create(':memory:');
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id INT, value TEXT)");
+
+            const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)");
+            for (let i = 5; i < count; i++) {
+                await stmt.run(i, 'Value for ' + i);
+                inserted++;
             }
-            stmt.finalize();
+            await stmt.finalize();
 
-            db.map("SELECT * FROM foo", function(err, map) {
-                if (err) throw err;
-                assert.deepEqual(map, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' });
-                assert.equal(inserted, 5);
-                done();
-            });
+            const results = await db.map("SELECT * FROM foo");
+            assert.deepEqual(results, { 5: 'Value for 5', 6: 'Value for 6', 7: 'Value for 7', 8: 'Value for 8', 9: 'Value for 9' });
+            assert.equal(inserted, 5);
         });
     });
 
-    it('test Database#map() with three columns', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('test Database#map() with three columns', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        var count = 10;
-        var inserted = 0;
+        const count = 10;
+        let inserted = 0;
 
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)");
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id INT, value TEXT, other TEXT)");
 
-            var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?)");
-            for (var i = 5; i < count; i++) {
-                stmt.run(i, 'Value for ' + i, null, function(err) {
-                    if (err) throw err;
-                    inserted++;
-                });
+            const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?, ?)");
+            for (let i = 5; i < count; i++) {
+                await stmt.run(i, 'Value for ' + i);
+                inserted++;
             }
-            stmt.finalize();
-
-            db.map("SELECT * FROM foo", function(err, map) {
-                if (err) throw err;
-                assert.deepEqual(map, {
-                    5: { id: 5, value: 'Value for 5', other: null },
-                    6: { id: 6, value: 'Value for 6', other: null },
-                    7: { id: 7, value: 'Value for 7', other: null },
-                    8: { id: 8, value: 'Value for 8', other: null },
-                    9: { id: 9, value: 'Value for 9', other: null }
-                });
-                assert.equal(inserted, 5);
-                done();
+            await stmt.finalize();
+
+            const results = await db.map("SELECT * FROM foo");
+            assert.deepEqual(results, {
+                5: { id: 5, value: 'Value for 5', other: null },
+                6: { id: 6, value: 'Value for 6', other: null },
+                7: { id: 7, value: 'Value for 7', other: null },
+                8: { id: 8, value: 'Value for 8', other: null },
+                9: { id: 9, value: 'Value for 9', other: null }
             });
+            assert.equal(inserted, 5);
         });
     });
 });
diff --git a/test/named_columns.test.js b/test/named_columns.test.js
index 9973bfce..f97b5c02 100644
--- a/test/named_columns.test.js
+++ b/test/named_columns.test.js
@@ -1,38 +1,36 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('named columns', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
     });
 
-    it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (txt TEXT, num INT)", done);
+    it('should create the table', async function() {
+        await db.run("CREATE TABLE foo (txt TEXT, num INT)");
     });
 
-    it('should insert a value', function(done) {
-        db.run("INSERT INTO foo VALUES($text, $id)", {
+    it('should insert a value', async function() {
+        await db.run("INSERT INTO foo VALUES($text, $id)", {
             $id: 1,
             $text: "Lorem Ipsum"
-        }, done);
+        });
     });
 
-    it('should retrieve the values', function(done) {
-        db.get("SELECT txt, num FROM foo ORDER BY num", function(err, row) {
-            if (err) throw err;
-            assert.equal(row.txt, "Lorem Ipsum");
-            assert.equal(row.num, 1);
-            done();
-        });
+    it('should retrieve the values', async function() {
+        const row = await db.get("SELECT txt, num FROM foo ORDER BY num");
+        assert.equal(row.txt, "Lorem Ipsum");
+        assert.equal(row.num, 1);
     });
 
-    it('should be able to retrieve rowid of last inserted value', function(done) {
-        db.get("SELECT last_insert_rowid() as last_id FROM foo", function(err, row) {
-            if (err) throw err;
-            assert.equal(row.last_id, 1);
-            done();
-        });
+    it('should be able to retrieve rowid of last inserted value', async function() {
+        const row = await db.get("SELECT last_insert_rowid() as last_id FROM foo");
+        assert.equal(row.last_id, 1);
     });
 
+    after(async function() {
+        await db.close();
+    });
 });
diff --git a/test/named_params.test.js b/test/named_params.test.js
index c03f2dd7..e4caf849 100644
--- a/test/named_params.test.js
+++ b/test/named_params.test.js
@@ -1,69 +1,71 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('named parameters', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
     });
 
-    it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (txt TEXT, num INT)", done);
+    it('should create the table', async function() {
+        await db.run("CREATE TABLE foo (txt TEXT, num INT)");
     });
 
-    it('should insert a value with $ placeholders', function(done) {
-        db.run("INSERT INTO foo VALUES($text, $id)", {
+    it('should insert a value with $ placeholders', async function() {
+        await db.run("INSERT INTO foo VALUES($text, $id)", {
             $id: 1,
             $text: "Lorem Ipsum"
-        }, done);
+        });
     });
 
-    it('should insert a value with : placeholders', function(done) {
-        db.run("INSERT INTO foo VALUES(:text, :id)", {
+    it('should insert a value with : placeholders', async function() {
+        await db.run("INSERT INTO foo VALUES(:text, :id)", {
             ':id': 2,
             ':text': "Dolor Sit Amet"
-        }, done);
+        });
     });
 
-    it('should insert a value with @ placeholders', function(done) {
-        db.run("INSERT INTO foo VALUES(@txt, @id)", {
+    it('should insert a value with @ placeholders', async function() {
+        await db.run("INSERT INTO foo VALUES(@txt, @id)", {
             "@id": 3,
             "@txt": "Consectetur Adipiscing Elit"
-        }, done);
+        });
     });
 
-    it('should insert a value with @ placeholders using an array', function(done) {
-        db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ], done);
+    it('should insert a value with @ placeholders using an array', async function() {
+        await db.run("INSERT INTO foo VALUES(@txt, @id)", [ 'Sed Do Eiusmod', 4 ]);
     });
 
-    it('should insert a value with indexed placeholders', function(done) {
-        db.run("INSERT INTO foo VALUES(?2, ?4)",
-            [ null, 'Tempor Incididunt', null, 5 ], done);
+    it('should insert a value with indexed placeholders', async function() {
+        await db.run("INSERT INTO foo VALUES(?2, ?4)",
+            [ null, 'Tempor Incididunt', null, 5 ]);
     });
 
-    it('should insert a value with autoindexed placeholders', function(done) {
-        db.run("INSERT INTO foo VALUES(?, ?)", {
+    it('should insert a value with autoindexed placeholders', async function() {
+        await db.run("INSERT INTO foo VALUES(?, ?)", {
             2: 6,
             1: "Ut Labore Et Dolore"
-        }, done);
+        });
     });
 
-    it('should retrieve all inserted values', function(done) {
-        db.all("SELECT txt, num FROM foo ORDER BY num", function(err, rows) {
-            if (err) throw err;
-            assert.equal(rows[0].txt, "Lorem Ipsum");
-            assert.equal(rows[0].num, 1);
-            assert.equal(rows[1].txt, "Dolor Sit Amet");
-            assert.equal(rows[1].num, 2);
-            assert.equal(rows[2].txt, "Consectetur Adipiscing Elit");
-            assert.equal(rows[2].num, 3);
-            assert.equal(rows[3].txt, "Sed Do Eiusmod");
-            assert.equal(rows[3].num, 4);
-            assert.equal(rows[4].txt, "Tempor Incididunt");
-            assert.equal(rows[4].num, 5);
-            assert.equal(rows[5].txt, "Ut Labore Et Dolore");
-            assert.equal(rows[5].num, 6);
-            done();
-        });
+    it('should retrieve all inserted values', async function() {
+        const rows = await db.all("SELECT txt, num FROM foo ORDER BY num");
+        assert.equal(rows[0].txt, "Lorem Ipsum");
+        assert.equal(rows[0].num, 1);
+        assert.equal(rows[1].txt, "Dolor Sit Amet");
+        assert.equal(rows[1].num, 2);
+        assert.equal(rows[2].txt, "Consectetur Adipiscing Elit");
+        assert.equal(rows[2].num, 3);
+        assert.equal(rows[3].txt, "Sed Do Eiusmod");
+        assert.equal(rows[3].num, 4);
+        assert.equal(rows[4].txt, "Tempor Incididunt");
+        assert.equal(rows[4].num, 5);
+        assert.equal(rows[5].txt, "Ut Labore Et Dolore");
+        assert.equal(rows[5].num, 6);
+    });
+
+    after(async function() {
+        await db.close();
     });
 });
diff --git a/test/null_error.test.js b/test/null_error.test.js
index 8c34d9bf..db8a8d7c 100644
--- a/test/null_error.test.js
+++ b/test/null_error.test.js
@@ -1,40 +1,32 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+const sqlite3 = require('..');
+const helper = require('./support/helper');
 
 describe('null error', function() {
-    var filename = 'test/tmp/test_sqlite_ok_error.db';
-    var db;
+    const filename = 'test/tmp/test_sqlite_ok_error.db';
+    /** @type {sqlite3.Database} */
+    let db;
 
-    before(function(done) {
+    before(async function() {
         helper.ensureExists('test/tmp');
         helper.deleteFile(filename);
-        db = new sqlite3.Database(filename, done);
+        db = await sqlite3.Database.create(filename);
     });
-
-    it('should create a table', function(done) {
-        db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)", done);
-    });
-
-    it('should insert rows with lots of null values', function(done) {
-        var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) {
+    
+    it('should insert rows with lots of null values', async function() {
+        await db.run("CREATE TABLE febp_data (leacode TEXT, leaname TEXT, state TEXT, postcode TEXT, fips TEXT, titleistim TEXT, ideastim TEXT, ideapool TEXT, ideapoolname TEXT, localebasis TEXT, localetype2 TEXT, version TEXT, leacount_2006 TEXT, ppexpend_2005 TEXT, ppexpend_2006 TEXT, ppexpend_2007 TEXT, ppexpend_2008 TEXT, ppexpendrank_2006 TEXT, ppexpendrank_2007 TEXT, ppexpendrank_2008 TEXT, rankppexpend_2005 TEXT, opbud_2004 TEXT, opbud_2006 TEXT, opbud_2007 TEXT, opbud_2008 TEXT, titlei_2004 TEXT, titlei_2006 TEXT, titlei_2007 TEXT, titlei_2008 TEXT, titlei_2009 TEXT, titlei_2010 TEXT, idea_2004 TEXT, idea_2005 TEXT, idea_2006 TEXT, idea_2007 TEXT, idea_2008 TEXT, idea_2009 TEXT, ideaest_2010 TEXT, impact_2007 TEXT, impact_2008 TEXT, impact_2009 TEXT, impact_2010 TEXT, fedrev_2006 TEXT, fedrev_2007 TEXT, fedrev_2008 TEXT, schonut_2006 TEXT, schonut_2007 TEXT, schomeal_2006 TEXT, schomeal_2007 TEXT, schoco_2006 TEXT, schocom_2007 TEXT, medicaid_2006 TEXT, medicaid_2007 TEXT, medicaid_2008 TEXT, cenpov_2004 TEXT, cenpov_2007 TEXT, cenpov_2008 TEXT, rankcenpov_2004 TEXT, rankcenpov_2007 TEXT, rankcenpov_2008 TEXT, enroll_2006 TEXT, enroll_2007 TEXT, enroll_2008 TEXT, white_2006 TEXT, white_2007 TEXT, white_2008 TEXT, afam_2006 TEXT, afam_2007 TEXT, afam_2008 TEXT, amin_2006 TEXT, amin_2007 TEXT, amin_2008 TEXT, asian_2006 TEXT, asian_2007 TEXT, asian_2008 TEXT, hisp_2006 TEXT, hisp_2007 TEXT, hisp_2008 TEXT, frpl_2006 TEXT, frpl_2007 TEXT, frpl_2008 TEXT, ell_2006 TEXT, ell_2007 TEXT, ell_2008 TEXT, sped_2006 TEXT, sped_2007 TEXT, sped_2008 TEXT, state4read_2005 TEXT, state4read_2006 TEXT, state4read_2007 TEXT, state4read_2008 TEXT, state4read_2009 TEXT, state4math_2005 TEXT, state4math_2006 TEXT, state4math_2007 TEXT, state4math_2008 TEXT, state4math_2009 TEXT, minor_2007 TEXT, minor_2008 TEXT, state8math_2006 TEXT, state8math_2007 TEXT, state8math_2008 TEXT, state8math_2009 TEXT, state8read_2006 TEXT, state8read_2007 TEXT, state8read_2008 TEXT, state8read_2009 TEXT, statehsmath_2006 TEXT, statehsmath_2007 TEXT, statehsmath_2008 TEXT, statehsmath_2009 TEXT, statehsread_2006 TEXT, statehsread_2007 TEXT, statehsread_2008 TEXT, statehsread_2009 TEXT)");
+        const stmt = await db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) {
             if (err) throw err;
 
-            for (var i = 0; i < 100; i++) {
-                stmt.run([ '100005', 'Albertville City School District', 'ALABAMA', 'AL', '1', '856031', '753000', 'NULL', 'NULL', '6-Small Town', 'Town', 21, '130', '6624', '7140', '8731', '8520', '102', '88', '100', '94', '23352000', '27280000', '30106000', '33028000', '768478', '845886', '782696', '1096819', '1279663', '1168521', '561522', '657649', '684366', '687531', '710543', '727276', '726647', 'N/A', 'N/A', 'N/A', 'N/A', '986', '977', '1006', '1080250', '1202325', '1009962', '1109310', '70287', '93015', '14693.56', '13634.58', 'N/A', '0.230', '0.301', '0.268882175', '73', '26', '29', '3718', '3747', '3790', '2663', '2615', '2575', '75', '82', '89', '3', '2', '6', '11', '9', '8', '955', '1028', '1102', '1991', '2061', '2146', '649', '729', '770', '443', '278', '267', '0.860', '0.86', '0.8474', '0.84', '0.8235', '0.810', '0.84', '0.7729', '0.75', '0.7843', '1121', '1205', '0.74', '0.6862', '0.72', '0.7317', '0.78', '0.7766', '0.79', '0.7387', '0.84', '0.9255', '0.86', '0.9302', '0.88', '0.9308', '0.84', '0.8605' ]);
-            }
-
-            stmt.finalize(function(err) {
-                if (err) throw err;
-                done();
-            });
         });
-    });
 
-    it('should have created the database', function() {
-        assert.fileExists(filename);
+        for (let i = 0; i < 100; i++) {
+            await stmt.run([ '100005', 'Albertville City School District', 'ALABAMA', 'AL', '1', '856031', '753000', 'NULL', 'NULL', '6-Small Town', 'Town', 21, '130', '6624', '7140', '8731', '8520', '102', '88', '100', '94', '23352000', '27280000', '30106000', '33028000', '768478', '845886', '782696', '1096819', '1279663', '1168521', '561522', '657649', '684366', '687531', '710543', '727276', '726647', 'N/A', 'N/A', 'N/A', 'N/A', '986', '977', '1006', '1080250', '1202325', '1009962', '1109310', '70287', '93015', '14693.56', '13634.58', 'N/A', '0.230', '0.301', '0.268882175', '73', '26', '29', '3718', '3747', '3790', '2663', '2615', '2575', '75', '82', '89', '3', '2', '6', '11', '9', '8', '955', '1028', '1102', '1991', '2061', '2146', '649', '729', '770', '443', '278', '267', '0.860', '0.86', '0.8474', '0.84', '0.8235', '0.810', '0.84', '0.7729', '0.75', '0.7843', '1121', '1205', '0.74', '0.6862', '0.72', '0.7317', '0.78', '0.7766', '0.79', '0.7387', '0.84', '0.9255', '0.86', '0.9302', '0.88', '0.9308', '0.84', '0.8605' ]);
+        }
+    
+        await stmt.finalize();
     });
 
+
     after(function() {
         helper.deleteFile(filename);
     });
diff --git a/test/open_close.test.js b/test/open_close.test.js
index 49d2af79..fa964597 100644
--- a/test/open_close.test.js
+++ b/test/open_close.test.js
@@ -1,25 +1,25 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
-var helper = require('./support/helper');
+const sqlite3 = require('..');
+const assert = require('assert');
+const helper = require('./support/helper');
 
 describe('open/close', function() {
     before(function() {
         helper.ensureExists('test/tmp');
     });
 
-    describe('open and close non-existant database', function() {
+    describe('open and close non-existant database', async function() {
         before(function() {
             helper.deleteFile('test/tmp/test_create.db');
         });
 
-        var db;
-        it('should open the database', function(done) {
-            db = new sqlite3.Database('test/tmp/test_create.db', done);
+        /** @type {sqlite3.Database} */
+        let db;
+        it('should open the database', async function() {
+            db = await sqlite3.Database.create('test/tmp/test_create.db');
         });
 
-        it('should close the database', function(done) {
-            db.close(done);
+        it('should close the database', async function() {
+            await db.close();
         });
 
         it('should have created the file', function() {
@@ -36,13 +36,14 @@ describe('open/close', function() {
             helper.deleteFile('test/tmp/test_create_shared.db');
         });
 
-        var db;
-        it('should open the database', function(done) {
-            db = new sqlite3.Database('file:./test/tmp/test_create_shared.db', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, done);
+        /** @type {sqlite3.Database} */
+        let db;
+        it('should open the database', async function() {
+            db = await sqlite3.Database.create('file:./test/tmp/test_create_shared.db', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE);
         });
 
-        it('should close the database', function(done) {
-            db.close(done);
+        it('should close the database', async function() {
+            await db.close();
         });
 
         it('should have created the file', function() {
@@ -57,49 +58,44 @@ describe('open/close', function() {
 
     (sqlite3.VERSION_NUMBER < 3008000 ? describe.skip : describe)('open and close shared memory database', function() {
 
-        var db1;
-        var db2;
+        /** @type {sqlite3.Database} */
+        let db1;
+        /** @type {sqlite3.Database} */
+        let db2;
 
-        it('should open the first database', function(done) {
-            db1 = new sqlite3.Database('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, done);
+        it('should open the first database', async function() {
+            db1 = await sqlite3.Database.create('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE);
         });
 
-        it('should open the second database', function(done) {
-            db2 = new sqlite3.Database('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, done);
+        it('should open the second database', async function() {
+            db2 = await sqlite3.Database.create('file:./test/tmp/test_memory.db?mode=memory', sqlite3.OPEN_URI | sqlite3.OPEN_SHAREDCACHE | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE);
         });
 
-        it('first database should set the user_version', function(done) {
-            db1.exec('PRAGMA user_version=42', done);
+        it('first database should set the user_version', async function() {
+            await db1.exec('PRAGMA user_version=42');
         });
 
-        it('second database should get the user_version', function(done) {
-            db2.get('PRAGMA user_version', function(err, row) {
-                if (err) throw err;
-                assert.equal(row.user_version, 42);
-                done();
-            });
+        it('second database should get the user_version', async function() {
+            const row = await db2.get('PRAGMA user_version');
+            assert.equal(row.user_version, 42);
         });
 
-        it('should close the first database', function(done) {
-            db1.close(done);
+        it('should close the first database', async function() {
+            await db1.close();
         });
 
-        it('should close the second database', function(done) {
-            db2.close(done);
+        it('should close the second database', async function() {
+            await db2.close();
         });
     });
 
-    it('should not be unable to open an inaccessible database', function(done) {
-        // NOTE: test assumes that the user is not allowed to create new files
-        // in /usr/bin.
-        var db = new sqlite3.Database('/test/tmp/directory-does-not-exist/test.db', function(err) {
-            if (err && err.errno === sqlite3.CANTOPEN) {
-                done();
-            } else if (err) {
-                done(err);
-            } else {
-                done('Opened database that should be inaccessible');
-            }
+    it('should not be unable to open an inaccessible database', async function() {
+        await assert.rejects(async () => {
+            const db = await sqlite3.Database.create('/test/tmp/directory-does-not-exist/test.db');
+            await db.close();
+        }, (err) => {
+            assert.strictEqual(err.errno, sqlite3.CANTOPEN);
+            return true;
         });
     });
 
@@ -109,19 +105,15 @@ describe('open/close', function() {
             helper.deleteFile('test/tmp/test_readonly.db');
         });
 
-        it('should fail to open the database', function(done) {
-            new sqlite3.Database('tmp/test_readonly.db', sqlite3.OPEN_READONLY, function(err) {
-                if (err && err.errno === sqlite3.CANTOPEN) {
-                    done();
-                } else if (err) {
-                    done(err);
-                } else {
-                    done('Created database without create flag');
-                }
+        it('should fail to open the database', async function() {
+            await assert.rejects(async () => {
+                const db = await sqlite3.Database.create('test/tmp/test_readonly.db', sqlite3.READONLY);
+                await db.close();
+            }, (err) => {
+                // TODO: This is the wrong error code?
+                assert.strictEqual(err.errno, sqlite3.MISUSE);
+                return true;
             });
-        });
-
-        it('should not have created the file', function() {
             assert.fileDoesNotExist('test/tmp/test_readonly.db');
         });
 
@@ -131,57 +123,43 @@ describe('open/close', function() {
     });
 
     describe('open and close memory database queuing', function() {
-        var db;
-        it('should open the database', function(done) {
-            db = new sqlite3.Database(':memory:', done);
-        });
 
-        it('should close the database', function(done) {
-            db.close(done);
-        });
-
-        it('shouldn\'t close the database again', function(done) {
-            db.close(function(err) {
+        
+        it('shouldn\'t close the database twice', async function() {
+            const db = await sqlite3.Database.create(':memory:');
+            await db.close();
+            await assert.rejects(db.close(), (err) => {
                 assert.ok(err, 'No error object received on second close');
                 assert.ok(err.errno === sqlite3.MISUSE);
-                done();
+                return true;
             });
         });
     });
 
     describe('closing with unfinalized statements', function(done) {
-        var completed = false;
-        var completedSecond = false;
-        var closed = false;
-
-        var db;
-        before(function() {
-            db = new sqlite3.Database(':memory:', done);
-        });
-
-        it('should create a table', function(done) {
-            db.run("CREATE TABLE foo (id INT, num INT)", done);
-        });
-
-        var stmt;
-        it('should prepare/run a statement', function(done) {
-            stmt = db.prepare('INSERT INTO foo VALUES (?, ?)');
+        /** @type {sqlite3.Database} */
+        let db;
+        /** @type {sqlite3.Statement} */
+        let stmt;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:', done);
+            await db.run("CREATE TABLE foo (id INT, num INT)");
+            stmt = await db.prepare('INSERT INTO foo VALUES (?, ?)');
             stmt.run(1, 2, done);
         });
 
-        it('should fail to close the database', function(done) {
-            db.close(function(err) {
+        it('should fail to close the database', async function() {
+            await assert.rejects(db.close(), function(err) {
                 assert.ok(err.message,
                     "SQLITE_BUSY: unable to close due to unfinalised statements");
-                done();
+                return true;
             });
         });
 
-        it('should succeed to close the database after finalizing', function(done) {
-            stmt.run(3, 4, function() {
-                stmt.finalize();
-                db.close(done);
-            });
+        it('should succeed to close the database after finalizing', async function() {
+            await stmt.run(3, 4);
+            await stmt.finalize();
+            await db.close();
         });
     });
 });
diff --git a/test/other_objects.test.js b/test/other_objects.test.js
index cc516c49..3078853d 100644
--- a/test/other_objects.test.js
+++ b/test/other_objects.test.js
@@ -1,42 +1,33 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('data types', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:');
-        db.run("CREATE TABLE txt_table (txt TEXT)");
-        db.run("CREATE TABLE int_table (int INTEGER)");
-        db.run("CREATE TABLE flt_table (flt FLOAT)");
-        db.wait(done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.run("CREATE TABLE txt_table (txt TEXT)");
+        await db.run("CREATE TABLE int_table (int INTEGER)");
+        await db.run("CREATE TABLE flt_table (flt FLOAT)");
+        await db.wait();
     });
 
-    beforeEach(function(done) {
-        db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;', done);
+    beforeEach(async function() {
+        await db.exec('DELETE FROM txt_table; DELETE FROM int_table; DELETE FROM flt_table;');
     });
 
-    it('should serialize Date()', function(done) {
-        var date = new Date();
-        db.run("INSERT INTO int_table VALUES(?)", date, function (err) {
-            if (err) throw err;
-            db.get("SELECT int FROM int_table", function(err, row) {
-                if (err) throw err;
-                assert.equal(row.int, +date);
-                done();
-            });
-        });
+    it('should serialize Date()', async function() {
+        const date = new Date();
+        await db.run("INSERT INTO int_table VALUES(?)", date);
+        const row = await db.get("SELECT int FROM int_table");
+        assert.equal(row.int, +date);
     });
 
-    it('should serialize RegExp()', function(done) {
-        var regexp = /^f\noo/;
-        db.run("INSERT INTO txt_table VALUES(?)", regexp, function (err) {
-            if (err) throw err;
-            db.get("SELECT txt FROM txt_table", function(err, row) {
-                if (err) throw err;
-                assert.equal(row.txt, String(regexp));
-                done();
-            });
-        });
+    it('should serialize RegExp()', async function() {
+        const regexp = /^f\noo/;
+        await db.run("INSERT INTO txt_table VALUES(?)", regexp);
+        const row = await db.get("SELECT txt FROM txt_table");
+        assert.equal(row.txt, String(regexp));
     });
 
     [
@@ -52,15 +43,10 @@ describe('data types', function() {
         -2.3948728634826374e+83,
         -Infinity
     ].forEach(function(flt) {
-        it('should serialize float ' + flt, function(done) {
-            db.run("INSERT INTO flt_table VALUES(?)", flt, function (err) {
-                if (err) throw err;
-                db.get("SELECT flt FROM flt_table", function(err, row) {
-                    if (err) throw err;
-                    assert.equal(row.flt, flt);
-                    done();
-                });
-            });
+        it('should serialize float ' + flt, async function() {
+            await db.run("INSERT INTO flt_table VALUES(?)", flt);
+            const row = await db.get("SELECT flt FROM flt_table");
+            assert.equal(row.flt, flt);
         });
     });
 
@@ -75,40 +61,28 @@ describe('data types', function() {
         -2.3948728634826374e+83,
         -Infinity
     ].forEach(function(integer) {
-        it('should serialize integer ' + integer, function(done) {
-            db.run("INSERT INTO int_table VALUES(?)", integer, function (err) {
-                if (err) throw err;
-                db.get("SELECT int AS integer FROM int_table", function(err, row) {
-                    if (err) throw err;
-                    assert.equal(row.integer, integer);
-                    done();
-                });
-            });
+        it('should serialize integer ' + integer, async function() {
+            await db.run("INSERT INTO int_table VALUES(?)", integer);
+            const row = await db.get("SELECT int AS integer FROM int_table");
+            assert.equal(row.integer, integer);
         });
     });
 
-    it('should ignore faulty toString', function(done) {
+    it('should ignore faulty toString', async function() {
         const faulty = { toString: 23 };
-        db.run("INSERT INTO txt_table VALUES(?)", faulty, function (err) {
-            assert.notEqual(err, undefined);
-            done();
-        });
+        // TODO: This is the previous behavior, but it seems like maybe the
+        // test is labelled incorrectly?
+        await assert.rejects(db.run("INSERT INTO txt_table VALUES(?)", faulty));
     });
 
-    it('should ignore faulty toString in array', function(done) {
+    it('should ignore faulty toString in array', async function() {
         const faulty = [[{toString: null}], 1];
-        db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty, function (err) {
-            assert.equal(err, null);
-            done();
-        });
+        await db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty);
     });
 
-    it('should ignore faulty toString set to function', function(done) {
+    it('should ignore faulty toString set to function', async function() {
         const faulty = [[{toString: function () {console.log('oh no');}}], 1];
-        db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty, function (err) {
-            assert.equal(err, undefined);
-            done();
-        });
+        await db.all('SELECT * FROM txt_table WHERE txt = ? LIMIT ?', faulty);
     });
 
 });
diff --git a/test/parallel_insert.test.js b/test/parallel_insert.test.js
index fc3829bc..62cc04d3 100644
--- a/test/parallel_insert.test.js
+++ b/test/parallel_insert.test.js
@@ -1,40 +1,33 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+const sqlite3 = require('..');
+const assert = require('assert');
+const helper = require('./support/helper');
 
 describe('parallel', function() {
-    var db;
-    before(function(done) {
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
         helper.deleteFile('test/tmp/test_parallel_inserts.db');
         helper.ensureExists('test/tmp');
-        db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done);
+        db = await sqlite3.Database.create('test/tmp/test_parallel_inserts.db', );
     });
 
-    var columns = [];
-    for (var i = 0; i < 128; i++) {
+    const columns = [];
+    for (let i = 0; i < 128; i++) {
         columns.push('id' + i);
     }
-
-    it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (" + columns + ")", done);
-    });
-
-    it('should insert in parallel', function(done) {
-        for (var i = 0; i < 1000; i++) {
-            for (var values = [], j = 0; j < columns.length; j++) {
+    
+    it('should insert in parallel', async function() {
+        await db.run("CREATE TABLE foo (" + columns + ")");
+        for (let i = 0; i < 1000; i++) {
+            const values = [];
+            for (let j = 0; j < columns.length; j++) {
                 values.push(i * j);
             }
             db.run("INSERT INTO foo VALUES (" + values + ")");
         }
 
-        db.wait(done);
-    });
-
-    it('should close the database', function(done) {
-        db.close(done);
-    });
-
-    it('should verify that the database exists', function() {
+        await db.wait();
+        await db.close();
         assert.fileExists('test/tmp/test_parallel_inserts.db');
     });
 
diff --git a/test/patching.test.js b/test/patching.test.js
index 3f9f68d5..ccbfcc45 100644
--- a/test/patching.test.js
+++ b/test/patching.test.js
@@ -1,10 +1,11 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('patching', function() {
     describe("Database", function() {
-        var db;
-        var originalFunctions = {};
+        /** @type {sqlite3.Database} */
+        let db;
+        const originalFunctions = {};
 
         before(function() {
             originalFunctions.close = sqlite3.Database.prototype.close;
@@ -17,48 +18,51 @@ describe('patching', function() {
             originalFunctions.interrupt = sqlite3.Database.prototype.interrupt;
         });
 
-        it('allow patching native functions', function() {
-            var myFun = function myFunction() {
+        it('allow patching native functions', async function() {
+            async function myAsyncFn() {
+                return "Success";
+            }
+            function myFn() {
                 return "Success";
             }
             
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.close = myFun;
+                sqlite3.Database.prototype.close = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.exec = myFun;
+                sqlite3.Database.prototype.exec = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.wait = myFun;
+                sqlite3.Database.prototype.wait = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.loadExtension = myFun;
+                sqlite3.Database.prototype.loadExtension = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.serialize = myFun;
+                sqlite3.Database.prototype.serialize = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.parallelize = myFun;
+                sqlite3.Database.prototype.parallelize = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.configure = myFun;
+                sqlite3.Database.prototype.configure = myFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Database.prototype.interrupt = myFun;
+                sqlite3.Database.prototype.interrupt = myFn;
             });
 
-            db = new sqlite3.Database(':memory:');
-            assert.strictEqual(db.close(), "Success");
-            assert.strictEqual(db.exec(), "Success");
-            assert.strictEqual(db.wait(), "Success");
-            assert.strictEqual(db.loadExtension(), "Success");
-            assert.strictEqual(db.serialize(), "Success");
-            assert.strictEqual(db.parallelize(), "Success");
+            db = await sqlite3.Database.create(':memory:');
+            assert.strictEqual(await db.close(), "Success");
+            assert.strictEqual(await db.exec(), "Success");
+            assert.strictEqual(await db.wait(), "Success");
+            assert.strictEqual(await db.loadExtension(), "Success");
+            assert.strictEqual(await db.serialize(), "Success");
+            assert.strictEqual(await db.parallelize(), "Success");
             assert.strictEqual(db.configure(), "Success");
             assert.strictEqual(db.interrupt(), "Success");
         });
 
-        after(function() {
+        after(async function() {
             if(db != null) {
                 sqlite3.Database.prototype.close = originalFunctions.close;
                 sqlite3.Database.prototype.exec = originalFunctions.exec;
@@ -68,15 +72,17 @@ describe('patching', function() {
                 sqlite3.Database.prototype.parallelize = originalFunctions.parallelize;
                 sqlite3.Database.prototype.configure = originalFunctions.configure;
                 sqlite3.Database.prototype.interrupt = originalFunctions.interrupt;
-                db.close();
+                await db.close();
             }
         });
     });
 
     describe('Statement', function() {
-        var db;
-        var statement;
-        var originalFunctions = {};
+        /** @type {sqlite3.Database} */
+        let db;
+        /** @type {sqlite3.Statement} */
+        let statement;
+        const originalFunctions = {};
 
         before(function() {
             originalFunctions.bind = sqlite3.Statement.prototype.bind;
@@ -88,45 +94,49 @@ describe('patching', function() {
             originalFunctions.finalize = sqlite3.Statement.prototype.finalize;
         });
 
-        it('allow patching native functions', function() {
-            var myFun = function myFunction() {
+        it('allow patching native functions', async function() {
+            async function myAsyncFn() {
                 return "Success";
             }
+            async function* myGeneratorFn() {
+                yield "Success";
+            }
+
             
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.bind = myFun;
+                sqlite3.Statement.prototype.bind = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.get = myFun;
+                sqlite3.Statement.prototype.get = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.run = myFun;
+                sqlite3.Statement.prototype.run = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.all = myFun;
+                sqlite3.Statement.prototype.all = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.each = myFun;
+                sqlite3.Statement.prototype.each = myGeneratorFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.reset = myFun;
+                sqlite3.Statement.prototype.reset = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Statement.prototype.finalize = myFun;
+                sqlite3.Statement.prototype.finalize = myAsyncFn;
             });
 
-            db = new sqlite3.Database(':memory:');
-            statement = db.prepare("");
-            assert.strictEqual(statement.bind(), "Success");
-            assert.strictEqual(statement.get(), "Success");
-            assert.strictEqual(statement.run(), "Success");
-            assert.strictEqual(statement.all(), "Success");
-            assert.strictEqual(statement.each(), "Success");
-            assert.strictEqual(statement.reset(), "Success");
-            assert.strictEqual(statement.finalize(), "Success");
+            db = await sqlite3.Database.create(':memory:');
+            statement = await db.prepare("");
+            assert.strictEqual(await statement.bind(), "Success");
+            assert.strictEqual(await statement.get(), "Success");
+            assert.strictEqual(await statement.run(), "Success");
+            assert.strictEqual(await statement.all(), "Success");
+            assert.strictEqual((await statement.each().next()).value, "Success");
+            assert.strictEqual(await statement.reset(), "Success");
+            assert.strictEqual(await statement.finalize(), "Success");
         });
 
-        after(function() {
+        after(async function() {
             if(statement != null) {
                 sqlite3.Statement.prototype.bind = originalFunctions.bind;
                 sqlite3.Statement.prototype.get = originalFunctions.get;
@@ -137,47 +147,49 @@ describe('patching', function() {
                 sqlite3.Statement.prototype.finalize = originalFunctions.finalize;
             }
             if(db != null) {
-                db.close();
+                await db.close();
             }
         });
     });
 
     describe('Backup', function() {
-        var db;
-        var backup;
-        var originalFunctions = {};
+        /** @type {sqlite3.Database} */
+        let db;
+        /** @type {sqlite3.Backup} */
+        let backup;
+        const originalFunctions = {};
 
         before(function() {
             originalFunctions.step = sqlite3.Backup.prototype.step;
             originalFunctions.finish = sqlite3.Backup.prototype.finish;
         });
 
-        it('allow patching native functions', function() {
-            var myFun = function myFunction() {
+        it('allow patching native functions', async function() {
+            async function myAsyncFn() {
                 return "Success";
             }
             
             assert.doesNotThrow(() => {
-                sqlite3.Backup.prototype.step = myFun;
+                sqlite3.Backup.prototype.step = myAsyncFn;
             });
             assert.doesNotThrow(() => {
-                sqlite3.Backup.prototype.finish = myFun;
+                sqlite3.Backup.prototype.finish = myAsyncFn;
             });
 
-            db = new sqlite3.Database(':memory:');
-            backup = db.backup("somefile", myFun);
-            assert.strictEqual(backup.step(), "Success");
-            assert.strictEqual(backup.finish(), "Success");
+            db = await sqlite3.Database.create(':memory:');
+            backup = await db.backup("somefile");
+            assert.strictEqual(await backup.step(), "Success");
+            assert.strictEqual(await backup.finish(), "Success");
         });
 
-        after(function() {
+        after(async function() {
             if(backup != null) {
                 sqlite3.Backup.prototype.step = originalFunctions.step;
                 sqlite3.Backup.prototype.finish = originalFunctions.finish;
-                backup.finish();
+                await backup.finish();
             }
             if(db != null) {
-                db.close();
+                await db.close();
             }
         });
     });
diff --git a/test/prepare.test.js b/test/prepare.test.js
index c237b622..5d77a566 100644
--- a/test/prepare.test.js
+++ b/test/prepare.test.js
@@ -1,427 +1,395 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('prepare', function() {
     describe('invalid SQL', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database(':memory:', done); });
-
-        var stmt;
-        it('should fail preparing a statement with invalid SQL', function(done) {
-            stmt = db.prepare('CRATE TALE foo text bar)', function(err, statement) {
-                if (err && err.errno == sqlite3.ERROR &&
-                    err.message === 'SQLITE_ERROR: near "CRATE": syntax error') {
-                    done();
-                }
-                else throw err;
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
+        });
+
+        it('should fail preparing a statement with invalid SQL', async function() {
+            await assert.rejects(db.prepare('CRATE TALE foo text bar)'), (err) => {
+                assert.strictEqual(err.errno, sqlite3.ERROR);
+                assert.strictEqual(err.message, 'SQLITE_ERROR: near "CRATE": syntax error');
+                return true;
             });
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
     describe('simple prepared statement', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database(':memory:', done); });
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
+        });
 
-        it('should prepare, run and finalize the statement', function(done) {
-            db.prepare("CREATE TABLE foo (text bar)")
-                .run()
-                .finalize(done);
+        it('should prepare, run and finalize the statement', async function() {
+            await db.prepare("CREATE TABLE foo (text bar)")
+                .then((statement) => statement.run())
+                .then((statement) => statement.finalize());
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            db.close();
+        });
     });
 
     describe('inserting and retrieving rows', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database(':memory:', done); });
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
+        });
 
-        var inserted = 0;
-        var retrieved = 0;
+        let inserted = 0;
+        let retrieved = 0;
 
         // We insert and retrieve that many rows.
-        var count = 1000;
-
-        it('should create the table', function(done) {
-            db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run().finalize(done);
-        });
-
-        it('should insert ' + count + ' rows', function(done) {
-            for (var i = 0; i < count; i++) {
-                db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)").run(
-                    'String ' + i,
-                    i,
-                    i * Math.PI,
-                    // null (SQLite sets this implicitly)
-                    function(err) {
-                        if (err) throw err;
-                        inserted++;
-                    }
-                ).finalize(function(err) {
-                    if (err) throw err;
-                    if (inserted == count) done();
-                });
+        const count = 1000;
+        
+        it('should prepare a statement and run it ' + (count + 5) + ' times', async function() {
+            const statement = await db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
+            await statement.run();
+            await statement.finalize();
+
+            for (let i = 0; i < count; i++) {
+                const statement = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
+                await statement.run('String ' + i, i, i * Math.PI);
+                inserted++;
+                await statement.finalize();
             }
-        });
-
-        it('should prepare a statement and run it ' + (count + 5) + ' times', function(done) {
-            var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err) {
-                if (err) throw err;
-                assert.equal(stmt.sql, 'SELECT txt, num, flt, blb FROM foo ORDER BY num');
-            });
-
-            for (var i = 0; i < count + 5; i++) (function(i) {
-                stmt.get(function(err, row) {
-                    if (err) throw err;
-
-                    if (retrieved >= 1000) {
-                        assert.equal(row, undefined);
-                    } else {
-                        assert.equal(row.txt, 'String ' + i);
-                        assert.equal(row.num, i);
-                        assert.equal(row.flt, i * Math.PI);
-                        assert.equal(row.blb, null);
-                    }
+            assert.strictEqual(inserted, count);
+            const stmt = await db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num");
+            assert.equal(stmt.sql, 'SELECT txt, num, flt, blb FROM foo ORDER BY num');
+
+            for (let i = 0; i < count; i++)  {
+                const row = await stmt.get();
+                assert.equal(row.txt, 'String ' + i);
+                assert.equal(row.num, i);
+                assert.equal(row.flt, i * Math.PI);
+                assert.equal(row.blb, null);
 
-                    retrieved++;
-                });
-            })(i);
+                retrieved++;
+            }
+            
+            for (let i = count; i < count + 5; i++)  {
+                const row = await stmt.get();
+                assert.equal(row, undefined);
 
-            stmt.finalize(done);
-        });
+                retrieved++;
+            }
 
-        it('should have retrieved ' + (count + 5) + ' rows', function() {
+            await stmt.finalize();
             assert.equal(count + 5, retrieved, "Didn't retrieve all rows");
         });
 
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            db.close();
+        });
     });
 
     describe('inserting with accidental undefined', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database(':memory:', done); });
-
-        var inserted = 0;
-        var retrieved = 0;
-
-        it('should create the table', function(done) {
-            db.prepare("CREATE TABLE foo (num int)").run().finalize(done);
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
         });
 
-        it('should insert two rows', function(done) {
-            db.prepare('INSERT INTO foo VALUES(4)').run(function(err) {
-                if (err) throw err;
-                inserted++;
-            }).run(undefined, function (err) {
+        let retrieved = 0;
+        
+        it('should retrieve the data', async function() {
+            await db.prepare("CREATE TABLE foo (num int)")
+                .then((statement) => statement.run())
+                .then((statement) => statement.finalize());
+
+            await db.prepare('INSERT INTO foo VALUES(4)')
+                .then((statement) => statement.run())
                 // The second time we pass undefined as a parameter. This is
                 // a mistake, but it should either throw an error or be ignored,
                 // not silently fail to run the statement.
-                if (err) throw err;
-                inserted++;
-            }).finalize(function(err) {
-                if (err) throw err;
-                if (inserted == 2) done();
-            });
-        });
-
-        it('should retrieve the data', function(done) {
-            var stmt = db.prepare("SELECT num FROM foo", function(err) {
-                if (err) throw err;
-            });
+                .then((statement) => statement.run(undefined))
+                .then((statement) => statement.finalize());
 
-            for (var i = 0; i < 2; i++) (function(i) {
-                stmt.get(function(err, row) {
-                    if (err) throw err;
-                    assert(row);
-                    assert.equal(row.num, 4);
-                    retrieved++;
-                });
-            })(i);
+            const stmt = await db.prepare("SELECT num FROM foo");
 
-            stmt.finalize(done);
-        });
+            for (let i = 0; i < 2; i++) {
+                const row = await stmt.get();
+                assert(row);
+                assert.equal(row.num, 4);
+                retrieved++;
+            }
 
-        it('should have retrieved two rows', function() {
+            await stmt.finalize();
             assert.equal(2, retrieved, "Didn't retrieve all rows");
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
     describe('retrieving reset() function', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
-
-        var retrieved = 0;
-
-        it('should retrieve the same row over and over again', function(done) {
-            var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num");
-            for (var i = 0; i < 10; i++) {
-                stmt.reset();
-                stmt.get(function(err, row) {
-                    if (err) throw err;
-                    assert.equal(row.txt, 'String 0');
-                    assert.equal(row.num, 0);
-                    assert.equal(row.flt, 0.0);
-                    assert.equal(row.blb, null);
-                    retrieved++;
-                });
-            }
-            stmt.finalize(done);
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
         });
 
-        it('should have retrieved 10 rows', function() {
+        let retrieved = 0;
+
+        it('should retrieve the same row over and over again', async function() {
+            const stmt = await db.prepare("SELECT txt, num, flt, blb FROM foo ORDER BY num");
+            for (let i = 0; i < 10; i++) {
+                await stmt.reset();
+                const row = await stmt.get();
+                assert.equal(row.txt, 'String 0');
+                assert.equal(row.num, 0);
+                assert.equal(row.flt, 0.0);
+                assert.equal(row.blb, null);
+                retrieved++;
+            }
+            await stmt.finalize();
             assert.equal(10, retrieved, "Didn't retrieve all rows");
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
     describe('multiple get() parameter binding', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
-
-        var retrieved = 0;
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
+        });
 
-        it('should retrieve particular rows', function(done) {
-            var stmt = db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ?");
+        let retrieved = 0;
 
-            for (var i = 0; i < 10; i++) (function(i) {
-                stmt.get(i * 10 + 1, function(err, row) {
-                    if (err) throw err;
-                    var val = i * 10 + 1;
-                    assert.equal(row.txt, 'String ' + val);
-                    assert.equal(row.num, val);
-                    assert.equal(row.flt, val * Math.PI);
-                    assert.equal(row.blb, null);
-                    retrieved++;
-                });
-            })(i);
+        it('should retrieve particular rows', async function() {
+            const stmt = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ?");
 
-            stmt.finalize(done);
-        });
+            for (let i = 0; i < 10; i++) {
+                const row = await stmt.get(i * 10 + 1);
+                const val = i * 10 + 1;
+                assert.equal(row.txt, 'String ' + val);
+                assert.equal(row.num, val);
+                assert.equal(row.flt, val * Math.PI);
+                assert.equal(row.blb, null);
+                retrieved++;
+            }
 
-        it('should have retrieved 10 rows', function() {
+            await stmt.finalize();
             assert.equal(10, retrieved, "Didn't retrieve all rows");
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
     describe('prepare() parameter binding', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
-
-        var retrieved = 0;
-
-        it('should retrieve particular rows', function(done) {
-            db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10')
-                .get(function(err, row) {
-                    if (err) throw err;
-                    assert.equal(row.txt, 'String 10');
-                    assert.equal(row.num, 10);
-                    assert.equal(row.flt, 10 * Math.PI);
-                    assert.equal(row.blb, null);
-                    retrieved++;
-                })
-                .finalize(done);
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
         });
 
-        it('should have retrieved 1 row', function() {
-            assert.equal(1, retrieved, "Didn't retrieve all rows");
+        it('should retrieve particular rows', async function() {
+            const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10');
+            const row = await statement.get();
+            await statement.finalize();
+            assert.equal(row.txt, 'String 10');
+            assert.equal(row.num, 10);
+            assert.equal(row.flt, 10 * Math.PI);
+            assert.equal(row.blb, null);
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
     describe('all()', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
-
-        var retrieved = 0;
-        var count = 1000;
-
-        it('should retrieve particular rows', function(done) {
-            db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num", count)
-                .all(function(err, rows) {
-                    if (err) throw err;
-                    for (var i = 0; i < rows.length; i++) {
-                        assert.equal(rows[i].txt, 'String ' + i);
-                        assert.equal(rows[i].num, i);
-                        assert.equal(rows[i].flt, i * Math.PI);
-                        assert.equal(rows[i].blb, null);
-                        retrieved++;
-                    }
-                })
-                .finalize(done);
-        });
-
-        it('should have retrieved all rows', function() {
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
+        });
+
+        let retrieved = 0;
+        const count = 1000;
+
+        it('should retrieve particular rows', async function() {
+            const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num < ? ORDER BY num", count);
+            const rows = await statement.all();
+            await statement.finalize();
+            for (let i = 0; i < rows.length; i++) {
+                assert.equal(rows[i].txt, 'String ' + i);
+                assert.equal(rows[i].num, i);
+                assert.equal(rows[i].flt, i * Math.PI);
+                assert.equal(rows[i].blb, null);
+                retrieved++;
+            }
             assert.equal(count, retrieved, "Didn't retrieve all rows");
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
     describe('all()', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
+        });
 
-        it('should retrieve particular rows', function(done) {
-            db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000")
-                .all(function(err, rows) {
-                    if (err) throw err;
-                    assert.ok(rows.length === 0);
-                })
-                .finalize(done);
+        it('should retrieve particular rows', async function() {
+            const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo WHERE num > 5000");
+            const rows = await statement.all();
+            await statement.finalize();
+            assert.ok(rows.length === 0);
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() { 
+            await db.close();
+        });
     });
 
     describe('high concurrency', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database(':memory:', done); });
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
+        });
 
         function randomString() {
-            var str = '';
-            for (var i = Math.random() * 300; i > 0; i--) {
+            let str = '';
+            for (let i = Math.random() * 300; i > 0; i--) {
                 str += String.fromCharCode(Math.floor(Math.random() * 256));
             }
             return str;
         }
 
         // Generate random data.
-        var data = [];
-        var length = Math.floor(Math.random() * 1000) + 200;
-        for (var i = 0; i < length; i++) {
+        const data = [];
+        const length = Math.floor(Math.random() * 1000) + 200;
+        for (let i = 0; i < length; i++) {
             data.push([ randomString(), i, i * Math.random(), null ]);
         }
 
-        var inserted = 0;
-        var retrieved = 0;
-
-        it('should create the table', function(done) {
-            db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)").run().finalize(done);
-        });
-
-        it('should insert all values', function(done) {
-            for (var i = 0; i < data.length; i++) {
-                var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
-                stmt.run(data[i][0], data[i][1], data[i][2], data[i][3], function(err) {
-                    if (err) throw err;
-                    inserted++;
-                }).finalize(function(err) {
-                    if (err) throw err;
-                    if (inserted == data.length) done();
-                });
+        let inserted = 0;
+        let retrieved = 0;
+        
+        it('should retrieve all values', async function() {
+            await db.prepare("CREATE TABLE foo (txt text, num int, flt float, blb blob)")
+                .then((statement) => statement.run())
+                .then((statement) => statement.finalize());
+
+            for (let i = 0; i < data.length; i++) {
+                const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
+                await stmt.run(data[i][0], data[i][1], data[i][2], data[i][3]);
+                await stmt.finalize();
+                inserted++;
             }
-        });
-
-        it('should retrieve all values', function(done) {
-            db.prepare("SELECT txt, num, flt, blb FROM foo")
-                .all(function(err, rows) {
-                    if (err) throw err;
 
-                    for (var i = 0; i < rows.length; i++) {
-                        assert.ok(data[rows[i].num] !== true);
+            const statement = await db.prepare("SELECT txt, num, flt, blb FROM foo");
+            const rows = await statement.all();
+            await statement.finalize();
 
-                        assert.equal(rows[i].txt, data[rows[i].num][0]);
-                        assert.equal(rows[i].num, data[rows[i].num][1]);
-                        assert.equal(rows[i].flt, data[rows[i].num][2]);
-                        assert.equal(rows[i].blb, data[rows[i].num][3]);
+            for (let i = 0; i < rows.length; i++) {
+                assert.ok(data[rows[i].num] !== true);
 
-                        // Mark the data row as already retrieved.
-                        data[rows[i].num] = true;
-                        retrieved++;
+                assert.equal(rows[i].txt, data[rows[i].num][0]);
+                assert.equal(rows[i].num, data[rows[i].num][1]);
+                assert.equal(rows[i].flt, data[rows[i].num][2]);
+                assert.equal(rows[i].blb, data[rows[i].num][3]);
 
-                    }
+                // Mark the data row as already retrieved.
+                data[rows[i].num] = true;
+                retrieved++;
+            }
 
-                    assert.equal(retrieved, data.length);
-                    assert.equal(retrieved, inserted);
-                })
-                .finalize(done);
+            assert.equal(retrieved, data.length);
+            assert.equal(retrieved, inserted);
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 
 
     describe('test Database#get()', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database('test/support/prepare.db', sqlite3.OPEN_READONLY, done); });
-
-        var retrieved = 0;
-
-        it('should get a row', function(done) {
-            db.get("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10', function(err, row) {
-                if (err) throw err;
-                assert.equal(row.txt, 'String 10');
-                assert.equal(row.num, 10);
-                assert.equal(row.flt, 10 * Math.PI);
-                assert.equal(row.blb, null);
-                retrieved++;
-                done();
-            });
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create('test/support/prepare.db', sqlite3.OPEN_READONLY);
         });
 
-        it('should have retrieved all rows', function() {
+        let retrieved = 0;
+
+        it('should get a row', async function() {
+            const row = await db.get("SELECT txt, num, flt, blb FROM foo WHERE num = ? AND txt = ?", 10, 'String 10');
+            assert.equal(row.txt, 'String 10');
+            assert.equal(row.num, 10);
+            assert.equal(row.flt, 10 * Math.PI);
+            assert.equal(row.blb, null);
+            retrieved++;
             assert.equal(1, retrieved, "Didn't retrieve all rows");
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() { 
+            await db.close();
+        });
     });
 
     describe('Database#run() and Database#all()', function() {
-        var db;
-        before(function(done) { db = new sqlite3.Database(':memory:', done); });
+        /** @type {sqlite3.Database} */
+        let db;
+        before(async function() {
+            db = await sqlite3.Database.create(':memory:');
+        });
 
-        var inserted = 0;
-        var retrieved = 0;
+        let inserted = 0;
+        let retrieved = 0;
 
         // We insert and retrieve that many rows.
-        var count = 1000;
-
-        it('should create the table', function(done) {
-            db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)", done);
-        });
-
-        it('should insert ' + count + ' rows', function(done) {
-            for (var i = 0; i < count; i++) {
-                db.run("INSERT INTO foo VALUES(?, ?, ?, ?)",
-                    'String ' + i,
-                    i,
-                    i * Math.PI,
-                    // null (SQLite sets this implicitly)
-                    function(err) {
-                        if (err) throw err;
-                        inserted++;
-                        if (inserted == count) done();
-                    }
-                );
+        const count = 1000;
+        
+        it('should retrieve all rows', async function() {
+            await db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
+    
+            for (let i = 0; i < count; i++) {
+                await db.run("INSERT INTO foo VALUES(?, ?, ?, ?)", 'String ' + i, i, i * Math.PI);
+                inserted++;
             }
-        });
 
-        it('should retrieve all rows', function(done) {
-            db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
-                if (err) throw err;
-                for (var i = 0; i < rows.length; i++) {
-                    assert.equal(rows[i].txt, 'String ' + i);
-                    assert.equal(rows[i].num, i);
-                    assert.equal(rows[i].flt, i * Math.PI);
-                    assert.equal(rows[i].blb, null);
-                    retrieved++;
-                }
+            const rows = await db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num");
 
-                assert.equal(retrieved, count);
-                assert.equal(retrieved, inserted);
+            for (let i = 0; i < rows.length; i++) {
+                assert.equal(rows[i].txt, 'String ' + i);
+                assert.equal(rows[i].num, i);
+                assert.equal(rows[i].flt, i * Math.PI);
+                assert.equal(rows[i].blb, null);
+                retrieved++;
+            }
 
-                done();
-            });
+            assert.equal(retrieved, count);
+            assert.equal(retrieved, inserted);
         });
 
-        after(function(done) { db.close(done); });
+        after(async function() {
+            await db.close();
+        });
     });
 });
diff --git a/test/profile.test.js b/test/profile.test.js
index d8eb8b5d..07f92a09 100644
--- a/test/profile.test.js
+++ b/test/profile.test.js
@@ -1,13 +1,14 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('profiling', function() {
-    var create = false;
-    var select = false;
+    let create = false;
+    let select = false;
 
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:', done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
 
         db.on('profile', function(sql, nsecs) {
             assert.ok(typeof nsecs === "number");
@@ -29,9 +30,8 @@ describe('profiling', function() {
 
     it('should profile a create table', function(done) {
         assert.ok(!create);
-        db.run("CREATE TABLE foo (id int)", function(err) {
-            if (err) throw err;
-            setImmediate(function() {
+        db.run("CREATE TABLE foo (id int)").then(() => {
+            setImmediate(() => {
                 assert.ok(create);
                 done();
             });
@@ -41,16 +41,15 @@ describe('profiling', function() {
 
     it('should profile a select', function(done) {
         assert.ok(!select);
-        db.run("SELECT * FROM foo", function(err) {
-            if (err) throw err;
+        db.run("SELECT * FROM foo").then(() => {
             setImmediate(function() {
                 assert.ok(select);
                 done();
-            }, 0);
+            });
         });
     });
 
-    after(function(done) {
-        db.close(done);
+    after(async function() {
+        await db.close();
     });
 });
diff --git a/test/rerun.test.js b/test/rerun.test.js
index e98562ec..4a83a4b2 100644
--- a/test/rerun.test.js
+++ b/test/rerun.test.js
@@ -1,50 +1,36 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('rerunning statements', function() {
-    var db;
-    before(function(done) { db = new sqlite3.Database(':memory:', done); });
+    /** @type {sqlite3.Database} */
+    let db;
+    const count = 10;
 
-    var count = 10;
-    var inserted = 0;
-    var retrieved = 0;
-
-    it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (id int)", done);
-    });
-
-    it('should insert repeatedly, reusing the same statement', function(done) {
-        var stmt = db.prepare("INSERT INTO foo VALUES(?)");
-        for (var i = 5; i < count; i++) {
-            stmt.run(i, function(err) {
-                if (err) throw err;
-                inserted++;
-            });
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.run("CREATE TABLE foo (id int)");
+        
+        const stmt = await db.prepare("INSERT INTO foo VALUES(?)");
+        for (let i = 5; i < count; i++) {
+            await stmt.run(i);
         }
-        stmt.finalize(done);
+    
+        await stmt.finalize();
     });
 
-    it('should retrieve repeatedly, resuing the same statement', function(done) {
-        var collected = [];
-        var stmt = db.prepare("SELECT id FROM foo WHERE id = ?");
-        for (var i = 0; i < count; i++) {
-            stmt.get(i, function(err, row) {
-                if (err) throw err;
-                if (row) collected.push(row);
-            });
+    it('should retrieve repeatedly, resuing the same statement', async function() {
+        const collected = [];
+        const stmt = await db.prepare("SELECT id FROM foo WHERE id = ?");
+        for (let i = 0; i < count; i++) {
+            const row = await stmt.get(i);
+            if (row) collected.push(row);
         }
-        stmt.finalize(function(err) {
-            if (err) throw err;
-            retrieved += collected.length;
-            assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]);
-            done();
-        });
+        await stmt.finalize();
+        assert.deepEqual(collected, [ { id: 5 }, { id: 6 }, { id: 7 }, { id: 8 }, { id: 9 } ]);
+        assert.equal(collected.length, 5);
     });
 
-    it('should have inserted and retrieved the right amount', function() {
-        assert.equal(inserted, 5);
-        assert.equal(retrieved, 5);
+    after(async function() { 
+        await db.close();
     });
-
-    after(function(done) { db.close(done); });
 });
diff --git a/test/scheduling.test.js b/test/scheduling.test.js
index e00a8cf5..3e8eaf38 100644
--- a/test/scheduling.test.js
+++ b/test/scheduling.test.js
@@ -1,44 +1,29 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('scheduling', function() {
-    it('scheduling after the database was closed', function(done) {
-        var db = new sqlite3.Database(':memory:');
-        db.on('error', function(err) {
-            assert.ok(err.message && err.message.indexOf("SQLITE_MISUSE: Database handle is closed") > -1);
-            done();
-        });
-
-        db.close();
-        db.run("CREATE TABLE foo (id int)");
-    });
-
-
-    it('scheduling a query with callback after the database was closed', function(done) {
-        var db = new sqlite3.Database(':memory:');
-        db.on('error', function(err) {
-            assert.ok(false, 'Event was accidentally triggered');
-        });
+    it('scheduling after the database was closed', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        db.close();
-        db.run("CREATE TABLE foo (id int)", function(err) {
-            assert.ok(err.message && err.message.indexOf("SQLITE_MISUSE: Database handle is closed") > -1);
-            done();
+        await db.close();
+        await assert.rejects(db.run("CREATE TABLE foo (id int)"), (err) => {
+            assert.ok(err.message && err.message.indexOf("SQLITE_MISUSE: Database is closed") > -1);
+            return true;
         });
     });
 
-    it('running a query after the database was closed', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('running a query after the database was closed', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        var stmt = db.prepare("SELECT * FROM sqlite_master", function(err) {
-            if (err) throw err;
-            db.close(function(err) {
-                assert.ok(err);
-                assert.ok(err.message && err.message.indexOf("SQLITE_BUSY: unable to close due to") > -1);
+        const stmt = await db.prepare("SELECT * FROM sqlite_master");
 
-                // Running a statement now should not fail.
-                stmt.run(done);
-            });
+        await assert.rejects(db.close(), (err) => {
+            assert.ok(err);
+            assert.ok(err.message && err.message.indexOf("SQLITE_BUSY: unable to close due to") > -1);
+            return true;
         });
+        // Running a statement now should not fail.
+        await stmt.run();
+        await stmt.finalize();
     });
 });
diff --git a/test/serialization.test.js b/test/serialization.test.js
index ccc58673..59b47ac5 100644
--- a/test/serialization.test.js
+++ b/test/serialization.test.js
@@ -1,104 +1,101 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 
 describe('serialize() and parallelize()', function() {
-    var db;
-    before(function(done) { db = new sqlite3.Database(':memory:', done); });
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+    });
 
-    var inserted1 = 0;
-    var inserted2 = 0;
-    var retrieved = 0;
+    let inserted1 = 0;
+    let inserted2 = 0;
+    let retrieved = 0;
 
-    var count = 1000;
+    const count = 1000;
 
-    it('should toggle', function(done) {
-        db.serialize();
-        db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
-        db.parallelize(done);
+    it('should toggle', async function() {
+        await db.serialize();
+        await db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
+        await db.parallelize();
     });
 
-    it('should insert rows', function() {
-        var stmt1 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
-        var stmt2 = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
-        for (var i = 0; i < count; i++) {
+    it('should insert rows', async function() {
+        const stmt1 = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
+        const stmt2 = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
+        for (let i = 0; i < count; i++) {
             // Interleaved inserts with two statements.
-            stmt1.run('String ' + i, i, i * Math.PI, function(err) {
-                if (err) throw err;
-                inserted1++;
-            });
+            await stmt1.run('String ' + i, i, i * Math.PI);
+            inserted1++;
             i++;
-            stmt2.run('String ' + i, i, i * Math.PI, function(err) {
-                if (err) throw err;
-                inserted2++;
-            });
+            await stmt2.run('String ' + i, i, i * Math.PI);
+            inserted2++;
         }
-        stmt1.finalize();
-        stmt2.finalize();
+        await stmt1.finalize();
+        await stmt2.finalize();
     });
 
-    it('should have inserted all the rows after synchronizing with serialize()', function(done) {
-        db.serialize();
-        db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
-            if (err) throw err;
-            for (var i = 0; i < rows.length; i++) {
-                assert.equal(rows[i].txt, 'String ' + i);
-                assert.equal(rows[i].num, i);
-                assert.equal(rows[i].flt, i * Math.PI);
-                assert.equal(rows[i].blb, null);
-                retrieved++;
-            }
+    it('should have inserted all the rows after synchronizing with serialize()', async function() {
+        await db.serialize();
+        const rows = await db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num");
 
-            assert.equal(count, inserted1 + inserted2, "Didn't insert all rows");
-            assert.equal(count, retrieved, "Didn't retrieve all rows");
-            done();
-        });
+        for (let i = 0; i < rows.length; i++) {
+            assert.equal(rows[i].txt, 'String ' + i);
+            assert.equal(rows[i].num, i);
+            assert.equal(rows[i].flt, i * Math.PI);
+            assert.equal(rows[i].blb, null);
+            retrieved++;
+        }
+
+        assert.equal(count, inserted1 + inserted2, "Didn't insert all rows");
+        assert.equal(count, retrieved, "Didn't retrieve all rows");
     });
 
-    after(function(done) { db.close(done); });
+    after(async function() {
+        await db.close();
+    });
 });
 
 describe('serialize(fn)', function() {
-    var db;
-    before(function(done) { db = new sqlite3.Database(':memory:', done); });
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+    });
 
-    var inserted = 0;
-    var retrieved = 0;
+    let inserted = 0;
+    let retrieved = 0;
 
-    var count = 1000;
+    const count = 1000;
 
-    it('should call the callback', function(done) {
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
+    it('should call the callback', async function() {
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (txt text, num int, flt float, blb blob)");
 
-            var stmt = db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
-            for (var i = 0; i < count; i++) {
-                stmt.run('String ' + i, i, i * Math.PI, function(err) {
-                    if (err) throw err;
-                    inserted++;
-                });
+            const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?, ?, ?)");
+            for (let i = 0; i < count; i++) {
+                await stmt.run('String ' + i, i, i * Math.PI);
+                inserted++;
             }
-            stmt.finalize();
-
-            db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num", function(err, rows) {
-                if (err) throw err;
-                for (var i = 0; i < rows.length; i++) {
-                    assert.equal(rows[i].txt, 'String ' + i);
-                    assert.equal(rows[i].num, i);
-                    assert.equal(rows[i].flt, i * Math.PI);
-                    assert.equal(rows[i].blb, null);
-                    retrieved++;
-                }
-                done();
-            });
-        });
-    });
+            await stmt.finalize();
 
+            const rows = await db.all("SELECT txt, num, flt, blb FROM foo ORDER BY num");
+
+            for (let i = 0; i < rows.length; i++) {
+                assert.equal(rows[i].txt, 'String ' + i);
+                assert.equal(rows[i].num, i);
+                assert.equal(rows[i].flt, i * Math.PI);
+                assert.equal(rows[i].blb, null);
+                retrieved++;
+            }
+        });
 
-    it('should have inserted and retrieved all rows', function() {
         assert.equal(count, inserted, "Didn't insert all rows");
         assert.equal(count, retrieved, "Didn't retrieve all rows");
     });
 
-    after(function(done) { db.close(done); });
+    after(async function() {
+        await db.close();
+    });
 });
diff --git a/test/support/createdb-electron.js b/test/support/createdb-electron.js
index c2cac418..59ee32df 100644
--- a/test/support/createdb-electron.js
+++ b/test/support/createdb-electron.js
@@ -1,8 +1,8 @@
 
-var {app} = require('electron');
-var createdb = require('./createdb.js');
+const {app} = require('electron');
+const createdb = require('./createdb.js');
 
-createdb(function () {
+createdb().then(() => {
     setTimeout(function () {
         app.quit();
     }, 20000);
diff --git a/test/support/createdb.js b/test/support/createdb.js
index ee22d05e..3e861c3c 100755
--- a/test/support/createdb.js
+++ b/test/support/createdb.js
@@ -1,42 +1,40 @@
 #!/usr/bin/env node
 
-function createdb(callback) {
-    var existsSync = require('fs').existsSync || require('path').existsSync;
-    var statSync   = require('fs').statSync || require('path').statSync;
-    var path = require('path');
+async function createdb() {
+    const existsSync = require('fs').existsSync || require('path').existsSync;
+    const statSync   = require('fs').statSync || require('path').statSync;
+    const path = require('path');
 
-    var sqlite3 = require('../../lib/sqlite3');
+    const sqlite3 = require('../../lib/sqlite3');
 
-    var count = 1000000;
-    var db_path = path.join(__dirname,'big.db');
+    const count = 1000000;
+    const dbPath = path.join(__dirname,'big.db');
 
     function randomString() {
-        var str = '';
-        var chars = 'abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY0123456789  ';
-        for (var i = Math.random() * 100; i > 0; i--) {
+        let str = '';
+        const chars = 'abcdefghijklmnopqrstuvwxzyABCDEFGHIJKLMNOPQRSTUVWXZY0123456789  ';
+        for (let i = Math.random() * 100; i > 0; i--) {
             str += chars[Math.floor(Math.random() * chars.length)];
         }
         return str;
     }
 
-// Make sure the file exists and is also valid.
-    if (existsSync(db_path) && statSync(db_path).size !== 0) {
-        console.log('okay: database already created (' + db_path + ')');
-        if (callback) callback();
+    // Make sure the file exists and is also valid.
+    if (existsSync(dbPath) && statSync(dbPath).size !== 0) {
+        console.log('okay: database already created (' + dbPath + ')');
     } else {
         console.log("Creating test database... This may take several minutes.");
-        var db = new sqlite3.Database(db_path);
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id INT, txt TEXT)");
-            db.run("BEGIN TRANSACTION");
-            var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-            for (var i = 0; i < count; i++) {
-                stmt.run(i, randomString());
+        const db = await sqlite3.Database.create(dbPath);
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id INT, txt TEXT)");
+            await db.run("BEGIN TRANSACTION");
+            const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)");
+            for (let i = 0; i < count; i++) {
+                await stmt.run(i, randomString());
             }
-            stmt.finalize();
-            db.run("COMMIT TRANSACTION", [], function () {
-                db.close(callback);
-            });
+            await stmt.finalize();
+            await db.run("COMMIT TRANSACTION", []);
+            await db.close();
         });
     }
 }
diff --git a/test/support/helper.js b/test/support/helper.js
index cb2075d2..73761668 100644
--- a/test/support/helper.js
+++ b/test/support/helper.js
@@ -1,6 +1,6 @@
-var assert = require('assert');
-var fs = require('fs');
-var pathExists = require('fs').existsSync || require('path').existsSync;
+const assert = require('assert');
+const fs = require('fs');
+const pathExists = require('fs').existsSync || require('path').existsSync;
 
 exports.deleteFile = function(name) {
     try {
@@ -12,7 +12,7 @@ exports.deleteFile = function(name) {
     }
 };
 
-exports.ensureExists = function(name,cb) {
+exports.ensureExists = function(name) {
     if (!pathExists(name)) {
         fs.mkdirSync(name);
     }
@@ -30,4 +30,4 @@ assert.fileDoesNotExist = function(name) {
 
 assert.fileExists = function(name) {
     fs.statSync(name);
-};
\ No newline at end of file
+};
diff --git a/test/support/uuid.c b/test/support/uuid.c
new file mode 100644
index 00000000..5b5b8085
--- /dev/null
+++ b/test/support/uuid.c
@@ -0,0 +1,233 @@
+/*
+** 2019-10-23
+**
+** The author disclaims copyright to this source code.  In place of
+** a legal notice, here is a blessing:
+**
+**    May you do good and not evil.
+**    May you find forgiveness for yourself and forgive others.
+**    May you share freely, never taking more than you give.
+**
+******************************************************************************
+**
+** This SQLite extension implements functions that handling RFC-4122 UUIDs
+** Three SQL functions are implemented:
+**
+**     uuid()        - generate a version 4 UUID as a string
+**     uuid_str(X)   - convert a UUID X into a well-formed UUID string
+**     uuid_blob(X)  - convert a UUID X into a 16-byte blob
+**
+** The output from uuid() and uuid_str(X) are always well-formed RFC-4122
+** UUID strings in this format:
+**
+**        xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
+**
+** All of the 'x', 'M', and 'N' values are lower-case hexadecimal digits.
+** The M digit indicates the "version".  For uuid()-generated UUIDs, the
+** version is always "4" (a random UUID).  The upper three bits of N digit
+** are the "variant".  This library only supports variant 1 (indicated
+** by values of N between '8' and 'b') as those are overwhelming the most
+** common.  Other variants are for legacy compatibility only.
+**
+** The output of uuid_blob(X) is always a 16-byte blob.  The UUID input
+** string is converted in network byte order (big-endian) in accordance
+** with RFC-4122 specifications for variant-1 UUIDs.  Note that network
+** byte order is *always* used, even if the input self-identifies as a
+** variant-2 UUID.
+**
+** The input X to the uuid_str() and uuid_blob() functions can be either
+** a string or a BLOB.  If it is a BLOB it must be exactly 16 bytes in
+** length or else a NULL is returned.  If the input is a string it must
+** consist of 32 hexadecimal digits, upper or lower case, optionally
+** surrounded by {...} and with optional "-" characters interposed in the
+** middle.  The flexibility of input is inspired by the PostgreSQL
+** implementation of UUID functions that accept in all of the following
+** formats:
+**
+**     A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11
+**     {a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}
+**     a0eebc999c0b4ef8bb6d6bb9bd380a11
+**     a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11
+**     {a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}
+**
+** If any of the above inputs are passed into uuid_str(), the output will
+** always be in the canonical RFC-4122 format:
+**
+**     a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11
+**
+** If the X input string has too few or too many digits or contains
+** stray characters other than {, }, or -, then NULL is returned.
+*/
+#include "sqlite3ext.h"
+SQLITE_EXTENSION_INIT1
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+
+#if !defined(SQLITE_ASCII) && !defined(SQLITE_EBCDIC)
+# define SQLITE_ASCII 1
+#endif
+
+/*
+** Translate a single byte of Hex into an integer.
+** This routine only works if h really is a valid hexadecimal
+** character:  0..9a..fA..F
+*/
+static unsigned char sqlite3UuidHexToInt(int h){
+  assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
+#ifdef SQLITE_ASCII
+  h += 9*(1&(h>>6));
+#endif
+#ifdef SQLITE_EBCDIC
+  h += 9*(1&~(h>>4));
+#endif
+  return (unsigned char)(h & 0xf);
+}
+
+/*
+** Convert a 16-byte BLOB into a well-formed RFC-4122 UUID.  The output
+** buffer zStr should be at least 37 bytes in length.   The output will
+** be zero-terminated.
+*/
+static void sqlite3UuidBlobToStr(
+  const unsigned char *aBlob,  /* Input blob */
+  unsigned char *zStr          /* Write the answer here */
+){
+  static const char zDigits[] = "0123456789abcdef";
+  int i, k;
+  unsigned char x;
+  k = 0;
+  for(i=0, k=0x550; i<16; i++, k=k>>1){
+    if( k&1 ){
+      zStr[0] = '-';
+      zStr++;
+    }
+    x = aBlob[i];
+    zStr[0] = zDigits[x>>4];
+    zStr[1] = zDigits[x&0xf];
+    zStr += 2;
+  }
+  *zStr = 0;
+}
+
+/*
+** Attempt to parse a zero-terminated input string zStr into a binary
+** UUID.  Return 0 on success, or non-zero if the input string is not
+** parsable.
+*/
+static int sqlite3UuidStrToBlob(
+  const unsigned char *zStr,   /* Input string */
+  unsigned char *aBlob         /* Write results here */
+){
+  int i;
+  if( zStr[0]=='{' ) zStr++;
+  for(i=0; i<16; i++){
+    if( zStr[0]=='-' ) zStr++;
+    if( isxdigit(zStr[0]) && isxdigit(zStr[1]) ){
+      aBlob[i] = (sqlite3UuidHexToInt(zStr[0])<<4)
+                      + sqlite3UuidHexToInt(zStr[1]);
+      zStr += 2;
+    }else{
+      return 1;
+    }
+  }
+  if( zStr[0]=='}' ) zStr++;
+  return zStr[0]!=0;
+}
+
+/*
+** Render sqlite3_value pIn as a 16-byte UUID blob.  Return a pointer
+** to the blob, or NULL if the input is not well-formed.
+*/
+static const unsigned char *sqlite3UuidInputToBlob(
+  sqlite3_value *pIn,     /* Input text */
+  unsigned char *pBuf     /* output buffer */
+){
+  switch( sqlite3_value_type(pIn) ){
+    case SQLITE_TEXT: {
+      const unsigned char *z = sqlite3_value_text(pIn);
+      if( sqlite3UuidStrToBlob(z, pBuf) ) return 0;
+      return pBuf;
+    }
+    case SQLITE_BLOB: {
+      int n = sqlite3_value_bytes(pIn);
+      return n==16 ? sqlite3_value_blob(pIn) : 0;
+    }
+    default: {
+      return 0;
+    }
+  }
+}
+
+/* Implementation of uuid() */
+static void sqlite3UuidFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  unsigned char aBlob[16];
+  unsigned char zStr[37];
+  (void)argc;
+  (void)argv;
+  sqlite3_randomness(16, aBlob);
+  aBlob[6] = (aBlob[6]&0x0f) + 0x40;
+  aBlob[8] = (aBlob[8]&0x3f) + 0x80;
+  sqlite3UuidBlobToStr(aBlob, zStr);
+  sqlite3_result_text(context, (char*)zStr, 36, SQLITE_TRANSIENT);
+}
+
+/* Implementation of uuid_str() */
+static void sqlite3UuidStrFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  unsigned char aBlob[16];
+  unsigned char zStr[37];
+  const unsigned char *pBlob;
+  (void)argc;
+  pBlob = sqlite3UuidInputToBlob(argv[0], aBlob);
+  if( pBlob==0 ) return;
+  sqlite3UuidBlobToStr(pBlob, zStr);
+  sqlite3_result_text(context, (char*)zStr, 36, SQLITE_TRANSIENT);
+}
+
+/* Implementation of uuid_blob() */
+static void sqlite3UuidBlobFunc(
+  sqlite3_context *context,
+  int argc,
+  sqlite3_value **argv
+){
+  unsigned char aBlob[16];
+  const unsigned char *pBlob;
+  (void)argc;
+  pBlob = sqlite3UuidInputToBlob(argv[0], aBlob);
+  if( pBlob==0 ) return;
+  sqlite3_result_blob(context, pBlob, 16, SQLITE_TRANSIENT);
+}
+
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_uuid_init(
+  sqlite3 *db,
+  char **pzErrMsg,
+  const sqlite3_api_routines *pApi
+){
+  int rc = SQLITE_OK;
+  SQLITE_EXTENSION_INIT2(pApi);
+  (void)pzErrMsg;  /* Unused parameter */
+  rc = sqlite3_create_function(db, "uuid", 0, SQLITE_UTF8|SQLITE_INNOCUOUS, 0,
+                               sqlite3UuidFunc, 0, 0);
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "uuid_str", 1, 
+                       SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
+                       0, sqlite3UuidStrFunc, 0, 0);
+  }
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(db, "uuid_blob", 1,
+                       SQLITE_UTF8|SQLITE_INNOCUOUS|SQLITE_DETERMINISTIC,
+                       0, sqlite3UuidBlobFunc, 0, 0);
+  }
+  return rc;
+}
diff --git a/test/trace.test.js b/test/trace.test.js
index 3f790bd8..4d7c0887 100644
--- a/test/trace.test.js
+++ b/test/trace.test.js
@@ -1,11 +1,11 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('tracing', function() {
-    it('Database tracing', function(done) {
-        var db = new sqlite3.Database(':memory:');
-        var create = false;
-        var select = false;
+    it('Database tracing', async function() {
+        const db = await sqlite3.Database.create(':memory:');
+        let create = false;
+        let select = false;
 
         db.on('trace', function(sql) {
             if (sql.match(/^SELECT/)) {
@@ -23,45 +23,42 @@ describe('tracing', function() {
             }
         });
 
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id int)");
-            db.run("SELECT * FROM foo");
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id int)");
+            await db.run("SELECT * FROM foo");
         });
 
-        db.close(function(err) {
-            if (err) throw err;
-            assert.ok(create);
-            assert.ok(select);
-            done();
-        });
+        await db.close();
+        assert.ok(create);
+        assert.ok(select);
     });
 
 
-    it('test disabling tracing #1', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('test disabling tracing #1', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        db.on('trace', function(sql) {});
+        db.on('trace', function() {});
         db.removeAllListeners('trace');
-        db._events['trace'] = function(sql) {
+        db._events['trace'] = function() {
             assert.ok(false);
         };
 
-        db.run("CREATE TABLE foo (id int)");
-        db.close(done);
+        await db.run("CREATE TABLE foo (id int)");
+        await db.close();
     });
 
 
-    it('test disabling tracing #2', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('test disabling tracing #2', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        var trace = function(sql) {};
+        const trace = function() {};
         db.on('trace', trace);
         db.removeListener('trace', trace);
-        db._events['trace'] = function(sql) {
+        db._events['trace'] = function() {
             assert.ok(false);
         };
 
-        db.run("CREATE TABLE foo (id int)");
-        db.close(done);
+        await db.run("CREATE TABLE foo (id int)");
+        await db.close();
     });
 });
diff --git a/test/unicode.test.js b/test/unicode.test.js
index 9a78c53d..8676311b 100644
--- a/test/unicode.test.js
+++ b/test/unicode.test.js
@@ -1,16 +1,17 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('unicode', function() {
-    var first_values = [],
-        trailing_values = [],
-        chars = [],
-        subranges = new Array(2),
-        len = subranges.length,
-        db,
-        i;
-
-    before(function(done) { db = new sqlite3.Database(':memory:', done); });
+    const first_values = [];
+    const trailing_values = [];
+    const subranges = new Array(2);
+    const len = subranges.length;
+    let db;
+    let i;
+
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+    });
 
     for (i = 0x20; i < 0x80; i++) {
         first_values.push(i);
@@ -41,7 +42,7 @@ describe('unicode', function() {
     }
 
     function random_utf8() {
-        var first = random_choice(first_values);
+        const first = random_choice(first_values);
 
         if (first < 0x80) {
             return String.fromCharCode(first);
@@ -57,8 +58,8 @@ describe('unicode', function() {
     }
 
     function randomString() {
-        var str = '',
-            i;
+        let str = '';
+        let i;
 
         for (i = Math.random() * 300; i > 0; i--) {
             str += random_utf8();
@@ -69,46 +70,35 @@ describe('unicode', function() {
 
 
     // Generate random data.
-    var data = [];
-    var length = Math.floor(Math.random() * 1000) + 200;
-    for (var i = 0; i < length; i++) {
+    const data = [];
+    const length = Math.floor(Math.random() * 1000) + 200;
+    for (let i = 0; i < length; i++) {
         data.push(randomString());
     }
 
-    var inserted = 0;
-    var retrieved = 0;
-
-    it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (id int, txt text)", done);
-    });
-
-    it('should insert all values', function(done) {
-        var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-        for (var i = 0; i < data.length; i++) {
-            stmt.run(i, data[i], function(err) {
-                if (err) throw err;
-                inserted++;
-            });
+    let inserted = 0;
+    let retrieved = 0;
+    
+    it('should retrieve all values', async function() {
+        await db.run("CREATE TABLE foo (id int, txt text)");
+        const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)");
+        for (let i = 0; i < data.length; i++) {
+            await stmt.run(i, data[i]);
+            inserted++;
         }
-        stmt.finalize(done);
-    });
-
-    it('should retrieve all values', function(done) {
-        db.all("SELECT txt FROM foo ORDER BY id", function(err, rows) {
-            if (err) throw err;
+        await stmt.finalize();
 
-            for (var i = 0; i < rows.length; i++) {
-                assert.equal(rows[i].txt, data[i]);
-                retrieved++;
-            }
-            done();
-        });
-    });
+        const rows = await db.all("SELECT txt FROM foo ORDER BY id");
 
-    it('should have inserted and retrieved the correct amount', function() {
+        for (let i = 0; i < rows.length; i++) {
+            assert.equal(rows[i].txt, data[i]);
+            retrieved++;
+        }
         assert.equal(inserted, length);
         assert.equal(retrieved, length);
     });
 
-    after(function(done) { db.close(done); });
+    after(async function() {
+        await db.close();
+    });
 });
diff --git a/test/update_hook.test.js b/test/update_hook.test.js
index 6507d2c8..26f5166a 100644
--- a/test/update_hook.test.js
+++ b/test/update_hook.test.js
@@ -1,15 +1,13 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('update_hook', function() {
-    var db;
+    /** @type {sqlite3.Database} */
+    let db;
 
-    beforeEach(function(done) {
-        db = new sqlite3.Database(':memory:', function(err) {
-            if (err) return done(err);
-
-            db.run("CREATE TABLE update_hooks_test (id int PRIMARY KEY, value text)", done);
-        });
+    beforeEach(async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.run("CREATE TABLE update_hooks_test (id int PRIMARY KEY, value text)");
     });
 
     it('emits insert event on inserting data to table', function(done) {
@@ -22,54 +20,51 @@ describe('update_hook', function() {
             return done();
         });
 
-        db.run("INSERT INTO update_hooks_test VALUES (1, 'value')", function(err) {
-            if (err) return done(err);
-        });
+        db.run("INSERT INTO update_hooks_test VALUES (1, 'value')")
+            .catch((err) => done(err));
     });
 
     it('emits update event on row modification in table', function(done) {
-        db.run("INSERT INTO update_hooks_test VALUES (2, 'value'), (3, 'value4')", function(err) {
-            if (err) return done(err);
-
-            db.addListener('change', function(eventType, database, table, rowId) {
-                assert.equal(eventType, 'update');
-                assert.equal(database, 'main');
-                assert.equal(table, 'update_hooks_test');
-                assert.equal(rowId, 1);
-
-                db.all("SELECT * FROM update_hooks_test WHERE rowid = ?", rowId, function(err, rows) {
-                    assert.deepEqual(rows, [{ id: 2, value: 'new_val' }]);
-
-                    return done(err);
+        db.run("INSERT INTO update_hooks_test VALUES (2, 'value'), (3, 'value4')")
+            .catch((err) => done(err))
+            .then(() => {
+                db.addListener('change', function(eventType, database, table, rowId) {
+                    assert.equal(eventType, 'update');
+                    assert.equal(database, 'main');
+                    assert.equal(table, 'update_hooks_test');
+                    assert.equal(rowId, 1);
+
+                    db.all("SELECT * FROM update_hooks_test WHERE rowid = ?", rowId)
+                        .catch((err) => done(err))
+                        .then((rows) => {
+                            assert.deepEqual(rows, [{ id: 2, value: 'new_val' }]);
+
+                            return done();
+                        });
                 });
-            });
 
-            db.run("UPDATE update_hooks_test SET value = 'new_val' WHERE id = 2", function(err) {
-                if (err) return done(err);
+                db.run("UPDATE update_hooks_test SET value = 'new_val' WHERE id = 2")
+                    .catch((err) => done(err));
             });
-        });
     });
 
     it('emits delete event on row was deleted from table', function(done) {
-        db.run("INSERT INTO update_hooks_test VALUES (2, 'value')", function(err) {
-            if (err) return done(err);
-
-            db.addListener('change', function(eventType, database, table, rowId) {
-                assert.equal(eventType, 'delete');
-                assert.equal(database, 'main');
-                assert.equal(table, 'update_hooks_test');
-                assert.equal(rowId, 1);
-
-                return done();
-            });
+        db.run("INSERT INTO update_hooks_test VALUES (2, 'value')")
+            .catch((err) => done(err))
+            .then(() => {
+                db.addListener('change', function(eventType, database, table, rowId) {
+                    assert.equal(eventType, 'delete');
+                    assert.equal(database, 'main');
+                    assert.equal(table, 'update_hooks_test');
+                    assert.equal(rowId, 1);
+                });
 
-            db.run("DELETE FROM update_hooks_test WHERE id = 2", function(err) {
-                if (err) return done(err);
+                db.run("DELETE FROM update_hooks_test WHERE id = 2")
+                    .catch((err) => done(err)).then(() => done());
             });
-        });
     });
 
-    afterEach(function(done) {
-        db.close(done);
+    afterEach(async function() {
+        await db.close();
     });
 });
diff --git a/test/upsert.test.js b/test/upsert.test.js
index f2aa8fa8..1f0f6e25 100644
--- a/test/upsert.test.js
+++ b/test/upsert.test.js
@@ -1,27 +1,26 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
 describe('query properties', function() {
-    var db;
-    before(function(done) {
-        db = new sqlite3.Database(':memory:');
-        db.run("CREATE TABLE foo (id INT PRIMARY KEY, count INT)", done);
+    /** @type {sqlite3.Database} */
+    let db;
+    before(async function() {
+        db = await sqlite3.Database.create(':memory:');
+        await db.run("CREATE TABLE foo (id INT PRIMARY KEY, count INT)");
     });
 
-    (sqlite3.VERSION_NUMBER < 3024000 ? it.skip : it)('should upsert', function(done) {
-        var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
-        stmt.run(1, 1, function(err) { // insert 1
-            if (err) throw err;
-            var upsert_stmt = db.prepare("INSERT INTO foo VALUES(?, ?) ON CONFLICT (id) DO UPDATE SET count = count + excluded.count");
-            upsert_stmt.run(1, 2, function(err) { // add 2
-                if (err) throw err;
-                var select_stmt = db.prepare("SELECT count FROM foo WHERE id = ?");
-                select_stmt.get(1, function(err, row) {
-                    if (err) throw err;
-                    assert.equal(row.count, 3); // equals 3
-                });
-            });
-        });
-        db.wait(done);
+    (sqlite3.VERSION_NUMBER < 3024000 ? it.skip : it)('should upsert', async function() {
+        const stmt = await db.prepare("INSERT INTO foo VALUES(?, ?)");
+        await stmt.run(1, 1);
+        await stmt.finalize();
+
+        const upsertStmt = await db.prepare("INSERT INTO foo VALUES(?, ?) ON CONFLICT (id) DO UPDATE SET count = count + excluded.count");
+        await upsertStmt.run(1, 2);
+        await upsertStmt.finalize();
+
+        const selectStmt = await db.prepare("SELECT count FROM foo WHERE id = ?");
+        const row = await selectStmt.get(1);
+        await selectStmt.finalize();
+        assert.equal(row.count, 3);
     });
 });
diff --git a/test/verbose.test.js b/test/verbose.test.js
index b680280c..8871f75f 100644
--- a/test/verbose.test.js
+++ b/test/verbose.test.js
@@ -1,60 +1,60 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+const sqlite3 = require('..');
+const assert = require('assert');
 
-var invalid_sql = 'update non_existent_table set id=1';
+const invalidSql = 'update non_existent_table set id=1';
 
-var originalMethods = {
+const originalMethods = {
     Database: {},
     Statement: {},
 };
 
 function backupOriginalMethods() {
-    for (var obj in originalMethods) {
-        for (var attr in sqlite3[obj].prototype) {
+    for (const obj in originalMethods) {
+        for (const attr in sqlite3[obj].prototype) {
             originalMethods[obj][attr] = sqlite3[obj].prototype[attr];
         }
     }
 }
 
 function resetVerbose() {
-    for (var obj in originalMethods) {
-        for (var attr in originalMethods[obj]) {
+    for (const obj in originalMethods) {
+        for (const attr in originalMethods[obj]) {
             sqlite3[obj].prototype[attr] = originalMethods[obj][attr];
         }
     }
 }
 
 describe('verbose', function() {
-    it('Shoud add trace info to error when verbose is called', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('Shoud add trace info to error when verbose is called', async function() {
+        const db = await sqlite3.Database.create(':memory:');
         backupOriginalMethods();
         sqlite3.verbose();
 
-        db.run(invalid_sql, function(err) {
-            assert(err instanceof Error);
+        await assert.rejects(db.run(invalidSql), function(err) {
+            assert.ok(err instanceof Error);
 
-            assert(
-                err.stack.indexOf(`Database#run('${invalid_sql}'`) > -1,
+            assert.ok(
+                err.stack.indexOf(`Database#run('${invalidSql}'`) > -1,
                 `Stack shoud contain trace info, stack = ${err.stack}`
             );
 
-            done();
             resetVerbose();
+            return true;
         });
     });
 
-    it('Shoud not add trace info to error when verbose is not called', function(done) {
-        var db = new sqlite3.Database(':memory:');
+    it('Shoud not add trace info to error when verbose is not called', async function() {
+        const db = await sqlite3.Database.create(':memory:');
 
-        db.run(invalid_sql, function(err) {
-            assert(err instanceof Error);
+        await assert.rejects(db.run(invalidSql), function(err) {
+            assert.ok(err instanceof Error);
 
-            assert(
-                err.stack.indexOf(invalid_sql) === -1,
+            assert.ok(
+                err.stack.indexOf(invalidSql) === -1,
                 `Stack shoud not contain trace info, stack = ${err.stack}`
             );
 
-            done();
+            return true;
         });
     });
 });
diff --git a/tools/benchmark/insert.js b/tools/benchmark/insert.js
index f2ebf7b9..57fbaa73 100644
--- a/tools/benchmark/insert.js
+++ b/tools/benchmark/insert.js
@@ -1,68 +1,72 @@
-var sqlite3 = require('../../lib/sqlite3');
-var fs = require('fs');
+const sqlite3 = require('../../lib/sqlite3');
+const fs = require('fs');
 
-var iterations = 10000;
+const iterations = 10000;
 
 exports.compare = {
-    'insert literal file': function(finished) {
-        var db = new sqlite3.Database('');
-        var file = fs.readFileSync('benchmark/insert-transaction.sql', 'utf8');
-        db.exec(file);
-        db.close(finished);
+    'insert literal file': async function(finished) {
+        const db = await sqlite3.Database.create('');
+        const file = fs.readFileSync('benchmark/insert-transaction.sql', 'utf8');
+        await db.exec(file);
+        await db.close();
+        finished();
     },
 
-    'insert with transaction and two statements': function(finished) {
-        var db = new sqlite3.Database('');
+    'insert with transaction and two statements': async function(finished) {
+        const db = await sqlite3.Database.create('');
 
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id INT, txt TEXT)");
-            db.run("BEGIN");
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id INT, txt TEXT)");
+            await db.run("BEGIN");
 
-            db.parallelize(function() {
-                var stmt1 = db.prepare("INSERT INTO foo VALUES (?, ?)");
-                var stmt2 = db.prepare("INSERT INTO foo VALUES (?, ?)");
-                for (var i = 0; i < iterations; i++) {
-                    stmt1.run(i, 'Row ' + i);
+            await db.parallelize(async function() {
+                const stmt1 = await db.prepare("INSERT INTO foo VALUES (?, ?)");
+                const stmt2 = await db.prepare("INSERT INTO foo VALUES (?, ?)");
+                for (let i = 0; i < iterations; i++) {
+                    await stmt1.run(i, 'Row ' + i);
                     i++;
-                    stmt2.run(i, 'Row ' + i);
+                    await stmt2.run(i, 'Row ' + i);
                 }
-                stmt1.finalize();
-                stmt2.finalize();
+                await stmt1.finalize();
+                await stmt2.finalize();
             });
 
-            db.run("COMMIT");
+            await db.run("COMMIT");
         });
 
-        db.close(finished);
+        await db.close();
+        finished();
     },
-    'insert with transaction': function(finished) {
-        var db = new sqlite3.Database('');
+    'insert with transaction': async function(finished) {
+        const db = await sqlite3.Database.create('');
 
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id INT, txt TEXT)");
-            db.run("BEGIN");
-            var stmt = db.prepare("INSERT INTO foo VALUES (?, ?)");
-            for (var i = 0; i < iterations; i++) {
-                stmt.run(i, 'Row ' + i);
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id INT, txt TEXT)");
+            await db.run("BEGIN");
+            const stmt = await db.prepare("INSERT INTO foo VALUES (?, ?)");
+            for (let i = 0; i < iterations; i++) {
+                await stmt.run(i, 'Row ' + i);
             }
-            stmt.finalize();
-            db.run("COMMIT");
+            await stmt.finalize();
+            await db.run("COMMIT");
         });
 
-        db.close(finished);
+        await db.close();
+        finished();
     },
-    'insert without transaction': function(finished) {
-        var db = new sqlite3.Database('');
+    'insert without transaction': async function(finished) {
+        const db = await sqlite3.Database.create('');
 
-        db.serialize(function() {
-            db.run("CREATE TABLE foo (id INT, txt TEXT)");
-            var stmt = db.prepare("INSERT INTO foo VALUES (?, ?)");
-            for (var i = 0; i < iterations; i++) {
-                stmt.run(i, 'Row ' + i);
+        await db.serialize(async function() {
+            await db.run("CREATE TABLE foo (id INT, txt TEXT)");
+            const stmt = await db.prepare("INSERT INTO foo VALUES (?, ?)");
+            for (let i = 0; i < iterations; i++) {
+                await stmt.run(i, 'Row ' + i);
             }
-            stmt.finalize();
+            await stmt.finalize();
         });
 
-        db.close(finished);
+        await db.close();
+        finished();
     }
-};
\ No newline at end of file
+};
diff --git a/tools/benchmark/select.js b/tools/benchmark/select.js
index be4b0e71..c9977358 100644
--- a/tools/benchmark/select.js
+++ b/tools/benchmark/select.js
@@ -1,28 +1,28 @@
 const sqlite3 = require('../../');
 const { readFileSync } = require('fs');
-const db = new sqlite3.Database(':memory:');
 
-db.serialize(() => {
-    db.exec(readFileSync(`${__dirname}/select-data.sql`, 'utf8'), (err) => {
-        if (err) throw err;
-        console.time('db.each');
-    });
 
-    {
-        const results = [];
-        db.each('SELECT * FROM foo', (err, row) => {
-            if (err) throw err;
-            results.push(row);
-        }, () => {
+async function benchmark() {
+    const db = await sqlite3.Database.create(':memory:');
+    
+    await db.serialize(async () => {
+        await db.exec(readFileSync(`${__dirname}/select-data.sql`, 'utf8'));
+        console.time('db.each');
+    
+        {
+            const results = [];
+            for await (const row of await db.each('SELECT * FROM foo')) {
+                results.push(row);
+            }
             console.timeEnd('db.each');
             console.time('db.all');
-        });
-    }
-
-    db.all('SELECT * FROM foo', (err, rows) => {
+        }
+    
+        await db.all('SELECT * FROM foo');
         console.timeEnd('db.all');
-        if (err) throw err;
+    
+        await db.close();
     });
+}
 
-    db.close();
-});
+benchmark();
diff --git a/tools/semver-check.js b/tools/semver-check.js
index 3b4a9a9c..4f920ce7 100644
--- a/tools/semver-check.js
+++ b/tools/semver-check.js
@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const semver = require('semver');
 
-const supportedVersions = '10.12.0';
+const supportedVersions = '16.0.0';
 
 function checkEngines(modulePath) {
     const packageJsonPath = path.join(modulePath, 'package.json');