Open-Source Databases · kriasoft

node-sqlite

node-sqlite is a TypeScript wrapper around sqlite3 that adds Promise-based async/await support and SQL migration management to Node.js SQLite applications. It requires sqlite3 as a peer dependency and eliminates callback-based code in favor of modern async patterns.

Talk to DEV.co Discuss Implementation

Source: GitHub — github.com/kriasoft/node-sqlite

932

GitHub stars

Forks

TypeScript

Primary language

MIT

License (OSI-approved)

Key facts

Objective fields from the source. Values we can't verify are shown as “Unknown” rather than guessed.

Field	Value
Repository	kriasoft/node-sqlite
Owner	kriasoft
Primary language	TypeScript
License	MIT — OSI-approved
Stars	932
Forks	92
Open issues	7
Latest release	v4.0.1 (2020-04-04)
Last updated	2025-04-28
Source	https://github.com/kriasoft/node-sqlite

What node-sqlite is

A zero-dependency wrapper exposing sqlite3 operations (exec, run, get, all, prepare) as Promises with TypeScript support and a file-based SQL migration API. Supports prepared statements, custom drivers conforming to sqlite3 API, and optional database caching via sqlite3.cached.

Quickstart

Get the node-sqlite source

Clone the repository and explore it locally.

terminalbash

1git clone https://github.com/kriasoft/node-sqlite.git2cd node-sqlite3# follow the project's README for install & configuration

Need it deployed, integrated, or customized instead? DEV.co ships production installs.

Best use cases

Rapid prototyping and hobby projects

Low setup overhead, zero wrapper dependencies, in-memory or file-based databases, and built-in migrations make this ideal for MVPs, CLIs, and small Node.js applications.

Embedded databases in Node.js desktop/CLI apps

Lightweight local persistence without network overhead; suitable for Electron apps, server-side rendering with local state, or command-line tools needing structured data.

Migration-driven schema management

SQL-based migration API simplifies version-controlled schema evolution; good fit for teams preferring SQL migrations over ORM schema builders.

Implementation considerations

Requires sqlite3 npm package as a peer dependency; ensure compatible version installed before node-sqlite.
Promise-based API replaces callbacks; v4 has breaking changes from v3—review CHANGELOG before upgrading in existing projects.
TypeScript typings available via generics for row type safety; projects should define interfaces for database schemas.
File path and mode configuration critical; plan for dev (:memory:), test, and production database locations.
Prepared statements and parameterized queries mandatory to prevent SQL injection; library supports ?, :name, and @name binding styles.

When to avoid it — and what to weigh

Multi-user, high-concurrency production databases — SQLite handles limited concurrent writes; unsuitable for high-traffic multi-tenant applications. PostgreSQL, MySQL, or managed cloud databases are better choices.
Distributed systems or horizontally scaled deployments — SQLite is file-based and cannot be easily shared across multiple servers. Breaks down in microservices, serverless, or load-balanced environments.
Complex relationship queries and advanced SQL features — While SQLite supports SQL, it lacks some advanced features (window functions, CTEs, JSON operators in older versions). Large analytical workloads belong on PostgreSQL.
Team requiring ORM abstractions and schema introspection — This library is a thin async wrapper, not an ORM. No query builder, validation layer, or schema introspection. Teams needing those should use Prisma, TypeORM, or Sequelize.

License & commercial use

MIT License. Permissive OSI-approved license allowing commercial use, modification, and distribution with attribution and no warranty.

MIT license permits commercial use. Verify sqlite3 peer dependency licensing (also MIT-compatible) in your production environment. No license restrictions on library itself, but confirm compliance with any additional dependencies in your stack.

DEV.co evaluation signals

Editorial assessment — not user reviews. Directional, with an explicit confidence level.

Signal	Assessment
Maintenance	Moderate
Documentation	Adequate
License clarity	Clear
Deployment complexity	Low
DEV.co fit	Good
Assessment confidence	High

Security considerations

Library itself supports parameterized queries (?, :name, @name bindings), which prevent SQL injection when used correctly. No security audit data provided. Dependency chain (sqlite3 native module) should be reviewed for known CVEs. File permissions on SQLite database file should be restricted to prevent unauthorized access. Trace events expose SQL queries—secure logging needed in debug mode.

Alternatives to consider

Prisma

Full-featured ORM with schema introspection, migrations, type safety, and multi-database support. Heavier but covers more use cases; requires setup and learning curve.

TypeORM

Decorator-based ORM with TypeScript-first design, query builder, and support for SQLite and PostgreSQL. More control than Prisma; steeper setup for simple projects.

better-sqlite3

Synchronous SQLite driver optimized for speed; avoids async overhead but requires callback refactoring. Use if Promise abstraction is not needed and performance is critical.

Software development agency

Build on node-sqlite with DEV.co software developers

Our engineers can architect and implement database layers tailored to your scale and complexity—from embedded SQLite to distributed SQL systems. Let's discuss your data strategy.

Talk to DEV.co

Related open-source tools

Surfaced by semantic similarity across the DEV.co open-source index.

better-sqlite3 sequelize atdatabases

Related on DEV.co

Explore the category and the services that help you build with it.

Open-Source Databases Application Development API Development Talk to DEV.co

node-sqlite FAQ

Do I need sqlite3 installed separately?

Yes. node-sqlite is a wrapper; sqlite3 must be installed as a peer dependency. Install via npm: npm install sqlite3 --save

Is this suitable for production applications?

Depends on scale. Single-machine, low-to-moderate concurrency workloads (e.g., desktop apps, small backends) are fine. High-traffic multi-server deployments require PostgreSQL or similar.

How do I run migrations?

Call db.migrate({migrationsPath: '...'}) with a folder containing numbered .sql files. Library executes them sequentially, tracking state in a _migrations table.

Can I use this with TypeScript?

Yes. Library is written in TypeScript with built-in type definitions. Use generics on get()/all() to type row results: db.get<User>('SELECT * FROM users')

Custom software development services

Adopting node-sqlite is usually one piece of a larger software development effort. As a software development agency, DEV.co provides software development services and web development expertise — pairing senior software developers and web developers with your team to design, build, and operate open-source databases software in production.

Need Help Integrating SQLite Into Your Node.js App?

Our engineers can architect and implement database layers tailored to your scale and complexity—from embedded SQLite to distributed SQL systems. Let's discuss your data strategy.

Talk to DEV.co Schedule a Consultation