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.

Don't forget to check brackets-storage to find out if an implementation already exists for the storage you'd like to work with.

If it's not the case, you will have to implement it yourself...

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

Tip

Once you have your implementation up and running, feel free to make 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>