Skip to content

Brackets Documentation

Storage

Storage

Info

This page is automatically generated using brackets-storage-calls.

To be compatible with every kind of storage, the manager is designed to use dependency injection, thanks to the CrudInterface implementation your are passing to its constructor.

The brackets-storage repository provides implementations for some storages:

Package
brackets-json-db
brackets-memory-db
brackets-prisma-db

If there is no implementation for the storage you want to use, you will have to implement it yourself...

As it can be hard to do with something like a SQL database, this page shows every usage of the CRUD interface by the manager so you don't have to read all the manager code.

Tip

Once you have your implementation up and running, consider opening a PR on brackets-storage to share your work with the community!

Dynamic table¶

`select()`¶

select(table, filter: Partial<DataTypes[T]>): Promise<DataTypes[T][] | null>

Stage¶

`insert()`¶

insert('stage', value: OmitId<Stage>): Promise<number>

insert('stage', values: Stage[]): Promise<boolean>

`select()`¶

select('stage'): Promise<Stage[] | null>

select('stage', id: Id): Promise<Stage | null>

select('stage', filter: {
    tournament_id: Id;
}): Promise<Stage[] | null>

`update()`¶

update('stage', id: Id, value: Stage): Promise<boolean>

`delete()`¶

delete('stage'): Promise<boolean>

delete('stage', filter: {
    id: Id;
}): Promise<boolean>

Group¶

`selectFirst()`¶

selectFirst('group', filter: {
    stage_id: Id;
    number: number;
}): Promise<Group | null>

`insert()`¶

insert('group', value: OmitId<Group>): Promise<number>

insert('group', values: Group[]): Promise<boolean>

`select()`¶

select('group'): Promise<Group[] | null>

select('group', id: Id): Promise<Group | null>

select('group', filter: {
    stage_id: Id;
}): Promise<Group[] | null>

`delete()`¶

delete('group'): Promise<boolean>

delete('group', filter: {
    stage_id: Id;
}): Promise<boolean>

Round¶

`selectLast()`¶

selectLast('round', filter: {
    group_id: Id;
}, assertUnique: false): Promise<Round | null>

`selectFirst()`¶

selectFirst('round', filter: {
    group_id: Id;
    number: number;
}): Promise<Round | null>

selectFirst('round', filter: {
    stage_id: Id;
    number: number;
}, assertUnique: false): Promise<Round | null>

`insert()`¶

insert('round', value: OmitId<Round>): Promise<number>

insert('round', values: Round[]): Promise<boolean>

`select()`¶

select('round'): Promise<Round[] | null>

select('round', id: Id): Promise<Round | null>

select('round', filter: {
    stage_id: Id;
}): Promise<Round[] | null>

select('round', filter: {
    group_id: Id;
}): Promise<Round[] | null>

`delete()`¶

delete('round'): Promise<boolean>

delete('round', filter: {
    stage_id: Id;
}): Promise<boolean>

Match¶

`selectFirst()`¶

selectFirst('match', filter: {
    round_id: Id;
    number: number;
}): Promise<Match | null>

selectFirst('match', filter: {
    group_id: Id;
    number: number;
}): Promise<Match | null>

`insert()`¶

insert('match', value: OmitId<Match>): Promise<number>

insert('match', values: Match[]): Promise<boolean>

`select()`¶

select('match'): Promise<Match[] | null>

select('match', id: Id): Promise<Match | null>

select('match', filter: {
    round_id: Id;
}): Promise<Match[] | null>

select('match', filter: {
    stage_id: Id;
}): Promise<Match[] | null>

select('match', filter: {
    group_id: Id;
}): Promise<Match[] | null>

`update()`¶

update('match', id: Id, value: Match): Promise<boolean>

update('match', id: Id, value: {
    id: Id;
    stage_id: Id;
    group_id: Id;
    round_id: Id;
    number: number;
    child_count: number;
    status: Status;
    opponent1: ParticipantResult | null;
    opponent2: ParticipantResult | null;
}): Promise<boolean>

update('match', id: Id, value: {
    child_count: number;
    id: Id;
    stage_id: Id;
    group_id: Id;
    round_id: Id;
    number: number;
    status: Status;
    opponent1: ParticipantResult | null;
    opponent2: ParticipantResult | null;
}): Promise<boolean>

update('match', filter: {
    stage_id: Id;
}, value: {
    child_count: number;
}): Promise<boolean>

update('match', filter: {
    group_id: Id;
}, value: {
    child_count: number;
}): Promise<boolean>

update('match', filter: {
    round_id: Id;
}, value: {
    child_count: number;
}): Promise<boolean>

`delete()`¶

delete('match'): Promise<boolean>

delete('match', filter: {
    stage_id: Id;
}): Promise<boolean>

Match game¶

`selectFirst()`¶

selectFirst('match_game', filter: {
    parent_id: Id;
    number: number;
}): Promise<MatchGame | null>

`insert()`¶

insert('match_game', value: {
    number: number;
    stage_id: Id;
    parent_id: Id;
    status: Status;
    opponent1: { 
       id: null;
    };
    opponent2: { 
       id: null;
    };
}): Promise<number>

insert('match_game', value: OmitId<MatchGame>): Promise<number>

insert('match_game', values: MatchGame[]): Promise<boolean>

`select()`¶

select('match_game', id: Id): Promise<MatchGame | null>

select('match_game', filter: {
    parent_id: Id;
}): Promise<MatchGame[] | null>

`update()`¶

update('match_game', id: Id, value: MatchGame): Promise<boolean>

update('match_game', filter: {
    parent_id: Id;
}, value: Partial<MatchGame>): Promise<boolean>

`delete()`¶

delete('match_game'): Promise<boolean>

delete('match_game', filter: {
    parent_id: Id;
    number: number;
}): Promise<boolean>

delete('match_game', filter: {
    stage_id: Id;
}): Promise<boolean>

Participant¶

`insert()`¶

insert('participant', value: OmitId<Participant>): Promise<number>

insert('participant', values: Participant[]): Promise<boolean>

insert('participant', values: OmitId<Participant>[]): Promise<boolean>

`select()`¶

select('participant'): Promise<Participant[] | null>

select('participant', filter: {
    tournament_id: Id;
}): Promise<Participant[] | null>

`delete()`¶

delete('participant'): Promise<boolean>