lowdb

Simple to use type-safe local JSON database 🦉

If you know JavaScript, you know how to use lowdb.

Read or create db.json

 const  db  =  await  JSONFilePreset ( 'db.json' ,  {  posts : [ ]  } )

Use plain JavaScript to change data

 const  post  =  {  id : one ,  title : 'lowdb is awesome' ,  views : one hundred  }

 // In two steps
 db . data . posts . push ( post )
 await  db . write ( )

 // Or in one
 await  db . update ( ( { posts } )  =>  posts . push ( post ) )

 // db.json
 {
   "posts" : [
     {  "id" : one ,  "title" : "lowdb is awesome" ,  "views" : one hundred  }
   ]
 }

In the same spirit, query using native Array functions:

 const  { posts }  =  db . data

 posts . at ( zero )  // First post
 posts . filter ( ( post )  =>  post . title . includes ( 'lowdb' ) )  // Filter by title
 posts . find ( ( post )  =>  post . id  ===  one )  // Find by id
 posts . toSorted ( ( a ,  b )  =>  a . views  -  b . views )  // Sort by views

It's that simple. db.data is just a JavaScript object, no magic.

Features

Lightweight
Minimalist
TypeScript
Plain JavaScript
Safe atomic writes
Hackable:
- Change storage, file format (JSON, YAML, ...) or add encryption via adapters
- Extend it with lodash, ramda, ... for super powers!
Automatically switches to fast in-memory mode during tests

Install

 npm install lowdb

Usage

Lowdb is a pure ESM package. If you're having trouble using it in your project, please read this .

 import  {  JSONFilePreset  }  from  'lowdb/node'

 // Read or create db.json
 const  defaultData  =  {  posts : [ ]  }
 const  db  =  await  JSONFilePreset ( 'db.json' ,  defaultData )

 // Update db.json
 await  db . update ( ( { posts } )  =>  posts . push ( 'hello world' ) )

 // Alternatively you can call db.write() explicitely later
 // to write to db.json
 db . data . posts . push ( 'hello world' )
 await  db . write ( )

 // db.json
 {
   "posts" : [  "hello world"  ]
 }

TypeScript

You can use TypeScript to check your data types.

 type  Data  =  {
   messages : string [ ]
 }

 const  defaultData : Data  =  {  messages : [ ]  }
 const  db  =  await  JSONPreset < Data > ( 'db.json' ,  defaultData )

 db . data . messages . push ( 'foo' )  //  ✅ Success
 db . data . messages . push ( one )  //  ❌ TypeScript error

Lodash

You can extend lowdb with Lodash (or other libraries). To be able to extend it, we're not using JSONPreset here. Instead, we're using lower components.

 import  {  Low  }  from  'lowdb'
 import  {  JSONFile  }  from  'lowdb/node'
 import  lodash  from  'lodash'

 type  Post  =  {
   id : number
   title : string
 }

 type  Data  =  {
   posts : Post [ ]
 }

 // Extend Low class with a new `chain` field
 class  LowWithLodash < T >  extends  Low < T >  {
   chain : lodash . ExpChain < this [ 'data' ] >  =  lodash . chain ( this ) . get ( 'data' )
 }

 const  defaultData : Data  =  {
   posts : [ ] ,
 }
 const  adapter  =  new  JSONFile < Data > ( 'db.json' ,  defaultData )

 const  db  =  new  LowWithLodash ( adapter )
 await  db . read ( )

 // Instead of db.data use db.chain to access lodash API
 const  post  =  db . chain . get ( 'posts' ) . find ( {  id : one  } ) . value ( )  // Important: value() must be called to execute chain

CLI, Server, Browser and in tests usage

See src/examples/ directory.

API

Presets

Lowdb provides four presets for common cases.

JSONFilePreset(filename, defaultData)
JSONFileSyncPreset(filename, defaultData)
LocalStoragePreset(name, defaultData)
SessionStoragePreset(name, defaultData)

See src/examples/ directory for usage.

Lowdb is extremely flexible, if you need to extend it or modify its behavior, use the classes and adapters below instead of the presets.

Classes

Lowdb has two classes (for asynchronous and synchronous adapters).

`new Low(adapter, defaultData)`

 import  {  Low  }  from  'lowdb'
 import  {  JSONFile  }  from  'lowdb/node'

 const  db  =  new  Low ( new  JSONFile ( 'file.json' ) ,  { } )
 await  db . read ( )
 await  db . write ( )

`new LowSync(adapterSync, defaultData)`

 import  {  LowSync  }  from  'lowdb'
 import  {  JSONFileSync  }  from  'lowdb/node'

 const  db  =  new  LowSync ( new  JSONFileSync ( 'file.json' ) ,  { } )
 db . read ( )
 db . write ( )

Methods

`db.read()`

Calls adapter.read() and sets db.data .

Note: JSONFile and JSONFileSync adapters will set db.data to null if file doesn't exist.

 db . data  // === null
 db . read ( )
 db . data  // !==  null

`db.write()`

Calls adapter.write(db.data) .

 db . data  =  {  posts : [ ]  }
 db . write ( )  // file.json will be { posts: [] }
 db . data  =  { }
 db . write ( )  // file.json will be {}

`db.update(fn)`

Calls fn() then db.write() .

 db . update ( ( data )  =>  {
   // make changes to data
   // ...
 } )
 // files.json will be updated

Properties

`db.data`

