SQLite Client for Node.js Apps

A wrapper library written in Typescript with ZERO dependencies that adds ES6 promises and SQL-based migrations API to sqlite3 (docs).

note v4 of sqlite has breaking changes compared to v3! Please see CHANGELOG.md for more details.

• Installation
  • Install sqlite3
  • Install sqlite
• Usage
  • Opening the database
    • Without caching
    • With caching
    • Enable verbose / debug mode
    • Tracing SQL errors
    • With a custom driver
    • Opening multiple databases
    • open config params
  • Examples
    • Creating a table and inserting data
    • Getting a single row
    • Getting many rows
    • Inserting rows
    • Updating rows
    • Prepared statement
    • each()
    • Get the driver instance
    • Closing the database
  • ES6 tagged template strings
  • Migrations
• Typescript tricks
  • Import interfaces from sqlite
  • Specify typings for a specific database driver
  • Use generics to get better typings on your rows
    • Get example
    • All example
• API Documentation
• Management Tools
• Alternative SQLite libraries
• References
• License

Installation

Install sqlite3

Most people who use this library will use sqlite3 as the database driver.

Any library that conforms to the sqlite3 (API) should also work.

$ npm install sqlite3 --save

Install sqlite

1# v4 of sqlite is targeted for nodejs 10 and on.
2$ npm install sqlite --save
3
4# If you need a legacy version for an older version of nodejs
5# install v3 instead, and look at the v3 branch readme for usage details
6$ npm install sqlite@3 --save

Usage

This module has the same API as the original sqlite3 library (docs), except that all its API methods return ES6 Promises and do not accept callback arguments (with the exception of each()).

Opening the database

Without caching

1import sqlite3 from 'sqlite3'
2import { open } from 'sqlite'
3
4// this is a top-level await 
5(async () => {
6    // open the database
7    const db = await open({
8      filename: '/tmp/database.db',
9      driver: sqlite3.Database
10    })
11})()

or

1import sqlite3 from 'sqlite3'
2import { open } from 'sqlite'
3
4open({
5  filename: '/tmp/database.db',
6  driver: sqlite3.Database
7}).then((db) => {
8  // do your thing
9})

or

1import sqlite3 from 'sqlite3'
2import { open } from 'sqlite'
3
4// you would have to import / invoke this in another file
5export async function openDb () {
6  return open({
7    filename: '/tmp/database.db',
8    driver: sqlite3.Database
9  })
10}

With caching

If you want to enable the database object cache

1import sqlite3 from 'sqlite3'
2import { open } from 'sqlite'
3
4(async () => {
5    const db = await open({
6      filename: '/tmp/database.db',
7      driver: sqlite3.cached.Database
8    })
9})()

Enable verbose / debug mode

1import sqlite3 from 'sqlite3'
2
3sqlite3.verbose()

Tracing SQL errors

For more info, see this doc.

1db.on('trace', (data) => {
2  
3})

With a custom driver

You can use an alternative library to sqlite3 as long as it conforms to the sqlite3 API.

For example, using sqlite3-offline-next:

1import sqlite3Offline from 'sqlite3-offline-next'
2import { open } from 'sqlite'
3
4(async () => {
5    const db = await open({
6      filename: '/tmp/database.db',
7      driver: sqlite3Offline.Database
8    })
9})()

Opening multiple databases

1import sqlite3 from 'sqlite3'
2import { open } from 'sqlite'
3
4(async () => {
5  const [db1, db2] = await Promise.all([
6    open({
7      filename: '/tmp/database.db',
8      driver: sqlite3.Database
9    }),
10    open({
11      filename: '/tmp/database2.db',
12      driver: sqlite3.Database
13    }),
14  ])
15
16  await db1.migrate({
17    migrationsPath: '...'
18  })
19
20  await db2.migrate({
21    migrationsPath: '...'
22  })
23})()

open config params

