shape-db

Limitations

This is a prototype that is not meant to be used in production. The list of its main limitations can be found here.

Getting started

Installation

npm install shape-db -S

Model

For each table field there must be a corresponding class member that is accessed by the constructor.

class User {

    constructor(
        public id: string,
        public firstName : string,
        public lastName : string,
        public membership : number,
        public statistic : number) {}

}

Tables

The remaining step is to create on eobject for every database table. This is done through a table factory function (named "createTable" in the example code below). This function has three parameters:

1. The constructor of the class that corresponds to the table
2. A function that retrieves the ID from a given object
3. An optional parameter that overrides the default table name setting.

const db = new Database(':memory:')
const createTable = createSqliteTableFactory(db)
const userTable = createTable(User, u => u.id, 'users')

Read operations

Selecting all records

userTable
    .select()
    .build()
    .fork(
        err => { ... },
        users => { ... }
    )

Selecting a single field

userTable
    .field(u => u.id)
    .build()
    .fork(
        err => { ... },
        ids => { ... }
    )

Mapping records

userTable
    .map(u => new Name(u.firstName, u.lastName))
    .build()
    .fork(
        err => { ... },
        ids => { ... }
    )

Filtering

userTable
    .select()
    .where(u => u.lastName == 'Some last name')
    .build()
    .fork(
        err => { ... },
        users => { ... }
    )

Grouping

userTable
    .select()
    .group(u => u.membership)
    .build()
    .fork(
        err => { ... },
        users => { ... }
    )

Joins

userTable
    .innerJoin(configurationTable, (u, c) => u.id == c.id)
    .map((u, c) => new UserConfiguration(u.id, u.membership, u.setting))
    .build()
    .fork(
        err => { ... },
        report => { ... }
    )

Aggregation

userTable
    .select()
    .group((u, a) => a.statistic.sum())
    .build()
    .fork(
        err => { ... },
        sums => { ... }
    )

Distinct selection

userTable
    .field(u => u.membership)
    .distinct()
    .build()
    .fork(
        err => { ... },
        groups => { ... }
    )

Write operations

Inserting an object

userTable
    .insert(new User('ID', 'First name', 'Last name'))
    .build()
    .fork(
        err => { ... },
        user => { ... }
    )

Inserting objects

userTable
    .batchInsert(
        [
            new User('1', 'First name A', 'Last name A'),
            new User('2', 'First name B', 'Last name B')
        ]
    )
    .build()
    .fork(
        err => { ... },
        users => { ... }
    )

Updating an object

userTable
    .update(new User('ID', 'Updated first name', 'Updated last name'))
    .build()
    .fork(
        err => { ... },
        user => { ... }
    )

Updating objects

userTable
    .batchUpdate(
        [
            new User('1', 'Updated first name A', 'Updated last name A'),
            new User('2', 'Updated first name B', 'Updated last name B')
        ]
    )
    .build()
    .fork(
        err => { ... },
        users => { ... }
    )

Insert selection

destinationTable
    .insertSelection(sourceTable.select())
    .build()
    .fork(
        err => { ... },
        selection => { ... }
    )

Delete all records

userTable
    .destroy()
    .build()
    .fork(
        err => { ... },
        () => { ... }
    )