brackets-drizzle-db 2.1.0

package/dist/storage-handlers/insert-handlers/tournament.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTournamentInsert = handleTournamentInsert;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+async function handleTournamentInsert(db, values) {
+    try {
+        if (Array.isArray(values)) {
+            await db.insert(schema_1.tournament).values(values.map((t) => {
+                const value = transformers_1.TournamentTransformer.to(t);
+                return { id: String(t.id), ...value, extra: value.extra ?? undefined };
+            }));
+            return true;
+        }
+        const value = transformers_1.TournamentTransformer.to(values);
+        const result = await db
+            .insert(schema_1.tournament)
+            .values({ id: String(values.id), ...value, extra: value.extra ?? undefined })
+            .returning({ id: schema_1.tournament.id });
+        return result[0]?.id ?? '';
+    }
+    catch {
+        return Array.isArray(values) ? false : '';
+    }
+}

package/dist/storage-handlers/insert.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../db';
+export declare function handleInsert<T extends keyof DataTypes>(db: DrizzleDatabase, table: T | 'tournament', values: DataTypes[T] | DataTypes[T][]): Promise<string | number | boolean>;

package/dist/storage-handlers/insert.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleInsert = handleInsert;
+const insert_handlers_1 = require("./insert-handlers");
+// With text IDs, we expect the caller to provide the id in the values
+async function handleInsert(db, table, values) {
+    switch (table) {
+        case 'tournament':
+            return (0, insert_handlers_1.handleTournamentInsert)(db, values);
+        case 'participant':
+            return (0, insert_handlers_1.handleParticipantInsert)(db, values);
+        case 'stage':
+            return (0, insert_handlers_1.handleStageInsert)(db, values);
+        case 'group':
+            return (0, insert_handlers_1.handleGroupInsert)(db, values);
+        case 'round':
+            return (0, insert_handlers_1.handleRoundInsert)(db, values);
+        case 'match':
+            return (0, insert_handlers_1.handleMatchInsert)(db, values);
+        case 'match_game':
+            return (0, insert_handlers_1.handleMatchGameInsert)(db, values);
+        default:
+            return false;
+    }
+}

package/dist/storage-handlers/select-handlers/group.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleGroupSelect(db: DrizzleDatabase, filter?: Partial<DataTypes['group']> | number | string): Promise<DataTypes['group'][] | DataTypes['group'] | null>;

package/dist/storage-handlers/select-handlers/group.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGroupSelect = handleGroupSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleGroupSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const values = await db
+                .select()
+                .from(schema_1.group)
+                .orderBy((0, drizzle_orm_1.asc)(schema_1.group.number));
+            return values.map(transformers_1.GroupTransformer.from);
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.group)
+                .where((0, drizzle_orm_1.eq)(schema_1.group.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            return transformers_1.GroupTransformer.from(values[0]);
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.id, String(filter.id)));
+        if (filter.stage_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.stageId, String(filter.stage_id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.number, filter.number));
+        const values = await db
+            .select()
+            .from(schema_1.group)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined)
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.group.number));
+        return values.map(transformers_1.GroupTransformer.from);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/storage-handlers/select-handlers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './group';
+export * from './match';
+export * from './match-game';
+export * from './participant';
+export * from './round';
+export * from './stage';
+export * from './tournament';

