• Stars
    star
    21,308
  • Rank 1,148 (Top 0.03 %)
  • Language
    JavaScript
  • License
    MIT License
  • Created over 10 years ago
  • Updated 6 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Simple and fast JSON database

lowdb Node.js CI

Simple to use local JSON database. Use native JavaScript API to query. Written in TypeScript. ๐Ÿฆ‰

// Edit db.json content using plain JavaScript
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, please sponsor.

Sponsors





Become a sponsor and have your company logo here ๐Ÿ‘‰ GitHub Sponsors

Features

  • Lightweight
  • Minimalist
  • TypeScript
  • plain JavaScript
  • Safe atomic writes
  • 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.

// 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'

// db.json file path
const __dirname = dirname(fileURLToPath(import.meta.url))
const file = join(__dirname, 'db.json')

// Configure lowdb to write data to JSON file
const adapter = new JSONFile(file)
const defaultData = { posts: [] }
const db = new Low(adapter, defaultData)

// Read data from JSON file, this will set db.data content
// If JSON file doesn't exist, defaultData is used instead
await db.read()

// Create and query items using plain JavaScript
db.data.posts.push('hello world')
const firstPost = db.data.posts[0]

// If you don't want to type db.data everytime, you can use destructuring assignment
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 = {
  messages: string[]
}

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

db.data.messages.push('foo') // โœ… Success
db.data.messages.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 defaultData: Data = {
  posts: [],
}
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, Browser and in tests usage

See src/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 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.

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), {})

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 } 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.

More Repositories

1

json-server

Get a full fake REST API with zero coding in less than 30 seconds (seriously)
JavaScript
72,441
star
2

husky

Git hooks made easy ๐Ÿถ woof!
JavaScript
32,250
star
3

hotel

๐Ÿฉ A simple process manager for developers. Start apps from your browser and access them using local domains
JavaScript
9,975
star
4

jsonplaceholder

A simple online fake REST API server
HTML
5,017
star
5

tlapse

๐Ÿ“ท Create a timelapse of your web development... or just automatically take screenshots of your hard work ;)
JavaScript
2,024
star
6

xv

๐Ÿ™…โ€โ™€๏ธ โœŒ๏ธ fastest test runner
JavaScript
832
star
7

mistcss

๐Ÿ’ง Write atomic components using only CSS! (JS-from-CSSโ„ข)
JavaScript
788
star
8

pegasus

Load JSON while still loading other scripts
JavaScript
703
star
9

katon

(use hotel instead)
JavaScript
684
star
10

steno

Super fast async file writer with atomic write โšก
JavaScript
678
star
11

react-fake-props

๐Ÿ”ฎ Magically generate fake props for your React tests
JavaScript
627
star
12

fetchival

Easy window.fetch requests
JavaScript
520
star
13

lodash-id

Makes it easy to manipulate id-based resources with lodash or lowdb
JavaScript
472
star
14

react-lodash

โš›๏ธ ๐Ÿ”ง Lodash as React components
JavaScript
356
star
15

stop-server

๐Ÿ“ฑ Shut down your computer with your phone
JavaScript
349
star
16

demo

Aย demo repository for My JSON Server (Alpha)
334
star
17

pinst

๐Ÿบ dev only postinstall hooks (package.json)
JavaScript
258
star
18

please-upgrade-node

๐Ÿ’ Show a message to your users to upgrade Node instead of a stacktrace
JavaScript
239
star
19

jsop

JSON file reader/writer (powered by Object.observe)
JavaScript
207
star
20

husky-4-to-8

Quickly migrate your hooks from husky v4 to husky@latest
JavaScript
131
star
21

user-startup

Auto start commands when you log in (cross-platform)
JavaScript
125
star
22

cult

cult monitors gulpfile changes and reloads gulp
JavaScript
119
star
23

bg.nvim

Automatically sync your terminal background with your colorscheme ๐ŸŽ†
Lua
97
star
24

logan

Mini template system for the console and colors
JavaScript
81
star
25

minihost

Easily start and access servers
JavaScript
46
star
26

ghwn

Get desktop notifications for new issues, comments, stars... (no installation required)
HTML
42
star
27

shoutjs

Make your ShellJS commands explicit and get a beautiful output
JavaScript
30
star
28

homerun

Turn npm package scripts into CLI commands
JavaScript
23
star
29

server-ready

Know when a server is ready to receive requests
JavaScript
20
star
30

husky-init

JavaScript
20
star
31

backbone-pegasus

Load models and collections data while loading Backbone
JavaScript
20
star
32

server-ready-cli

Run commands only when a server is available
JavaScript
19
star
33

eslint-config

JavaScript
8
star
34

typicode.github.io

HTML
8
star