JavaScripting

The definitive source of the best
JavaScript libraries, frameworks, and plugins.


  • ×

    An extendable JSON database for Node and the browser powered by lodash
    Filed under 

    • 🔾83%Overall
    • 16,197
    • 14.1 days
    • 🕩767
    • 👥16

    lowdb Node.js CI

    Tiny local JSON database for small projects 🦉

    // This is pure JS, not specific to lowdb ;)
    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

    Limited to Open Source projects and Sponsors

    To help with OSS funding, lowdb v2 is released under Parity license for a limited time. It'll be released under MIT license once the goal of 100 sponsors is reached (currently at 61/100) or in five months.

    Meanwhile, lowdb v2 can be freely used in Open Source projects. Sponsors can use it in any type of project.

    If you've installed this new version without knowing about the license change, you're excused for 30 days. There's also a 30 days trial. See license files for more details.

    Thank you for your support!

    Note: if you're already sponsoring husky, you can use lowdb v2 today :)

    Features

    • Lightweight
    • Minimalist and easy to learn API
    • Query and modify data using plain JS
    • Improved TypeScript support
    • 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 2 is a pure ESM package. If you're having trouble importing it in your project, please read this.

    import { join, dirname } from 'path'
    import { Low, JSONFile } from 'lowdb'
    import { fileURLToPath } from 'url'
    
    const __dirname = dirname(fileURLToPath(import.meta.url));
    
    // Use JSON file for storage
    const file = join(__dirname, 'db.json')
    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 file.json doesn't exist, db.data will be null
    // Set default data
    db.data ||= { posts: [] }
    // db.data = db.data || { posts: [] } // for node < v15.x
    
    // Create and query items using plain JS
    db.data.posts.push('hello world')
    db.data.posts[0]
    
    // You can also use this syntax if you prefer
    const { posts } = db.data
    posts.push('hello world')
    
    // Write db.data content to db.json
    await db.write()
    
    // db.json
    {
      "posts": [ "hello world" ]
    }
    

    TypeScript

    Lowdb now comes with TypeScript support. You can even type db.data content.

    type Data = {
      posts: string[] // Expect posts to be an array of strings
    }
    const adapter = new JSONFile<Data>('db.json')
    const db = new Low<Data>(adapter)
    
    db.data
      .posts
      .push(1) // TypeScript error 🎉
    

    Lodash

    You can easily add lodash or other utility libraries to improve lowdb.

    import lodash from 'lodash'
    
    // ...
    // Note: db.data needs to be initialized before lodash.chain is called.
    db.chain = lodash.chain(db.data)
    
    // Instead of db.data, you can now use db.chain if you want to use the powerful API that lodash provides
    const post = db.chain
      .get('posts')
      .find({ id: 1 })
      .value() // Important: value() needs to be called to execute chain
    

    More examples

    For CLI, server and browser usage, see examples/ directory.

    API

    Classes

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

    new Low(adapter)

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

    new LowSync(adapterSync)

    import { LowSync, JSONFileSync } from 'lowdb'
    
    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 {}
    

    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.

    new Low(new JSONFile(filename))
    new LowSync(new JSONFileSync(filename))
    

    Memory MemorySync

    In-memory adapters. Useful for speeding up unit tests.

    new Low(new Memory())
    new LowSync(new MemorySync())
    

    LocalStorage

    Synchronous adapter for window.localStorage.

    new LowSync(new LocalStorage(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 or TextFileSync.

    For example:

    import { Adapter, Low, TextFile } from 'lowdb'
    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 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, MongoDB, ...

    License

    License Zero Parity 7.0.0 and MIT (contributions) with exception License Zero Patron 1.0.0.

    Show All