brackets-drizzle-db 2.1.0

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

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

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameDelete = handleMatchGameDelete;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleMatchGameDelete(db, filter) {
+    try {
+        if (!filter) {
+            // Delete participant results first, then match games
+            await db.delete(schema_1.participantMatchGameResult);
+            await db.delete(schema_1.matchGame);
+            return true;
+        }
+        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)));
+        // Find matching match games
+        const games = await db
+            .select({ id: schema_1.matchGame.id })
+            .from(schema_1.matchGame)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        if (games.length === 0)
+            return true;
+        const gameIds = games.map((g) => g.id);
+        // Delete related participant results first
+        await db.delete(schema_1.participantMatchGameResult).where((0, drizzle_orm_1.or)((0, drizzle_orm_1.inArray)(schema_1.participantMatchGameResult.opponent1MatchGameId, gameIds), (0, drizzle_orm_1.inArray)(schema_1.participantMatchGameResult.opponent2MatchGameId, gameIds)));
+        // Then delete the match games
+        await db.delete(schema_1.matchGame).where((0, drizzle_orm_1.inArray)(schema_1.matchGame.id, gameIds));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchDelete = handleMatchDelete;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleMatchDelete(db, filter) {
+    try {
+        if (!filter) {
+            // Delete participant results first, then matches
+            await db.delete(schema_1.participantMatchResult);
+            await db.delete(schema_1.match);
+            return true;
+        }
+        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)));
+        // Find matching matches
+        const matches = await db
+            .select({ id: schema_1.match.id })
+            .from(schema_1.match)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        if (matches.length === 0)
+            return true;
+        const matchIds = matches.map((m) => m.id);
+        // Delete related participant results first
+        await db.delete(schema_1.participantMatchResult).where((0, drizzle_orm_1.or)((0, drizzle_orm_1.inArray)(schema_1.participantMatchResult.opponent1MatchId, matchIds), (0, drizzle_orm_1.inArray)(schema_1.participantMatchResult.opponent2MatchId, matchIds)));
+        // Then delete the matches
+        await db.delete(schema_1.match).where((0, drizzle_orm_1.inArray)(schema_1.match.id, matchIds));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParticipantDelete = handleParticipantDelete;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleParticipantDelete(db, filter) {
+    try {
+        if (!filter) {
+            await db.delete(schema_1.participant);
+            return true;
+        }
+        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)));
+        await db
+            .delete(schema_1.participant)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoundDelete = handleRoundDelete;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleRoundDelete(db, filter) {
+    try {
+        if (!filter) {
+            await db.delete(schema_1.round);
+            return true;
+        }
+        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));
+        await db
+            .delete(schema_1.round)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageDelete = handleStageDelete;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleStageDelete(db, filter) {
+    try {
+        if (!filter) {
+            // No filter: delete in the right order to satisfy FK constraints
+            await db.delete(schema_1.stageSettings);
+            await db.delete(schema_1.stage);
+            return true;
+        }
+        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.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.number, filter.number));
+        if (filter.tournament_id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.tournamentId, String(filter.tournament_id)));
+        if (filter.type !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.stage.type, transformers_1.StageTypeTransformer.to(filter.type)));
+        // Find matching stages
+        const stages = await db
+            .select({ id: schema_1.stage.id })
+            .from(schema_1.stage)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        if (stages.length === 0)
+            return true;
+        const stageIds = stages.map((s) => s.id);
+        // Delete related StageSettings first to satisfy FK constraints
+        await db
+            .delete(schema_1.stageSettings)
+            .where((0, drizzle_orm_1.inArray)(schema_1.stageSettings.stageId, stageIds));
+        // Then delete the stages
+        await db.delete(schema_1.stage).where((0, drizzle_orm_1.inArray)(schema_1.stage.id, stageIds));
+        return true;
+    }
+    catch (e) {
+        console.error(new Error(`Error deleting stages with filter ${JSON.stringify(filter)}`, {
+            cause: e,
+        }));
+        return false;
+    }
+}

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

@@ -0,0 +1,3 @@
+import { Tournament } from '../../transformers';
+import type { DrizzleDatabase } from '../../db';
+export declare function handleTournamentDelete(db: DrizzleDatabase, filter?: Partial<Tournament>): Promise<boolean>;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTournamentDelete = handleTournamentDelete;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleTournamentDelete(db, filter) {
+    try {
+        if (!filter) {
+            await db.delete(schema_1.tournament);
+            return true;
+        }
+        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));
+        await db
+            .delete(schema_1.tournament)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