Holds your db content. If you're using the adapters coming with lowdb, it can be any type supported by JSON.stringify .

For example:

 db . data  =  'string'
 db . data  =  [ one ,  two ,  three ]
 db . data  =  {  key : 'value'  }

Adapters

Lowdb adapters

`JSONFile` `JSONFileSync`

Adapters for reading and writing JSON files.

 import  {  JSONFile ,  JSONFileSync  }  from  'lowdb/node'

 new  Low ( new  JSONFile ( filename ) ,  { } )
 new  LowSync ( new  JSONFileSync ( filename ) ,  { } )

`Memory` `MemorySync`

In-memory adapters. Useful for speeding up unit tests. See src/examples/ directory.

 import  {  Memory ,  MemorySync  }  from  'lowdb'

 new  Low ( new  Memory ( ) ,  { } )
 new  LowSync ( new  MemorySync ( ) ,  { } )

`LocalStorage` `SessionStorage`

Synchronous adapter for window.localStorage and window.sessionStorage .

 import  {  LocalStorage ,  SessionStorage  }  from  'lowdb/browser'
 new  LowSync ( new  LocalStorage ( name ) ,  { } )
 new  LowSync ( new  SessionStorage ( name ) ,  { } )

Utility adapters

`TextFile` `TextFileSync`

Adapters for reading and writing text. Useful for creating custom adapters.

`DataFile` `DataFileSync`

Adapters for easily supporting other data formats or adding behaviors (encrypt, compress...).

 import  {  DataFile  }  from  'lowdb/node'
 new  DataFile ( filename ,  {
   parse : YAML . parse ,
   stringify : YAML . stringify
 } )
 new  DataFile ( filename ,  {
   parse : ( data )  =>  {  decypt ( JSON . parse ( data ) )  } ,
   stringify : ( str )  =>  {  encrypt ( JSON . stringify ( str ) )  }
 } )

Third-party adapters

If you've published an adapter for lowdb, feel free to create a PR to add it here.

Writing your own adapter

You may want to create an adapter to write db.data to YAML, XML, encrypt data, a remote storage, ...

An adapter is a simple class that just needs to expose two methods:

 class  AsyncAdapter  {
   read ( )  {
     /* ... */
   }  // should return Promise<data>
   write ( data )  {
     /* ... */
   }  // should return Promise<void>
 }

 class  SyncAdapter  {
   read ( )  {
     /* ... */
   }  // should return data
   write ( data )  {
     /* ... */
   }  // should return nothing
 }

For example, let's say you have some async storage and want to create an adapter for it:

 import  {  Low  }  from  'lowdb'
 import  {  api  }  from  './ AsyncStorage'

 class  CustomAsyncAdapter  {
   // Optional: your adapter can take arguments
   constructor ( args )  {
     // ...
   }

   async  read ( )  {
     const  data  =  await  api . read ( )
     return  data
   }

   async  write ( data )  {
     await  api . write ( data )
   }
 }

 const  adapter  =  new  CustomAsyncAdapter ( )
 const  db  =  new  Low ( adapter ,  { } )

See src/adapters/ for more examples.

Custom serialization

To create an adapter for another format than JSON, you can use TextFile or TextFileSync .

For example:

 import  {  Adapter ,  Low  }  from  'lowdb'
 import  {  TextFile  }  from  'lowdb/node'
 import  YAML  from  'yaml'

 class  YAMLFile  {
   constructor ( filename )  {
     this . adapter  =  new  TextFile ( filename )
   }

   async  read ( )  {
     const  data  =  await  this . adapter . read ( )
     if  ( data  ===  null )  {
       return  null
     }  else  {
       return  YAML . parse ( data )
     }
   }

   write ( obj )  {
     return  this . adapter . write ( YAML . stringify ( obj ) )
   }
 }

 const  adapter  =  new  YAMLFile ( 'file.yaml' )
 const  db  =  new  Low ( adapter ,  { } )

Limits

Lowdb doesn't support Node's cluster module.

If you have large JavaScript objects ( ~10-100MB ) you may hit some performance issues. This is because whenever you call db.write , the whole db.data is serialized using JSON.stringify and written to storage.

Depending on your use case, this can be fine or not. It can be mitigated by doing batch operations and calling db.write only when you need it.

If you plan to scale, it's highly recommended to use databases like PostgreSQL or MongoDB instead.

Name		Name	Last commit message	Last commit date
Latest commit History 545 Commits
.github		.github
.husky		.husky
src		src
.commitlintrc.json		.commitlintrc.json
.eslintrc.json		.eslintrc.json
.gitattributes		.gitattributes
.gitignore		.gitignore
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
package-lock.json		package-lock.json
package.json		package.json
tsconfig.json		tsconfig.json

License

typicode/lowdb

Folders and files

Latest commit

History

Repository files navigation

lowdb

Sponsors

Features

Install

Usage

TypeScript

Lodash

CLI, Server, Browser and in tests usage

API

Presets

Classes

new Low(adapter, defaultData)

new LowSync(adapterSync, defaultData)

Methods

db.read()

db.write()

db.update(fn)

Properties

db.data

Adapters

Lowdb adapters

JSONFile JSONFileSync

Memory MemorySync

LocalStorage SessionStorage

Utility adapters

TextFile TextFileSync

DataFile DataFileSync

Third-party adapters

Writing your own adapter

Custom serialization

Limits

About

Topics

Resources