Security

We take security very seriously and have implemented robust measures to ensure data protection. Below are the specifications for our security features:

| Feature | Description | |--------------------------------|-----------------------------------------------------------------------------| | Password Hashing | We use PBKDF2 (Password-Based Key Derivation Function 2) with HMAC-SHA3-256 for password hashing. This method involves multiple iterations to enhance security against brute-force attacks. Learn more about PBKDF2 | | Encryption | Data is encrypted using AES-256-GCM (Advanced Encryption Standard with Galois/Counter Mode), which provides both confidentiality and integrity. Learn more about AES-GCM | | Integrity | We ensure data integrity by hashing data with SHA3-512 and comparing it with the stored hash to detect any tampering. Learn more about SHA-3 |

Supported features

By default RIDB is bundled with a default InMemory storage with support for write, create, update, fetch one, remove, find and count operations.

| Feature | Description | |--------------------------------|-----------------------------------------------------------------------------| | Schemas | Creation of declarative schemas with required fields, default and encrypted fields | | Validation | Implement validation across all the flows extracting properties and required fields when needed | | Primary Key Management | Primary key and index management | | Plugin Engine | Extend the functionality of your Database implementation with wasm or Javascript plugins | | Data Encryption Plugin | Secure data with encryption plugins | | Migration Plugin | Support for data migrations | | Integrity Plugin | Support for data has not been tampered with | | IndexDB Storage | Robust type safe replacement for Dexie

Install

In order to install simply run the following command npm:

text
1
npm i @trust0/ridb --save

yarn:

text
1
yarn add @trust0/ridb

Usage

Creating your own database is pretty straight forward.

javascript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import {
    RIDB,
    SchemaFieldType
} from '@trust0/ridb';

(async () => {
    const db =  new RIDB({
        demo: {
            version: 0,
            primaryKey: 'id',
            type: SchemaFieldType.object,
            properties: {
                id: {
                    type: SchemaFieldType.string,
                    maxLength: 60
                }
            }
        }
    });
    console.log("Starting the database");
    await db.start({dbName: "demo"});
    console.log("Ok :)");
})()

Use with custom storage (IndexDB and InMemory)

javascript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import {
    RIDB,
    SchemaFieldType,
    StorageType
} from '@trust0/ridb';

(async () => {
    const db =  new RIDB({
        demo: {
            version: 0,
            primaryKey: 'id',
            type: SchemaFieldType.object,
            properties: {
                id: {
                    type: SchemaFieldType.string,
                    maxLength: 60
                }
            }
        }
    });
    console.log("Starting the database");
    await db.start({dbName: "demo", storage: StorageType.IndexDB //or StorageType.InMemory});
    console.log("Ok :)");
})()

Specification

Storage

A valid storage must extend BaseStorage class here's some example:

typescript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
export class InMemory<T extends SchemaTypeRecord>  extends BaseStorage<T> {

    static create<SchemasCreate extends SchemaTypeRecord>(
        name: string,
        schemas: SchemasCreate,
        options: any
    ): Promise<
        BaseStorage<
            SchemasCreate
        >
    > {
        throw new Error("Method not implemented.");
    }

    constructor(name: string, schemas: T, options: any) {
        super(name, schemas, options);
    }

    findDocumentById(collectionName: keyof T, id: string): Promise<Doc<T[keyof T]> | null> {
        throw new Error("Method not implemented.");
    }
    find(collectionName: keyof T, query: QueryType<T[keyof T]>): Promise<Doc<T[keyof T]>[]> {
        throw new Error("Method not implemented.");
    }
    write(op: Operation<T[keyof T]>): Promise<Doc<T[keyof T]>> {
        throw new Error("Method not implemented.");
    }
    count(collectionName: keyof T, query: QueryType<T[keyof T]>): Promise<number> {
        throw new Error("Method not implemented.");
    }
    start(): Promise<void> {
        throw new Error("Method not implemented.");
    }
    close(): Promise<void> {
        throw new Error("Method not implemented.");
    }

}

Plugins

Plugins extend the functionality of the database by hooking into the database lifecycle.

typescript
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * A simple plugin that overrides the docCreateHook and docRecoverHook methods.
 */
class MySimplePlugin extends BasePlugin {
    constructor() {
        super();
        this.docCreateHook = (
            schema,
            migration,
            docs
        ) => docs;
        this.docRecoverHook = (
            schema,
            migration,
            docs
        ) => docs;
    }
}