stenodb

✍ Easy to use local JSON database.

Install

npm install stenodb

yarn add stenodb

pnpm add stenodb

Package	Version	Description
@stenodb/node		Node.js
@stenodb/browser		Browser (localStorage, sessionStorage)
@stenodb/nest		Nest.js module
@stenodb/fastify		Fastify plugin
@stenodb/lodash		Lodash wrapper for Node.js and Browser
@stenodb/logger		Logger

Examples

Note
You can find more detailed examples here

class-transformer entity

// entities.ts
import { Type } from 'class-transformer'

export class Users {
  @Type(() => User)
  users: User[]

  constructor(...users: User[]) {
    this.users = users
  }
}

export class User {
  username: string

  @Type(() => Post)
  posts: Post[]

  constructor(username: string, ...posts: Post[]) {
    this.username = username
    this.posts = posts
  }

  addPost(post: Post) {
    this.posts.push(post)
  }
}

export class Post {
  title: string

  constructor(text: string) {
    this.title = title
  }
}

@stenodb/node

import 'reflect-metadata'
import { dirname, resolve } from 'node:path'
import { fileURLToPath } from 'node:url'
import { AsyncAdapter, NodeProvider } from '@stenodb/node'
import { Users, User, Post } from './entities.js'

const path = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'db')
const initialData = new Users(new User('John Doe'))
const adapter = new AsyncAdapter('users', Users, initialData)
const provider = new NodeProvider({ path })
const db = await provider.create(adapter)

await db.read()
db.data?.users[0]?.addPost(new Post('Lorem ipsum'))
await db.write()

@stenodb/browser

import 'reflect-metadata'
import { LocalStorage, BrowserProvider } from '@stenodb/browser'
import { Users, User, Post } from './entities.js'

const initialData = new Users(new User('John Doe'))
const adapter = new LocalStorage('users', Users, initialData)
const provider = new BrowserProvider()
const db = provider.create(adapter)

db.read()
db.data?.users[0]?.addPost(new Post('Lorem ipsum'))
db.write()

@stenodb/nest

// users.dto.ts
import { Exclude, Type } from 'class-transformer'
import { Length, Max, Min } from 'class-validator'

export class Users {
  @Type(() => CreateUserDto)
  users: CreateUserDto[] = []

  constructor(...users: CreateUserDto[]) {
    this.users = users
  }
}

export class CreateUserDto {
  @Exclude({ toPlainOnly: true })
  id: number

  @Length(1, 20)
  name: string

  @Min(12)
  @Max(100)
  age: number

  constructor(id: number, name: string, age: number) {
    this.id = id
    this.name = name
    this.age = age
  }
}

// app.module.ts
import { resolve } from 'node:path'
import { Module } from '@nestjs/common'
import { StenoModule } from '@stenodb/nest'

@Module({
  imports: [
    StenoModule.register({
      path: resolve(process.cwd(), 'db')
    })
  ]
})
export class AppModule {}

// users.service.ts
import { Injectable, OnModuleInit } from '@nestjs/common'
import { Steno, StenoService } from '@stenodb/nest'
import { Users, CreateUserDto } from './users.dto'

@Injectable()
export class UsersService implements OnModuleInit {
  private usersProvider: Steno.NodeProvider<Users>

  constructor(private readonly stenoService: StenoService) {}

  async onModuleInit(): Promise<void> {
    this.usersProvider = await this.stenoService.create(
      'users',
      Users,
      new Users(
        new CreateUserDto(1, 'John', 22)
      )
    )

    await this.usersProvider.read()
  }

  get users(): CreateUserDto[] {
    return this.usersProvider.data.users
  }
}

Credits

• steno - Specialized fast async file writer.
• fastify-plugin - Plugin helper for Fastify.
• nest - A progressive Node.js framework for building efficient and scalable server-side applications.
• class-transformer - Decorator-based transformation, serialization, and deserialization between objects and classes.
• class-validator - Decorator-based property validation for classes.
• class-validator-jsonschema - Convert class-validator decorated classes into JSON schema.
• json-difference - A simple way to find the difference between two objects or json diff.
• tslog - Universal Logger for TypeScript and JavaScript.

License

MIT - crashmax