novadb-angular

Angular service for NovaDB — the high-performance embeddable Rust database.

Install

npm install novadb-angular novadb-rs

Setup — register NovaDBModule

// app.module.ts
import { NgModule } from '@angular/core'
import { BrowserModule } from '@angular/platform-browser'
import { NovaDBModule } from 'novadb-angular'
import { NovaDb } from 'novadb-rs'
import { AppComponent } from './app.component'

@NgModule({
  imports: [
    BrowserModule,
    NovaDBModule.forRoot(() => NovaDb.inMemory()),
  ],
  declarations: [AppComponent],
  bootstrap:    [AppComponent],
})
export class AppModule {}

Standalone (Angular 17+)

// main.ts
import { bootstrapApplication } from '@angular/platform-browser'
import { provideNovaDB } from 'novadb-angular'
import { NovaDb } from 'novadb-rs'
import { AppComponent } from './app/app.component'

bootstrapApplication(AppComponent, {
  providers: [
    provideNovaDB(() => NovaDb.inMemory()),
  ],
})

Inject NovaDBService

import { Component, OnInit } from '@angular/core'
import { NovaDBService } from 'novadb-angular'
import { Observable } from 'rxjs'

interface User { _id: string; name: string; age: number }

@Component({
  selector: 'app-users',
  template: `
    <ul>
      <li *ngFor="let user of users$ | async">
        {{ user.name }} ({{ user.age }})
        <button (click)="delete(user._id)">Delete</button>
      </li>
    </ul>
    <button (click)="add()">Add User</button>
  `,
})
export class UsersComponent implements OnInit {
  users$!: Observable<User[]>

  constructor(private nova: NovaDBService) {}

  ngOnInit() {
    this.users$ = this.nova.query<User>('users', {})
  }

  async add() {
    await this.nova.insert('users', { name: 'Alice', age: 30 })
  }

  async delete(id: string) {
    await this.nova.deleteOne('users', { _id: id })
  }
}

Service API

class NovaDBService {
  // Query — returns an Observable that emits once
  query<T>(collection: string, filter: object): Observable<T[]>

  // Find one document
  findOne<T>(collection: string, filter: object): Observable<T | null>

  // Count matching documents
  count(collection: string, filter: object): Observable<number>

  // Insert a document
  insert(collection: string, doc: object): Promise<object>

  // Insert multiple documents
  insertMany(collection: string, docs: object[]): Promise<object>

  // Update first matching document
  updateOne(collection: string, filter: object, update: object): Promise<object>

  // Update all matching documents
  updateMany(collection: string, filter: object, update: object): Promise<object>

  // Delete first matching document
  deleteOne(collection: string, filter: object): Promise<object>

  // Delete all matching documents
  deleteMany(collection: string, filter: object): Promise<object>

  // Direct access to the underlying NovaDB instance
  getDb(): NovaDBInstance
}

Reactive polling with interval

import { switchMap, timer } from 'rxjs'

// Re-query every 3 seconds
this.users$ = timer(0, 3000).pipe(
  switchMap(() => this.nova.query<User>('users', {}))
)

License

MIT