Marketing Hub: RBAC, i18n (AR/EN), tasks overhaul, team/user merge, tutorial

Features:
- Full RBAC with 3 roles (superadmin/manager/contributor)
- Ownership tracking on posts, tasks, campaigns, projects
- Task system: assign to anyone, filter combobox, visibility scoping
- Team members merged into users table (single source of truth)
- Post thumbnails on kanban cards from attachments
- Publication link validation before publishing
- Interactive onboarding tutorial with Settings restart
- Full Arabic/English i18n with RTL layout support
- Language toggle in sidebar, IBM Plex Sans Arabic font
- Brand-based visibility filtering for non-superadmins
- Manager can only create contributors
- Profile completion flow for new users
- Cookie-based sessions (express-session + SQLite)

server/node_modules/sqlite3/LICENSE

@@ -0,0 +1,25 @@
+Copyright (c) MapBox
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+- Neither the name "MapBox" nor the names of its contributors may be
+  used to endorse or promote products derived from this software without
+  specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

server/node_modules/sqlite3/README.md

@@ -0,0 +1,249 @@
+# ⚙️ node-sqlite3
+
+Asynchronous, non-blocking [SQLite3](https://sqlite.org/) bindings for [Node.js](http://nodejs.org/).
+
+[![Latest release](https://img.shields.io/github/release/TryGhost/node-sqlite3.svg)](https://www.npmjs.com/package/sqlite3)
+![Build Status](https://github.com/TryGhost/node-sqlite3/workflows/CI/badge.svg?branch=master)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmapbox%2Fnode-sqlite3.svg?type=shield)](https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmapbox%2Fnode-sqlite3?ref=badge_shield)
+[![N-API v3 Badge](https://img.shields.io/badge/N--API-v3-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api)
+[![N-API v6 Badge](https://img.shields.io/badge/N--API-v6-green.svg)](https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api)
+
+# Features
+
+ - Straightforward query and parameter binding interface
+ - Full Buffer/Blob support
+ - Extensive [debugging support](https://github.com/tryghost/node-sqlite3/wiki/Debugging)
+ - [Query serialization](https://github.com/tryghost/node-sqlite3/wiki/Control-Flow) API
+ - [Extension support](https://github.com/TryGhost/node-sqlite3/wiki/API#databaseloadextensionpath-callback), including bundled support for the [json1 extension](https://www.sqlite.org/json1.html)
+ - Big test suite
+ - Written in modern C++ and tested for memory leaks
+ - Bundles SQLite v3.44.2, or you can build using a local SQLite
+
+# Installing
+
+You can use [`npm`](https://github.com/npm/cli) or [`yarn`](https://github.com/yarnpkg/yarn) to install `sqlite3`:
+
+* (recommended) Latest published package:
+```bash
+npm install sqlite3
+# or
+yarn add sqlite3
+```
+* GitHub's `master` branch: `npm install https://github.com/tryghost/node-sqlite3/tarball/master`
+
+### Prebuilt binaries
+
+`sqlite3` v5+ was rewritten to use [Node-API](https://nodejs.org/api/n-api.html) so prebuilt binaries do not need to be built for specific Node versions. `sqlite3` currently builds for both Node-API v3 and v6. Check the [Node-API version matrix](https://nodejs.org/api/n-api.html#node-api-version-matrix) to ensure your Node version supports one of these. The prebuilt binaries should be supported on Node v10+.
+
+The module uses [`prebuild-install`](https://github.com/prebuild/prebuild-install) to download the prebuilt binary for your platform, if it exists. These binaries are hosted on GitHub Releases for `sqlite3` versions above 5.0.2, and they are hosted on S3 otherwise. The following targets are currently provided:
+
+* `darwin-arm64`
+* `darwin-x64`
+* `linux-arm64`
+* `linux-x64`
+* `linuxmusl-arm64`
+* `linuxmusl-x64`
+* `win32-ia32`
+* `win32-x64`
+
+Unfortunately, [prebuild](https://github.com/prebuild/prebuild/issues/174) cannot differentiate between `armv6` and `armv7`, and instead uses `arm` as the `{arch}`. Until that is fixed, you will still need to install `sqlite3` from [source](#source-install).
+
+Support for other platforms and architectures may be added in the future if CI supports building on them.
+
+If your environment isn't supported, it'll use `node-gyp` to build SQLite, but you will need to install a C++ compiler and linker.
+
+### Other ways to install
+
+It is also possible to make your own build of `sqlite3` from its source instead of its npm package ([See below.](#source-install)).
+
+The `sqlite3` module also works with [node-webkit](https://github.com/rogerwang/node-webkit) if node-webkit contains a supported version of Node.js engine. [(See below.)](#building-for-node-webkit)
+
+SQLite's [SQLCipher extension](https://github.com/sqlcipher/sqlcipher) is also supported. [(See below.)](#building-for-sqlcipher)
+
+# API
+
+See the [API documentation](https://github.com/TryGhost/node-sqlite3/wiki/API) in the wiki.
+
+# Usage
+
+**Note:** the module must be [installed](#installing) before use.
+
+``` js
+const sqlite3 = require('sqlite3').verbose();
+const db = new sqlite3.Database(':memory:');
+
+db.serialize(() => {
+    db.run("CREATE TABLE lorem (info TEXT)");
+
+    const stmt = db.prepare("INSERT INTO lorem VALUES (?)");
+    for (let i = 0; i < 10; i++) {
+        stmt.run("Ipsum " + i);
+    }
+    stmt.finalize();
+
+    db.each("SELECT rowid AS id, info FROM lorem", (err, row) => {
+        console.log(row.id + ": " + row.info);
+    });
+});
+
+db.close();
+```
+
+## Source install
+
+To skip searching for pre-compiled binaries, and force a build from source, use
+
+```bash
+npm install --build-from-source
+```
+
+The sqlite3 module depends only on libsqlite3. However, by default, an internal/bundled copy of sqlite will be built and statically linked, so an externally installed sqlite3 is not required.
+
+If you wish to install against an external sqlite then you need to pass the `--sqlite` argument to `npm` wrapper:
+
+```bash
+npm install --build-from-source --sqlite=/usr/local
+```
+
+If building against an external sqlite3 make sure to have the development headers available. Mac OS X ships with these by default. If you don't have them installed, install the `-dev` package with your package manager, e.g. `apt-get install libsqlite3-dev` for Debian/Ubuntu. Make sure that you have at least `libsqlite3` >= 3.6.
+
+Note, if building against homebrew-installed sqlite on OS X you can do:
+
+```bash
+npm install --build-from-source --sqlite=/usr/local/opt/sqlite/
+```
+
+## Custom file header (magic)
+
+The default sqlite file header is "SQLite format 3". You can specify a different magic, though this will make standard tools and libraries unable to work with your files.
+
+```bash
+npm install --build-from-source --sqlite_magic="MyCustomMagic15"
+```
+
+Note that the magic *must* be exactly 15 characters long (16 bytes including null terminator).
+
+## Building for node-webkit
+
+Because of ABI differences, `sqlite3` must be built in a custom to be used with [node-webkit](https://github.com/rogerwang/node-webkit).
+
+To build `sqlite3` for node-webkit:
+
+1. Install [`nw-gyp`](https://github.com/rogerwang/nw-gyp) globally: `npm install nw-gyp -g` *(unless already installed)*
+
+2. Build the module with the custom flags of `--runtime`, `--target_arch`, and `--target`:
+
+```bash
+NODE_WEBKIT_VERSION="0.8.6" # see latest version at https://github.com/rogerwang/node-webkit#downloads
+npm install sqlite3 --build-from-source --runtime=node-webkit --target_arch=ia32 --target=$(NODE_WEBKIT_VERSION)
+```
+
+You can also run this command from within a `sqlite3` checkout:
+
+```bash
+npm install --build-from-source --runtime=node-webkit --target_arch=ia32 --target=$(NODE_WEBKIT_VERSION)
+```
+
+Remember the following:
+
+* You must provide the right `--target_arch` flag. `ia32` is needed to target 32bit node-webkit builds, while `x64` will target 64bit node-webkit builds (if available for your platform).
+
+* After the `sqlite3` package is built for node-webkit it cannot run in the vanilla Node.js (and vice versa).
+   * For example, `npm test` of the node-webkit's package would fail.
+
+Visit the “[Using Node modules](https://github.com/rogerwang/node-webkit/wiki/Using-Node-modules)” article in the node-webkit's wiki for more details.
+
+## Building for SQLCipher
+
+For instructions on building SQLCipher, see [Building SQLCipher for Node.js](https://coolaj86.com/articles/building-sqlcipher-for-node-js-on-raspberry-pi-2/). Alternatively, you can install it with your local package manager.
+
+To run against SQLCipher, you need to compile `sqlite3` from source by passing build options like:
+
+```bash
+npm install sqlite3 --build-from-source --sqlite_libname=sqlcipher --sqlite=/usr/
+
+node -e 'require("sqlite3")'
+```
+
+If your SQLCipher is installed in a custom location (if you compiled and installed it yourself), you'll need to set some environment variables:
+
+### On OS X with Homebrew
+
+Set the location where `brew` installed it:
+
+```bash
+export LDFLAGS="-L`brew --prefix`/opt/sqlcipher/lib"
+export CPPFLAGS="-I`brew --prefix`/opt/sqlcipher/include/sqlcipher"
+npm install sqlite3 --build-from-source --sqlite_libname=sqlcipher --sqlite=`brew --prefix`
+
+node -e 'require("sqlite3")'
+```
+
+### On most Linuxes (including Raspberry Pi)
+
+Set the location where `make` installed it:
+
+```bash
+export LDFLAGS="-L/usr/local/lib"
+export CPPFLAGS="-I/usr/local/include -I/usr/local/include/sqlcipher"
+export CXXFLAGS="$CPPFLAGS"
+npm install sqlite3 --build-from-source --sqlite_libname=sqlcipher --sqlite=/usr/local --verbose
+
+node -e 'require("sqlite3")'
+```
+
+### Custom builds and Electron
+
+Running `sqlite3` through [electron-rebuild](https://github.com/electron/electron-rebuild) does not preserve the SQLCipher extension, so some additional flags are needed to make this build Electron compatible. Your `npm install sqlite3 --build-from-source` command needs these additional flags (be sure to replace the target version with the current Electron version you are working with):
+
+```bash
+--runtime=electron --target=18.2.1 --dist-url=https://electronjs.org/headers
+```
+
+In the case of MacOS with Homebrew, the command should look like the following:
+
+```bash
+npm install sqlite3 --build-from-source --sqlite_libname=sqlcipher --sqlite=`brew --prefix` --runtime=electron --target=18.2.1 --dist-url=https://electronjs.org/headers
+```
+
+# Testing
+
+```bash
+npm test
+```
+
+# Contributors
+
+* [Daniel Lockyer](https://github.com/daniellockyer)
+* [Konstantin Käfer](https://github.com/kkaefer)
+* [Dane Springmeyer](https://github.com/springmeyer)
+* [Will White](https://github.com/willwhite)
+* [Orlando Vazquez](https://github.com/orlandov)
+* [Artem Kustikov](https://github.com/artiz)
+* [Eric Fredricksen](https://github.com/grumdrig)
+* [John Wright](https://github.com/mrjjwright)
+* [Ryan Dahl](https://github.com/ry)
+* [Tom MacWright](https://github.com/tmcw)
+* [Carter Thaxton](https://github.com/carter-thaxton)
+* [Audrius Kažukauskas](https://github.com/audriusk)
+* [Johannes Schauer](https://github.com/pyneo)
+* [Mithgol](https://github.com/Mithgol)
+* [Kewde](https://github.com/kewde)
+
+# Acknowledgments
+
+Thanks to [Orlando Vazquez](https://github.com/orlandov),
+[Eric Fredricksen](https://github.com/grumdrig) and
+[Ryan Dahl](https://github.com/ry) for their SQLite bindings for node, and to mraleph on Freenode's #v8 for answering questions.
+
+This module was originally created by [Mapbox](https://mapbox.com/) & is now maintained by [Ghost](https://ghost.org).
+
+# Changelog
+
+We use [GitHub releases](https://github.com/TryGhost/node-sqlite3/releases) for notes on the latest versions. See [CHANGELOG.md](https://github.com/TryGhost/node-sqlite3/blob/b05f4594cf8b0de64743561fcd2cfe6f4571754d/CHANGELOG.md) in git history for details on older versions.
+
+# License
+
+`node-sqlite3` is [BSD licensed](https://github.com/tryghost/node-sqlite3/raw/master/LICENSE).
+
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmapbox%2Fnode-sqlite3.svg?type=large)](https://app.fossa.io/projects/git%2Bhttps%3A%2F%2Fgithub.com%2Fmapbox%2Fnode-sqlite3?ref=badge_large)

server/node_modules/sqlite3/binding.gyp

@@ -0,0 +1,58 @@
+{
+  "includes": [ "deps/common-sqlite.gypi" ],
+  "variables": {
+      "sqlite%":"internal",
+      "sqlite_libname%":"sqlite3",
+      "module_name": "node_sqlite3",
+  },
+  "targets": [
+    {
+      "target_name": "<(module_name)",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "xcode_settings": { "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.7",
+      },
+      "msvs_settings": {
+        "VCCLCompilerTool": { "ExceptionHandling": 1 },
+      },
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"],
+      "conditions": [
+        ["sqlite != 'internal'", {
+            "include_dirs": [
+              "<!@(node -p \"require('node-addon-api').include\")", "<(sqlite)/include" ],
+            "libraries": [
+               "-l<(sqlite_libname)"
+            ],
+            "conditions": [
+              [ "OS=='linux'", {"libraries+":["-Wl,-rpath=<@(sqlite)/lib"]} ],
+              [ "OS!='win'", {"libraries+":["-L<@(sqlite)/lib"]} ]
+            ],
+            'msvs_settings': {
+              'VCLinkerTool': {
+                'AdditionalLibraryDirectories': [
+                  '<(sqlite)/lib'
+                ],
+              },
+            }
+        },
+        {
+            "dependencies": [
+              "<!(node -p \"require('node-addon-api').gyp\")",
+              "deps/sqlite3.gyp:sqlite3"
+            ]
+        }
+        ]
+      ],
+      "sources": [
+        "src/backup.cc",
+        "src/database.cc",
+        "src/node_sqlite3.cc",
+        "src/statement.cc"
+      ],
+      "defines": [ "NAPI_VERSION=<(napi_build_version)", "NAPI_DISABLE_CPP_EXCEPTIONS=1" ]
+    }
+  ]
+}

server/node_modules/sqlite3/deps/common-sqlite.gypi

@@ -0,0 +1,60 @@
+{
+  'variables': {
+      'sqlite_version%':'3440200',
+      "toolset%":'',
+  },
+  'target_defaults': {
+    'default_configuration': 'Release',
+    'conditions': [
+      [ 'toolset!=""', {
+        'msbuild_toolset':'<(toolset)'
+      }]
+    ],
+    'configurations': {
+      'Debug': {
+        'defines!': [
+          'NDEBUG'
+        ],
+        'cflags_cc!': [
+          '-O3',
+          '-Os',
+          '-DNDEBUG'
+        ],
+        'xcode_settings': {
+          'OTHER_CPLUSPLUSFLAGS!': [
+            '-O3',
+            '-Os',
+            '-DDEBUG'
+          ],
+          'GCC_OPTIMIZATION_LEVEL': '0',
+          'GCC_GENERATE_DEBUGGING_SYMBOLS': 'YES'
+        },
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'ExceptionHandling': 1, # /EHsc
+          }
+        }
+      },
+      'Release': {
+        'defines': [
+          'NDEBUG'
+        ],
+        'xcode_settings': {
+          'OTHER_CPLUSPLUSFLAGS!': [
+            '-Os',
+            '-O2'
+          ],
+          'GCC_OPTIMIZATION_LEVEL': '3',
+          'GCC_GENERATE_DEBUGGING_SYMBOLS': 'NO',
+          'DEAD_CODE_STRIPPING': 'YES',
+          'GCC_INLINES_ARE_PRIVATE_EXTERN': 'YES'
+        },
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'ExceptionHandling': 1, # /EHsc
+          }
+        }
+      }
+    }
+  }
+}

server/node_modules/sqlite3/deps/extract.js

@@ -0,0 +1,10 @@
+const tar = require("tar");
+const path = require("path");
+const tarball = path.resolve(process.argv[2]);
+const dirname = path.resolve(process.argv[3]);
+
+tar.extract({
+    sync: true,
+    file: tarball,
+    cwd: dirname,
+});

server/node_modules/sqlite3/deps/sqlite3.gyp

@@ -0,0 +1,121 @@
+{
+  'includes': [ 'common-sqlite.gypi' ],
+
+  'variables': {
+    'sqlite_magic%': '',
+  },
+
+  'target_defaults': {
+    'default_configuration': 'Release',
+    'cflags':[
+      '-std=c99'
+    ],
+    'configurations': {
+      'Debug': {
+        'defines': [ 'DEBUG', '_DEBUG' ],
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'RuntimeLibrary': 1, # static debug
+          },
+        },
+      },
+      'Release': {
+        'defines': [ 'NDEBUG' ],
+        'msvs_settings': {
+          'VCCLCompilerTool': {
+            'RuntimeLibrary': 0, # static release
+          },
+        },
+      }
+    },
+    'msvs_settings': {
+      'VCCLCompilerTool': {
+      },
+      'VCLibrarianTool': {
+      },
+      'VCLinkerTool': {
+        'GenerateDebugInformation': 'true',
+      },
+    },
+    'conditions': [
+      ['OS == "win"', {
+        'defines': [
+          'WIN32'
+        ],
+      }]
+    ],
+  },
+
+  'targets': [
+    {
+      'target_name': 'action_before_build',
+      'type': 'none',
+      'hard_dependency': 1,
+      'actions': [
+        {
+          'action_name': 'unpack_sqlite_dep',
+          'inputs': [
+            './sqlite-autoconf-<@(sqlite_version).tar.gz'
+          ],
+          'outputs': [
+            '<(SHARED_INTERMEDIATE_DIR)/sqlite-autoconf-<@(sqlite_version)/sqlite3.c'
+          ],
+          'action': ['node','./extract.js','./sqlite-autoconf-<@(sqlite_version).tar.gz','<(SHARED_INTERMEDIATE_DIR)']
+        }
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          '<(SHARED_INTERMEDIATE_DIR)/sqlite-autoconf-<@(sqlite_version)/',
+        ]
+      },
+    },
+    {
+      'target_name': 'sqlite3',
+      'type': 'static_library',
+      'include_dirs': [ '<(SHARED_INTERMEDIATE_DIR)/sqlite-autoconf-<@(sqlite_version)/' ],
+      'dependencies': [
+        'action_before_build'
+      ],
+      'sources': [
+        '<(SHARED_INTERMEDIATE_DIR)/sqlite-autoconf-<@(sqlite_version)/sqlite3.c'
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '<(SHARED_INTERMEDIATE_DIR)/sqlite-autoconf-<@(sqlite_version)/' ],
+        'defines': [
+          'SQLITE_THREADSAFE=1',
+          'HAVE_USLEEP=1',
+          'SQLITE_ENABLE_FTS3',
+          'SQLITE_ENABLE_FTS4',
+          'SQLITE_ENABLE_FTS5',
+          'SQLITE_ENABLE_RTREE',
+          'SQLITE_ENABLE_DBSTAT_VTAB=1',
+          'SQLITE_ENABLE_MATH_FUNCTIONS'
+        ],
+      },
+      'cflags_cc': [
+          '-Wno-unused-value'
+      ],
+      'defines': [
+        '_REENTRANT=1',
+        'SQLITE_THREADSAFE=1',
+        'HAVE_USLEEP=1',
+        'SQLITE_ENABLE_FTS3',
+        'SQLITE_ENABLE_FTS4',
+        'SQLITE_ENABLE_FTS5',
+        'SQLITE_ENABLE_RTREE',
+        'SQLITE_ENABLE_DBSTAT_VTAB=1',
+        'SQLITE_ENABLE_MATH_FUNCTIONS'
+      ],
+      'export_dependent_settings': [
+        'action_before_build',
+      ],
+      'conditions': [
+        ["sqlite_magic != ''", {
+            'defines': [
+              'SQLITE_FILE_HEADER="<(sqlite_magic)"'
+            ]
+        }]
+      ],
+    }
+  ]
+}

server/node_modules/sqlite3/lib/sqlite3-binding.js

@@ -0,0 +1 @@
+module.exports = require('bindings')('node_sqlite3.node');

server/node_modules/sqlite3/lib/sqlite3.d.ts

@@ -0,0 +1,205 @@
+// Type definitions for sqlite3
+// Project: http://github.com/tryghost/node-sqlite3
+
+/// <reference types="node" />
+
+import events = require("events");
+
+export const OPEN_READONLY: number;
+export const OPEN_READWRITE: number;
+export const OPEN_CREATE: number;
+export const OPEN_FULLMUTEX: number;
+export const OPEN_SHAREDCACHE: number;
+export const OPEN_PRIVATECACHE: number;
+export const OPEN_URI: number;
+
+export const VERSION: string;
+export const SOURCE_ID: string;
+export const VERSION_NUMBER: number;
+
+export const OK: number;
+export const ERROR: number;
+export const INTERNAL: number;
+export const PERM: number;
+export const ABORT: number;
+export const BUSY: number;
+export const LOCKED: number;
+export const NOMEM: number;
+export const READONLY: number;
+export const INTERRUPT: number
+export const IOERR: number;
+export const CORRUPT: number
+export const NOTFOUND: number;
+export const FULL: number;
+export const CANTOPEN: number;
+export const PROTOCOL: number;
+export const EMPTY: number;
+export const SCHEMA: number;
+export const TOOBIG: number
+export const CONSTRAINT: number
+export const MISMATCH: number;
+export const MISUSE: number;
+export const NOLFS: number;
+export const AUTH: number
+export const FORMAT: number;
+export const RANGE: number
+export const NOTADB: number;
+
+export const LIMIT_LENGTH: number;
+export const LIMIT_SQL_LENGTH: number;
+export const LIMIT_COLUMN: number;
+export const LIMIT_EXPR_DEPTH: number;
+export const LIMIT_COMPOUND_SELECT: number;
+export const LIMIT_VDBE_OP: number;
+export const LIMIT_FUNCTION_ARG: number;
+export const LIMIT_ATTACHED: number;
+export const LIMIT_LIKE_PATTERN_LENGTH: number;
+export const LIMIT_VARIABLE_NUMBER: number;
+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;
+};
+
+export interface RunResult extends Statement {
+    lastID: number;
+    changes: number;
+}
+
+export class Statement extends events.EventEmitter {
+    bind(callback?: (err: Error | null) => void): this;
+    bind(...params: any[]): this;
+
+    reset(callback?: (err: null) => void): this;
+
+    finalize(callback?: (err: Error) => void): Database;
+
+    run(callback?: (err: Error | null) => void): this;
+    run(params: any, callback?: (this: RunResult, err: Error | null) => void): this;
+    run(...params: any[]): this;
+
+    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;
+
+    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;
+
+    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;
+}
+
+export class Database extends events.EventEmitter {
+    constructor(filename: string, callback?: (err: Error | null) => void);
+    constructor(filename: string, mode?: number, callback?: (err: Error | null) => void);
+
+    close(callback?: (err: Error | null) => void): void;
+
+    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;
+
+    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;
+
+    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;
+
+    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;
+
+    exec(sql: string, callback?: (this: Statement, err: Error | null) => void): this;
+
+    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;
+
+    serialize(callback?: () => void): void;
+    parallelize(callback?: () => void): void;
+
+    on(event: "trace", listener: (sql: string) => void): this;
+    on(event: "profile", listener: (sql: string, time: number) => void): this;
+    on(event: "change", listener: (type: string, database: string, table: string, rowid: number) => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "open" | "close", listener: () => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+
+    configure(option: "busyTimeout", value: number): void;
+    configure(option: "limit", id: number, value: number): void;
+
+    loadExtension(filename: string, callback?: (err: Error | null) => void): this;
+
+    wait(callback?: (param: null) => void): this;
+
+    interrupt(): void;
+}
+
+export function verbose(): sqlite3;
+
+export interface sqlite3 {
+    OPEN_READONLY: number;
+    OPEN_READWRITE: number;
+    OPEN_CREATE: number;
+    OPEN_FULLMUTEX: number;
+    OPEN_SHAREDCACHE: number;
+    OPEN_PRIVATECACHE: number;
+    OPEN_URI: number;
+
+    VERSION: string;
+    SOURCE_ID: string;
+    VERSION_NUMBER: number;
+
+    OK: number;
+    ERROR: number;
+    INTERNAL: number;
+    PERM: number;
+    ABORT: number;
+    BUSY: number;
+    LOCKED: number;
+    NOMEM: number;
+    READONLY: number;
+    INTERRUPT: number
+    IOERR: number;
+    CORRUPT: number
+    NOTFOUND: number;
+    FULL: number;
+    CANTOPEN: number;
+    PROTOCOL: number;
+    EMPTY: number;
+    SCHEMA: number;
+    TOOBIG: number
+    CONSTRAINT: number
+    MISMATCH: number;
+    MISUSE: number;
+    NOLFS: number;
+    AUTH: number
+    FORMAT: number;
+    RANGE: number
+    NOTADB: number;
+
+    LIMIT_LENGTH: number;
+    LIMIT_SQL_LENGTH: number;
+    LIMIT_COLUMN: number;
+    LIMIT_EXPR_DEPTH: number;
+    LIMIT_COMPOUND_SELECT: number;
+    LIMIT_VDBE_OP: number;
+    LIMIT_FUNCTION_ARG: number;
+    LIMIT_ATTACHED: number;
+    LIMIT_LIKE_PATTERN_LENGTH: number;
+    LIMIT_VARIABLE_NUMBER: number;
+    LIMIT_TRIGGER_DEPTH: number;
+    LIMIT_WORKER_THREADS: number;
+
+    cached: typeof cached;
+    RunResult: RunResult;
+    Statement: typeof Statement;
+    Database: typeof Database;
+    verbose(): this;
+}

server/node_modules/sqlite3/lib/sqlite3.js

@@ -0,0 +1,207 @@
+const path = require('path');
+const sqlite3 = require('./sqlite3-binding.js');
+const EventEmitter = require('events').EventEmitter;
+module.exports = exports = sqlite3;
+
+function normalizeMethod (fn) {
+    return function (sql) {
+        let errBack;
+        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);
+        return fn.call(this, statement, args);
+    };
+}
+
+function inherits(target, source) {
+    for (const k in source.prototype)
+        target.prototype[k] = source.prototype[k];
+}
+
+sqlite3.cached = {
+    Database: function(file, a, b) {
+        if (file === '' || file === ':memory:') {
+            // Don't cache special databases.
+            return new Database(file, a, b);
+        }
+
+        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);
+            }
+        }
+
+        return db;
+    },
+    objects: {}
+};
+
+
+const Database = sqlite3.Database;
+const Statement = sqlite3.Statement;
+const Backup = sqlite3.Backup;
+
+inherits(Database, EventEmitter);
+inherits(Statement, EventEmitter);
+inherits(Backup, EventEmitter);
+
+// Database#prepare(sql, [bind1, bind2, ...], [callback])
+Database.prototype.prepare = normalizeMethod(function(statement, params) {
+    return params.length
+        ? statement.bind.apply(statement, params)
+        : statement;
+});
+
+// Database#run(sql, [bind1, bind2, ...], [callback])
+Database.prototype.run = normalizeMethod(function(statement, params) {
+    statement.run.apply(statement, params).finalize();
+    return this;
+});
+
+// Database#get(sql, [bind1, bind2, ...], [callback])
+Database.prototype.get = normalizeMethod(function(statement, params) {
+    statement.get.apply(statement, params).finalize();
+    return this;
+});
+
+// Database#all(sql, [bind1, bind2, ...], [callback])
+Database.prototype.all = normalizeMethod(function(statement, params) {
+    statement.all.apply(statement, params).finalize();
+    return this;
+});
+
+// Database#each(sql, [bind1, bind2, ...], [callback], [complete])
+Database.prototype.each = normalizeMethod(function(statement, params) {
+    statement.each.apply(statement, params).finalize();
+    return this;
+});
+
+Database.prototype.map = normalizeMethod(function(statement, params) {
+    statement.map.apply(statement, params).finalize();
+    return this;
+});
+
+// Database#backup(filename, [callback])
+// Database#backup(filename, destName, sourceName, filenameIsDest, [callback])
+Database.prototype.backup = function() {
+    let backup;
+    if (arguments.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]);
+    } 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]);
+    }
+    // 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];
+                }
+            }
+        }
+        callback(err, result);
+    });
+    return this.all.apply(this, params);
+};
+
+let isVerbose = false;
+
+const supportedEvents = [ 'trace', 'profile', 'change' ];
+
+Database.prototype.addListener = Database.prototype.on = function(type) {
+    const val = EventEmitter.prototype.addListener.apply(this, arguments);
+    if (supportedEvents.indexOf(type) >= 0) {
+        this.configure(type, true);
+    }
+    return val;
+};
+
+Database.prototype.removeListener = function(type) {
+    const val = EventEmitter.prototype.removeListener.apply(this, arguments);
+    if (supportedEvents.indexOf(type) >= 0 && !this._events[type]) {
+        this.configure(type, false);
+    }
+    return val;
+};
+
+Database.prototype.removeAllListeners = function(type) {
+    const val = EventEmitter.prototype.removeAllListeners.apply(this, arguments);
+    if (supportedEvents.indexOf(type) >= 0) {
+        this.configure(type, false);
+    }
+    return val;
+};
+
+// Save the stack trace over EIO callbacks.
+sqlite3.verbose = function() {
+    if (!isVerbose) {
+        const trace = require('./trace');
+        [
+            'prepare',
+            'get',
+            'run',
+            'all',
+            'each',
+            'map',
+            'close',
+            'exec'
+        ].forEach(function (name) {
+            trace.extendTrace(Database.prototype, name);
+        });
+        [
+            'bind',
+            'get',
+            'run',
+            'all',
+            'each',
+            'map',
+            'reset',
+            'finalize',
+        ].forEach(function (name) {
+            trace.extendTrace(Statement.prototype, name);
+        });
+        isVerbose = true;
+    }
+
+    return sqlite3;
+};

server/node_modules/sqlite3/lib/trace.js

@@ -0,0 +1,38 @@
+// Inspired by https://github.com/tlrobinson/long-stack-traces
+const util = require('util');
+
+function extendTrace(object, property, pos) {
+    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);
+    };
+}
+exports.extendTrace = extendTrace;
+
+
+function filter(error) {
+    return error.stack.split('\n').filter(function(line) {
+        return line.indexOf(__filename) < 0;
+    });
+}

server/node_modules/sqlite3/node_modules/node-addon-api/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 [Node.js API collaborators](https://github.com/nodejs/node-addon-api#collaborators)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

server/node_modules/sqlite3/node_modules/node-addon-api/README.md

@@ -0,0 +1,319 @@
+NOTE: The default branch has been renamed!
+master is now named main
+
+If you have a local clone, you can update it by running:
+
+```shell
+git branch -m master main
+git fetch origin
+git branch -u origin/main main
+```
+
+# **node-addon-api module**
+This module contains  **header-only C++ wrapper classes** which simplify
+the use of the C based [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
+provided by Node.js when using C++. It provides a C++ object model
+and exception handling semantics with low overhead.
+
+There are three options for implementing addons: Node-API, nan, or direct
+use of internal V8, libuv, and Node.js libraries. Unless there is a need for
+direct access to functionality that is not exposed by Node-API as outlined
+in [C/C++ addons](https://nodejs.org/dist/latest/docs/api/addons.html)
+in Node.js core, use Node-API. Refer to
+[C/C++ addons with Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
+for more information on Node-API.
+
+Node-API is an ABI stable C interface provided by Node.js for building native
+addons. It is independent of the underlying JavaScript runtime (e.g. V8 or ChakraCore)
+and is maintained as part of Node.js itself. It is intended to insulate
+native addons from changes in the underlying JavaScript engine and allow
+modules compiled for one version to run on later versions of Node.js without
+recompilation.
+
+The `node-addon-api` module, which is not part of Node.js, preserves the benefits
+of the Node-API as it consists only of inline code that depends only on the stable API
+provided by Node-API. As such, modules built against one version of Node.js
+using node-addon-api should run without having to be rebuilt with newer versions
+of Node.js.
+
+It is important to remember that *other* Node.js interfaces such as
+`libuv` (included in a project via `#include <uv.h>`) are not ABI-stable across
+Node.js major versions. Thus, an addon must use Node-API and/or `node-addon-api`
+exclusively and build against a version of Node.js that includes an
+implementation of Node-API (meaning an active LTS version of Node.js) in
+order to benefit from ABI stability across Node.js major versions. Node.js
+provides an [ABI stability guide][] containing a detailed explanation of ABI
+stability in general, and the Node-API ABI stability guarantee in particular.
+
+As new APIs are added to Node-API, node-addon-api must be updated to provide
+wrappers for those new APIs. For this reason, node-addon-api provides
+methods that allow callers to obtain the underlying Node-API handles so
+direct calls to Node-API and the use of the objects/methods provided by
+node-addon-api can be used together. For example, in order to be able
+to use an API for which the node-addon-api does not yet provide a wrapper.
+
+APIs exposed by node-addon-api are generally used to create and
+manipulate JavaScript values. Concepts and operations generally map
+to ideas specified in the **ECMA262 Language Specification**.
+
+The [Node-API Resource](https://nodejs.github.io/node-addon-examples/) offers an
+excellent orientation and tips for developers just getting started with Node-API
+and node-addon-api.
+
+- **[Setup](#setup)**
+- **[API Documentation](#api)**
+- **[Examples](#examples)**
+- **[Tests](#tests)**
+- **[More resource and info about native Addons](#resources)**
+- **[Badges](#badges)**
+- **[Code of Conduct](CODE_OF_CONDUCT.md)**
+- **[Contributors](#contributors)**
+- **[License](#license)**
+
+## **Current version: 7.1.1**
+
+(See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
+
+[![NPM](https://nodei.co/npm/node-addon-api.png?downloads=true&downloadRank=true)](https://nodei.co/npm/node-addon-api/) [![NPM](https://nodei.co/npm-dl/node-addon-api.png?months=6&height=1)](https://nodei.co/npm/node-addon-api/)
+
+<a name="setup"></a>
+
+node-addon-api is based on [Node-API](https://nodejs.org/api/n-api.html) and supports using different Node-API versions.
+This allows addons built with it to run with Node.js versions which support the targeted Node-API version.
+**However** the node-addon-api support model is to support only the active LTS Node.js versions. This means that
+every year there will be a new major which drops support for the Node.js LTS version which has gone out of service.
+
+The oldest Node.js version supported by the current version of node-addon-api is Node.js 16.x.
+
+## Setup
+  - [Installation and usage](doc/setup.md)
+  - [node-gyp](doc/node-gyp.md)
+  - [cmake-js](doc/cmake-js.md)
+  - [Conversion tool](doc/conversion-tool.md)
+  - [Checker tool](doc/checker-tool.md)
+  - [Generator](doc/generator.md)
+  - [Prebuild tools](doc/prebuild_tools.md)
+
+<a name="api"></a>
+
+### **API Documentation**
+
+The following is the documentation for node-addon-api.
+
+ - [Full Class Hierarchy](doc/hierarchy.md)
+ - [Addon Structure](doc/addon.md)
+ - Data Types:
+    - [Env](doc/env.md)
+    - [CallbackInfo](doc/callbackinfo.md)
+    - [Reference](doc/reference.md)
+    - [Value](doc/value.md)
+        - [Name](doc/name.md)
+            - [Symbol](doc/symbol.md)
+            - [String](doc/string.md)
+        - [Number](doc/number.md)
+        - [Date](doc/date.md)
+        - [BigInt](doc/bigint.md)
+        - [Boolean](doc/boolean.md)
+        - [External](doc/external.md)
+        - [Object](doc/object.md)
+            - [Array](doc/array.md)
+            - [ObjectReference](doc/object_reference.md)
+    - [PropertyDescriptor](doc/property_descriptor.md)
+    - [Function](doc/function.md)
+        - [FunctionReference](doc/function_reference.md)
+    - [ObjectWrap](doc/object_wrap.md)
+        - [ClassPropertyDescriptor](doc/class_property_descriptor.md)
+    - [Buffer](doc/buffer.md)
+    - [ArrayBuffer](doc/array_buffer.md)
+    - [TypedArray](doc/typed_array.md)
+      - [TypedArrayOf](doc/typed_array_of.md)
+    - [DataView](doc/dataview.md)
+ - [Error Handling](doc/error_handling.md)
+    - [Error](doc/error.md)
+      - [TypeError](doc/type_error.md)
+      - [RangeError](doc/range_error.md)
+      - [SyntaxError](doc/syntax_error.md)
+ - [Object Lifetime Management](doc/object_lifetime_management.md)
+    - [HandleScope](doc/handle_scope.md)
+    - [EscapableHandleScope](doc/escapable_handle_scope.md)
+ - [Memory Management](doc/memory_management.md)
+ - [Async Operations](doc/async_operations.md)
+    - [AsyncWorker](doc/async_worker.md)
+    - [AsyncContext](doc/async_context.md)
+    - [AsyncWorker Variants](doc/async_worker_variants.md)
+ - [Thread-safe Functions](doc/threadsafe.md)
+    - [ThreadSafeFunction](doc/threadsafe_function.md)
+    - [TypedThreadSafeFunction](doc/typed_threadsafe_function.md)
+ - [Promises](doc/promises.md)
+ - [Version management](doc/version_management.md)
+
+<a name="examples"></a>
+
+### **Examples**
+
+Are you new to **node-addon-api**? Take a look at our **[examples](https://github.com/nodejs/node-addon-examples)**
+
+- **[Hello World](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/1_hello_world)**
+- **[Pass arguments to a function](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/2_function_arguments/node-addon-api)**
+- **[Callbacks](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/3_callbacks/node-addon-api)**
+- **[Object factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/4_object_factory/node-addon-api)**
+- **[Function factory](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/5_function_factory/node-addon-api)**
+- **[Wrapping C++ Object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/6_object_wrap/node-addon-api)**
+- **[Factory of wrapped object](https://github.com/nodejs/node-addon-examples/tree/main/src/1-getting-started/7_factory_wrap/node-addon-api)**
+- **[Passing wrapped object around](https://github.com/nodejs/node-addon-examples/tree/main/src/2-js-to-native-conversion/8_passing_wrapped/node-addon-api)**
+
+<a name="tests"></a>
+
+### **Tests**
+
+To run the **node-addon-api** tests do:
+
+```
+npm install
+npm test
+```
+
+To avoid testing the deprecated portions of the API run
+```
+npm install
+npm test --disable-deprecated
+```
+
+To run the tests targeting a specific version of Node-API run
+```
+npm install
+export NAPI_VERSION=X
+npm test --NAPI_VERSION=X
+```
+
+where X is the version of Node-API you want to target.
+
+To run a specific unit test, filter conditions are available
+
+**Example:**
+  compile and run only tests on objectwrap.cc and objectwrap.js
+  ```
+    npm run unit --filter=objectwrap
+  ```
+
+Multiple unit tests cane be selected with wildcards
+
+**Example:**
+compile and run all test files ending with "reference" -> function_reference.cc, object_reference.cc, reference.cc
+ ```
+    npm run unit --filter=*reference
+ ```
+
+Multiple filter conditions can be joined to broaden the test selection
+
+**Example:**
+ compile and run all tests under folders threadsafe_function and typed_threadsafe_function and also the objectwrap.cc file
+    npm run unit --filter='*function objectwrap'
+
+### **Debug**
+
+To run the **node-addon-api** tests with `--debug` option:
+
+```
+npm run-script dev
+```
+
+If you want a faster build, you might use the following option:
+
+```
+npm run-script dev:incremental
+```
+
+Take a look and get inspired by our **[test suite](https://github.com/nodejs/node-addon-api/tree/HEAD/test)**
+
+### **Benchmarks**
+
+You can run the available benchmarks using the following command:
+
+```
+npm run-script benchmark
+```
+
+See [benchmark/README.md](benchmark/README.md) for more details about running and adding benchmarks.
+
+<a name="resources"></a>
+
+### **More resource and info about native Addons**
+- **[C++ Addons](https://nodejs.org/dist/latest/docs/api/addons.html)**
+- **[Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)**
+- **[Node-API - Next Generation Node API for Native Modules](https://youtu.be/-Oniup60Afs)**
+- **[How We Migrated Realm JavaScript From NAN to Node-API](https://developer.mongodb.com/article/realm-javascript-nan-to-n-api)**
+
+As node-addon-api's core mission is to expose the plain C Node-API as C++
+wrappers, tools that facilitate n-api/node-addon-api providing more
+convenient patterns for developing a Node.js add-on with n-api/node-addon-api
+can be published to NPM as standalone packages. It is also recommended to tag
+such packages with `node-addon-api` to provide more visibility to the community.
+
+Quick links to NPM searches: [keywords:node-addon-api](https://www.npmjs.com/search?q=keywords%3Anode-addon-api).
+
+<a name="other-bindings"></a>
+
+### **Other bindings**
+
+- **[napi-rs](https://napi.rs)** - (`Rust`)
+
+<a name="badges"></a>
+
+### **Badges**
+
+The use of badges is recommended to indicate the minimum version of Node-API
+required for the module. This helps to determine which Node.js major versions are
+supported. Addon maintainers can consult the [Node-API support matrix][] to determine
+which Node.js versions provide a given Node-API version. The following badges are
+available:
+
+![Node-API v1 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v1%20Badge.svg)
+![Node-API v2 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v2%20Badge.svg)
+![Node-API v3 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v3%20Badge.svg)
+![Node-API v4 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v4%20Badge.svg)
+![Node-API v5 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v5%20Badge.svg)
+![Node-API v6 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v6%20Badge.svg)
+![Node-API v7 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v7%20Badge.svg)
+![Node-API v8 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v8%20Badge.svg)
+![Node-API v9 Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20v9%20Badge.svg)
+![Node-API Experimental Version Badge](https://github.com/nodejs/abi-stable-node/blob/doc/assets/Node-API%20Experimental%20Version%20Badge.svg)
+
+## **Contributing**
+
+We love contributions from the community to **node-addon-api**!
+See [CONTRIBUTING.md](CONTRIBUTING.md) for more details on our philosophy around extending this module.
+
+<a name="contributors"></a>
+
+## Team members
+
+### Active
+| Name                | GitHub Link                                           |
+| ------------------- | ----------------------------------------------------- |
+| Anna Henningsen     | [addaleax](https://github.com/addaleax)               |
+| Chengzhong Wu       | [legendecas](https://github.com/legendecas)           |
+| Jack Xia            | [JckXia](https://github.com/JckXia)                   |
+| Kevin Eady          | [KevinEady](https://github.com/KevinEady)             |
+| Michael Dawson      | [mhdawson](https://github.com/mhdawson)               |
+| Nicola Del Gobbo    | [NickNaso](https://github.com/NickNaso)               |
+| Vladimir Morozov    | [vmoroz](https://github.com/vmoroz)                   |
+
+### Emeritus
+| Name                | GitHub Link                                           |
+| ------------------- | ----------------------------------------------------- |
+| Arunesh Chandra     | [aruneshchandra](https://github.com/aruneshchandra)   |
+| Benjamin Byholm     | [kkoopa](https://github.com/kkoopa)                   |
+| Gabriel Schulhof    | [gabrielschulhof](https://github.com/gabrielschulhof) |
+| Hitesh Kanwathirtha | [digitalinfinity](https://github.com/digitalinfinity) |
+| Jason Ginchereau    | [jasongin](https://github.com/jasongin)               |
+| Jim Schlight        | [jschlight](https://github.com/jschlight)             |
+| Sampson Gao         | [sampsongao](https://github.com/sampsongao)           |
+| Taylor Woll         | [boingoing](https://github.com/boingoing)             |
+
+<a name="license"></a>
+
+Licensed under [MIT](./LICENSE.md)
+
+[ABI stability guide]: https://nodejs.org/en/docs/guides/abi-stability/
+[Node-API support matrix]: https://nodejs.org/dist/latest/docs/api/n-api.html#n_api_n_api_version_matrix

server/node_modules/sqlite3/node_modules/node-addon-api/common.gypi

@@ -0,0 +1,20 @@
+{
+  'variables': {
+    'NAPI_VERSION%': "<!(node -p \"process.env.NAPI_VERSION || process.versions.napi\")",
+    'disable_deprecated': "<!(node -p \"process.env['npm_config_disable_deprecated']\")"
+  },
+  'conditions': [
+    ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
+    ['disable_deprecated=="true"', {
+      'defines': ['NODE_ADDON_API_DISABLE_DEPRECATED']
+    }],
+    ['OS=="mac"', {
+      'cflags+': ['-fvisibility=hidden'],
+      'xcode_settings': {
+        'OTHER_CFLAGS': ['-fvisibility=hidden']
+      }
+    }]
+  ],
+  'cflags': [ '-Werror', '-Wall', '-Wextra', '-Wpedantic', '-Wunused-parameter' ],
+  'cflags_cc': [ '-Werror', '-Wall', '-Wextra', '-Wpedantic', '-Wunused-parameter' ]
+}

server/node_modules/sqlite3/node_modules/node-addon-api/except.gypi

@@ -0,0 +1,25 @@
+{
+  'defines': [ 'NAPI_CPP_EXCEPTIONS' ],
+  'cflags!': [ '-fno-exceptions' ],
+  'cflags_cc!': [ '-fno-exceptions' ],
+  'conditions': [
+    ["OS=='win'", {
+      "defines": [
+        "_HAS_EXCEPTIONS=1"
+      ],
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          "ExceptionHandling": 1,
+          'EnablePREfast': 'true',
+        },
+      },
+    }],
+    ["OS=='mac'", {
+      'xcode_settings': {
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+      },
+    }],
+  ],
+}

server/node_modules/sqlite3/node_modules/node-addon-api/index.js

@@ -0,0 +1,12 @@
+const path = require('path');
+
+const includeDir = path.relative('.', __dirname);
+
+module.exports = {
+  include: `"${__dirname}"`, // deprecated, can be removed as part of 4.0.0
+  include_dir: includeDir,
+  gyp: path.join(includeDir, 'node_api.gyp:nothing'), // deprecated.
+  targets: path.join(includeDir, 'node_addon_api.gyp'),
+  isNodeApiBuiltin: true,
+  needsFlag: false
+};

server/node_modules/sqlite3/node_modules/node-addon-api/napi-inl.deprecated.h

@@ -0,0 +1,186 @@
+#ifndef SRC_NAPI_INL_DEPRECATED_H_
+#define SRC_NAPI_INL_DEPRECATED_H_
+
+////////////////////////////////////////////////////////////////////////////////
+// PropertyDescriptor class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::CallbackData<Getter, Napi::Value>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* data) {
+  return Accessor(utf8name.c_str(), getter, attributes, data);
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::CallbackData<Getter, Napi::Value>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name, Getter getter, napi_property_attributes attributes, void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Accessor(nameValue, getter, attributes, data);
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
+  return Accessor(utf8name.c_str(), getter, setter, attributes, data);
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Getter, typename Setter>
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Accessor(
+      nameValue, getter, setter, attributes, data);
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const char* utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
+  using CbData = details::CallbackData<Callable, ReturnType>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const std::string& utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* data) {
+  return Function(utf8name.c_str(), cb, attributes, data);
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    napi_value name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
+  using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
+  using CbData = details::CallbackData<Callable, ReturnType>;
+  // TODO: Delete when the function is destroyed
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
+}
+
+template <typename Callable>
+inline PropertyDescriptor PropertyDescriptor::Function(
+    Name name, Callable cb, napi_property_attributes attributes, void* data) {
+  napi_value nameValue = name;
+  return PropertyDescriptor::Function(nameValue, cb, attributes, data);
+}
+
+#endif  // !SRC_NAPI_INL_DEPRECATED_H_

server/node_modules/sqlite3/node_modules/node-addon-api/node_addon_api.gyp

@@ -0,0 +1,32 @@
+{
+  'targets': [
+    {
+      'target_name': 'node_addon_api',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_except',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['except.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_maybe',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+        'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
+      }
+    },
+  ]
+}

server/node_modules/sqlite3/node_modules/node-addon-api/node_api.gyp

@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'nothing',
+      'type': 'static_library',
+      'sources': [ 'nothing.c' ]
+    }
+  ]
+}

server/node_modules/sqlite3/node_modules/node-addon-api/noexcept.gypi

@@ -0,0 +1,26 @@
+{
+  'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
+  'cflags': [ '-fno-exceptions' ],
+  'cflags_cc': [ '-fno-exceptions' ],
+  'conditions': [
+    ["OS=='win'", {
+      # _HAS_EXCEPTIONS is already defined and set to 0 in common.gypi
+      #"defines": [
+      #  "_HAS_EXCEPTIONS=0"
+      #],
+      "msvs_settings": {
+        "VCCLCompilerTool": {
+          'ExceptionHandling': 0,
+          'EnablePREfast': 'true',
+        },
+      },
+    }],
+    ["OS=='mac'", {
+      'xcode_settings': {
+        'CLANG_CXX_LIBRARY': 'libc++',
+        'MACOSX_DEPLOYMENT_TARGET': '10.7',
+        'GCC_ENABLE_CPP_EXCEPTIONS': 'NO',
+      },
+    }],
+  ],
+}

server/node_modules/sqlite3/node_modules/node-addon-api/package-support.json

@@ -0,0 +1,21 @@
+{
+  "versions": [
+    {
+      "version": "*",
+      "target": {
+        "node": "active"
+      },
+      "response": {
+        "type": "time-permitting",
+        "paid": false,
+        "contact": {
+          "name": "node-addon-api team",
+          "url": "https://github.com/nodejs/node-addon-api/issues"
+        }
+      },
+      "backing": [ { "project": "https://github.com/nodejs" },
+                   { "foundation": "https://openjsf.org/" }
+      ]
+    }
+  ]
+}

server/node_modules/sqlite3/node_modules/node-addon-api/package.json

@@ -0,0 +1,480 @@
+{
+  "bugs": {
+    "url": "https://github.com/nodejs/node-addon-api/issues"
+  },
+  "contributors": [
+    {
+      "name": "Abhishek Kumar Singh",
+      "url": "https://github.com/abhi11210646"
+    },
+    {
+      "name": "Alba Mendez",
+      "url": "https://github.com/jmendeth"
+    },
+    {
+      "name": "Alexander Floh",
+      "url": "https://github.com/alexanderfloh"
+    },
+    {
+      "name": "Ammar Faizi",
+      "url": "https://github.com/ammarfaizi2"
+    },
+    {
+      "name": "András Timár, Dr",
+      "url": "https://github.com/timarandras"
+    },
+    {
+      "name": "Andrew Petersen",
+      "url": "https://github.com/kirbysayshi"
+    },
+    {
+      "name": "Anisha Rohra",
+      "url": "https://github.com/anisha-rohra"
+    },
+    {
+      "name": "Anna Henningsen",
+      "url": "https://github.com/addaleax"
+    },
+    {
+      "name": "Arnaud Botella",
+      "url": "https://github.com/BotellaA"
+    },
+    {
+      "name": "Arunesh Chandra",
+      "url": "https://github.com/aruneshchandra"
+    },
+    {
+      "name": "Azlan Mukhtar",
+      "url": "https://github.com/azlan"
+    },
+    {
+      "name": "Ben Berman",
+      "url": "https://github.com/rivertam"
+    },
+    {
+      "name": "Benjamin Byholm",
+      "url": "https://github.com/kkoopa"
+    },
+    {
+      "name": "Bill Gallafent",
+      "url": "https://github.com/gallafent"
+    },
+    {
+      "name": "blagoev",
+      "url": "https://github.com/blagoev"
+    },
+    {
+      "name": "Bruce A. MacNaughton",
+      "url": "https://github.com/bmacnaughton"
+    },
+    {
+      "name": "Cory Mickelson",
+      "url": "https://github.com/corymickelson"
+    },
+    {
+      "name": "Daniel Bevenius",
+      "url": "https://github.com/danbev"
+    },
+    {
+      "name": "Dante Calderón",
+      "url": "https://github.com/dantehemerson"
+    },
+    {
+      "name": "Darshan Sen",
+      "url": "https://github.com/RaisinTen"
+    },
+    {
+      "name": "David Halls",
+      "url": "https://github.com/davedoesdev"
+    },
+    {
+      "name": "Deepak Rajamohan",
+      "url": "https://github.com/deepakrkris"
+    },
+    {
+      "name": "Dmitry Ashkadov",
+      "url": "https://github.com/dmitryash"
+    },
+    {
+      "name": "Dongjin Na",
+      "url": "https://github.com/nadongguri"
+    },
+    {
+      "name": "Doni Rubiagatra",
+      "url": "https://github.com/rubiagatra"
+    },
+    {
+      "name": "Eric Bickle",
+      "url": "https://github.com/ebickle"
+    },
+    {
+      "name": "extremeheat",
+      "url": "https://github.com/extremeheat"
+    },
+    {
+      "name": "Feng Yu",
+      "url": "https://github.com/F3n67u"
+    },
+    {
+      "name": "Ferdinand Holzer",
+      "url": "https://github.com/fholzer"
+    },
+    {
+      "name": "Gabriel Schulhof",
+      "url": "https://github.com/gabrielschulhof"
+    },
+    {
+      "name": "Guenter Sandner",
+      "url": "https://github.com/gms1"
+    },
+    {
+      "name": "Gus Caplan",
+      "url": "https://github.com/devsnek"
+    },
+    {
+      "name": "Helio Frota",
+      "url": "https://github.com/helio-frota"
+    },
+    {
+      "name": "Hitesh Kanwathirtha",
+      "url": "https://github.com/digitalinfinity"
+    },
+    {
+      "name": "ikokostya",
+      "url": "https://github.com/ikokostya"
+    },
+    {
+      "name": "Jack Xia",
+      "url": "https://github.com/JckXia"
+    },
+    {
+      "name": "Jake Barnes",
+      "url": "https://github.com/DuBistKomisch"
+    },
+    {
+      "name": "Jake Yoon",
+      "url": "https://github.com/yjaeseok"
+    },
+    {
+      "name": "Jason Ginchereau",
+      "url": "https://github.com/jasongin"
+    },
+    {
+      "name": "Jenny",
+      "url": "https://github.com/egg-bread"
+    },
+    {
+      "name": "Jeroen Janssen",
+      "url": "https://github.com/japj"
+    },
+    {
+      "name": "Jim Schlight",
+      "url": "https://github.com/jschlight"
+    },
+    {
+      "name": "Jinho Bang",
+      "url": "https://github.com/romandev"
+    },
+    {
+      "name": "José Expósito",
+      "url": "https://github.com/JoseExposito"
+    },
+    {
+      "name": "joshgarde",
+      "url": "https://github.com/joshgarde"
+    },
+    {
+      "name": "Julian Mesa",
+      "url": "https://github.com/julianmesa-gitkraken"
+    },
+    {
+      "name": "Kasumi Hanazuki",
+      "url": "https://github.com/hanazuki"
+    },
+    {
+      "name": "Kelvin",
+      "url": "https://github.com/kelvinhammond"
+    },
+    {
+      "name": "Kevin Eady",
+      "url": "https://github.com/KevinEady"
+    },
+    {
+      "name": "Kévin VOYER",
+      "url": "https://github.com/kecsou"
+    },
+    {
+      "name": "kidneysolo",
+      "url": "https://github.com/kidneysolo"
+    },
+    {
+      "name": "Koki Nishihara",
+      "url": "https://github.com/Nishikoh"
+    },
+    {
+      "name": "Konstantin Tarkus",
+      "url": "https://github.com/koistya"
+    },
+    {
+      "name": "Kyle Farnung",
+      "url": "https://github.com/kfarnung"
+    },
+    {
+      "name": "Kyle Kovacs",
+      "url": "https://github.com/nullromo"
+    },
+    {
+      "name": "legendecas",
+      "url": "https://github.com/legendecas"
+    },
+    {
+      "name": "LongYinan",
+      "url": "https://github.com/Brooooooklyn"
+    },
+    {
+      "name": "Lovell Fuller",
+      "url": "https://github.com/lovell"
+    },
+    {
+      "name": "Luciano Martorella",
+      "url": "https://github.com/lmartorella"
+    },
+    {
+      "name": "mastergberry",
+      "url": "https://github.com/mastergberry"
+    },
+    {
+      "name": "Mathias Küsel",
+      "url": "https://github.com/mathiask88"
+    },
+    {
+      "name": "Mathias Stearn",
+      "url": "https://github.com/RedBeard0531"
+    },
+    {
+      "name": "Matteo Collina",
+      "url": "https://github.com/mcollina"
+    },
+    {
+      "name": "Michael Dawson",
+      "url": "https://github.com/mhdawson"
+    },
+    {
+      "name": "Michael Price",
+      "url": "https://github.com/mikepricedev"
+    },
+    {
+      "name": "Michele Campus",
+      "url": "https://github.com/kYroL01"
+    },
+    {
+      "name": "Mikhail Cheshkov",
+      "url": "https://github.com/mcheshkov"
+    },
+    {
+      "name": "nempoBu4",
+      "url": "https://github.com/nempoBu4"
+    },
+    {
+      "name": "Nicola Del Gobbo",
+      "url": "https://github.com/NickNaso"
+    },
+    {
+      "name": "Nick Soggin",
+      "url": "https://github.com/iSkore"
+    },
+    {
+      "name": "Nikolai Vavilov",
+      "url": "https://github.com/seishun"
+    },
+    {
+      "name": "Nurbol Alpysbayev",
+      "url": "https://github.com/anurbol"
+    },
+    {
+      "name": "pacop",
+      "url": "https://github.com/pacop"
+    },
+    {
+      "name": "Peter Šándor",
+      "url": "https://github.com/petersandor"
+    },
+    {
+      "name": "Philipp Renoth",
+      "url": "https://github.com/DaAitch"
+    },
+    {
+      "name": "rgerd",
+      "url": "https://github.com/rgerd"
+    },
+    {
+      "name": "Richard Lau",
+      "url": "https://github.com/richardlau"
+    },
+    {
+      "name": "Rolf Timmermans",
+      "url": "https://github.com/rolftimmermans"
+    },
+    {
+      "name": "Ross Weir",
+      "url": "https://github.com/ross-weir"
+    },
+    {
+      "name": "Ryuichi Okumura",
+      "url": "https://github.com/okuryu"
+    },
+    {
+      "name": "Saint Gabriel",
+      "url": "https://github.com/chineduG"
+    },
+    {
+      "name": "Sampson Gao",
+      "url": "https://github.com/sampsongao"
+    },
+    {
+      "name": "Sam Roberts",
+      "url": "https://github.com/sam-github"
+    },
+    {
+      "name": "strager",
+      "url": "https://github.com/strager"
+    },
+    {
+      "name": "Taylor Woll",
+      "url": "https://github.com/boingoing"
+    },
+    {
+      "name": "Thomas Gentilhomme",
+      "url": "https://github.com/fraxken"
+    },
+    {
+      "name": "Tim Rach",
+      "url": "https://github.com/timrach"
+    },
+    {
+      "name": "Tobias Nießen",
+      "url": "https://github.com/tniessen"
+    },
+    {
+      "name": "todoroff",
+      "url": "https://github.com/todoroff"
+    },
+    {
+      "name": "Toyo Li",
+      "url": "https://github.com/toyobayashi"
+    },
+    {
+      "name": "Tux3",
+      "url": "https://github.com/tux3"
+    },
+    {
+      "name": "Vlad Velmisov",
+      "url": "https://github.com/Velmisov"
+    },
+    {
+      "name": "Vladimir Morozov",
+      "url": "https://github.com/vmoroz"
+
+    },
+    {
+      "name": "WenheLI",
+      "url": "https://github.com/WenheLI"
+    },
+    {
+      "name": "Xuguang Mei",
+      "url": "https://github.com/meixg"
+    },
+    {
+      "name": "Yohei Kishimoto",
+      "url": "https://github.com/morokosi"
+    },
+    {
+      "name": "Yulong Wang",
+      "url": "https://github.com/fs-eire"
+    },
+    {
+      "name": "Ziqiu Zhao",
+      "url": "https://github.com/ZzqiZQute"
+    },
+    {
+      "name": "Feng Yu",
+      "url": "https://github.com/F3n67u"
+    },
+    {
+      "name": "wanlu wang",
+      "url": "https://github.com/wanlu"
+    },
+    {
+      "name": "Caleb Hearon",
+      "url": "https://github.com/chearon"
+    },
+    {
+      "name": "Marx",
+      "url": "https://github.com/MarxJiao"
+    },
+    {
+      "name": "Ömer AKGÜL",
+      "url": "https://github.com/tuhalf"
+    }
+  ],
+  "description": "Node.js API (Node-API)",
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "bindings": "^1.5.0",
+    "clang-format": "^1.4.0",
+    "eslint": "^7.32.0",
+    "eslint-config-semistandard": "^16.0.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.24.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.1.0",
+    "fs-extra": "^11.1.1",
+    "path": "^0.12.7",
+    "pre-commit": "^1.2.2",
+    "safe-buffer": "^5.1.1"
+  },
+  "directories": {},
+  "gypfile": false,
+  "homepage": "https://github.com/nodejs/node-addon-api",
+  "keywords": [
+    "n-api",
+    "napi",
+    "addon",
+    "native",
+    "bindings",
+    "c",
+    "c++",
+    "nan",
+    "node-addon-api"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "node-addon-api",
+  "readme": "README.md",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/nodejs/node-addon-api.git"
+  },
+  "files": [
+    "*.{c,h,gyp,gypi}",
+    "package-support.json",
+    "tools/"
+  ],
+  "scripts": {
+    "prebenchmark": "node-gyp rebuild -C benchmark",
+    "benchmark": "node benchmark",
+    "pretest": "node-gyp rebuild -C test",
+    "test": "node test",
+    "test:debug": "node-gyp rebuild -C test --debug && NODE_API_BUILD_CONFIG=Debug node ./test/index.js",
+    "predev": "node-gyp rebuild -C test --debug",
+    "dev": "node test",
+    "predev:incremental": "node-gyp configure build -C test --debug",
+    "dev:incremental": "node test",
+    "doc": "doxygen doc/Doxyfile",
+    "lint": "node tools/eslint-format && node tools/clang-format",
+    "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
+  },
+  "pre-commit": "lint",
+  "version": "7.1.1",
+  "support": true
+}

server/node_modules/sqlite3/node_modules/node-addon-api/tools/README.md

@@ -0,0 +1,73 @@
+# Tools
+
+## clang-format
+
+The clang-format checking tools is designed to check changed lines of code compared to given git-refs.
+
+## Migration Script
+
+The migration tool is designed to reduce repetitive work in the migration process. However, the script is not aiming to convert every thing for you. There are usually some small fixes and major reconstruction required.
+
+### How To Use
+
+To run the conversion script, first make sure you have the latest `node-addon-api` in your `node_modules` directory.
+```
+npm install node-addon-api
+```
+
+Then run the script passing your project directory
+```
+node ./node_modules/node-addon-api/tools/conversion.js ./
+```
+
+After finish, recompile and debug things that are missed by the script.
+
+
+### Quick Fixes
+Here is the list of things that can be fixed easily.
+  1. Change your methods' return value to void if it doesn't return value to JavaScript.
+  2. Use `.` to access attribute or to invoke member function in Napi::Object instead of `->`.
+  3. `Napi::New(env, value);` to `Napi::[Type]::New(env, value);
+
+
+### Major Reconstructions
+The implementation of `Napi::ObjectWrap` is significantly different from NAN's. `Napi::ObjectWrap` takes a pointer to the wrapped object and creates a reference to the wrapped object inside ObjectWrap constructor. `Napi::ObjectWrap` also associates wrapped object's instance methods to Javascript module instead of static methods like NAN.
+
+So if you use Nan::ObjectWrap in your module, you will need to execute the following steps.
+
+  1. Convert your [ClassName]::New function to a constructor function that takes a `Napi::CallbackInfo`. Declare it as
+```
+[ClassName](const Napi::CallbackInfo& info);
+```
+and define it as
+```
+[ClassName]::[ClassName](const Napi::CallbackInfo& info) : Napi::ObjectWrap<[ClassName]>(info){
+  ...
+}
+```
+This way, the `Napi::ObjectWrap` constructor will be invoked after the object has been instantiated and `Napi::ObjectWrap` can use the `this` pointer to create a reference to the wrapped object.
+
+  2. Move your original constructor code into the new constructor. Delete your original constructor.
+  3. In your class initialization function, associate native methods in the following way.
+```
+Napi::FunctionReference constructor;
+
+void [ClassName]::Init(Napi::Env env, Napi::Object exports, Napi::Object module) {
+  Napi::HandleScope scope(env);
+  Napi::Function ctor = DefineClass(env, "Canvas", {
+    InstanceMethod<&[ClassName]::Func1>("Func1"),
+    InstanceMethod<&[ClassName]::Func2>("Func2"),
+    InstanceAccessor<&[ClassName]::ValueGetter>("Value"),
+    StaticMethod<&[ClassName]::StaticMethod>("MethodName"),
+    InstanceValue("Value", Napi::[Type]::New(env, value)),
+  });
+
+  constructor = Napi::Persistent(ctor);
+  constructor .SuppressDestruct();
+  exports.Set("[ClassName]", ctor);
+}
+```
+  4. In function where you need to Unwrap the ObjectWrap in NAN like `[ClassName]* native = Nan::ObjectWrap::Unwrap<[ClassName]>(info.This());`, use `this` pointer directly as the unwrapped object as each ObjectWrap instance is associated with a unique object instance.
+
+
+If you still find issues after following this guide, please leave us an issue describing your problem and we will try to resolve it.

server/node_modules/sqlite3/node_modules/node-addon-api/tools/check-napi.js

@@ -0,0 +1,99 @@
+'use strict';
+// Descend into a directory structure and, for each file matching *.node, output
+// based on the imports found in the file whether it's an N-API module or not.
+
+const fs = require('fs');
+const path = require('path');
+
+// Read the output of the command, break it into lines, and use the reducer to
+// decide whether the file is an N-API module or not.
+function checkFile (file, command, argv, reducer) {
+  const child = require('child_process').spawn(command, argv, {
+    stdio: ['inherit', 'pipe', 'inherit']
+  });
+  let leftover = '';
+  let isNapi;
+  child.stdout.on('data', (chunk) => {
+    if (isNapi === undefined) {
+      chunk = (leftover + chunk.toString()).split(/[\r\n]+/);
+      leftover = chunk.pop();
+      isNapi = chunk.reduce(reducer, isNapi);
+      if (isNapi !== undefined) {
+        child.kill();
+      }
+    }
+  });
+  child.on('close', (code, signal) => {
+    if ((code === null && signal !== null) || (code !== 0)) {
+      console.log(
+        command + ' exited with code: ' + code + ' and signal: ' + signal);
+    } else {
+      // Green if it's a N-API module, red otherwise.
+      console.log(
+        '\x1b[' + (isNapi ? '42' : '41') + 'm' +
+          (isNapi ? '    N-API' : 'Not N-API') +
+          '\x1b[0m: ' + file);
+    }
+  });
+}
+
+// Use nm -a to list symbols.
+function checkFileUNIX (file) {
+  checkFile(file, 'nm', ['-a', file], (soFar, line) => {
+    if (soFar === undefined) {
+      line = line.match(/([0-9a-f]*)? ([a-zA-Z]) (.*$)/);
+      if (line[2] === 'U') {
+        if (/^napi/.test(line[3])) {
+          soFar = true;
+        }
+      }
+    }
+    return soFar;
+  });
+}
+
+// Use dumpbin /imports to list symbols.
+function checkFileWin32 (file) {
+  checkFile(file, 'dumpbin', ['/imports', file], (soFar, line) => {
+    if (soFar === undefined) {
+      line = line.match(/([0-9a-f]*)? +([a-zA-Z0-9]) (.*$)/);
+      if (line && /^napi/.test(line[line.length - 1])) {
+        soFar = true;
+      }
+    }
+    return soFar;
+  });
+}
+
+// Descend into a directory structure and pass each file ending in '.node' to
+// one of the above checks, depending on the OS.
+function recurse (top) {
+  fs.readdir(top, (error, items) => {
+    if (error) {
+      throw new Error('error reading directory ' + top + ': ' + error);
+    }
+    items.forEach((item) => {
+      item = path.join(top, item);
+      fs.stat(item, ((item) => (error, stats) => {
+        if (error) {
+          throw new Error('error about ' + item + ': ' + error);
+        }
+        if (stats.isDirectory()) {
+          recurse(item);
+        } else if (/[.]node$/.test(item) &&
+            // Explicitly ignore files called 'nothing.node' because they are
+            // artefacts of node-addon-api having identified a version of
+            // Node.js that ships with a correct implementation of N-API.
+            path.basename(item) !== 'nothing.node') {
+          process.platform === 'win32'
+            ? checkFileWin32(item)
+            : checkFileUNIX(item);
+        }
+      })(item));
+    });
+  });
+}
+
+// Start with the directory given on the command line or the current directory
+// if nothing was given.
+recurse(process.argv.length > 3 ? process.argv[2] : '.');

server/node_modules/sqlite3/node_modules/node-addon-api/tools/clang-format.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+const spawn = require('child_process').spawnSync;
+const path = require('path');
+
+const filesToCheck = ['*.h', '*.cc'];
+const FORMAT_START = process.env.FORMAT_START || 'main';
+
+function main (args) {
+  let fix = false;
+  while (args.length > 0) {
+    switch (args[0]) {
+      case '-f':
+      case '--fix':
+        fix = true;
+        break;
+      default:
+    }
+    args.shift();
+  }
+
+  const clangFormatPath = path.dirname(require.resolve('clang-format'));
+  const binary = process.platform === 'win32'
+    ? 'node_modules\\.bin\\clang-format.cmd'
+    : 'node_modules/.bin/clang-format';
+  const options = ['--binary=' + binary, '--style=file'];
+  if (fix) {
+    options.push(FORMAT_START);
+  } else {
+    options.push('--diff', FORMAT_START);
+  }
+
+  const gitClangFormatPath = path.join(clangFormatPath, 'bin/git-clang-format');
+  const result = spawn(
+    'python',
+    [gitClangFormatPath, ...options, '--', ...filesToCheck],
+    { encoding: 'utf-8' }
+  );
+
+  if (result.stderr) {
+    console.error('Error running git-clang-format:', result.stderr);
+    return 2;
+  }
+
+  const clangFormatOutput = result.stdout.trim();
+  // Bail fast if in fix mode.
+  if (fix) {
+    console.log(clangFormatOutput);
+    return 0;
+  }
+  // Detect if there is any complains from clang-format
+  if (
+    clangFormatOutput !== '' &&
+    clangFormatOutput !== 'no modified files to format' &&
+    clangFormatOutput !== 'clang-format did not modify any files'
+  ) {
+    console.error(clangFormatOutput);
+    const fixCmd = 'npm run lint:fix';
+    console.error(`
+      ERROR: please run "${fixCmd}" to format changes in your commit
+        Note that when running the command locally, please keep your local
+        main branch and working branch up to date with nodejs/node-addon-api
+        to exclude un-related complains.
+        Or you can run "env FORMAT_START=upstream/main ${fixCmd}".`);
+    return 1;
+  }
+}
+
+if (require.main === module) {
+  process.exitCode = main(process.argv.slice(2));
+}

server/node_modules/sqlite3/node_modules/node-addon-api/tools/conversion.js

@@ -0,0 +1,301 @@
+#! /usr/bin/env node
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const args = process.argv.slice(2);
+const dir = args[0];
+if (!dir) {
+  console.log('Usage: node ' + path.basename(__filename) + ' <target-dir>');
+  process.exit(1);
+}
+
+const NodeApiVersion = require('../package.json').version;
+
+const disable = args[1];
+let ConfigFileOperations;
+if (disable !== '--disable' && dir !== '--disable') {
+  ConfigFileOperations = {
+    'package.json': [
+      [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1  "node-addon-api": "' + NodeApiVersion + '",'],
+      [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '']
+    ],
+    'binding.gyp': [
+      [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\','],
+      [/([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!(node -p \\"require(\'node-addon-api\').include_dir\\")",'],
+      [/[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, ''],
+      [/([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n      $2cflags!$2: [ $2-fno-exceptions$2 ],\n      $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n      $2xcode_settings$2: { $2GCC_ENABLE_CPP_EXCEPTIONS$2: $2YES$2,\n        $2CLANG_CXX_LIBRARY$2: $2libc++$2,\n        $2MACOSX_DEPLOYMENT_TARGET$2: $210.7$2,\n      },\n      $2msvs_settings$2: {\n        $2VCCLCompilerTool$2: { $2ExceptionHandling$2: 1 },\n      },']
+    ]
+  };
+} else {
+  ConfigFileOperations = {
+    'package.json': [
+      [/([ ]*)"dependencies": {/g, '$1"dependencies": {\n$1  "node-addon-api": "' + NodeApiVersion + '",'],
+      [/[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '']
+    ],
+    'binding.gyp': [
+      [/([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\','],
+      [/([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!(node -p \'require(\\"node-addon-api\\").include_dir\')",'],
+      [/[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, ''],
+      [/([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n      $2cflags!$2: [ $2-fno-exceptions$2 ],\n      $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n      $2defines$2: [ $2NAPI_DISABLE_CPP_EXCEPTIONS$2 ],\n      $2conditions$2: [\n        [\'OS=="win"\', { $2defines$2: [ $2_HAS_EXCEPTIONS=1$2 ] }]\n      ]']
+    ]
+  };
+}
+
+const SourceFileOperations = [
+  [/Nan::SetMethod\(target,[\s]*"(.*)"[\s]*,[\s]*([^)]+)\)/g, 'exports.Set(Napi::String::New(env, "$1"), Napi::Function::New(env, $2))'],
+
+  [/v8::Local<v8::FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'],
+  [/Local<FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);\s+(\w+)\.Reset\((\1)\);\s+\1->SetClassName\((Nan::String::New|Nan::New<(v8::)*String>)\("(.+?)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$6", {'],
+  [/Local<FunctionTemplate>\s+(\w+)\s*=\s*Nan::New<FunctionTemplate>\([\w\d:]+\);(?:\w+->Reset\(\1\))?\s+\1->SetClassName\(Nan::String::New\("(\w+)"\)\);/g, 'Napi::Function $1 = DefineClass(env, "$2", {'],
+  [/Nan::New<v8::FunctionTemplate>\(([\w\d:]+)\)->GetFunction\(\)/g, 'Napi::Function::New(env, $1)'],
+  [/Nan::New<FunctionTemplate>\(([\w\d:]+)\)->GetFunction()/g, 'Napi::Function::New(env, $1);'],
+  [/Nan::New<v8::FunctionTemplate>\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'],
+  [/Nan::New<FunctionTemplate>\(([\w\d:]+)\)/g, 'Napi::Function::New(env, $1)'],
+
+  // FunctionTemplate to FunctionReference
+  [/Nan::Persistent<(v8::)*FunctionTemplate>/g, 'Napi::FunctionReference'],
+  [/Nan::Persistent<(v8::)*Function>/g, 'Napi::FunctionReference'],
+  [/v8::Local<v8::FunctionTemplate>/g, 'Napi::FunctionReference'],
+  [/Local<FunctionTemplate>/g, 'Napi::FunctionReference'],
+  [/v8::FunctionTemplate/g, 'Napi::FunctionReference'],
+  [/FunctionTemplate/g, 'Napi::FunctionReference'],
+
+  [/([ ]*)Nan::SetPrototypeMethod\(\w+, "(\w+)", (\w+)\);/g, '$1InstanceMethod("$2", &$3),'],
+  [/([ ]*)(?:\w+\.Reset\(\w+\);\s+)?\(target\)\.Set\("(\w+)",\s*Nan::GetFunction\((\w+)\)\);/gm,
+    '});\n\n' +
+    '$1constructor = Napi::Persistent($3);\n' +
+    '$1constructor.SuppressDestruct();\n' +
+    '$1target.Set("$2", $3);'],
+
+  // TODO: Other attribute combinations
+  [/static_cast<PropertyAttribute>\(ReadOnly\s*\|\s*DontDelete\)/gm,
+    'static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)'],
+
+  [/([\w\d:<>]+?)::Cast\((.+?)\)/g, '$2.As<$1>()'],
+
+  [/\*Nan::Utf8String\(([^)]+)\)/g, '$1->As<Napi::String>().Utf8Value().c_str()'],
+  [/Nan::Utf8String +(\w+)\(([^)]+)\)/g, 'std::string $1 = $2.As<Napi::String>()'],
+  [/Nan::Utf8String/g, 'std::string'],
+
+  [/v8::String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'],
+  [/String::Utf8Value (.+?)\((.+?)\)/g, 'Napi::String $1(env, $2)'],
+  [/\.length\(\)/g, '.Length()'],
+
+  [/Nan::MakeCallback\(([^,]+),[\s\\]+([^,]+),/gm, '$2.MakeCallback($1,'],
+
+  [/class\s+(\w+)\s*:\s*public\s+Nan::ObjectWrap/g, 'class $1 : public Napi::ObjectWrap<$1>'],
+  [/(\w+)\(([^)]*)\)\s*:\s*Nan::ObjectWrap\(\)\s*(,)?/gm, '$1($2) : Napi::ObjectWrap<$1>()$3'],
+
+  // HandleOKCallback to OnOK
+  [/HandleOKCallback/g, 'OnOK'],
+  // HandleErrorCallback to OnError
+  [/HandleErrorCallback/g, 'OnError'],
+
+  // ex. .As<Function>() to .As<Napi::Object>()
+  [/\.As<v8::(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As<Napi::$1>()'],
+  [/\.As<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>\(\)/g, '.As<Napi::$1>()'],
+
+  // ex. Nan::New<Number>(info[0]) to Napi::Number::New(info[0])
+  [/Nan::New<(v8::)*Integer>\((.+?)\)/g, 'Napi::Number::New(env, $2)'],
+  [/Nan::New\(([0-9.]+)\)/g, 'Napi::Number::New(env, $1)'],
+  [/Nan::New<(v8::)*String>\("(.+?)"\)/g, 'Napi::String::New(env, "$2")'],
+  [/Nan::New\("(.+?)"\)/g, 'Napi::String::New(env, "$1")'],
+  [/Nan::New<(v8::)*(.+?)>\(\)/g, 'Napi::$2::New(env)'],
+  [/Nan::New<(.+?)>\(\)/g, 'Napi::$1::New(env)'],
+  [/Nan::New<(v8::)*(.+?)>\(/g, 'Napi::$2::New(env, '],
+  [/Nan::New<(.+?)>\(/g, 'Napi::$1::New(env, '],
+  [/Nan::NewBuffer\(/g, 'Napi::Buffer<char>::New(env, '],
+  // TODO: Properly handle this
+  [/Nan::New\(/g, 'Napi::New(env, '],
+
+  [/\.IsInt32\(\)/g, '.IsNumber()'],
+  [/->IsInt32\(\)/g, '.IsNumber()'],
+
+  [/(.+?)->BooleanValue\(\)/g, '$1.As<Napi::Boolean>().Value()'],
+  [/(.+?)->Int32Value\(\)/g, '$1.As<Napi::Number>().Int32Value()'],
+  [/(.+?)->Uint32Value\(\)/g, '$1.As<Napi::Number>().Uint32Value()'],
+  [/(.+?)->IntegerValue\(\)/g, '$1.As<Napi::Number>().Int64Value()'],
+  [/(.+?)->NumberValue\(\)/g, '$1.As<Napi::Number>().DoubleValue()'],
+
+  // ex. Nan::To<bool>(info[0]) to info[0].Value()
+  [/Nan::To<v8::(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To<Napi::$1>()'],
+  [/Nan::To<(Boolean|String|Number|Object|Array|Symbol|Function)>\((.+?)\)/g, '$2.To<Napi::$1>()'],
+  // ex. Nan::To<bool>(info[0]) to info[0].As<Napi::Boolean>().Value()
+  [/Nan::To<bool>\((.+?)\)/g, '$1.As<Napi::Boolean>().Value()'],
+  // ex. Nan::To<int>(info[0]) to info[0].As<Napi::Number>().Int32Value()
+  [/Nan::To<int>\((.+?)\)/g, '$1.As<Napi::Number>().Int32Value()'],
+  // ex. Nan::To<int32_t>(info[0]) to info[0].As<Napi::Number>().Int32Value()
+  [/Nan::To<int32_t>\((.+?)\)/g, '$1.As<Napi::Number>().Int32Value()'],
+  // ex. Nan::To<uint32_t>(info[0]) to info[0].As<Napi::Number>().Uint32Value()
+  [/Nan::To<uint32_t>\((.+?)\)/g, '$1.As<Napi::Number>().Uint32Value()'],
+  // ex. Nan::To<int64_t>(info[0]) to info[0].As<Napi::Number>().Int64Value()
+  [/Nan::To<int64_t>\((.+?)\)/g, '$1.As<Napi::Number>().Int64Value()'],
+  // ex. Nan::To<float>(info[0]) to info[0].As<Napi::Number>().FloatValue()
+  [/Nan::To<float>\((.+?)\)/g, '$1.As<Napi::Number>().FloatValue()'],
+  // ex. Nan::To<double>(info[0]) to info[0].As<Napi::Number>().DoubleValue()
+  [/Nan::To<double>\((.+?)\)/g, '$1.As<Napi::Number>().DoubleValue()'],
+
+  [/Nan::New\((\w+)\)->HasInstance\((\w+)\)/g, '$2.InstanceOf($1.Value())'],
+
+  [/Nan::Has\(([^,]+),\s*/gm, '($1).Has('],
+  [/\.Has\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Has($1)'],
+  [/\.Has\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Has($1)'],
+
+  [/Nan::Get\(([^,]+),\s*/gm, '($1).Get('],
+  [/\.Get\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\)/gm, '.Get($1)'],
+  [/\.Get\([\s|\\]*Nan::New\(([^)]+)\)\)/gm, '.Get($1)'],
+
+  [/Nan::Set\(([^,]+),\s*/gm, '($1).Set('],
+  [/\.Set\([\s|\\]*Nan::New<(v8::)*String>\(([^)]+)\)\s*,/gm, '.Set($1,'],
+  [/\.Set\([\s|\\]*Nan::New\(([^)]+)\)\s*,/gm, '.Set($1,'],
+
+  // ex. node::Buffer::HasInstance(info[0]) to info[0].IsBuffer()
+  [/node::Buffer::HasInstance\((.+?)\)/g, '$1.IsBuffer()'],
+  // ex. node::Buffer::Length(info[0]) to info[0].Length()
+  [/node::Buffer::Length\((.+?)\)/g, '$1.As<Napi::Buffer<char>>().Length()'],
+  // ex. node::Buffer::Data(info[0]) to info[0].Data()
+  [/node::Buffer::Data\((.+?)\)/g, '$1.As<Napi::Buffer<char>>().Data()'],
+  [/Nan::CopyBuffer\(/g, 'Napi::Buffer::Copy(env, '],
+
+  // Nan::AsyncQueueWorker(worker)
+  [/Nan::AsyncQueueWorker\((.+)\);/g, '$1.Queue();'],
+  [/Nan::(Undefined|Null|True|False)\(\)/g, 'env.$1()'],
+
+  // Nan::ThrowError(error) to Napi::Error::New(env, error).ThrowAsJavaScriptException()
+  [/([ ]*)return Nan::Throw(\w*?)Error\((.+?)\);/g, '$1Napi::$2Error::New(env, $3).ThrowAsJavaScriptException();\n$1return env.Null();'],
+  [/Nan::Throw(\w*?)Error\((.+?)\);\n(\s*)return;/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n$3return env.Null();'],
+  [/Nan::Throw(\w*?)Error\((.+?)\);/g, 'Napi::$1Error::New(env, $2).ThrowAsJavaScriptException();\n'],
+  // Nan::RangeError(error) to Napi::RangeError::New(env, error)
+  [/Nan::(\w*?)Error\((.+)\)/g, 'Napi::$1Error::New(env, $2)'],
+
+  [/Nan::Set\((.+?),\n* *(.+?),\n* *(.+?),\n* *(.+?)\)/g, '$1.Set($2, $3, $4)'],
+
+  [/Nan::(Escapable)?HandleScope\s+(\w+)\s*;/g, 'Napi::$1HandleScope $2(env);'],
+  [/Nan::(Escapable)?HandleScope/g, 'Napi::$1HandleScope'],
+  [/Nan::ForceSet\(([^,]+), ?/g, '$1->DefineProperty('],
+  [/\.ForceSet\(Napi::String::New\(env, "(\w+)"\),\s*?/g, '.DefineProperty("$1", '],
+  // [ /Nan::GetPropertyNames\(([^,]+)\)/, '$1->GetPropertyNames()' ],
+  [/Nan::Equals\(([^,]+),/g, '$1.StrictEquals('],
+
+  [/(.+)->Set\(/g, '$1.Set('],
+
+  [/Nan::Callback/g, 'Napi::FunctionReference'],
+
+  [/Nan::Persistent<Object>/g, 'Napi::ObjectReference'],
+  [/Nan::ADDON_REGISTER_FUNCTION_ARGS_TYPE target/g, 'Napi::Env& env, Napi::Object& target'],
+
+  [/(\w+)\*\s+(\w+)\s*=\s*Nan::ObjectWrap::Unwrap<\w+>\(info\.This\(\)\);/g, '$1* $2 = this;'],
+  [/Nan::ObjectWrap::Unwrap<(\w+)>\((.*)\);/g, '$2.Unwrap<$1>();'],
+
+  [/Nan::NAN_METHOD_RETURN_TYPE/g, 'void'],
+  [/NAN_INLINE/g, 'inline'],
+
+  [/Nan::NAN_METHOD_ARGS_TYPE/g, 'const Napi::CallbackInfo&'],
+  [/NAN_METHOD\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
+  [/static\s*NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
+  [/NAN_GETTER\(([\w\d:]+?)\)/g, 'Napi::Value $1(const Napi::CallbackInfo& info)'],
+  [/static\s*NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'],
+  [/NAN_SETTER\(([\w\d:]+?)\)/g, 'void $1(const Napi::CallbackInfo& info, const Napi::Value& value)'],
+  [/void Init\((v8::)*Local<(v8::)*Object> exports\)/g, 'Napi::Object Init(Napi::Env env, Napi::Object exports)'],
+  [/NAN_MODULE_INIT\(([\w\d:]+?)\);/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports);'],
+  [/NAN_MODULE_INIT\(([\w\d:]+?)\)/g, 'Napi::Object $1(Napi::Env env, Napi::Object exports)'],
+
+  [/::(Init(?:ialize)?)\(target\)/g, '::$1(env, target, module)'],
+  [/constructor_template/g, 'constructor'],
+
+  [/Nan::FunctionCallbackInfo<(v8::)?Value>[ ]*& [ ]*info\)[ ]*{\n*([ ]*)/gm, 'Napi::CallbackInfo& info) {\n$2Napi::Env env = info.Env();\n$2'],
+  [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&\s*info\);/g, 'Napi::CallbackInfo& info);'],
+  [/Nan::FunctionCallbackInfo<(v8::)*Value>\s*&/g, 'Napi::CallbackInfo&'],
+
+  [/Buffer::HasInstance\(([^)]+)\)/g, '$1.IsBuffer()'],
+
+  [/info\[(\d+)\]->/g, 'info[$1].'],
+  [/info\[([\w\d]+)\]->/g, 'info[$1].'],
+  [/info\.This\(\)->/g, 'info.This().'],
+  [/->Is(Object|String|Int32|Number)\(\)/g, '.Is$1()'],
+  [/info.GetReturnValue\(\).SetUndefined\(\)/g, 'return env.Undefined()'],
+  [/info\.GetReturnValue\(\)\.Set\(((\n|.)+?)\);/g, 'return $1;'],
+
+  // ex. Local<Value> to Napi::Value
+  [/v8::Local<v8::(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'],
+  [/Local<(Value|Boolean|String|Number|Object|Array|Symbol|External|Function)>/g, 'Napi::$1'],
+
+  // Declare an env in helper functions that take a Napi::Value
+  [/(\w+)\(Napi::Value (\w+)(,\s*[^()]+)?\)\s*{\n*([ ]*)/gm, '$1(Napi::Value $2$3) {\n$4Napi::Env env = $2.Env();\n$4'],
+
+  // delete #include <node.h> and/or <v8.h>
+  [/#include +(<|")(?:node|nan).h("|>)/g, '#include $1napi.h$2\n#include $1uv.h$2'],
+  // NODE_MODULE to NODE_API_MODULE
+  [/NODE_MODULE/g, 'NODE_API_MODULE'],
+  [/Nan::/g, 'Napi::'],
+  [/nan.h/g, 'napi.h'],
+
+  // delete .FromJust()
+  [/\.FromJust\(\)/g, ''],
+  // delete .ToLocalCheck()
+  [/\.ToLocalChecked\(\)/g, ''],
+  [/^.*->SetInternalFieldCount\(.*$/gm, ''],
+
+  // replace using node; and/or using v8; to using Napi;
+  [/using (node|v8);/g, 'using Napi;'],
+  [/using namespace (node|Nan|v8);/g, 'using namespace Napi;'],
+  // delete using v8::Local;
+  [/using v8::Local;\n/g, ''],
+  // replace using v8::XXX; with using Napi::XXX
+  [/using v8::([A-Za-z]+);/g, 'using Napi::$1;']
+
+];
+
+const paths = listFiles(dir);
+paths.forEach(function (dirEntry) {
+  const filename = dirEntry.split('\\').pop().split('/').pop();
+
+  // Check whether the file is a source file or a config file
+  // then execute function accordingly
+  const sourcePattern = /.+\.h|.+\.cc|.+\.cpp/;
+  if (sourcePattern.test(filename)) {
+    convertFile(dirEntry, SourceFileOperations);
+  } else if (ConfigFileOperations[filename] != null) {
+    convertFile(dirEntry, ConfigFileOperations[filename]);
+  }
+});
+
+function listFiles (dir, filelist) {
+  const files = fs.readdirSync(dir);
+  filelist = filelist || [];
+  files.forEach(function (file) {
+    if (file === 'node_modules') {
+      return;
+    }
+
+    if (fs.statSync(path.join(dir, file)).isDirectory()) {
+      filelist = listFiles(path.join(dir, file), filelist);
+    } else {
+      filelist.push(path.join(dir, file));
+    }
+  });
+  return filelist;
+}
+
+function convert (content, operations) {
+  for (let i = 0; i < operations.length; i++) {
+    const operation = operations[i];
+    content = content.replace(operation[0], operation[1]);
+  }
+  return content;
+}
+
+function convertFile (fileName, operations) {
+  fs.readFile(fileName, 'utf-8', function (err, file) {
+    if (err) throw err;
+
+    file = convert(file, operations);
+
+    fs.writeFile(fileName, file, function (err) {
+      if (err) throw err;
+    });
+  });
+}

server/node_modules/sqlite3/node_modules/node-addon-api/tools/eslint-format.js

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+
+const spawn = require('child_process').spawnSync;
+
+const filesToCheck = '*.js';
+const FORMAT_START = process.env.FORMAT_START || 'main';
+const IS_WIN = process.platform === 'win32';
+const ESLINT_PATH = IS_WIN ? 'node_modules\\.bin\\eslint.cmd' : 'node_modules/.bin/eslint';
+
+function main (args) {
+  let fix = false;
+  while (args.length > 0) {
+    switch (args[0]) {
+      case '-f':
+      case '--fix':
+        fix = true;
+        break;
+      default:
+    }
+    args.shift();
+  }
+
+  // Check js files that change on unstaged file
+  const fileUnStaged = spawn(
+    'git',
+    ['diff', '--name-only', '--diff-filter=d', FORMAT_START, filesToCheck],
+    {
+      encoding: 'utf-8'
+    }
+  );
+
+  // Check js files that change on staged file
+  const fileStaged = spawn(
+    'git',
+    ['diff', '--name-only', '--cached', '--diff-filter=d', FORMAT_START, filesToCheck],
+    {
+      encoding: 'utf-8'
+    }
+  );
+
+  const options = [
+    ...fileStaged.stdout.split('\n').filter((f) => f !== ''),
+    ...fileUnStaged.stdout.split('\n').filter((f) => f !== '')
+  ];
+
+  if (fix) {
+    options.push('--fix');
+  }
+
+  const result = spawn(ESLINT_PATH, [...options], {
+    encoding: 'utf-8'
+  });
+
+  if (result.error && result.error.errno === 'ENOENT') {
+    console.error('Eslint not found! Eslint is supposed to be found at ', ESLINT_PATH);
+    return 2;
+  }
+
+  if (result.status === 1) {
+    console.error('Eslint error:', result.stdout);
+    const fixCmd = 'npm run lint:fix';
+    console.error(`ERROR: please run "${fixCmd}" to format changes in your commit
+    Note that when running the command locally, please keep your local
+    main branch and working branch up to date with nodejs/node-addon-api
+    to exclude un-related complains.
+    Or you can run "env FORMAT_START=upstream/main ${fixCmd}".
+    Also fix JS files by yourself if necessary.`);
+    return 1;
+  }
+
+  if (result.stderr) {
+    console.error('Error running eslint:', result.stderr);
+    return 2;
+  }
+}
+
+if (require.main === module) {
+  process.exitCode = main(process.argv.slice(2));
+}

server/node_modules/sqlite3/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "sqlite3",
+  "description": "Asynchronous, non-blocking SQLite3 bindings",
+  "version": "5.1.7",
+  "homepage": "https://github.com/TryGhost/node-sqlite3",
+  "author": {
+    "name": "Mapbox",
+    "url": "https://mapbox.com/"
+  },
+  "binary": {
+    "napi_versions": [
+      3,
+      6
+    ]
+  },
+  "contributors": [
+    "Daniel Lockyer <hi@daniellockyer.com>",
+    "Konstantin Käfer <mail@kkaefer.com>",
+    "Dane Springmeyer <dane@mapbox.com>",
+    "Will White <will@mapbox.com>",
+    "Orlando Vazquez <ovazquez@gmail.com>",
+    "Artem Kustikov <kustikoff@gmail.com>",
+    "Eric Fredricksen <efredricksen@gmail.com>",
+    "John Wright <mrjjwright@gmail.com>",
+    "Ryan Dahl <ry@tinyclouds.org>",
+    "Tom MacWright <tom@mapbox.com>",
+    "Carter Thaxton <carter.thaxton@gmail.com>",
+    "Audrius Kažukauskas <audrius@neutrino.lt>",
+    "Johannes Schauer <josch@pyneo.org>",
+    "Nathan Rajlich <nathan@tootallnate.net>",
+    "AJ ONeal <coolaj86@gmail.com>",
+    "Mithgol",
+    "Ben Noordhuis <ben@strongloop.com>"
+  ],
+  "files": [
+    "binding.gyp",
+    "deps/",
+    "lib/*.js",
+    "lib/*.d.ts",
+    "src/"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TryGhost/node-sqlite3.git"
+  },
+  "dependencies": {
+    "bindings": "^1.5.0",
+    "node-addon-api": "^7.0.0",
+    "prebuild-install": "^7.1.1",
+    "tar": "^6.1.11"
+  },
+  "devDependencies": {
+    "eslint": "8.56.0",
+    "mocha": "10.2.0",
+    "prebuild": "12.1.0"
+  },
+  "peerDependencies": {
+    "node-gyp": "8.x"
+  },
+  "peerDependenciesMeta": {
+    "node-gyp": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "node-gyp": "8.x"
+  },
+  "scripts": {
+    "install": "prebuild-install -r napi || node-gyp rebuild",
+    "prebuild": "prebuild --runtime napi --all --verbose",
+    "rebuild": "node-gyp rebuild",
+    "upload": "prebuild --verbose --prerelease",
+    "test": "node test/support/createdb.js && mocha -R spec --timeout 480000"
+  },
+  "license": "BSD-3-Clause",
+  "keywords": [
+    "sql",
+    "sqlite",
+    "sqlite3",
+    "database"
+  ],
+  "main": "./lib/sqlite3",
+  "types": "./lib/sqlite3.d.ts",
+  "renovate": {
+    "extends": [
+      "@tryghost:base"
+    ]
+  }
+}

server/node_modules/sqlite3/src/async.h

@@ -0,0 +1,76 @@
+#ifndef NODE_SQLITE3_SRC_ASYNC_H
+#define NODE_SQLITE3_SRC_ASYNC_H
+
+#include <napi.h>
+#include <uv.h>
+
+#include "threading.h"
+
+// Generic uv_async handler.
+template <class Item, class Parent> class Async {
+    typedef void (*Callback)(Parent* parent, Item* item);
+
+protected:
+    uv_async_t watcher;
+    NODE_SQLITE3_MUTEX_t
+    std::vector<Item*> data;
+    Callback callback;
+public:
+    Parent* parent;
+
+public:
+    Async(Parent* parent_, Callback cb_)
+        : callback(cb_), parent(parent_) {
+        watcher.data = this;
+        NODE_SQLITE3_MUTEX_INIT
+        uv_loop_t *loop;
+        napi_get_uv_event_loop(parent_->Env(), &loop);
+        uv_async_init(loop, &watcher, reinterpret_cast<uv_async_cb>(listener));
+    }
+
+    static void listener(uv_async_t* handle) {
+        auto* async = static_cast<Async*>(handle->data);
+        std::vector<Item*> rows;
+        NODE_SQLITE3_MUTEX_LOCK(&async->mutex)
+        rows.swap(async->data);
+        NODE_SQLITE3_MUTEX_UNLOCK(&async->mutex)
+        for(auto row : rows)
+            async->callback(async->parent, row);
+    }
+
+    static void close(uv_handle_t* handle) {
+        assert(handle != NULL);
+        assert(handle->data != NULL);
+        auto* async = static_cast<Async*>(handle->data);
+        delete async;
+    }
+
+    void finish() {
+        // Need to call the listener again to ensure all items have been
+        // processed. Is this a bug in uv_async? Feels like uv_close
+        // should handle that.
+        listener(&watcher);
+        uv_close((uv_handle_t*)&watcher, close);
+    }
+
+    void add(Item* item) {
+        NODE_SQLITE3_MUTEX_LOCK(&mutex);
+        data.emplace_back(item);
+        NODE_SQLITE3_MUTEX_UNLOCK(&mutex)
+    }
+
+    void send() {
+        uv_async_send(&watcher);
+    }
+
+    void send(Item* item) {
+        add(item);
+        send();
+    }
+
+    ~Async() {
+        NODE_SQLITE3_MUTEX_DESTROY
+    }
+};
+
+#endif

server/node_modules/sqlite3/src/backup.cc

@@ -0,0 +1,418 @@
+#include <cstring>
+#include <napi.h>
+#include "macros.h"
+#include "database.h"
+#include "backup.h"
+
+using namespace node_sqlite3;
+
+Napi::Object Backup::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+
+    // declare napi_default_method here as it is only available in Node v14.12.0+
+    auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);
+
+    auto t = DefineClass(env, "Backup", {
+        InstanceMethod("step", &Backup::Step, napi_default_method),
+        InstanceMethod("finish", &Backup::Finish, napi_default_method),
+        InstanceAccessor("idle", &Backup::IdleGetter, nullptr),
+        InstanceAccessor("completed", &Backup::CompletedGetter, nullptr),
+        InstanceAccessor("failed", &Backup::FailedGetter, nullptr),
+        InstanceAccessor("remaining", &Backup::RemainingGetter, nullptr),
+        InstanceAccessor("pageCount", &Backup::PageCountGetter, nullptr),
+        InstanceAccessor("retryErrors", &Backup::RetryErrorGetter, &Backup::RetryErrorSetter),
+    });
+
+    exports.Set("Backup", t);
+    return exports;
+}
+
+void Backup::Process() {
+    if (finished && !queue.empty()) {
+        return CleanQueue();
+    }
+
+    while (inited && !locked && !queue.empty()) {
+        auto call = std::move(queue.front());
+        queue.pop();
+
+        call->callback(call->baton);
+    }
+}
+
+void Backup::Schedule(Work_Callback callback, Baton* baton) {
+    if (finished) {
+        queue.emplace(new Call(callback, baton));
+        CleanQueue();
+    }
+    else if (!inited || locked || !queue.empty()) {
+        queue.emplace(new Call(callback, baton));
+    }
+    else {
+        callback(baton);
+    }
+}
+
+template <class T> void Backup::Error(T* baton) {
+    auto env = baton->backup->Env();
+    Napi::HandleScope scope(env);
+
+    Backup* backup = baton->backup;
+    // Fail hard on logic errors.
+    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);
+    }
+}
+
+void Backup::CleanQueue() {
+    auto env = this->Env();
+    Napi::HandleScope scope(env);
+
+    if (inited && !queue.empty()) {
+        // This backup has already been initialized and is now finished.
+        // 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()) {
+            auto call = std::move(queue.front());
+            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);
+        }
+    }
+    else while (!queue.empty()) {
+        // Just delete all items in the queue; we already fired an event when
+        // initializing the backup failed.
+        auto call = std::move(queue.front());
+        queue.pop();
+
+        // We don't call the actual callback, so we have to make sure that
+        // the baton gets destroyed.
+        delete call->baton;
+    }
+}
+
+Backup::Backup(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Backup>(info) {
+    auto env = info.Env();
+    if (!info.IsConstructCall()) {
+        Napi::TypeError::New(env, "Use the new operator to create new Backup objects").ThrowAsJavaScriptException();
+        return;
+    }
+
+    auto length = info.Length();
+
+    if (length <= 0 || !Database::HasInstance(info[0])) {
+        Napi::TypeError::New(env, "Database object expected").ThrowAsJavaScriptException();
+        return;
+    }
+    else if (length <= 1 || !info[1].IsString()) {
+        Napi::TypeError::New(env, "Filename expected").ThrowAsJavaScriptException();
+        return;
+    }
+    else if (length <= 2 || !info[2].IsString()) {
+        Napi::TypeError::New(env, "Source database name expected").ThrowAsJavaScriptException();
+        return;
+    }
+    else if (length <= 3 || !info[3].IsString()) {
+        Napi::TypeError::New(env, "Destination database name expected").ThrowAsJavaScriptException();
+        return;
+    }
+    else if (length <= 4 || !info[4].IsBoolean()) {
+        Napi::TypeError::New(env, "Direction flag expected").ThrowAsJavaScriptException();
+        return;
+    }
+    else if (length > 5 && !info[5].IsUndefined() && !info[5].IsFunction()) {
+        Napi::TypeError::New(env, "Callback expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    this->db = Napi::ObjectWrap<Database>::Unwrap(info[0].As<Napi::Object>());
+    this->db->Ref();
+
+    auto filename = info[1].As<Napi::String>();
+    auto sourceName = info[2].As<Napi::String>();
+    auto destName = info[3].As<Napi::String>();
+    auto filenameIsDest = info[4].As<Napi::Boolean>();
+
+    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();
+
+    this->db->Schedule(Work_BeginInitialize, baton);
+}
+
+void Backup::Work_BeginInitialize(Database::Baton* baton) {
+    assert(baton->db->open);
+    baton->db->pending++;
+    auto env = baton->db->Env();
+    CREATE_WORK("sqlite3.Backup.Initialize", Work_Initialize, Work_AfterInitialize);
+}
+
+void Backup::Work_Initialize(napi_env e, void* data) {
+    BACKUP_INIT(InitializeBaton);
+
+    // In case stepping fails, we use a mutex to make sure we get the associated
+    // error message.
+    auto* mtx = sqlite3_db_mutex(baton->db->_handle);
+    sqlite3_mutex_enter(mtx);
+
+    backup->status = sqlite3_open(baton->filename.c_str(), &backup->_otherDb);
+
+    if (backup->status == SQLITE_OK) {
+        backup->_handle = sqlite3_backup_init(
+            baton->filenameIsDest ? backup->_otherDb : backup->db->_handle,
+            baton->destName.c_str(),
+            baton->filenameIsDest ? backup->db->_handle : backup->_otherDb,
+            baton->sourceName.c_str());
+    }
+    backup->_destDb = baton->filenameIsDest ? backup->_otherDb : backup->db->_handle;
+
+    if (backup->status != SQLITE_OK) {
+        backup->message = std::string(sqlite3_errmsg(backup->_destDb));
+        sqlite3_close(backup->_otherDb);
+        backup->_otherDb = NULL;
+        backup->_destDb = NULL;
+    }
+
+    sqlite3_mutex_leave(mtx);
+}
+
+void Backup::Work_AfterInitialize(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<InitializeBaton> baton(static_cast<InitializeBaton*>(data));
+    auto* backup = baton->backup;
+
+    auto env = backup->Env();
+    Napi::HandleScope scope(env);
+
+    if (backup->status != SQLITE_OK) {
+        Error(baton.get());
+        backup->FinishAll();
+    }
+    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();
+}
+
+Napi::Value Backup::Step(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    auto env = backup->Env();
+
+    REQUIRE_ARGUMENT_INTEGER(0, pages);
+    OPTIONAL_ARGUMENT_FUNCTION(1, callback);
+
+    auto* baton = new StepBaton(backup, callback, pages);
+    backup->GetRetryErrors(baton->retryErrorsSet);
+    backup->Schedule(Work_BeginStep, baton);
+    return info.This();
+}
+
+void Backup::Work_BeginStep(Baton* baton) {
+    BACKUP_BEGIN(Step);
+}
+
+void Backup::Work_Step(napi_env e, void* data) {
+    BACKUP_INIT(StepBaton);
+    if (backup->_handle) {
+        backup->status = sqlite3_backup_step(backup->_handle, baton->pages);
+        backup->remaining = sqlite3_backup_remaining(backup->_handle);
+        backup->pageCount = sqlite3_backup_pagecount(backup->_handle);
+    }
+    if (backup->status != SQLITE_OK) {
+        // Text of message is a little awkward to get, since the error is not associated
+        // with a db connection.
+#if SQLITE_VERSION_NUMBER >= 3007015
+        // sqlite3_errstr is a relatively new method
+        backup->message = std::string(sqlite3_errstr(backup->status));
+#else
+        backup->message = "Sqlite error";
+#endif
+        if (baton->retryErrorsSet.size() > 0) {
+            if (baton->retryErrorsSet.find(backup->status) == baton->retryErrorsSet.end()) {
+                backup->FinishSqlite();
+            }
+        }
+    }
+}
+
+void Backup::Work_AfterStep(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<StepBaton> baton(static_cast<StepBaton*>(data));
+    auto* backup = baton->backup;
+
+    auto env = backup->Env();
+    Napi::HandleScope scope(env);
+
+    if (backup->status == SQLITE_DONE) {
+        backup->completed = true;
+    } else if (!backup->_handle) {
+        backup->failed = true;
+    }
+
+    if (backup->status != SQLITE_OK && backup->status != SQLITE_DONE) {
+        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);
+        }
+    }
+
+    BACKUP_END();
+}
+
+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);
+    backup->Schedule(Work_BeginFinish, baton);
+    return info.This();
+}
+
+void Backup::Work_BeginFinish(Baton* baton) {
+    BACKUP_BEGIN(Finish);
+}
+
+void Backup::Work_Finish(napi_env e, void* data) {
+    BACKUP_INIT(Baton);
+    backup->FinishSqlite();
+}
+
+void Backup::Work_AfterFinish(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<Baton> baton(static_cast<Baton*>(data));
+    auto* backup = baton->backup;
+
+    auto env = backup->Env();
+    Napi::HandleScope scope(env);
+
+    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();
+}
+
+void Backup::FinishAll() {
+    assert(!finished);
+    if (!completed && !failed) {
+        failed = true;
+    }
+    finished = true;
+    CleanQueue();
+    FinishSqlite();
+    db->Unref();
+}
+
+void Backup::FinishSqlite() {
+    if (_handle) {
+        sqlite3_backup_finish(_handle);
+        _handle = NULL;
+    }
+    if (_otherDb) {
+        sqlite3_close(_otherDb);
+        _otherDb = NULL;
+    }
+    _destDb = NULL;
+}
+
+Napi::Value Backup::IdleGetter(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    bool idle = backup->inited && !backup->locked && backup->queue.empty();
+    return Napi::Boolean::New(this->Env(), idle);
+}
+
+Napi::Value Backup::CompletedGetter(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    return Napi::Boolean::New(this->Env(), backup->completed);
+}
+
+Napi::Value Backup::FailedGetter(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    return Napi::Boolean::New(this->Env(), backup->failed);
+}
+
+Napi::Value Backup::RemainingGetter(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    return Napi::Number::New(this->Env(), backup->remaining);
+}
+
+Napi::Value Backup::PageCountGetter(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    return Napi::Number::New(this->Env(), backup->pageCount);
+}
+
+Napi::Value Backup::RetryErrorGetter(const Napi::CallbackInfo& info) {
+    auto* backup = this;
+    return backup->retryErrors.Value();
+}
+
+void Backup::RetryErrorSetter(const Napi::CallbackInfo& info, const Napi::Value& value) {
+    auto* backup = this;
+    auto env = backup->Env();
+    if (!value.IsArray()) {
+        Napi::Error::New(env, "retryErrors must be an array").ThrowAsJavaScriptException();
+        return;
+    }
+    Napi::Array array = value.As<Napi::Array>();
+    backup->retryErrors.Reset(array, 1);
+}
+
+void Backup::GetRetryErrors(std::set<int>& retryErrorsSet) {
+    retryErrorsSet.clear();
+    Napi::Array array = retryErrors.Value();
+    auto length = array.Length();
+    for (size_t i = 0; i < length; i++) {
+        Napi::Value code = (array).Get(static_cast<uint32_t>(i));
+        if (code.IsNumber()) {
+            retryErrorsSet.insert(code.As<Napi::Number>().Int32Value());
+        }
+    }
+}

server/node_modules/sqlite3/src/backup.h

@@ -0,0 +1,209 @@
+#ifndef NODE_SQLITE3_SRC_BACKUP_H
+#define NODE_SQLITE3_SRC_BACKUP_H
+
+#include "database.h"
+
+#include <string>
+#include <queue>
+#include <set>
+
+#include <sqlite3.h>
+#include <napi.h>
+
+using namespace Napi;
+
+namespace node_sqlite3 {
+
+/**
+ *
+ * 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.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();
+ *
+ */
+class Backup : public Napi::ObjectWrap<Backup> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    struct Baton {
+        napi_async_work request = NULL;
+        Backup* backup;
+        Napi::FunctionReference callback;
+
+        Baton(Backup* backup_, Napi::Function cb_) : backup(backup_) {
+            backup->Ref();
+            callback.Reset(cb_, 1);
+        }
+        virtual ~Baton() {
+            if (request) napi_delete_async_work(backup->Env(), request);
+            backup->Unref();
+            callback.Reset();
+        }
+    };
+
+    struct InitializeBaton : Database::Baton {
+        Backup* backup;
+        std::string filename;
+        std::string sourceName;
+        std::string destName;
+        bool filenameIsDest;
+        InitializeBaton(Database* db_, Napi::Function cb_, Backup* backup_) :
+            Baton(db_, cb_), backup(backup_), filenameIsDest(true) {
+            backup->Ref();
+        }
+        virtual ~InitializeBaton() override {
+            backup->Unref();
+            if (!db->IsOpen() && db->IsLocked()) {
+                // The database handle was closed before the backup could be opened.
+                backup->FinishAll();
+            }
+        }
+    };
+
+    struct StepBaton : Baton {
+        int pages;
+        std::set<int> retryErrorsSet;
+        StepBaton(Backup* backup_, Napi::Function cb_, int pages_) :
+            Baton(backup_, cb_), pages(pages_) {}
+        virtual ~StepBaton() override = default;
+    };
+
+    typedef void (*Work_Callback)(Baton* baton);
+
+    struct Call {
+        Call(Work_Callback cb_, Baton* baton_) : callback(cb_), baton(baton_) {};
+        Work_Callback callback;
+        Baton* baton;
+    };
+
+    Backup(const Napi::CallbackInfo& info);
+
+    ~Backup() {
+        if (!finished) {
+            FinishAll();
+        }
+        retryErrors.Reset();
+    }
+
+    WORK_DEFINITION(Step)
+    WORK_DEFINITION(Finish)
+
+    Napi::Value IdleGetter(const Napi::CallbackInfo& info);
+    Napi::Value CompletedGetter(const Napi::CallbackInfo& info);
+    Napi::Value FailedGetter(const Napi::CallbackInfo& info);
+    Napi::Value PageCountGetter(const Napi::CallbackInfo& info);
+    Napi::Value RemainingGetter(const Napi::CallbackInfo& info);
+    Napi::Value FatalErrorGetter(const Napi::CallbackInfo& info);
+    Napi::Value RetryErrorGetter(const Napi::CallbackInfo& info);
+
+    void FatalErrorSetter(const Napi::CallbackInfo& info, const Napi::Value& value);
+    void RetryErrorSetter(const Napi::CallbackInfo& info, const Napi::Value& value);
+
+protected:
+    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);
+
+    void Schedule(Work_Callback callback, Baton* baton);
+    void Process();
+    void CleanQueue();
+    template <class T> static void Error(T* baton);
+
+    void FinishAll();
+    void FinishSqlite();
+    void GetRetryErrors(std::set<int>& retryErrorsSet);
+
+    Database* db;
+
+    sqlite3_backup* _handle = NULL;
+    sqlite3* _otherDb = NULL;
+    sqlite3* _destDb = NULL;
+
+    bool inited = false;
+    bool locked = true;
+    bool completed = false;
+    bool failed = false;
+    int remaining = -1;
+    int pageCount = -1;
+    bool finished = false;
+
+    int status;
+    std::string message;
+    std::queue<std::unique_ptr<Call>> queue;
+
+    Napi::Reference<Array> retryErrors;
+};
+
+}
+
+#endif

server/node_modules/sqlite3/src/database.cc

@@ -0,0 +1,751 @@
+#include <cstring>
+#include <napi.h>
+
+#include "macros.h"
+#include "database.h"
+#include "statement.h"
+
+using namespace node_sqlite3;
+
+#if NAPI_VERSION < 6
+Napi::FunctionReference Database::constructor;
+#endif
+
+Napi::Object Database::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+    // declare napi_default_method here as it is only available in Node v14.12.0+
+    auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable); 
+
+    auto t = DefineClass(env, "Database", {
+        InstanceMethod("close", &Database::Close, napi_default_method),
+        InstanceMethod("exec", &Database::Exec, napi_default_method),
+        InstanceMethod("wait", &Database::Wait, napi_default_method),
+        InstanceMethod("loadExtension", &Database::LoadExtension, napi_default_method),
+        InstanceMethod("serialize", &Database::Serialize, napi_default_method),
+        InstanceMethod("parallelize", &Database::Parallelize, napi_default_method),
+        InstanceMethod("configure", &Database::Configure, napi_default_method),
+        InstanceMethod("interrupt", &Database::Interrupt, napi_default_method),
+        InstanceAccessor("open", &Database::Open, nullptr)
+    });
+
+#if NAPI_VERSION < 6
+    constructor = Napi::Persistent(t);
+    constructor.SuppressDestruct();
+#else
+    Napi::FunctionReference* constructor = new Napi::FunctionReference();
+    *constructor = Napi::Persistent(t);
+    env.SetInstanceData<Napi::FunctionReference>(constructor);
+#endif
+
+    exports.Set("Database", t);
+    return exports;
+}
+
+void Database::Process() {
+    auto env = this->Env();
+    Napi::HandleScope scope(env);
+
+    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);
+        }
+        return;
+    }
+
+    while (open && (!locked || pending == 0) && !queue.empty()) {
+        Call *c = queue.front();
+
+        if (c->exclusive && pending > 0) {
+            break;
+        }
+
+        queue.pop();
+        std::unique_ptr<Call> call(c);
+        locked = call->exclusive;
+        call->callback(call->baton);
+
+        if (locked) break;
+    }
+}
+
+void Database::Schedule(Work_Callback callback, Baton* baton, bool exclusive) {
+    auto env = this->Env();
+    Napi::HandleScope scope(env);
+
+    if (!open && locked) {
+        EXCEPTION(Napi::String::New(env, "Database is closed"), SQLITE_MISUSE, exception);
+        Napi::Function cb = baton->callback.Value();
+        // 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);
+        }
+        return;
+    }
+
+    if (!open || ((locked || exclusive || serialize) && pending > 0)) {
+        queue.emplace(new Call(callback, baton, exclusive || serialize));
+    }
+    else {
+        locked = exclusive;
+        callback(baton);
+    }
+}
+
+Database::Database(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Database>(info) {
+    auto env = info.Env();
+
+    if (info.Length() <= 0 || !info[0].IsString()) {
+        Napi::TypeError::New(env, "String expected").ThrowAsJavaScriptException();
+        return;
+    }
+    auto filename = info[0].As<Napi::String>().Utf8Value();
+
+    unsigned int pos = 1;
+
+    int mode;
+    if (info.Length() >= pos && info[pos].IsNumber() && OtherIsInt(info[pos].As<Napi::Number>())) {
+        mode = info[pos++].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>();
+    }
+
+    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);
+    Work_BeginOpen(baton);
+}
+
+void Database::Work_BeginOpen(Baton* baton) {
+    auto env = baton->db->Env();
+    CREATE_WORK("sqlite3.Database.Open", Work_Open, Work_AfterOpen);
+}
+
+void Database::Work_Open(napi_env e, void* data) {
+    auto* baton = static_cast<OpenBaton*>(data);
+    auto* db = baton->db;
+
+    baton->status = sqlite3_open_v2(
+        baton->filename.c_str(),
+        &db->_handle,
+        baton->mode,
+        NULL
+    );
+
+    if (baton->status != SQLITE_OK) {
+        baton->message = std::string(sqlite3_errmsg(db->_handle));
+        sqlite3_close(db->_handle);
+        db->_handle = NULL;
+    }
+    else {
+        // Set default database handle values.
+        sqlite3_busy_timeout(db->_handle, 1000);
+    }
+}
+
+void Database::Work_AfterOpen(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<OpenBaton> baton(static_cast<OpenBaton*>(data));
+
+    auto* db = baton->db;
+
+    auto env = db->Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Value argv[1];
+    if (baton->status != SQLITE_OK) {
+        EXCEPTION(Napi::String::New(env, baton->message.c_str()), baton->status, exception);
+        argv[0] = exception;
+    }
+    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) {
+        Napi::Value info[] = { Napi::String::New(env, "open") };
+        EMIT_EVENT(db->Value(), 1, info);
+        db->Process();
+    }
+}
+
+Napi::Value Database::Open(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+    return Napi::Boolean::New(env, db->open);
+}
+
+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);
+    db->Schedule(Work_BeginClose, baton, true);
+
+    return info.This();
+}
+
+void Database::Work_BeginClose(Baton* baton) {
+    assert(baton->db->locked);
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+    assert(baton->db->pending == 0);
+
+    baton->db->pending++;
+    baton->db->RemoveCallbacks();
+    baton->db->closing = true;
+
+    auto env = baton->db->Env();
+    CREATE_WORK("sqlite3.Database.Close", Work_Close, Work_AfterClose);
+}
+
+void Database::Work_Close(napi_env e, void* data) {
+    auto* baton = static_cast<Baton*>(data);
+    auto* db = baton->db;
+
+    baton->status = sqlite3_close(db->_handle);
+
+    if (baton->status != SQLITE_OK) {
+        baton->message = std::string(sqlite3_errmsg(db->_handle));
+    }
+    else {
+        db->_handle = NULL;
+    }
+}
+
+void Database::Work_AfterClose(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<Baton> baton(static_cast<Baton*>(data));
+
+    auto* db = baton->db;
+
+    auto env = db->Env();
+    Napi::HandleScope scope(env);
+
+    db->pending--;
+    db->closing = false;
+
+    Napi::Value argv[1];
+    if (baton->status != SQLITE_OK) {
+        EXCEPTION(Napi::String::New(env, baton->message.c_str()), baton->status, exception);
+        argv[0] = exception;
+    }
+    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) {
+        Napi::Value info[] = { Napi::String::New(env, "close") };
+        EMIT_EVENT(db->Value(), 1, info);
+        db->Process();
+    }
+}
+
+Napi::Value Database::Serialize(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
+
+    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();
+
+    return info.This();
+}
+
+Napi::Value Database::Parallelize(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+    OPTIONAL_ARGUMENT_FUNCTION(0, callback);
+
+    auto 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();
+
+    return info.This();
+}
+
+Napi::Value Database::Configure(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+
+    REQUIRE_ARGUMENTS(2);
+
+    Napi::Function handle;
+    if (info[0].StrictEquals( Napi::String::New(env, "trace"))) {    
+       auto* baton = new Baton(db, handle);
+        db->Schedule(RegisterTraceCallback, baton);
+    }
+    else if (info[0].StrictEquals( Napi::String::New(env, "profile"))) {
+       auto* baton = new Baton(db, handle);
+        db->Schedule(RegisterProfileCallback, baton);
+    }
+    else if (info[0].StrictEquals( Napi::String::New(env, "busyTimeout"))) {
+        if (!info[1].IsNumber()) {
+            Napi::TypeError::New(env, "Value must be an integer").ThrowAsJavaScriptException();
+            return env.Null();
+        }
+       auto* baton = new Baton(db, handle);
+        baton->status = info[1].As<Napi::Number>().Int32Value();
+        db->Schedule(SetBusyTimeout, baton);
+    }
+    else if (info[0].StrictEquals( Napi::String::New(env, "limit"))) {
+        REQUIRE_ARGUMENTS(3);
+        if (!info[1].IsNumber()) {
+            Napi::TypeError::New(env, "limit id must be an integer").ThrowAsJavaScriptException();
+            return env.Null();
+        }
+        if (!info[2].IsNumber()) {
+            Napi::TypeError::New(env, "limit value must be an integer").ThrowAsJavaScriptException();
+            return env.Null();
+        }
+        int id = info[1].As<Napi::Number>().Int32Value();
+        int value = info[2].As<Napi::Number>().Int32Value();
+        Baton* baton = new LimitBaton(db, handle, id, value);
+        db->Schedule(SetLimit, baton);
+    }
+    else if (info[0].StrictEquals(Napi::String::New(env, "change"))) {
+       auto* baton = new Baton(db, handle);
+        db->Schedule(RegisterUpdateCallback, baton);
+    }
+    else {
+        Napi::TypeError::New(env, (StringConcat(
+#if V8_MAJOR_VERSION > 6
+            info.GetIsolate(),
+#endif
+            info[0].As<Napi::String>(),
+            Napi::String::New(env, " is not a valid configuration option")
+        )).Utf8Value().c_str()).ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    db->Process();
+
+    return info.This();
+}
+
+Napi::Value Database::Interrupt(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+
+    if (!db->open) {
+        Napi::Error::New(env, "Database is not open").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    if (db->closing) {
+        Napi::Error::New(env, "Database is closing").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+
+    sqlite3_interrupt(db->_handle);
+    return info.This();
+}
+
+void Database::SetBusyTimeout(Baton* b) {
+    auto baton = std::unique_ptr<Baton>(b);
+
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+
+    // Abuse the status field for passing the timeout.
+    sqlite3_busy_timeout(baton->db->_handle, baton->status);
+}
+
+void Database::SetLimit(Baton* b) {
+    std::unique_ptr<LimitBaton> baton(static_cast<LimitBaton*>(b));
+
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+
+    sqlite3_limit(baton->db->_handle, baton->id, baton->value);
+}
+
+void Database::RegisterTraceCallback(Baton* b) {
+    auto baton = std::unique_ptr<Baton>(b);
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+    auto* db = baton->db;
+
+    if (db->debug_trace == NULL) {
+        // Add it.
+        db->debug_trace = new AsyncTrace(db, TraceCallback);
+        sqlite3_trace(db->_handle, TraceCallback, db);
+    }
+    else {
+        // Remove it.
+        sqlite3_trace(db->_handle, NULL, NULL);
+        db->debug_trace->finish();
+        db->debug_trace = NULL;
+    }
+}
+
+void Database::TraceCallback(void* db, const char* sql) {
+    // Note: This function is called in the thread pool.
+    // Note: Some queries, such as "EXPLAIN" queries, are not sent through this.
+    static_cast<Database*>(db)->debug_trace->send(new std::string(sql));
+}
+
+void Database::TraceCallback(Database* db, std::string* s) {
+    std::unique_ptr<std::string> sql(s);
+    // Note: This function is called in the main V8 thread.
+    auto env = db->Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Value argv[] = {
+        Napi::String::New(env, "trace"),
+        Napi::String::New(env, sql->c_str())
+    };
+    EMIT_EVENT(db->Value(), 2, argv);
+}
+
+void Database::RegisterProfileCallback(Baton* b) {
+    auto baton = std::unique_ptr<Baton>(b);
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+    auto* db = baton->db;
+
+    if (db->debug_profile == NULL) {
+        // Add it.
+        db->debug_profile = new AsyncProfile(db, ProfileCallback);
+        sqlite3_profile(db->_handle, ProfileCallback, db);
+    }
+    else {
+        // Remove it.
+        sqlite3_profile(db->_handle, NULL, NULL);
+        db->debug_profile->finish();
+        db->debug_profile = NULL;
+    }
+}
+
+void Database::ProfileCallback(void* db, const char* sql, sqlite3_uint64 nsecs) {
+    // Note: This function is called in the thread pool.
+    // Note: Some queries, such as "EXPLAIN" queries, are not sent through this.
+    auto* info = new ProfileInfo();
+    info->sql = std::string(sql);
+    info->nsecs = nsecs;
+    static_cast<Database*>(db)->debug_profile->send(info);
+}
+
+void Database::ProfileCallback(Database *db, ProfileInfo* i) {
+    auto info = std::unique_ptr<ProfileInfo>(i);
+    auto env = db->Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Value argv[] = {
+        Napi::String::New(env, "profile"),
+        Napi::String::New(env, info->sql.c_str()),
+        Napi::Number::New(env, (double)info->nsecs / 1000000.0)
+    };
+    EMIT_EVENT(db->Value(), 3, argv);
+}
+
+void Database::RegisterUpdateCallback(Baton* b) {
+    auto baton = std::unique_ptr<Baton>(b);
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+    auto* db = baton->db;
+
+    if (db->update_event == NULL) {
+        // Add it.
+        db->update_event = new AsyncUpdate(db, UpdateCallback);
+        sqlite3_update_hook(db->_handle, UpdateCallback, db);
+    }
+    else {
+        // Remove it.
+        sqlite3_update_hook(db->_handle, NULL, NULL);
+        db->update_event->finish();
+        db->update_event = NULL;
+    }
+}
+
+void Database::UpdateCallback(void* db, int type, const char* database,
+        const char* table, sqlite3_int64 rowid) {
+    // Note: This function is called in the thread pool.
+    // Note: Some queries, such as "EXPLAIN" queries, are not sent through this.
+    auto* info = new UpdateInfo();
+    info->type = type;
+    info->database = std::string(database);
+    info->table = std::string(table);
+    info->rowid = rowid;
+    static_cast<Database*>(db)->update_event->send(info);
+}
+
+void Database::UpdateCallback(Database *db, UpdateInfo* i) {
+    auto info = std::unique_ptr<UpdateInfo>(i);
+    auto env = db->Env();
+    Napi::HandleScope scope(env);
+
+    Napi::Value argv[] = {
+        Napi::String::New(env, "change"),
+        Napi::String::New(env, sqlite_authorizer_string(info->type)),
+        Napi::String::New(env, info->database.c_str()),
+        Napi::String::New(env, info->table.c_str()),
+        Napi::Number::New(env, info->rowid),
+    };
+    EMIT_EVENT(db->Value(), 5, argv);
+}
+
+Napi::Value Database::Exec(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+
+    REQUIRE_ARGUMENT_STRING(0, sql);
+    OPTIONAL_ARGUMENT_FUNCTION(1, callback);
+
+    Baton* baton = new ExecBaton(db, callback, sql.c_str());
+    db->Schedule(Work_BeginExec, baton, true);
+
+    return info.This();
+}
+
+void Database::Work_BeginExec(Baton* baton) {
+    assert(baton->db->locked);
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+    assert(baton->db->pending == 0);
+    baton->db->pending++;
+
+    auto env = baton->db->Env();
+    CREATE_WORK("sqlite3.Database.Exec", Work_Exec, Work_AfterExec);
+}
+
+void Database::Work_Exec(napi_env e, void* data) {
+    auto* baton = static_cast<ExecBaton*>(data);
+
+    char* message = NULL;
+    baton->status = sqlite3_exec(
+        baton->db->_handle,
+        baton->sql.c_str(),
+        NULL,
+        NULL,
+        &message
+    );
+
+    if (baton->status != SQLITE_OK && message != NULL) {
+        baton->message = std::string(message);
+        sqlite3_free(message);
+    }
+}
+
+void Database::Work_AfterExec(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<ExecBaton> baton(static_cast<ExecBaton*>(data));
+
+    auto* db = baton->db;
+    db->pending--;
+
+    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);
+    }
+
+    db->Process();
+}
+
+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);
+    db->Schedule(Work_Wait, baton, true);
+
+    return info.This();
+}
+
+void Database::Work_Wait(Baton* b) {
+    auto baton = std::unique_ptr<Baton>(b);
+
+    auto env = baton->db->Env();
+    Napi::HandleScope scope(env);
+
+    assert(baton->db->locked);
+    assert(baton->db->open);
+    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();
+}
+
+Napi::Value Database::LoadExtension(const Napi::CallbackInfo& info) {
+    auto env = this->Env();
+    auto* db = this;
+
+    REQUIRE_ARGUMENT_STRING(0, filename);
+    OPTIONAL_ARGUMENT_FUNCTION(1, callback);
+
+    Baton* baton = new LoadExtensionBaton(db, callback, filename.c_str());
+    db->Schedule(Work_BeginLoadExtension, baton, true);
+
+    return info.This();
+}
+
+void Database::Work_BeginLoadExtension(Baton* baton) {
+    assert(baton->db->locked);
+    assert(baton->db->open);
+    assert(baton->db->_handle);
+    assert(baton->db->pending == 0);
+    baton->db->pending++;
+
+    auto env = baton->db->Env();
+    CREATE_WORK("sqlite3.Database.LoadExtension", Work_LoadExtension, Work_AfterLoadExtension);
+}
+
+void Database::Work_LoadExtension(napi_env e, void* data) {
+    auto* baton = static_cast<LoadExtensionBaton*>(data);
+
+    sqlite3_enable_load_extension(baton->db->_handle, 1);
+
+    char* message = NULL;
+    baton->status = sqlite3_load_extension(
+        baton->db->_handle,
+        baton->filename.c_str(),
+        0,
+        &message
+    );
+
+    sqlite3_enable_load_extension(baton->db->_handle, 0);
+
+    if (baton->status != SQLITE_OK && message != NULL) {
+        baton->message = std::string(message);
+        sqlite3_free(message);
+    }
+}
+
+void Database::Work_AfterLoadExtension(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<LoadExtensionBaton> baton(static_cast<LoadExtensionBaton*>(data));
+
+    auto* db = baton->db;
+    db->pending--;
+
+    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);
+    }
+
+    db->Process();
+}
+
+void Database::RemoveCallbacks() {
+    if (debug_trace) {
+        debug_trace->finish();
+        debug_trace = NULL;
+    }
+    if (debug_profile) {
+        debug_profile->finish();
+        debug_profile = NULL;
+    }
+    if (update_event) {
+        update_event->finish();
+        update_event = NULL;
+    }
+}

server/node_modules/sqlite3/src/database.h

@@ -0,0 +1,188 @@
+
+#ifndef NODE_SQLITE3_SRC_DATABASE_H
+#define NODE_SQLITE3_SRC_DATABASE_H
+
+
+#include <assert.h>
+#include <string>
+#include <queue>
+
+#include <sqlite3.h>
+#include <napi.h>
+
+#include "async.h"
+
+using namespace Napi;
+
+namespace node_sqlite3 {
+
+class Database;
+
+
+class Database : public Napi::ObjectWrap<Database> {
+public:
+#if NAPI_VERSION < 6
+    static Napi::FunctionReference constructor;
+#endif
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+
+    static inline bool HasInstance(Napi::Value val) {
+        auto env = val.Env();
+        Napi::HandleScope scope(env);
+        if (!val.IsObject()) return false;
+        auto obj = val.As<Napi::Object>();
+#if NAPI_VERSION < 6
+        return obj.InstanceOf(constructor.Value());
+#else
+        auto constructor =
+            env.GetInstanceData<Napi::FunctionReference>();
+        return obj.InstanceOf(constructor->Value());
+#endif
+    }
+
+    struct Baton {
+        napi_async_work request = NULL;
+        Database* db;
+        Napi::FunctionReference callback;
+        int status;
+        std::string message;
+
+        Baton(Database* db_, Napi::Function cb_) :
+                db(db_), 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_) {}
+        virtual ~OpenBaton() override = default;
+    };
+
+    struct ExecBaton : Baton {
+        std::string sql;
+        ExecBaton(Database* db_, Napi::Function cb_, const char* sql_) :
+            Baton(db_, cb_), 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_) {}
+        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_) {}
+        virtual ~LimitBaton() override = default;
+    };
+
+    typedef void (*Work_Callback)(Baton* baton);
+
+    struct Call {
+        Call(Work_Callback cb_, Baton* baton_, bool exclusive_ = false) :
+            callback(cb_), exclusive(exclusive_), baton(baton_) {};
+        Work_Callback callback;
+        bool exclusive;
+        Baton* baton;
+    };
+
+    struct ProfileInfo {
+        std::string sql;
+        sqlite3_int64 nsecs;
+    };
+
+    struct UpdateInfo {
+        int type;
+        std::string database;
+        std::string table;
+        sqlite3_int64 rowid;
+    };
+
+    bool IsOpen() { return open; }
+    bool IsLocked() { return locked; }
+
+    typedef Async<std::string, Database> AsyncTrace;
+    typedef Async<ProfileInfo, Database> AsyncProfile;
+    typedef Async<UpdateInfo, Database> AsyncUpdate;
+
+    friend class Statement;
+    friend class Backup;
+
+    Database(const Napi::CallbackInfo& info);
+
+    ~Database() {
+        RemoveCallbacks();
+        sqlite3_close(_handle);
+        _handle = NULL;
+        open = false;
+    }
+
+protected:
+    WORK_DEFINITION(Open);
+    WORK_DEFINITION(Exec);
+    WORK_DEFINITION(Close);
+    WORK_DEFINITION(LoadExtension);
+
+    void Schedule(Work_Callback callback, Baton* baton, bool exclusive = false);
+    void Process();
+
+    Napi::Value Wait(const Napi::CallbackInfo& info);
+    static void Work_Wait(Baton* baton);
+
+    Napi::Value Serialize(const Napi::CallbackInfo& info);
+    Napi::Value Parallelize(const Napi::CallbackInfo& info);
+    Napi::Value Configure(const Napi::CallbackInfo& info);
+    Napi::Value Interrupt(const Napi::CallbackInfo& info);
+
+    static void SetBusyTimeout(Baton* baton);
+    static void SetLimit(Baton* baton);
+
+    static void RegisterTraceCallback(Baton* baton);
+    static void TraceCallback(void* db, const char* sql);
+    static void TraceCallback(Database* db, std::string* sql);
+
+    static void RegisterProfileCallback(Baton* baton);
+    static void ProfileCallback(void* db, const char* sql, sqlite3_uint64 nsecs);
+    static void ProfileCallback(Database* db, ProfileInfo* info);
+
+    static void RegisterUpdateCallback(Baton* baton);
+    static void UpdateCallback(void* db, int type, const char* database, const char* table, sqlite3_int64 rowid);
+    static void UpdateCallback(Database* db, UpdateInfo* info);
+
+    void RemoveCallbacks();
+
+protected:
+    sqlite3* _handle = NULL;
+
+    bool open = false;
+    bool closing = false;
+    bool locked = false;
+    unsigned int pending = 0;
+
+    bool serialize = false;
+
+    std::queue<Call*> queue;
+
+    AsyncTrace* debug_trace = NULL;
+    AsyncProfile* debug_profile = NULL;
+    AsyncUpdate* update_event = NULL;
+};
+
+}
+
+#endif

server/node_modules/sqlite3/src/gcc-preinclude.h

@@ -0,0 +1,30 @@
+// http://web.archive.org/web/20140401031018/http://rjpower9000.wordpress.com:80/2012/04/09/fun-with-shared-libraries-version-glibc_2-14-not-found/
+
+#if defined(__linux__)
+
+#define _GNU_SOURCE
+#include <features.h>
+#undef _GNU_SOURCE
+
+#if defined(__USE_GNU)
+
+#if defined(__x86_64__)
+__asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
+__asm__(".symver exp,exp@GLIBC_2.2.5");
+__asm__(".symver log,log@GLIBC_2.2.5");
+__asm__(".symver log2,log2@GLIBC_2.2.5");
+__asm__(".symver pow,pow@GLIBC_2.2.5");
+__asm__(".symver fcntl64,fcntl@GLIBC_2.2.5");
+#endif
+
+#if defined(__aarch64__) || defined(_M_ARM64)
+__asm__(".symver memcpy,memcpy@GLIBC_2.17");
+__asm__(".symver exp,exp@GLIBC_2.17");
+__asm__(".symver log,log@GLIBC_2.17");
+__asm__(".symver log2,log2@GLIBC_2.17");
+__asm__(".symver pow,pow@GLIBC_2.17");
+__asm__(".symver fcntl64,fcntl@GLIBC_2.17");
+#endif
+
+#endif
+#endif

server/node_modules/sqlite3/src/macros.h

@@ -0,0 +1,207 @@
+#ifndef NODE_SQLITE3_SRC_MACROS_H
+#define NODE_SQLITE3_SRC_MACROS_H
+
+const char* sqlite_code_string(int code);
+const char* sqlite_authorizer_string(int type);
+#include <vector>
+
+// TODO: better way to work around StringConcat?
+#include <napi.h>
+inline Napi::String StringConcat(Napi::Value str1, Napi::Value str2) {
+  return Napi::String::New(str1.Env(), str1.As<Napi::String>().Utf8Value() +
+                    str2.As<Napi::String>().Utf8Value() );
+}
+
+// A Napi substitute IsInt32()
+inline bool OtherIsInt(Napi::Number source) {
+    double orig_val = source.DoubleValue();
+    double int_val = static_cast<double>(source.Int32Value());
+    if (orig_val == int_val) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+#define IS_FUNCTION(cb) \
+    !cb.IsUndefined() && cb.IsFunction()
+
+#define REQUIRE_ARGUMENTS(n)                                                   \
+    if (info.Length() < (n)) {                                                 \
+        Napi::TypeError::New(env, "Expected " #n "arguments").ThrowAsJavaScriptException(); \
+        return env.Null(); \
+    }
+
+
+#define REQUIRE_ARGUMENT_EXTERNAL(i, var)                                      \
+    if (info.Length() <= (i) || !info[i].IsExternal()) {                       \
+        Napi::TypeError::New(env, "Argument " #i " invalid").ThrowAsJavaScriptException(); \
+        return env.Null(); \
+    }                                                                          \
+    Napi::External var = info[i].As<Napi::External>();
+
+
+#define REQUIRE_ARGUMENT_FUNCTION(i, var)                                      \
+    if (info.Length() <= (i) || !info[i].IsFunction()) {                        \
+        Napi::TypeError::New(env, "Argument " #i " must be a function").ThrowAsJavaScriptException(); \
+        return env.Null(); \
+    }                                                                          \
+    Napi::Function var = info[i].As<Napi::Function>();
+
+
+#define REQUIRE_ARGUMENT_STRING(i, var)                                        \
+    if (info.Length() <= (i) || !info[i].IsString()) {                         \
+        Napi::TypeError::New(env, "Argument " #i " must be a string").ThrowAsJavaScriptException(); \
+        return env.Null(); \
+    }                                                                          \
+    std::string var = info[i].As<Napi::String>();
+
+#define REQUIRE_ARGUMENT_INTEGER(i, var)                                        \
+    if (info.Length() <= (i) || !info[i].IsNumber()) {                        \
+        Napi::TypeError::New(env, "Argument " #i " must be an integer").ThrowAsJavaScriptException(); \
+        return env.Null();        \
+    }                                                                          \
+    int var(info[i].As<Napi::Number>().Int32Value());
+
+#define OPTIONAL_ARGUMENT_FUNCTION(i, var)                                     \
+    Napi::Function var;                                                        \
+    if (info.Length() > i && !info[i].IsUndefined()) {                         \
+        if (!info[i].IsFunction()) {                                           \
+            Napi::TypeError::New(env, "Argument " #i " must be a function").ThrowAsJavaScriptException(); \
+            return env.Null(); \
+        }                                                                      \
+        var = info[i].As<Napi::Function>();                                    \
+    }
+
+
+#define OPTIONAL_ARGUMENT_INTEGER(i, var, default)                             \
+    int var;                                                                   \
+    if (info.Length() <= (i)) {                                                \
+        var = (default);                                                       \
+    }                                                                          \
+    else if (info[i].IsNumber()) {                                             \
+        if (OtherIsInt(info[i].As<Number>())) {                                \
+            var = info[i].As<Napi::Number>().Int32Value();                     \
+        }                                                                      \
+    }                                                                          \
+    else {                                                                     \
+        Napi::TypeError::New(env, "Argument " #i " must be an integer").ThrowAsJavaScriptException(); \
+        return env.Null(); \
+    }
+
+
+#define DEFINE_CONSTANT_INTEGER(target, constant, name)                        \
+    Napi::PropertyDescriptor::Value(#name, Napi::Number::New(env, constant),   \
+        static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)),
+
+#define DEFINE_CONSTANT_STRING(target, constant, name)                         \
+    Napi::PropertyDescriptor::Value(#name, Napi::String::New(env, constant),   \
+        static_cast<napi_property_attributes>(napi_enumerable | napi_configurable)),
+
+#define EXCEPTION(msg, errno, name)                                            \
+    Napi::Value name = Napi::Error::New(env,                                   \
+        StringConcat(                                                          \
+            StringConcat(                                                      \
+                Napi::String::New(env, sqlite_code_string(errno)),             \
+                Napi::String::New(env, ": ")                                   \
+            ),                                                                 \
+            (msg)                                                              \
+        ).Utf8Value()                                                          \
+    ).Value();                                                                 \
+    Napi::Object name ##_obj = name.As<Napi::Object>();                        \
+    (name ##_obj).Set( Napi::String::New(env, "errno"), Napi::Number::New(env, errno)); \
+    (name ##_obj).Set( Napi::String::New(env, "code"),                         \
+        Napi::String::New(env, sqlite_code_string(errno)));
+
+
+#define EMIT_EVENT(obj, argc, argv)                                            \
+    TRY_CATCH_CALL((obj),                                                      \
+        (obj).Get("emit").As<Napi::Function>(),\
+        argc, argv                                                             \
+    );
+
+// The Mac OS compiler complains when argv is NULL unless we
+// first assign it to a locally defined variable.
+#define TRY_CATCH_CALL(context, callback, argc, argv, ...)                     \
+    Napi::Value* passed_argv = argv;\
+    std::vector<napi_value> args;\
+    if ((argc != 0) && (passed_argv != NULL)) {\
+      args.assign(passed_argv, passed_argv + argc);\
+    }\
+    Napi::Value res = (callback).Call(Napi::Value(context), args);             \
+    if (res.IsEmpty()) return __VA_ARGS__;
+
+#define WORK_DEFINITION(name)                                                  \
+    Napi::Value name(const Napi::CallbackInfo& info);                          \
+    static void Work_Begin##name(Baton* baton);                                \
+    static void Work_##name(napi_env env, void* data);                         \
+    static void Work_After##name(napi_env env, napi_status status, void* data);
+
+#ifdef DEBUG
+    #define ASSERT_STATUS() assert(status == 0);
+#else
+    #define ASSERT_STATUS() (void)status;
+#endif
+
+#define CREATE_WORK(name, workerFn, afterFn)                                    \
+    int status = napi_create_async_work(env, NULL, Napi::String::New(env, name),\
+                             workerFn, afterFn, baton, &baton->request);        \
+                                                                                \
+    ASSERT_STATUS();                                                            \
+    napi_queue_async_work(env, baton->request);
+
+#define STATEMENT_BEGIN(type)                                                  \
+    assert(baton);                                                             \
+    assert(baton->stmt);                                                       \
+    assert(!baton->stmt->locked);                                              \
+    assert(!baton->stmt->finalized);                                           \
+    assert(baton->stmt->prepared);                                             \
+    baton->stmt->locked = true;                                                \
+    baton->stmt->db->pending++;                                                \
+    auto env = baton->stmt->Env();                                             \
+    CREATE_WORK("sqlite3.Statement."#type, Work_##type, Work_After##type);
+
+#define STATEMENT_INIT(type)                                                   \
+    type* baton = static_cast<type*>(data);                                    \
+    Statement* stmt = baton->stmt;
+
+#define STATEMENT_MUTEX(name) \
+    if (!stmt->db->_handle) { \
+        stmt->status = SQLITE_MISUSE; \
+        stmt->message = "Database handle is closed"; \
+        return; \
+    } \
+    sqlite3_mutex* name = sqlite3_db_mutex(stmt->db->_handle);
+
+#define STATEMENT_END()                                                        \
+    assert(stmt->locked);                                                      \
+    assert(stmt->db->pending);                                                 \
+    stmt->locked = false;                                                      \
+    stmt->db->pending--;                                                       \
+    stmt->Process();                                                           \
+    stmt->db->Process();
+
+#define BACKUP_BEGIN(type)                                                     \
+    assert(baton);                                                             \
+    assert(baton->backup);                                                     \
+    assert(!baton->backup->locked);                                            \
+    assert(!baton->backup->finished);                                          \
+    assert(baton->backup->inited);                                             \
+    baton->backup->locked = true;                                              \
+    baton->backup->db->pending++;                                              \
+    auto env = baton->backup->Env();                                           \
+    CREATE_WORK("sqlite3.Backup."#type, Work_##type, Work_After##type);
+
+#define BACKUP_INIT(type)                                                      \
+    type* baton = static_cast<type*>(data);                                    \
+    Backup* backup = baton->backup;
+
+#define BACKUP_END()                                                           \
+    assert(backup->locked);                                                    \
+    assert(backup->db->pending);                                               \
+    backup->locked = false;                                                    \
+    backup->db->pending--;                                                     \
+    backup->Process();                                                         \
+    backup->db->Process();
+
+#endif

server/node_modules/sqlite3/src/node_sqlite3.cc

@@ -0,0 +1,128 @@
+#include <stdint.h>
+#include <sstream>
+#include <cstring>
+#include <string>
+#include <sqlite3.h>
+
+#include "macros.h"
+#include "database.h"
+#include "statement.h"
+#include "backup.h"
+
+using namespace node_sqlite3;
+
+namespace {
+
+Napi::Object RegisterModule(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+
+    Database::Init(env, exports);
+    Statement::Init(env, exports);
+    Backup::Init(env, exports);
+
+    exports.DefineProperties({
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_READONLY, OPEN_READONLY)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_READWRITE, OPEN_READWRITE)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_CREATE, OPEN_CREATE)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_FULLMUTEX, OPEN_FULLMUTEX)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_URI, OPEN_URI)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_SHAREDCACHE, OPEN_SHAREDCACHE)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OPEN_PRIVATECACHE, OPEN_PRIVATECACHE)
+        DEFINE_CONSTANT_STRING(exports, SQLITE_VERSION, VERSION)
+#ifdef SQLITE_SOURCE_ID
+        DEFINE_CONSTANT_STRING(exports, SQLITE_SOURCE_ID, SOURCE_ID)
+#endif
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_VERSION_NUMBER, VERSION_NUMBER)
+
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_OK, OK)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_ERROR, ERROR)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_INTERNAL, INTERNAL)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_PERM, PERM)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_ABORT, ABORT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_BUSY, BUSY)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LOCKED, LOCKED)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_NOMEM, NOMEM)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_READONLY, READONLY)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_INTERRUPT, INTERRUPT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_IOERR, IOERR)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_CORRUPT, CORRUPT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_NOTFOUND, NOTFOUND)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_FULL, FULL)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_CANTOPEN, CANTOPEN)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_PROTOCOL, PROTOCOL)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_EMPTY, EMPTY)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_SCHEMA, SCHEMA)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_TOOBIG, TOOBIG)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_CONSTRAINT, CONSTRAINT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_MISMATCH, MISMATCH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_MISUSE, MISUSE)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_NOLFS, NOLFS)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_AUTH, AUTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_FORMAT, FORMAT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_RANGE, RANGE)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_NOTADB, NOTADB)
+
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_LENGTH, LIMIT_LENGTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_SQL_LENGTH, LIMIT_SQL_LENGTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_COLUMN, LIMIT_COLUMN)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_EXPR_DEPTH, LIMIT_EXPR_DEPTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_COMPOUND_SELECT, LIMIT_COMPOUND_SELECT)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_VDBE_OP, LIMIT_VDBE_OP)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_FUNCTION_ARG, LIMIT_FUNCTION_ARG)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_ATTACHED, LIMIT_ATTACHED)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_LIKE_PATTERN_LENGTH, LIMIT_LIKE_PATTERN_LENGTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_VARIABLE_NUMBER, LIMIT_VARIABLE_NUMBER)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_TRIGGER_DEPTH, LIMIT_TRIGGER_DEPTH)
+        DEFINE_CONSTANT_INTEGER(exports, SQLITE_LIMIT_WORKER_THREADS, LIMIT_WORKER_THREADS)
+    });
+
+    return exports;
+}
+
+}
+
+const char* sqlite_code_string(int code) {
+    switch (code) {
+        case SQLITE_OK:         return "SQLITE_OK";
+        case SQLITE_ERROR:      return "SQLITE_ERROR";
+        case SQLITE_INTERNAL:   return "SQLITE_INTERNAL";
+        case SQLITE_PERM:       return "SQLITE_PERM";
+        case SQLITE_ABORT:      return "SQLITE_ABORT";
+        case SQLITE_BUSY:       return "SQLITE_BUSY";
+        case SQLITE_LOCKED:     return "SQLITE_LOCKED";
+        case SQLITE_NOMEM:      return "SQLITE_NOMEM";
+        case SQLITE_READONLY:   return "SQLITE_READONLY";
+        case SQLITE_INTERRUPT:  return "SQLITE_INTERRUPT";
+        case SQLITE_IOERR:      return "SQLITE_IOERR";
+        case SQLITE_CORRUPT:    return "SQLITE_CORRUPT";
+        case SQLITE_NOTFOUND:   return "SQLITE_NOTFOUND";
+        case SQLITE_FULL:       return "SQLITE_FULL";
+        case SQLITE_CANTOPEN:   return "SQLITE_CANTOPEN";
+        case SQLITE_PROTOCOL:   return "SQLITE_PROTOCOL";
+        case SQLITE_EMPTY:      return "SQLITE_EMPTY";
+        case SQLITE_SCHEMA:     return "SQLITE_SCHEMA";
+        case SQLITE_TOOBIG:     return "SQLITE_TOOBIG";
+        case SQLITE_CONSTRAINT: return "SQLITE_CONSTRAINT";
+        case SQLITE_MISMATCH:   return "SQLITE_MISMATCH";
+        case SQLITE_MISUSE:     return "SQLITE_MISUSE";
+        case SQLITE_NOLFS:      return "SQLITE_NOLFS";
+        case SQLITE_AUTH:       return "SQLITE_AUTH";
+        case SQLITE_FORMAT:     return "SQLITE_FORMAT";
+        case SQLITE_RANGE:      return "SQLITE_RANGE";
+        case SQLITE_NOTADB:     return "SQLITE_NOTADB";
+        case SQLITE_ROW:        return "SQLITE_ROW";
+        case SQLITE_DONE:       return "SQLITE_DONE";
+        default:                return "UNKNOWN";
+    }
+}
+
+const char* sqlite_authorizer_string(int type) {
+    switch (type) {
+        case SQLITE_INSERT:     return "insert";
+        case SQLITE_UPDATE:     return "update";
+        case SQLITE_DELETE:     return "delete";
+        default:                return "";
+    }
+}
+
+NODE_API_MODULE(node_sqlite3, RegisterModule)

server/node_modules/sqlite3/src/statement.cc

@@ -0,0 +1,939 @@
+#include <cstring>
+#include <napi.h>
+#include <uv.h>
+
+#include "macros.h"
+#include "database.h"
+#include "statement.h"
+
+using namespace node_sqlite3;
+
+Napi::Object Statement::Init(Napi::Env env, Napi::Object exports) {
+    Napi::HandleScope scope(env);
+
+    // declare napi_default_method here as it is only available in Node v14.12.0+
+    auto napi_default_method = static_cast<napi_property_attributes>(napi_writable | napi_configurable);
+
+    auto t = DefineClass(env, "Statement", {
+      InstanceMethod("bind", &Statement::Bind, napi_default_method),
+      InstanceMethod("get", &Statement::Get, napi_default_method),
+      InstanceMethod("run", &Statement::Run, napi_default_method),
+      InstanceMethod("all", &Statement::All, napi_default_method),
+      InstanceMethod("each", &Statement::Each, napi_default_method),
+      InstanceMethod("reset", &Statement::Reset, napi_default_method),
+      InstanceMethod("finalize", &Statement::Finalize_, napi_default_method),
+    });
+
+    exports.Set("Statement", t);
+    return exports;
+}
+
+// A Napi InstanceOf for Javascript Objects "Date" and "RegExp"
+bool OtherInstanceOf(Napi::Object source, const char* object_type) {
+    if (strncmp(object_type, "Date", 4) == 0) {
+        return source.InstanceOf(source.Env().Global().Get("Date").As<Function>());
+    } else if (strncmp(object_type, "RegExp", 6) == 0) {
+        return source.InstanceOf(source.Env().Global().Get("RegExp").As<Function>());
+    }
+
+    return false;
+}
+
+void Statement::Process() {
+    if (finalized && !queue.empty()) {
+        return CleanQueue();
+    }
+
+    while (prepared && !locked && !queue.empty()) {
+        auto call = std::unique_ptr<Call>(queue.front());
+        queue.pop();
+
+        call->callback(call->baton);
+    }
+}
+
+void Statement::Schedule(Work_Callback callback, Baton* baton) {
+    if (finalized) {
+        queue.emplace(new Call(callback, baton));
+        CleanQueue();
+    }
+    else if (!prepared || locked) {
+        queue.emplace(new Call(callback, baton));
+    }
+    else {
+        callback(baton);
+    }
+}
+
+template <class T> void Statement::Error(T* baton) {
+    Statement* stmt = baton->stmt;
+
+    auto env = stmt->Env();
+    Napi::HandleScope scope(env);
+
+    // Fail hard on logic errors.
+    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);
+    }
+}
+
+// { Database db, String sql, Array params, Function callback }
+Statement::Statement(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Statement>(info) {
+    auto env = info.Env();
+    int length = info.Length();
+
+    if (length <= 0 || !Database::HasInstance(info[0])) {
+        Napi::TypeError::New(env, "Database object expected").ThrowAsJavaScriptException();
+        return;
+    }
+    else if (length <= 1 || !info[1].IsString()) {
+        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>();
+
+    info.This().As<Napi::Object>().DefineProperty(Napi::PropertyDescriptor::Value("sql", sql, napi_default));
+
+
+    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);
+}
+
+void Statement::Work_BeginPrepare(Database::Baton* baton) {
+    assert(baton->db->open);
+    baton->db->pending++;
+
+    auto env = baton->db->Env();
+    CREATE_WORK("sqlite3.Statement.Prepare", Work_Prepare, Work_AfterPrepare);
+}
+
+void Statement::Work_Prepare(napi_env e, void* data) {
+    STATEMENT_INIT(PrepareBaton);
+
+    // In case preparing fails, we use a mutex to make sure we get the associated
+    // error message.
+    STATEMENT_MUTEX(mtx);
+    sqlite3_mutex_enter(mtx);
+
+    stmt->status = sqlite3_prepare_v2(
+        baton->db->_handle,
+        baton->sql.c_str(),
+        baton->sql.size(),
+        &stmt->_handle,
+        NULL
+    );
+
+    if (stmt->status != SQLITE_OK) {
+        stmt->message = std::string(sqlite3_errmsg(baton->db->_handle));
+        stmt->_handle = NULL;
+    }
+
+    sqlite3_mutex_leave(mtx);
+}
+
+void Statement::Work_AfterPrepare(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<PrepareBaton> baton(static_cast<PrepareBaton*>(data));
+    auto* stmt = baton->stmt;
+
+    auto env = stmt->Env();
+    Napi::HandleScope scope(env);
+
+    if (stmt->status != SQLITE_OK) {
+        Error(baton.get());
+        stmt->Finalize_();
+    }
+    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);
+        }
+    }
+
+    STATEMENT_END();
+}
+
+template <class T> std::unique_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());
+    }
+    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());
+    }
+    else if (source.IsNumber()) {
+        if (OtherIsInt(source.As<Napi::Number>())) {
+            return std::make_unique<Values::Integer>(pos, source.As<Napi::Number>().Int32Value());
+        } else {
+            return std::make_unique<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);
+    }
+    else if (source.IsNull()) {
+        return std::make_unique<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());
+    }
+    else if (OtherInstanceOf(source.As<Object>(), "Date")) {
+        return std::make_unique<Values::Float>(pos, source.ToNumber().DoubleValue());
+    }
+    else if (source.IsObject()) {
+        auto napiVal = Napi::String::New(source.Env(), "[object Object]");
+        // Check whether toString returned a value that is not undefined.
+        if(napiVal.Type() == 0) {
+            return NULL;
+        }
+
+        std::string val = napiVal.Utf8Value();
+        return std::make_unique<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);
+
+    if (start < last) {
+        if (info[start].IsArray()) {
+            auto array = info[start].As<Napi::Array>();
+            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));
+            }
+        }
+        else if (!info[start].IsObject() || OtherInstanceOf(info[start].As<Object>(), "RegExp") 
+                || OtherInstanceOf(info[start].As<Object>(), "Date") || info[start].IsBuffer()) {
+            // 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));
+            }
+        }
+        else if (info[start].IsObject()) {
+            auto object = info[start].As<Napi::Object>();
+            auto array = object.GetPropertyNames();
+            int length = array.Length();
+            for (int i = 0; i < length; i++) {
+                Napi::Value name = (array).Get(i);
+                Napi::Number num = name.ToNumber();
+
+                if (num.Int32Value() == num.DoubleValue()) {
+                    baton->parameters.emplace_back(
+                        BindParameter((object).Get(name), num.Int32Value()));
+                }
+                else {
+                    baton->parameters.emplace_back(BindParameter((object).Get(name),
+                        name.As<Napi::String>().Utf8Value().c_str()));
+                }
+            }
+        }
+        else {
+            return NULL;
+        }
+    }
+
+    return baton;
+}
+
+bool Statement::Bind(const Parameters & parameters) {
+    if (parameters.empty()) {
+        return true;
+    }
+
+    sqlite3_reset(_handle);
+    sqlite3_clear_bindings(_handle);
+
+    for (auto& field : parameters) {
+        if (field == NULL)
+            continue;
+
+        unsigned int pos;
+        if (field->index > 0) {
+            pos = field->index;
+        }
+        else {
+            pos = sqlite3_bind_parameter_index(_handle, field->name.c_str());
+        }
+
+        switch (field->type) {
+            case SQLITE_INTEGER: {
+                status = sqlite3_bind_int(_handle, pos,
+                    (static_cast<Values::Integer*>(field.get()))->value);
+            } break;
+            case SQLITE_FLOAT: {
+                status = sqlite3_bind_double(_handle, pos,
+                    (static_cast<Values::Float*>(field.get()))->value);
+            } break;
+            case SQLITE_TEXT: {
+                status = sqlite3_bind_text(_handle, pos,
+                    (static_cast<Values::Text*>(field.get()))->value.c_str(),
+                    (static_cast<Values::Text*>(field.get()))->value.size(), SQLITE_TRANSIENT);
+            } break;
+            case SQLITE_BLOB: {
+                status = sqlite3_bind_blob(_handle, pos,
+                    (static_cast<Values::Blob*>(field.get()))->value,
+                    (static_cast<Values::Blob*>(field.get()))->length, SQLITE_TRANSIENT);
+            } break;
+            case SQLITE_NULL: {
+                status = sqlite3_bind_null(_handle, pos);
+            } break;
+        }
+
+            if (status != SQLITE_OK) {
+                message = std::string(sqlite3_errmsg(db->_handle));
+                return false;
+            }
+        }
+
+    return true;
+}
+
+Napi::Value Statement::Bind(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    Statement* stmt = this;
+
+    auto baton = stmt->Bind<Baton>(info);
+    if (baton == NULL) {
+        Napi::TypeError::New(env, "Data type is not supported").ThrowAsJavaScriptException();
+        return env.Null();
+    }
+    else {
+        stmt->Schedule(Work_BeginBind, baton);
+        return info.This();
+    }
+}
+
+void Statement::Work_BeginBind(Baton* baton) {
+    STATEMENT_BEGIN(Bind);
+}
+
+void Statement::Work_Bind(napi_env e, void* data) {
+    STATEMENT_INIT(Baton);
+
+    STATEMENT_MUTEX(mtx);
+    sqlite3_mutex_enter(mtx);
+    stmt->Bind(baton->parameters);
+    sqlite3_mutex_leave(mtx);
+}
+
+void Statement::Work_AfterBind(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<Baton> baton(static_cast<Baton*>(data));
+    auto* stmt = baton->stmt;
+
+    auto env = stmt->Env();
+    Napi::HandleScope scope(env);
+
+    if (stmt->status != SQLITE_OK) {
+        Error(baton.get());
+    }
+    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);
+        }
+    }
+
+    STATEMENT_END();
+}
+
+
+
+Napi::Value Statement::Get(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    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();
+    }
+    else {
+        stmt->Schedule(Work_BeginGet, baton);
+        return info.This();
+    }
+}
+
+void Statement::Work_BeginGet(Baton* baton) {
+    STATEMENT_BEGIN(Get);
+}
+
+void Statement::Work_Get(napi_env e, void* data) {
+    STATEMENT_INIT(RowBaton);
+
+    if (stmt->status != SQLITE_DONE || baton->parameters.size()) {
+        STATEMENT_MUTEX(mtx);
+        sqlite3_mutex_enter(mtx);
+
+        if (stmt->Bind(baton->parameters)) {
+            stmt->status = sqlite3_step(stmt->_handle);
+
+            if (!(stmt->status == SQLITE_ROW || stmt->status == SQLITE_DONE)) {
+                stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));
+            }
+        }
+
+        sqlite3_mutex_leave(mtx);
+
+        if (stmt->status == SQLITE_ROW) {
+            // Acquire one result row before returning.
+            GetRow(&baton->row, stmt->_handle);
+        }
+    }
+}
+
+void Statement::Work_AfterGet(napi_env e, napi_status status, void* 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_ROW && stmt->status != SQLITE_DONE) {
+        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);
+            }
+        }
+    }
+
+    STATEMENT_END();
+}
+
+Napi::Value Statement::Run(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    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();
+    }
+    else {
+        stmt->Schedule(Work_BeginRun, baton);
+        return info.This();
+    }
+}
+
+void Statement::Work_BeginRun(Baton* baton) {
+    STATEMENT_BEGIN(Run);
+}
+
+void Statement::Work_Run(napi_env e, void* data) {
+    STATEMENT_INIT(RunBaton);
+
+    STATEMENT_MUTEX(mtx);
+    sqlite3_mutex_enter(mtx);
+
+    // Make sure that we also reset when there are no parameters.
+    if (!baton->parameters.size()) {
+        sqlite3_reset(stmt->_handle);
+    }
+
+    if (stmt->Bind(baton->parameters)) {
+        stmt->status = sqlite3_step(stmt->_handle);
+
+        if (!(stmt->status == SQLITE_ROW || stmt->status == SQLITE_DONE)) {
+            stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));
+        }
+        else {
+            baton->inserted_id = sqlite3_last_insert_rowid(stmt->db->_handle);
+            baton->changes = sqlite3_changes(stmt->db->_handle);
+        }
+    }
+
+    sqlite3_mutex_leave(mtx);
+}
+
+void Statement::Work_AfterRun(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<RunBaton> baton(static_cast<RunBaton*>(data));
+    auto* stmt = baton->stmt;
+
+    auto env = stmt->Env();
+    Napi::HandleScope scope(env);
+
+    if (stmt->status != SQLITE_ROW && stmt->status != SQLITE_DONE) {
+        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);
+        }
+    }
+
+    STATEMENT_END();
+}
+
+Napi::Value Statement::All(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    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();
+    }
+    else {
+        stmt->Schedule(Work_BeginAll, baton);
+        return info.This();
+    }
+}
+
+void Statement::Work_BeginAll(Baton* baton) {
+    STATEMENT_BEGIN(All);
+}
+
+void Statement::Work_All(napi_env e, void* data) {
+    STATEMENT_INIT(RowsBaton);
+
+    STATEMENT_MUTEX(mtx);
+    sqlite3_mutex_enter(mtx);
+
+    // Make sure that we also reset when there are no parameters.
+    if (!baton->parameters.size()) {
+        sqlite3_reset(stmt->_handle);
+    }
+
+    if (stmt->Bind(baton->parameters)) {
+        while ((stmt->status = sqlite3_step(stmt->_handle)) == SQLITE_ROW) {
+            auto row = std::make_unique<Row>();
+            GetRow(row.get(), stmt->_handle);
+            baton->rows.emplace_back(std::move(row));
+        }
+
+        if (stmt->status != SQLITE_DONE) {
+            stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));
+        }
+    }
+
+    sqlite3_mutex_leave(mtx);
+}
+
+void Statement::Work_AfterAll(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<RowsBaton> baton(static_cast<RowsBaton*>(data));
+    auto* stmt = baton->stmt;
+
+    auto env = stmt->Env();
+    Napi::HandleScope scope(env);
+
+    if (stmt->status != SQLITE_DONE) {
+        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);
+            }
+        }
+    }
+
+    STATEMENT_END();
+}
+
+Napi::Value Statement::Each(const Napi::CallbackInfo& info) {
+    auto env = info.Env();
+    Statement* stmt = this;
+
+    int last = info.Length();
+
+    Napi::Function completed;
+    if (last >= 2 && info[last - 1].IsFunction() && info[last - 2].IsFunction()) {
+        completed = info[--last].As<Napi::Function>();
+    }
+
+    auto baton = stmt->Bind<EachBaton>(info, 0, last);
+    if (baton == NULL) {
+        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();
+    }
+}
+
+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);
+}
+
+void Statement::Work_Each(napi_env e, void* data) {
+    STATEMENT_INIT(EachBaton);
+
+    auto* async = baton->async;
+
+    STATEMENT_MUTEX(mtx);
+
+    // Make sure that we also reset when there are no parameters.
+    if (!baton->parameters.size()) {
+        sqlite3_reset(stmt->_handle);
+    }
+
+    if (stmt->Bind(baton->parameters)) {
+        while (true) {
+            sqlite3_mutex_enter(mtx);
+            stmt->status = sqlite3_step(stmt->_handle);
+            if (stmt->status == SQLITE_ROW) {
+                sqlite3_mutex_leave(mtx);
+                auto row = std::make_unique<Row>();
+                GetRow(row.get(), stmt->_handle);
+                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 {
+                if (stmt->status != SQLITE_DONE) {
+                    stmt->message = std::string(sqlite3_errmsg(stmt->db->_handle));
+                }
+                sqlite3_mutex_leave(mtx);
+                break;
+            }
+        }
+    }
+
+    async->completed = true;
+    uv_async_send(&async->watcher);
+}
+
+void Statement::CloseCallback(uv_handle_t* handle) {
+    assert(handle != NULL);
+    assert(handle->data != NULL);
+    auto* async = static_cast<Async*>(handle->data);
+    delete async;
+}
+
+void Statement::AsyncEach(uv_async_t* handle) {
+    auto* async = static_cast<Async*>(handle->data);
+
+    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);
+            }
+        }
+    }
+
+    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);
+        }
+        uv_close(reinterpret_cast<uv_handle_t*>(handle), CloseCallback);
+    }
+}
+
+void Statement::Work_AfterEach(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<EachBaton> baton(static_cast<EachBaton*>(data));
+    auto* stmt = baton->stmt;
+
+    auto env = stmt->Env();
+    Napi::HandleScope scope(env);
+
+    if (stmt->status != SQLITE_DONE) {
+        Error(baton.get());
+    }
+
+    STATEMENT_END();
+}
+
+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);
+    stmt->Schedule(Work_BeginReset, baton);
+
+    return info.This();
+}
+
+void Statement::Work_BeginReset(Baton* baton) {
+    STATEMENT_BEGIN(Reset);
+}
+
+void Statement::Work_Reset(napi_env e, void* data) {
+    STATEMENT_INIT(Baton);
+
+    sqlite3_reset(stmt->_handle);
+    stmt->status = SQLITE_OK;
+}
+
+void Statement::Work_AfterReset(napi_env e, napi_status status, void* data) {
+    std::unique_ptr<Baton> baton(static_cast<Baton*>(data));
+    auto* stmt = baton->stmt;
+
+    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);
+    }
+
+    STATEMENT_END();
+}
+
+Napi::Value Statement::RowToJS(Napi::Env env, Row* row) {
+    Napi::EscapableHandleScope scope(env);
+
+    auto result = Napi::Object::New(env);
+
+    for (auto& field : *row) {
+
+        Napi::Value value;
+
+        switch (field->type) {
+            case SQLITE_INTEGER: {
+                value = Napi::Number::New(env, (static_cast<Values::Integer*>(field.get()))->value);
+            } break;
+            case SQLITE_FLOAT: {
+                value = Napi::Number::New(env, (static_cast<Values::Float*>(field.get()))->value);
+            } break;
+            case SQLITE_TEXT: {
+                value = Napi::String::New(env, (static_cast<Values::Text*>(field.get()))->value.c_str(), 
+                                               (static_cast<Values::Text*>(field.get()))->value.size());
+            } break;
+            case SQLITE_BLOB: {
+                value = Napi::Buffer<char>::Copy(env, (static_cast<Values::Blob*>(field.get()))->value, 
+                                                      (static_cast<Values::Blob*>(field.get()))->length);
+            } break;
+            case SQLITE_NULL: {
+                value = env.Null();
+            } break;
+        }
+
+        result.Set(field->name, value);
+    }
+
+    return scope.Escape(result);
+}
+
+void Statement::GetRow(Row* row, sqlite3_stmt* stmt) {
+    int cols = sqlite3_column_count(stmt);
+
+    for (int i = 0; i < cols; i++) {
+        int type = sqlite3_column_type(stmt, i);
+        const char* name = sqlite3_column_name(stmt, i);
+        if (name == NULL) {
+            assert(false);
+        }
+
+        switch (type) {
+            case SQLITE_INTEGER: {
+                row->emplace_back(std::make_unique<Values::Integer>(name, sqlite3_column_int64(stmt, i)));
+            }   break;
+            case SQLITE_FLOAT: {
+                row->emplace_back(std::make_unique<Values::Float>(name, sqlite3_column_double(stmt, i)));
+            }   break;
+            case SQLITE_TEXT: {
+                const char* text = (const char*)sqlite3_column_text(stmt, i);
+                int length = sqlite3_column_bytes(stmt, i);
+                row->emplace_back(std::make_unique<Values::Text>(name, length, text));
+            } break;
+            case SQLITE_BLOB: {
+                const void* blob = sqlite3_column_blob(stmt, i);
+                int length = sqlite3_column_bytes(stmt, i);
+                row->emplace_back(std::make_unique<Values::Blob>(name, length, blob));
+            }   break;
+            case SQLITE_NULL: {
+                row->emplace_back(std::make_unique<Values::Null>(name));
+            }   break;
+            default:
+                assert(false);
+        }
+    }
+}
+
+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);
+    stmt->Schedule(Finalize_, baton);
+
+    return stmt->db->Value();
+}
+
+void Statement::Finalize_(Baton* b) {
+    auto baton = std::unique_ptr<Baton>(b);
+    auto env = baton->stmt->Env();
+    Napi::HandleScope scope(env);
+
+    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);
+    }
+}
+
+void Statement::Finalize_() {
+    assert(!finalized);
+    finalized = true;
+    CleanQueue();
+    // Finalize returns the status code of the last operation. We already fired
+    // error events in case those failed.
+    sqlite3_finalize(_handle);
+    _handle = NULL;
+    db->Unref();
+}
+
+void Statement::CleanQueue() {
+    auto env = this->Env();
+    Napi::HandleScope scope(env);
+
+    if (prepared && !queue.empty()) {
+        // This statement has already been prepared and is now finalized.
+        // 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()) {
+            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 (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);
+        }
+    }
+    else while (!queue.empty()) {
+        // Just delete all items in the queue; we already fired an event when
+        // preparing the statement failed.
+        auto call = std::unique_ptr<Call>(queue.front());
+        queue.pop();
+        // We don't call the actual callback, so we have to make sure that
+        // the baton gets destroyed.
+        delete call->baton;
+    }
+}

server/node_modules/sqlite3/src/statement.h

@@ -0,0 +1,244 @@
+#ifndef NODE_SQLITE3_SRC_STATEMENT_H
+#define NODE_SQLITE3_SRC_STATEMENT_H
+
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <queue>
+#include <vector>
+#include <sqlite3.h>
+#include <napi.h>
+#include <uv.h>
+
+#include "database.h"
+#include "threading.h"
+
+using namespace Napi;
+
+namespace node_sqlite3 {
+
+namespace Values {
+    struct Field {
+        inline Field(unsigned short _index, unsigned short _type = SQLITE_NULL) :
+            type(_type), index(_index) {}
+        inline Field(const char* _name, unsigned short _type = SQLITE_NULL) :
+            type(_type), index(0), name(_name) {}
+
+        unsigned short type;
+        unsigned short index;
+        std::string name;
+
+        virtual ~Field() = default;
+    };
+
+    struct Integer : Field {
+        template <class T> inline Integer(T _name, int64_t val) :
+            Field(_name, SQLITE_INTEGER), value(val) {}
+        int64_t value;
+        virtual ~Integer() override = default;
+    };
+
+    struct Float : Field {
+        template <class T> inline Float(T _name, double val) :
+            Field(_name, SQLITE_FLOAT), value(val) {}
+        double value;
+        virtual ~Float() override = default;
+    };
+
+    struct Text : Field {
+        template <class T> inline Text(T _name, size_t len, const char* val) :
+            Field(_name, SQLITE_TEXT), value(val, len) {}
+        std::string value;
+        virtual ~Text() override = default;
+    };
+
+    struct Blob : Field {
+        template <class T> inline Blob(T _name, size_t len, const void* val) :
+                Field(_name, SQLITE_BLOB), length(len) {
+            value = new char[len];
+            assert(value != nullptr);
+            memcpy(value, val, len);
+        }
+        inline virtual ~Blob() override {
+            delete[] value;
+        }
+        int length;
+        char* value;
+    };
+
+    typedef Field Null;
+}
+
+typedef std::vector<std::unique_ptr<Values::Field> > Row;
+typedef std::vector<std::unique_ptr<Row> > Rows;
+typedef Row Parameters;
+
+
+
+class Statement : public Napi::ObjectWrap<Statement> {
+public:
+    static Napi::Object Init(Napi::Env env, Napi::Object exports);
+    static Napi::Value New(const Napi::CallbackInfo& info);
+
+    struct Baton {
+        napi_async_work request = NULL;
+        Statement* stmt;
+        Napi::FunctionReference callback;
+        Parameters parameters;
+
+        Baton(Statement* stmt_, Napi::Function cb_) : stmt(stmt_) {
+            stmt->Ref();
+            callback.Reset(cb_, 1);
+        }
+        virtual ~Baton() {
+            parameters.clear();
+            if (request) napi_delete_async_work(stmt->Env(), request);
+            stmt->Unref();
+            callback.Reset();
+        }
+    };
+
+    struct RowBaton : Baton {
+        RowBaton(Statement* stmt_, Napi::Function cb_) :
+            Baton(stmt_, cb_) {}
+        Row row;
+        virtual ~RowBaton() override = default;
+    };
+
+    struct RunBaton : Baton {
+        RunBaton(Statement* stmt_, Napi::Function cb_) :
+            Baton(stmt_, cb_), 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_) {}
+        Rows rows;
+        virtual ~RowsBaton() override = default;
+    };
+
+    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();
+        }
+    };
+
+    struct PrepareBaton : Database::Baton {
+        Statement* stmt;
+        std::string sql;
+        PrepareBaton(Database* db_, Napi::Function cb_, Statement* stmt_) :
+            Baton(db_, cb_), stmt(stmt_) {
+            stmt->Ref();
+        }
+        virtual ~PrepareBaton() override {
+            stmt->Unref();
+            if (!db->IsOpen() && db->IsLocked()) {
+                // The database handle was closed before the statement could be
+                // prepared.
+                stmt->Finalize_();
+            }
+        }
+    };
+
+    typedef void (*Work_Callback)(Baton* baton);
+
+    struct Call {
+        Call(Work_Callback cb_, Baton* baton_) : callback(cb_), baton(baton_) {};
+        Work_Callback callback;
+        Baton* baton;
+    };
+
+    struct Async {
+        uv_async_t watcher;
+        Statement* stmt;
+        Rows data;
+        NODE_SQLITE3_MUTEX_t;
+        bool completed;
+        int retrieved;
+
+        // Store the callbacks here because we don't have
+        // access to the baton in the async callback.
+        Napi::FunctionReference item_cb;
+        Napi::FunctionReference completed_cb;
+
+        Async(Statement* st, uv_async_cb async_cb) :
+                stmt(st), completed(false), retrieved(0) {
+            watcher.data = this;
+            NODE_SQLITE3_MUTEX_INIT
+            stmt->Ref();
+            uv_loop_t *loop;
+            napi_get_uv_event_loop(stmt->Env(), &loop);
+            uv_async_init(loop, &watcher, async_cb);
+        }
+
+        ~Async() {
+            stmt->Unref();
+            item_cb.Reset();
+            completed_cb.Reset();
+            NODE_SQLITE3_MUTEX_DESTROY
+        }
+    };
+
+    Statement(const Napi::CallbackInfo& info);
+
+    ~Statement() {
+        if (!finalized) Finalize_();
+    }
+
+    WORK_DEFINITION(Bind)
+    WORK_DEFINITION(Get)
+    WORK_DEFINITION(Run)
+    WORK_DEFINITION(All)
+    WORK_DEFINITION(Each)
+    WORK_DEFINITION(Reset)
+
+    Napi::Value Finalize_(const Napi::CallbackInfo& info);
+
+protected:
+    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);
+
+    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 Bind(const Parameters &parameters);
+
+    static void GetRow(Row* row, sqlite3_stmt* stmt);
+    static Napi::Value RowToJS(Napi::Env env, Row* row);
+    void Schedule(Work_Callback callback, Baton* baton);
+    void Process();
+    void CleanQueue();
+    template <class T> static void Error(T* baton);
+
+protected:
+    Database* db;
+
+    sqlite3_stmt* _handle = NULL;
+    int status = SQLITE_OK;
+    bool prepared = false;
+    bool locked = true;
+    bool finalized = false;
+
+    std::queue<Call*> queue;
+    std::string message;
+};
+
+}
+
+#endif

server/node_modules/sqlite3/src/threading.h

@@ -0,0 +1,10 @@
+#ifndef NODE_SQLITE3_SRC_THREADING_H
+#define NODE_SQLITE3_SRC_THREADING_H
+
+#define NODE_SQLITE3_MUTEX_t uv_mutex_t mutex;
+#define NODE_SQLITE3_MUTEX_INIT uv_mutex_init(&mutex);
+#define NODE_SQLITE3_MUTEX_LOCK(m) uv_mutex_lock(m);
+#define NODE_SQLITE3_MUTEX_UNLOCK(m) uv_mutex_unlock(m);
+#define NODE_SQLITE3_MUTEX_DESTROY uv_mutex_destroy(&mutex);
+
+#endif // NODE_SQLITE3_SRC_THREADING_H