package/dist/storage-handlers/delete.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDelete = handleDelete;
+const delete_handlers_1 = require("./delete-handlers");
+async function handleDelete(db, table, filter) {
+    switch (table) {
+        case 'tournament':
+            return (0, delete_handlers_1.handleTournamentDelete)(db, filter);
+        case 'participant':
+            return (0, delete_handlers_1.handleParticipantDelete)(db, filter);
+        case 'stage':
+            return (0, delete_handlers_1.handleStageDelete)(db, filter);
+        case 'group':
+            return (0, delete_handlers_1.handleGroupDelete)(db, filter);
+        case 'round':
+            return (0, delete_handlers_1.handleRoundDelete)(db, filter);
+        case 'match':
+            return (0, delete_handlers_1.handleMatchDelete)(db, filter);
+        case 'match_game':
+            return (0, delete_handlers_1.handleMatchGameDelete)(db, filter);
+        default:
+            return false;
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './delete';
+export * from './insert';
+export * from './select';
+export * from './update';

package/dist/storage-handlers/index.js

@@ -0,0 +1,20 @@
+"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("./delete"), exports);
+__exportStar(require("./insert"), exports);
+__exportStar(require("./select"), exports);
+__exportStar(require("./update"), exports);

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

@@ -0,0 +1,5 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+type GroupInsertInput = DataTypes['group'];
+export declare function handleGroupInsert(db: DrizzleDatabase, values: GroupInsertInput | GroupInsertInput[]): Promise<string | boolean>;
+export {};

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

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

package/dist/storage-handlers/insert-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/insert-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/insert-handlers/match-game.d.ts

@@ -0,0 +1,5 @@
+import type { DrizzleDatabase } from '../../db';
+import type { MatchGameWithExtra } from '../../types';
+type MatchGameInsertInput = MatchGameWithExtra;
+export declare function handleMatchGameInsert(db: DrizzleDatabase, values: MatchGameInsertInput | MatchGameInsertInput[]): Promise<string | boolean>;
+export {};

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameInsert = handleMatchGameInsert;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const crypto_1 = require("crypto");
+async function handleMatchGameInsert(db, values) {
+    try {
+        if (Array.isArray(values)) {
+            for (const value of values) {
+                await insertSingleMatchGame(db, value);
+            }
+            return true;
+        }
+        const result = await insertSingleMatchGame(db, values);
+        return result ?? '';
+    }
+    catch {
+        return Array.isArray(values) ? false : '';
+    }
+}
+async function insertSingleMatchGame(db, value) {
+    const matchGameData = transformers_1.MatchGameTransformer.to(value);
+    const matchGameId = String(value.id);
+    const matchGameResult = await db
+        .insert(schema_1.matchGame)
+        .values({
+        id: matchGameId,
+        ...matchGameData,
+        extra: value.extra ?? null,
+    })
+        .returning({ id: schema_1.matchGame.id });
+    const insertedMatchGameId = matchGameResult[0]?.id;
+    if (!insertedMatchGameId) {
+        throw new Error('Failed to insert match game');
+    }
+    // Insert opponent1 result if provided
+    if (value.opponent1) {
+        await db.insert(schema_1.participantMatchGameResult).values({
+            id: (0, crypto_1.randomUUID)(),
+            participantId: value.opponent1.id != null ? String(value.opponent1.id) : null,
+            forfeit: value.opponent1.forfeit ?? null,
+            position: value.opponent1.position ?? null,
+            score: value.opponent1.score ?? null,
+            result: value.opponent1.result
+                ? transformers_1.MatchResultTransformer.to(value.opponent1.result)
+                : null,
+            opponent1MatchGameId: insertedMatchGameId,
+        });
+    }
+    // Insert opponent2 result if provided
+    if (value.opponent2) {
+        await db.insert(schema_1.participantMatchGameResult).values({
+            id: (0, crypto_1.randomUUID)(),
+            participantId: value.opponent2.id != null ? String(value.opponent2.id) : null,
+            forfeit: value.opponent2.forfeit ?? null,
+            position: value.opponent2.position ?? null,
+            score: value.opponent2.score ?? null,
+            result: value.opponent2.result
+                ? transformers_1.MatchResultTransformer.to(value.opponent2.result)
+                : null,
+            opponent2MatchGameId: insertedMatchGameId,
+        });
+    }
+    return insertedMatchGameId;
+}

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

@@ -0,0 +1,5 @@
+import type { DrizzleDatabase } from '../../db';
+import type { MatchWithExtra } from '../../types';
+type MatchInsertInput = MatchWithExtra;
+export declare function handleMatchInsert(db: DrizzleDatabase, values: MatchInsertInput | MatchInsertInput[]): Promise<string | boolean>;
+export {};

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchInsert = handleMatchInsert;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const crypto_1 = require("crypto");
+async function handleMatchInsert(db, values) {
+    try {
+        if (Array.isArray(values)) {
+            for (const value of values) {
+                await insertSingleMatch(db, value);
+            }
+            return true;
+        }
+        const result = await insertSingleMatch(db, values);
+        return result ?? '';
+    }
+    catch {
+        return Array.isArray(values) ? false : '';
+    }
+}
+async function insertSingleMatch(db, value) {
+    const matchData = transformers_1.MatchTransformer.to(value);
+    const matchId = String(value.id);
+    const matchResult = await db
+        .insert(schema_1.match)
+        .values({
+        id: matchId,
+        ...matchData,
+        extra: value.extra ?? null,
+    })
+        .returning({ id: schema_1.match.id });
+    const insertedMatchId = matchResult[0]?.id;
+    if (!insertedMatchId) {
+        throw new Error('Failed to insert match');
+    }
+    // Insert opponent1 result if provided
+    if (value.opponent1) {
+        await db.insert(schema_1.participantMatchResult).values({
+            id: (0, crypto_1.randomUUID)(),
+            participantId: value.opponent1.id != null ? String(value.opponent1.id) : null,
+            forfeit: value.opponent1.forfeit ?? null,
+            position: value.opponent1.position ?? null,
+            score: value.opponent1.score ?? null,
+            result: value.opponent1.result
+                ? transformers_1.MatchResultTransformer.to(value.opponent1.result)
+                : null,
+            opponent1MatchId: insertedMatchId,
+        });
+    }
+    // Insert opponent2 result if provided
+    if (value.opponent2) {
+        await db.insert(schema_1.participantMatchResult).values({
+            id: (0, crypto_1.randomUUID)(),
+            participantId: value.opponent2.id != null ? String(value.opponent2.id) : null,
+            forfeit: value.opponent2.forfeit ?? null,
+            position: value.opponent2.position ?? null,
+            score: value.opponent2.score ?? null,
+            result: value.opponent2.result
+                ? transformers_1.MatchResultTransformer.to(value.opponent2.result)
+                : null,
+            opponent2MatchId: insertedMatchId,
+        });
+    }
+    return insertedMatchId;
+}

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

@@ -0,0 +1,5 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+type ParticipantInsertInput = DataTypes['participant'];
+export declare function handleParticipantInsert(db: DrizzleDatabase, values: ParticipantInsertInput | ParticipantInsertInput[]): Promise<string | boolean>;
+export {};

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

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

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

@@ -0,0 +1,5 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+type RoundInsertInput = DataTypes['round'];
+export declare function handleRoundInsert(db: DrizzleDatabase, values: RoundInsertInput | RoundInsertInput[]): Promise<string | boolean>;
+export {};

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

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

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

@@ -0,0 +1,5 @@
+import { DataTypes } from 'brackets-manager/dist/types';
+import type { DrizzleDatabase } from '../../db';
+type StageInsertInput = DataTypes['stage'];
+export declare function handleStageInsert(db: DrizzleDatabase, values: StageInsertInput | StageInsertInput[]): Promise<string | boolean>;
+export {};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageInsert = handleStageInsert;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const crypto_1 = require("crypto");
+async function handleStageInsert(db, values) {
+    try {
+        if (Array.isArray(values)) {
+            // For batch insert, we need to insert stages first, then settings
+            for (const v of values) {
+                const stageId = String(v.id);
+                const stageResult = await db
+                    .insert(schema_1.stage)
+                    .values({ id: stageId, ...transformers_1.StageTransformer.to(v) })
+                    .returning({ id: schema_1.stage.id });
+                if (stageResult[0] && v.settings) {
+                    await db.insert(schema_1.stageSettings).values({
+                        id: (0, crypto_1.randomUUID)(),
+                        stageId: stageResult[0].id,
+                        ...transformers_1.StageSettingsTransformer.to(v.settings),
+                    });
+                }
+            }
+            return true;
+        }
+        const stageId = String(values.id);
+        const stageResult = await db
+            .insert(schema_1.stage)
+            .values({ id: stageId, ...transformers_1.StageTransformer.to(values) })
+            .returning({ id: schema_1.stage.id });
+        if (stageResult[0] && values.settings) {
+            await db.insert(schema_1.stageSettings).values({
+                id: (0, crypto_1.randomUUID)(),
+                stageId: stageResult[0].id,
+                ...transformers_1.StageSettingsTransformer.to(values.settings),
+            });
+        }
+        return stageResult[0]?.id ?? '';
+    }
+    catch {
+        return Array.isArray(values) ? false : '';
+    }
+}

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

@@ -0,0 +1,5 @@
+import { Tournament } from '../../transformers';
+import type { DrizzleDatabase } from '../../db';
+type TournamentInsertInput = Tournament;
+export declare function handleTournamentInsert(db: DrizzleDatabase, values: TournamentInsertInput | TournamentInsertInput[]): Promise<string | boolean>;
+export {};