SignalDB

SignalDB is a local JavaScript database with a MongoDB-like interface and T...

DatabaseMongoDBOfflineReactive programming
maxnowack/signaldbsignaldb.js.org/signaldb

README

SignalDB


Client-Side JavaScript Database with TypeScript Support and Reactive Interfaces

SignalDB is an innovative client-side database designed for modern web applications. It provides a powerful MongoDB-like interface that simplifies data handling with first-class TypeScript support, enhancing type safety and development experience. This JavaScript database is tailored for creating an optimistic UI, allowing developers to build responsive and dynamic user interfaces with ease.

Data persistence is a core feature of SignalDB. It enables the storage of data through a JSON interface in various storage providers, including the widely-used localStorage. This flexibility allows you to choose the most suitable storage mechanism for your application, whether you're aiming for temporary session storage or more permanent data retention.

SignalDB excels in situations where quick and efficient data handling is crucial. The use of a client-side approach ensures that data is readily available without the latency associated with server-side databases. This instant access to data is particularly beneficial for applications requiring high performance and real-time interactions.

Furthermore, SignalDB's architecture is designed to be lightweight and unobtrusive. It doesn't lock you into a specific framework, making it a versatile choice for a wide range of JavaScript applications. Whether you're working on a small project or a large-scale application, SignalDB's intuitive API and flexible design make it an ideal choice for developers looking to enhance their application's data management capabilities.

Installation


  1. ````
  2.   $ npm install signaldb
  3. ````

Usage


  1. ```js
  2. import { Collection } from 'signaldb'

  4. const posts = new Collection()
  5. const postId = posts.insert({ title: 'Foo', text: 'Lorem ipsum …' })
  6. const cursor = collection.find({})
  7. console.log(cursor.fetch()) // returns an array with all documents in the collection
  8. ```

Reactivity

In theory, every signal library is supported. SignalDB currently have pre-build reactivity adapters for these libraries:
@preact/signals-core
@reactively/core
Angular
Maverick-js Signals
Meteor Tracker
MobX
oby
S.js
sinuous
Solid.js
usignal
Vue.js
and more to come!

More information in the reactivity section of the documentation.

  1. ```js
  2. import { effect } from '@preact/signals-core'
  3. // OR
  4. import { effect } from '@angular/core'
  5. // OR
  6. import { autorun as effect } from 'mobx'
  7. // OR
  8. import { createEffect as effect } from 'solid-js'
  9. // OR
  10. import { watchEffect as effect } from 'vue'
  11. // ...

  13. const posts = new Collection({
  14.   reactivity: /* ... */ // see https://signaldb.js.org/reactivity/ for reactivity adapters for your favorite library,
  15. })

  17. effect(() => { // will be executed everytime the query result changes
  18.   const cursor = posts.find({ author: 'John' })
  19.   console.log(cursor.count())
  20. })

  22. ```

Please also take a look at the documentation

Architecture


Reactivity


SignalDB harnesses the power of signal-based reactivity to offer a dynamic and responsive user experience. Our architecture integrates seamlessly with various signal libraries, ensuring compatibility and flexibility across different JavaScript frameworks. Whether you're using Angular, React, Vue.js, or others, SignalDB adapts to your preferred environment, enhancing the reactivity of your web applications.

Collections & Queries


At the heart of SignalDB lies its advanced handling of collections and queries. Our in-memory data storage approach ensures blazing-fast query performance, perfect for applications requiring real-time data manipulation and retrieval. This setup allows for a synchronous API, eliminating the complexity of asynchronous operations and making data handling straightforward and efficient.

Data Persistance


SignalDB's data persistence layer is designed for scalability and flexibility. It offers various strategies for persisting data, from simple localStorage implementations to more complex external systems. This versatility allows for customization based on your application's needs, ensuring data is stored efficiently and securely. Our architecture supports the evolution of your application, providing a solid foundation for growth and expansion.

Replication


Looking ahead, SignalDB plans to implement a cutting-edge data replication engine, drawing inspiration from established protocols like the RxDB replication protocol (more info). Initially, we'll offer data replication through a persistence interface for RxDB, with further expansions to follow. Our commitment to extensibility means that we're continually evolving, adding new features and capabilities to meet the ever-changing demands of modern web development.

License

Licensed under MIT license. Copyright (c) 2023 Max Nowack

Contributions

Contributions are welcome. Please open issues and/or file Pull Requests.

Maintainers

- Max Nowack (maxnowack)