TypeScript icon, indicating that this package has built-in type declarations

1.0.5 • Public • Published

npm version Build Workflow Coverage Status DeepScan grade

PRs Welcome License

HomeOfThings - Sqlite3 for NestJs

This module allows you to map your model, written in JavaScript or TypeScript, to a database schema using SQLite Version 3. nestjs-sqlite3 offers connection pool, automatic upgrades and online backups as well as typesafe database queries and refactoring, using a filter syntax designed to serialize safely without any SQL injection possibility

NOTE: Your contribution is highly welcome! Feel free to pick-up a TODO-item or add yours.

This module is based on sqlite3orm

supporting SQLCipher


npm install @homeofthings/nestjs-sqlite3

quick start

import module in AppModule by providing connection options synchronously

  imports: [
    Sqlite3Module.register(Sqlite3Module, {file: SQL_MEMORY_DB_SHARED}),
export class AppModule {}

import module in AppModule by providing connection options asynchronously

  imports: [
    Sqlite3Module.registerAsync(Sqlite3Module, {
      imports: [], // optional
      useFactory: (): Promise<Sqlite3ModuleOptions> => Promise.resolve({
        // provide your options
      inject: [], // optional inject params for useFactory method
export class AppModule {}

inject connection manager

export class MyService {
  constructor(connectionManager: ConnectionManager) {}

get connection

  const connection = await this.connectionManager.getConnection(connectionName);

This is using asynchronous context tracking to get the same database connection from the pool throughout the lifetime of a web request or any other asynchronous duration You can create a new context by calling ConnectionManager.createConnectionContext() and close it by calling ConnectionManager.closeConnectionContext(). For web requests this is automatically accomblished by the provided Sqlite3Interceptor.

If you need a connection which works independend from the asynchronous connection context (e.g for backup, schema creation/upgrade, ...), you can get it from the pool:

  const connection = await this.connectionManager.getConnectionPool(connectionName).get();

NOTE: all repositories as well as the entity-manager require an asynchronous connection context to be created

inject connection pool

export class MyService {
  constructor(@InjectConnectionPool() sqlConnectionPool: SqlConnectionPool) {}

optional you can provide connectionName as argument for @InjectConnectionPool


please see (https://github.com/gms1/node-sqlite3-orm#mapping-intruduction)

inject entity manager

export class MyService {
  constructor(@InjectEntityManager() entityManager: EntityManager) {}

optional you can provide connectionName as argument for @InjectEntityManager

inject standard repository

register repository by providing entity class to the Sqlite3Module.forFeature method

  imports: [
export class AppModule {}

thereafter you can inject the standard repository using:

export class MyService {
  constructor(@InjectRepository(User) repository: Repository<User>) {}

optional you can provide connectionName as second argument for Sqlite3Module.forFeature

inject custom repository

define a custom repository:

export class UserRepository extends Repository<User> {
  constructor(connectionManager: ConnectionManager, connectionName: string) {
    super(User, connectionManager, connectionName);

register the custom Repository using the Sqlite3Module.forFeature method:

  imports: [
export class AppModule {}

inject the custom repository using InjectCustomRepository decorator

export class MyService {
  constructor(@InjectCustomRepository(UserRepository) repository: UserRepository) {}

define entities

for convenience, similar decorators are supported as by typeorm

@Entity({ name: 'USERS', autoIncrement: true })
class User {
  @PrimaryKeyColumn({ name: 'user_id', dbtype: 'INTEGER NOT NULL' })
  public id?: number;

  @Column({ name: 'user_email', dbtype: 'TEXT NOT NULL' })
  @Index('idx_users_email', true)
  public email: string;

  @Column({ name: 'user_firstname', dbtype: 'TEXT NOT NULL' })
  public firstName: string;

  @Column({ name: 'user_lastname', dbtype: 'TEXT NOT NULL' })
  public lastName: string;

  public password: string;

relations can be defined by using the ForeignKey decorator

type safe query syntax

please see (https://github.com/gms1/node-sqlite3-orm#typesafe-query-syntax)

create schema manually

please see (https://github.com/gms1/node-sqlite3-orm#schema-creation)

ceeate/upgrade schema automatically

  const connection = await this.connectionManager.getConnection(connectionName);
  const autoUpgrader = new AutoUpgrader(connection);

  // run autoupgrade for all registered tables

  // run autoupgrade for all tables referenced by a connection:

NOTE: if you are using a single database, you can call upgradeAllTables, otherwise you will need to specify the tables for the specific database that you want to upgrade. All tables referenced by a forFeature call for a specific database can be retrieved by calling ConnectionManager.getTables

online backup

to run the backup in one step you can call:

  const connection = await this.connectionManager.getConnection(connectionName);
  const backup = await connection.backup('backup.db');
  await backup.step(-1);


sqlite3orm uses the debug module, so you can turn on the logging by setting the 'DEBUG' environment to "sqlite3orm:*"




npm i @homeofthings/nestjs-sqlite3

DownloadsWeekly Downloads






Unpacked Size

101 kB

Total Files


Last publish


  • gms1