1
2// db is an instance of `sqlite#Database`
3// which is a wrapper around `sqlite3#Database`
4const db = await open({
5  /**
6   * Valid values are filenames, ":memory:" for an anonymous in-memory
7   * database and an empty string for an anonymous disk-based database.
8   * Anonymous databases are not persisted and when closing the database
9   * handle, their contents are lost.
10   */
11  filename: string
12
13  /**
14   * One or more of sqlite3.OPEN_READONLY, sqlite3.OPEN_READWRITE and
15   * sqlite3.OPEN_CREATE. The default value is OPEN_READWRITE | OPEN_CREATE.
16   */
17  mode?: number
18
19  /**
20   * The database driver. Most will install `sqlite3` and use the `Database` class from it.
21   * As long as the library you are using conforms to the `sqlite3` API, you can use it as
22   * the driver.
23   *
24   * @example
25   *
26   * ```
27   * import sqlite from 'sqlite3'
28   *
29   * const driver = sqlite.Database
30   * ```
31   */
32  driver: any
33})

Examples

• See the src/**/__tests__ directory for more example usages
• See the docs/ directory for full documentation.
• Also visit the sqlite3 library API docs

Creating a table and inserting data

1await db.exec('CREATE TABLE tbl (col TEXT)')
2await db.exec('INSERT INTO tbl VALUES ("test")')

Getting a single row

1const result = await db.get('SELECT col FROM tbl WHERE col = ?', 'test')
2
3// { col: 'test' }

1const result = await db.get('SELECT col FROM tbl WHERE col = ?', ['test'])
2
3// { col: 'test' }

1const result = await db.get('SELECT col FROM tbl WHERE col = :test', {
2  ':test': 'test'
3})
4
5// { col: 'test' }

Getting many rows

1const result = await db.all('SELECT col FROM tbl')
2
3// [{ col: 'test' }]

Inserting rows

1const result = await db.run(
2  'INSERT INTO tbl (col) VALUES (?)',
3  'foo'
4)
5
6/*
7{
8  // row ID of the inserted row
9  lastID: 1,
10  // instance of `sqlite#Statement`
11  // which is a wrapper around `sqlite3#Statement`
12  stmt: <Statement>
13}
14*/

1const result = await db.run('INSERT INTO tbl(col) VALUES (:col)', {
2  ':col': 'something'
3})

Updating rows

1const result = await db.run(
2  'UPDATE tbl SET col = ? WHERE col = ?',
3  'foo',
4  'test'
5)
6
7/*
8{
9  // number of rows changed
10  changes: 1,
11  // instance of `sqlite#Statement`
12  // which is a wrapper around `sqlite3#Statement`
13  stmt: <Statement>
14}
15*/

Prepared statement

1// stmt is an instance of `sqlite#Statement`
2// which is a wrapper around `sqlite3#Statement`
3const stmt = await db.prepare('SELECT col FROM tbl WHERE 1 = ? AND 5 = ?5')
4await stmt.bind({ 1: 1, 5: 5 })
5let result = await stmt.get()
6// { col: 'some text' }

1const stmt = await db.prepare(
2  'SELECT col FROM tbl WHERE 13 = @thirteen ORDER BY col DESC'
3)
4
5const result = await stmt.all({ '@thirteen': 13 })

each()

each() is a bit different compared to the other operations due to its underlying implementation.

The function signature looks like this:

async each (sql, [...params], callback)

• callback(err, row) is triggered when the database has a row to return
• The promise resolves when all rows have returned with the number of rows returned.

1try {
2  // You need to wrap this in a try / catch for SQL parse / connection errors
3  const rowsCount = await db.each(
4    'SELECT col FROM tbl WHERE ROWID = ?',
5    [2],
6    (err, row) => {
7      if (err) {
8        // This would be if there is an error specific to the row result
9        throw err
10      }
11
12      // row = { col: 'other thing' }
13    }
14  )
15} catch (e) {
16  throw e
17}
18
19// rowsCount = 1