package/dist/storage-handlers/select-handlers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./group"), exports);
+__exportStar(require("./match"), exports);
+__exportStar(require("./match-game"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./stage"), exports);
+__exportStar(require("./tournament"), exports);

package/dist/storage-handlers/select-handlers/match-game.d.ts

@@ -0,0 +1,3 @@
+import type { DrizzleDatabase } from '../../db';
+import type { MatchGameWithExtra } from '../../types';
+export declare function handleMatchGameSelect(db: DrizzleDatabase, filter?: Partial<MatchGameWithExtra> | number | string): Promise<MatchGameWithExtra[] | MatchGameWithExtra | null>;

package/dist/storage-handlers/select-handlers/match-game.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameSelect = handleMatchGameSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleMatchGameSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const games = await db
+                .select()
+                .from(schema_1.matchGame)
+                .orderBy((0, drizzle_orm_1.asc)(schema_1.matchGame.number));
+            return Promise.all(games.map(async (game) => {
+                const opponents = await getOpponents(db, game.id);
+                return transformers_1.MatchGameTransformer.from({
+                    ...game,
+                    ...opponents,
+                });
+            }));
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.matchGame)
+                .where((0, drizzle_orm_1.eq)(schema_1.matchGame.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            const opponents = await getOpponents(db, values[0].id);
+            return transformers_1.MatchGameTransformer.from({
+                ...values[0],
+                ...opponents,
+            });
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.id, String(filter.id)));
+        if (filter.stage_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.stageId, String(filter.stage_id)));
+        if (filter.parent_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.matchId, String(filter.parent_id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.number, filter.number));
+        if (filter.status !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.status, transformers_1.MatchStatusTransformer.to(filter.status)));
+        const games = await db
+            .select()
+            .from(schema_1.matchGame)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined)
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.matchGame.number));
+        return Promise.all(games.map(async (game) => {
+            const opponents = await getOpponents(db, game.id);
+            return transformers_1.MatchGameTransformer.from({
+                ...game,
+                ...opponents,
+            });
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function getOpponents(db, matchGameId) {
+    const opponent1Results = await db
+        .select()
+        .from(schema_1.participantMatchGameResult)
+        .where((0, drizzle_orm_1.eq)(schema_1.participantMatchGameResult.opponent1MatchGameId, matchGameId))
+        .limit(1);
+    const opponent2Results = await db
+        .select()
+        .from(schema_1.participantMatchGameResult)
+        .where((0, drizzle_orm_1.eq)(schema_1.participantMatchGameResult.opponent2MatchGameId, matchGameId))
+        .limit(1);
+    return {
+        opponent1Result: opponent1Results[0] ?? null,
+        opponent2Result: opponent2Results[0] ?? null,
+    };
+}

package/dist/storage-handlers/select-handlers/match.d.ts

@@ -0,0 +1,3 @@
+import type { DrizzleDatabase } from '../../db';
+import type { MatchWithExtra } from '../../types';
+export declare function handleMatchSelect(db: DrizzleDatabase, filter?: Partial<MatchWithExtra> | number | string): Promise<MatchWithExtra[] | MatchWithExtra | null>;

package/dist/storage-handlers/select-handlers/match.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchSelect = handleMatchSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleMatchSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const matches = await db
+                .select()
+                .from(schema_1.match)
+                .leftJoin(schema_1.round, (0, drizzle_orm_1.eq)(schema_1.match.roundId, schema_1.round.id))
+                .orderBy((0, drizzle_orm_1.asc)(schema_1.round.number), (0, drizzle_orm_1.asc)(schema_1.match.number));
+            return Promise.all(matches.map(async (row) => {
+                const opponents = await getOpponents(db, row.Match.id);
+                return transformers_1.MatchTransformer.from({
+                    ...row.Match,
+                    ...opponents,
+                });
+            }));
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.match)
+                .where((0, drizzle_orm_1.eq)(schema_1.match.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            const opponents = await getOpponents(db, values[0].id);
+            return transformers_1.MatchTransformer.from({
+                ...values[0],
+                ...opponents,
+            });
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.id, String(filter.id)));
+        if (filter.stage_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.stageId, String(filter.stage_id)));
+        if (filter.group_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.groupId, String(filter.group_id)));
+        if (filter.round_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.roundId, String(filter.round_id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.number, filter.number));
+        if (filter.status !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.status, transformers_1.MatchStatusTransformer.to(filter.status)));
+        if (filter.child_count !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.childCount, filter.child_count));
+        const matches = await db
+            .select()
+            .from(schema_1.match)
+            .leftJoin(schema_1.round, (0, drizzle_orm_1.eq)(schema_1.match.roundId, schema_1.round.id))
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined)
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.round.number), (0, drizzle_orm_1.asc)(schema_1.match.number));
+        return Promise.all(matches.map(async (row) => {
+            const opponents = await getOpponents(db, row.Match.id);
+            return transformers_1.MatchTransformer.from({
+                ...row.Match,
+                ...opponents,
+            });
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+async function getOpponents(db, matchId) {
+    const opponent1Results = await db
+        .select()
+        .from(schema_1.participantMatchResult)
+        .where((0, drizzle_orm_1.eq)(schema_1.participantMatchResult.opponent1MatchId, matchId))
+        .limit(1);
+    const opponent2Results = await db
+        .select()
+        .from(schema_1.participantMatchResult)
+        .where((0, drizzle_orm_1.eq)(schema_1.participantMatchResult.opponent2MatchId, matchId))
+        .limit(1);
+    return {
+        opponent1Result: opponent1Results[0] ?? null,
+        opponent2Result: opponent2Results[0] ?? null,
+    };
+}

package/dist/storage-handlers/select-handlers/participant.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleParticipantSelect(db: DrizzleDatabase, filter?: Partial<DataTypes['participant']> | number | string): Promise<DataTypes['participant'][] | DataTypes['participant'] | null>;

package/dist/storage-handlers/select-handlers/participant.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParticipantSelect = handleParticipantSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleParticipantSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const values = await db.select().from(schema_1.participant);
+            return values.map(transformers_1.ParticipantTransformer.from);
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.participant)
+                .where((0, drizzle_orm_1.eq)(schema_1.participant.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            return transformers_1.ParticipantTransformer.from(values[0]);
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.participant.id, String(filter.id)));
+        if (filter.name !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.participant.name, filter.name));
+        if (filter.tournament_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.participant.tournamentId, String(filter.tournament_id)));
+        const values = await db
+            .select()
+            .from(schema_1.participant)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return values.map(transformers_1.ParticipantTransformer.from);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/storage-handlers/select-handlers/round.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleRoundSelect(db: DrizzleDatabase, filter?: Partial<DataTypes['round']> | number | string): Promise<DataTypes['round'][] | DataTypes['round'] | null>;

