- ×
An extendable JSON database for Node and the browser powered by lodash
Filed under dataShow Alllowdb
Simple to use local JSON database. Use native JavaScript API to query. Written in TypeScript. 🦉
// Edit db.json content using native JS API db.data .posts .push({ id: 1, title: 'lowdb is awesome' }) // Save to file db.write()
// db.json { "posts": [ { "id": 1, "title": "lowdb is awesome" } ] }
If you like lowdb, see also xv (test runner) and steno (fast file writer).
Sponsors
Become a sponsor and have your company logo here.
Please help me build OSS 👉 GitHub Sponsors
Features
- Lightweight
- Minimalist
- TypeScript
- plain JS
- Atomic write
- Hackable:
- Change storage, file format (JSON, YAML, ...) or add encryption via adapters
- Add lodash, ramda, ... for super powers!
Install
npm install lowdb
Usage
Lowdb is a pure ESM package. If you're having trouble using it in your project, please read this.
Next.js: there's a known issue. Until it's fixed, please use this workaround or lowdb
^4.0.0
.// Remember to set type: module in package.json or use .mjs extension import { join, dirname } from 'node:path' import { fileURLToPath } from 'node:url' import { Low } from 'lowdb' import { JSONFile } from 'lowdb/node' // File path const __dirname = dirname(fileURLToPath(import.meta.url)); const file = join(__dirname, 'db.json') // Configure lowdb to write to JSONFile const adapter = new JSONFile(file) const db = new Low(adapter) // Read data from JSON file, this will set db.data content await db.read() // If db.json doesn't exist, db.data will be null // Use the code below to set default data // db.data = db.data || { posts: [] } // For Node < v15.x db.data ||= { posts: [] } // For Node >= 15.x // Create and query items using native JS API db.data.posts.push('hello world') const firstPost = db.data.posts[0] // Alternatively, you can also use this syntax if you prefer const { posts } = db.data posts.push('hello world') // Finally write db.data content to file await db.write()
// db.json { "posts": [ "hello world" ] }
TypeScript
You can use TypeScript to check your data types.
type Data = { words: string[] } const adapter = new JSONFile<Data>('db.json') const db = new Low(adapter) db.data .words .push('foo') // ✅ Success db.data .words .push(1) // ❌ TypeScript error
Lodash
You can also add lodash or other utility libraries to improve lowdb.
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 adapter = new JSONFile<Data>('db.json') 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: 1 }) .value() // Important: value() must be called to execute chain
CLI, Server and Browser usage
See
examples/
directory.API
Classes
Lowdb has two classes (for asynchronous and synchronous adapters).
new Low(adapter)
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)
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 setsdb.data
.Note:
JSONFile
andJSONFileSync
adapters will setdb.data
tonull
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 {}
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 = [1, 2, 3] 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
examples/
directory.import { Memory, MemorySync } from 'lowdb' new Low(new Memory()) new LowSync(new MemorySync())
LocalStorage
SessionStorage
Synchronous adapter for
window.localStorage
andwindow.sessionStorage
.import { LocalStorage, SessionStorage } from 'lowdb/browser' new LowSync(new LocalStorage(name)) new LowSync(new SessionStorage(name))
TextFile
TextFileSync
Adapters for reading and writing text. Useful for creating custom adapters.
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 { 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
orTextFileSync
.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 calldb.write
, the wholedb.data
is serialized usingJSON.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.