Get the driver instance

Useful if you need to call methods that are not supported yet.

1const rawDb = db.getDatabaseInstance()
2const rawStatement = stmt.getStatementInstance()

Closing the database

1await db.close()

ES6 tagged template strings

This module is compatible with sql-template-strings.

1import SQL from 'sql-template-strings'
2
3const book = 'harry potter';
4const author = 'J. K. Rowling';
5
6const data = await db.all(SQL`SELECT author FROM books WHERE name = ${book} AND author = ${author}`);

Migrations

This module comes with a lightweight migrations API that works with SQL-based migration files

With default configuration, you can create a migrations/ directory in your project with SQL files, and call the migrate() method to run the SQL in the directory against the database.

See this project's migrations/ folder for examples.

1await db.migrate({    
2    /**
3    * If true, will force the migration API to rollback and re-apply the latest migration over
4    * again each time when Node.js app launches.
5    */
6    force?: boolean
7    /**
8    * Migrations table name. Default is 'migrations'
9    */
10    table?: string
11    /**
12    * Path to the migrations folder. Default is `path.join(process.cwd(), 'migrations')`
13    */
14    migrationsPath?: string
15})

Typescript tricks

Import interfaces from sqlite

import { ISqlite, IMigrate } from 'sqlite'

See the definitions for more details.

Specify typings for a specific database driver

1// Assuming you have @types/sqlite3 installed
2import sqlite3 from 'sqlite3'
3
4// sqlite3.Database, sqlite3.Statement is the default if no explicit generic is specified
5await open<sqlite3.Database, sqlite3.Statement>({
6  filename: ':memory'
7})

Use generics to get better typings on your rows

Most methods allow for the use of generics to specify the data type of your returned data. This allows your IDE to perform better autocomplete and the typescript compiler to perform better static type analysis.

Get example

1
2interface Row {
3  col: string
4}
5
6// result will be of type Row, allowing Typescript supported IDEs to autocomplete on the properties!
7const result = await db.get<Row>('SELECT col FROM tbl WHERE col = ?', 'test')

All example

1interface Row {
2  col: string
3}
4
5// Result is an array of rows, you can now have array-autocompletion data
6const result = await db.all<Row[]>('SELECT col FROM tbl')
7
8result.each((row) => {
9  // row should have type information now!
10})

API Documentation

See the docs directory for full documentation.

Management Tools

• Beekeeper Studio: Open Source SQL Editor and Database Manager
• DB Browser for SQLite: Desktop-based browser.
• datasette: Datasette is a tool for exploring and publishing data. Starts up a server that provides a web interface to your SQLite data.
• SQLite Studio: A free, open source, multi-platform SQLite database manager written in C++, with use of Qt framework.
• HeidiSQL: Full-featured database editor.
• DBeaver: Full-featured multi-platform database tool and designer.

Alternative SQLite libraries

This library and the library it primarily supports, sqlite3, may not be the best library that fits your use-case. You might want to try these other SQLite libraries:

• better-sqlite3: Totes itself as the fastest and simplest library for SQLite3 in Node.js.
• Bun sqlite3: bun:sqlite is a high-performance builtin SQLite3 module for bun.js.
• sql.js: SQLite compiled to Webassembly.
• sqlite3-offline-next: Offers pre-compiled sqlite3 binaries if your machine cannot compile it. Should be mostly compatible with this library.

If you know of any others, feel free to open a PR to add them to the list.

References

• Using SQLite with Node.js for Rapid Prototyping on Medium.com
• SQLite Documentation, e.g. SQL Syntax, Data Types etc. on SQLite.org
• ES6 tagged sql-template-strings.

License

The MIT License © 2020-present Kriasoft / Theo Gravity. All rights reserved.

---

Made with ♥ by Konstantin Tarkus (@koistya), Theo Gravity and contributors