package/dist/storage-handlers/select-handlers/round.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoundSelect = handleRoundSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleRoundSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const values = await db
+                .select()
+                .from(schema_1.round)
+                .orderBy((0, drizzle_orm_1.asc)(schema_1.round.number));
+            return values.map(transformers_1.RoundTransformer.from);
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.round)
+                .where((0, drizzle_orm_1.eq)(schema_1.round.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            return transformers_1.RoundTransformer.from(values[0]);
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.round.id, String(filter.id)));
+        if (filter.stage_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.round.stageId, String(filter.stage_id)));
+        if (filter.group_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.round.groupId, String(filter.group_id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.round.number, filter.number));
+        const values = await db
+            .select()
+            .from(schema_1.round)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined)
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.round.number));
+        return values.map(transformers_1.RoundTransformer.from);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/storage-handlers/select-handlers/stage.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleStageSelect(db: DrizzleDatabase, filter?: Partial<DataTypes['stage']> | number | string): Promise<DataTypes['stage'][] | DataTypes['stage'] | null>;

package/dist/storage-handlers/select-handlers/stage.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageSelect = handleStageSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleStageSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const values = await db
+                .select()
+                .from(schema_1.stage)
+                .leftJoin(schema_1.stageSettings, (0, drizzle_orm_1.eq)(schema_1.stage.id, schema_1.stageSettings.stageId))
+                .orderBy((0, drizzle_orm_1.asc)(schema_1.stage.number));
+            return values.map((row) => transformers_1.StageTransformer.from({
+                ...row.Stage,
+                settings: row.StageSettings,
+            }));
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.stage)
+                .leftJoin(schema_1.stageSettings, (0, drizzle_orm_1.eq)(schema_1.stage.id, schema_1.stageSettings.stageId))
+                .where((0, drizzle_orm_1.eq)(schema_1.stage.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            return transformers_1.StageTransformer.from({
+                ...values[0].Stage,
+                settings: values[0].StageSettings,
+            });
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.id, String(filter.id)));
+        if (filter.name !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.name, filter.name));
+        if (filter.tournament_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.tournamentId, String(filter.tournament_id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.number, filter.number));
+        if (filter.type !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.type, transformers_1.StageTypeTransformer.to(filter.type)));
+        const values = await db
+            .select()
+            .from(schema_1.stage)
+            .leftJoin(schema_1.stageSettings, (0, drizzle_orm_1.eq)(schema_1.stage.id, schema_1.stageSettings.stageId))
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined)
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.stage.number));
+        return values.map((row) => transformers_1.StageTransformer.from({
+            ...row.Stage,
+            settings: row.StageSettings,
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/storage-handlers/select-handlers/tournament.d.ts

@@ -0,0 +1,3 @@
+import { Tournament } from '../../transformers';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleTournamentSelect(db: DrizzleDatabase, filter?: Partial<Tournament> | number | string): Promise<Tournament[] | Tournament | null>;

package/dist/storage-handlers/select-handlers/tournament.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTournamentSelect = handleTournamentSelect;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleTournamentSelect(db, filter) {
+    try {
+        if (filter === undefined) {
+            const values = await db.select().from(schema_1.tournament);
+            return values.map(transformers_1.TournamentTransformer.from);
+        }
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            const values = await db
+                .select()
+                .from(schema_1.tournament)
+                .where((0, drizzle_orm_1.eq)(schema_1.tournament.id, String(filter)))
+                .limit(1);
+            if (values.length === 0) {
+                return null;
+            }
+            return transformers_1.TournamentTransformer.from(values[0]);
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.tournament.id, String(filter.id)));
+        if (filter.name !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.tournament.name, filter.name));
+        const values = await db
+            .select()
+            .from(schema_1.tournament)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return values.map(transformers_1.TournamentTransformer.from);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/storage-handlers/select.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../db';
+export declare function handleSelect<T extends keyof DataTypes>(db: DrizzleDatabase, table: T | 'tournament', filter?: Partial<DataTypes[T]> | number | string): Promise<DataTypes[T][] | DataTypes[T] | null>;

package/dist/storage-handlers/select.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSelect = handleSelect;
+const select_handlers_1 = require("./select-handlers");
+async function handleSelect(db, table, filter) {
+    switch (table) {
+        case 'tournament':
+            return (0, select_handlers_1.handleTournamentSelect)(db, filter);
+        case 'participant':
+            return (0, select_handlers_1.handleParticipantSelect)(db, filter);
+        case 'stage':
+            return (0, select_handlers_1.handleStageSelect)(db, filter);
+        case 'group':
+            return (0, select_handlers_1.handleGroupSelect)(db, filter);
+        case 'round':
+            return (0, select_handlers_1.handleRoundSelect)(db, filter);
+        case 'match':
+            return (0, select_handlers_1.handleMatchSelect)(db, filter);
+        case 'match_game':
+            return (0, select_handlers_1.handleMatchGameSelect)(db, filter);
+        default:
+            return null;
+    }
+}

package/dist/storage-handlers/update-handlers/group.d.ts

@@ -0,0 +1,3 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleGroupUpdate(db: DrizzleDatabase, filter: Partial<DataTypes['group']> | number | string, value: Partial<DataTypes['group']> | DataTypes['group']): Promise<boolean>;

package/dist/storage-handlers/update-handlers/group.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGroupUpdate = handleGroupUpdate;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleGroupUpdate(db, filter, value) {
+    try {
+        const updateData = {};
+        if (value.number !== undefined)
+            updateData.number = value.number;
+        if (value.stage_id !== undefined)
+            updateData.stageId = String(value.stage_id);
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            await db.update(schema_1.group).set(updateData).where((0, drizzle_orm_1.eq)(schema_1.group.id, String(filter)));
+            return true;
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.id, String(filter.id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.number, filter.number));
+        if (filter.stage_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.group.stageId, String(filter.stage_id)));
+        await db
+            .update(schema_1.group)
+            .set(updateData)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/storage-handlers/update-handlers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './group';
+export * from './match';
+export * from './match-game';
+export * from './participant';
+export * from './round';
+export * from './stage';
+export * from './tournament';

package/dist/storage-handlers/update-handlers/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./group"), exports);
+__exportStar(require("./match"), exports);
+__exportStar(require("./match-game"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./stage"), exports);
+__exportStar(require("./tournament"), exports);

package/dist/storage-handlers/update-handlers/match-game.d.ts

@@ -0,0 +1,3 @@
+import type { DrizzleDatabase } from '../../db';
+import type { MatchGameWithExtra } from '../../types';
+export declare function handleMatchGameUpdate(db: DrizzleDatabase, filter: Partial<MatchGameWithExtra> | number | string, value: Partial<MatchGameWithExtra> | MatchGameWithExtra): Promise<boolean>;