brackets-drizzle-db 2.1.0

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

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchGameUpdate = handleMatchGameUpdate;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+const crypto_1 = require("crypto");
+async function upsertParticipantResult(db, matchGameId, value, isOpponent1) {
+    const existingResults = await db
+        .select()
+        .from(schema_1.participantMatchGameResult)
+        .where(isOpponent1
+        ? (0, drizzle_orm_1.eq)(schema_1.participantMatchGameResult.opponent1MatchGameId, matchGameId)
+        : (0, drizzle_orm_1.eq)(schema_1.participantMatchGameResult.opponent2MatchGameId, matchGameId))
+        .limit(1);
+    const resultData = {
+        participantId: value.id != null ? String(value.id) : null,
+        forfeit: value.forfeit ?? null,
+        position: value.position ?? null,
+        score: value.score ?? null,
+        result: value.result ? transformers_1.MatchResultTransformer.to(value.result) : null,
+    };
+    if (existingResults.length > 0) {
+        await db
+            .update(schema_1.participantMatchGameResult)
+            .set(resultData)
+            .where((0, drizzle_orm_1.eq)(schema_1.participantMatchGameResult.id, existingResults[0].id));
+    }
+    else {
+        await db.insert(schema_1.participantMatchGameResult).values({
+            id: (0, crypto_1.randomUUID)(),
+            ...resultData,
+            ...(isOpponent1
+                ? { opponent1MatchGameId: matchGameId }
+                : { opponent2MatchGameId: matchGameId }),
+        });
+    }
+}
+async function updateById(db, id, value, previousExtra) {
+    let extraSource = previousExtra ?? null;
+    if (previousExtra === undefined) {
+        const existing = await db
+            .select({ extra: schema_1.matchGame.extra })
+            .from(schema_1.matchGame)
+            .where((0, drizzle_orm_1.eq)(schema_1.matchGame.id, id))
+            .limit(1);
+        extraSource = existing[0]?.extra ?? null;
+    }
+    const extrasInput = value;
+    const extra = (0, transformers_1.matchGameExtraFromInput)(extrasInput, extraSource);
+    const updateData = {};
+    if (value.stage_id !== undefined)
+        updateData.stageId = String(value.stage_id);
+    if (value.parent_id !== undefined)
+        updateData.matchId = String(value.parent_id);
+    if (value.number !== undefined)
+        updateData.number = value.number;
+    if (value.status !== undefined)
+        updateData.status = transformers_1.MatchStatusTransformer.to(value.status);
+    if (extra !== undefined)
+        updateData.extra = extra;
+    if (Object.keys(updateData).length > 0) {
+        await db.update(schema_1.matchGame).set(updateData).where((0, drizzle_orm_1.eq)(schema_1.matchGame.id, id));
+    }
+    if (value.opponent1) {
+        await upsertParticipantResult(db, id, value.opponent1, true);
+    }
+    if (value.opponent2) {
+        await upsertParticipantResult(db, id, value.opponent2, false);
+    }
+}
+async function handleMatchGameUpdate(db, filter, value) {
+    try {
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            await updateById(db, String(filter), value);
+            return true;
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.id, String(filter.id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.matchGame.number, filter.number));
+        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.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);
+        await Promise.all(games.map((game) => updateById(db, game.id, value, game.extra ?? null)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleMatchUpdate = handleMatchUpdate;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+const crypto_1 = require("crypto");
+async function upsertParticipantResult(db, matchId, value, isOpponent1) {
+    const existingResults = await db
+        .select()
+        .from(schema_1.participantMatchResult)
+        .where(isOpponent1
+        ? (0, drizzle_orm_1.eq)(schema_1.participantMatchResult.opponent1MatchId, matchId)
+        : (0, drizzle_orm_1.eq)(schema_1.participantMatchResult.opponent2MatchId, matchId))
+        .limit(1);
+    const resultData = {
+        participantId: value.id != null ? String(value.id) : null,
+        forfeit: value.forfeit ?? null,
+        position: value.position ?? null,
+        score: value.score ?? null,
+        result: value.result ? transformers_1.MatchResultTransformer.to(value.result) : null,
+    };
+    if (existingResults.length > 0) {
+        await db
+            .update(schema_1.participantMatchResult)
+            .set(resultData)
+            .where((0, drizzle_orm_1.eq)(schema_1.participantMatchResult.id, existingResults[0].id));
+    }
+    else {
+        await db.insert(schema_1.participantMatchResult).values({
+            id: (0, crypto_1.randomUUID)(),
+            ...resultData,
+            ...(isOpponent1
+                ? { opponent1MatchId: matchId }
+                : { opponent2MatchId: matchId }),
+        });
+    }
+}
+async function updateById(db, id, value, previousExtra) {
+    let extraSource = previousExtra ?? null;
+    if (previousExtra === undefined) {
+        const existing = await db
+            .select({ extra: schema_1.match.extra })
+            .from(schema_1.match)
+            .where((0, drizzle_orm_1.eq)(schema_1.match.id, id))
+            .limit(1);
+        extraSource = existing[0]?.extra ?? null;
+    }
+    const extrasInput = value;
+    const extra = (0, transformers_1.matchExtraFromInput)(extrasInput, extraSource);
+    const updateData = {};
+    if (value.stage_id !== undefined)
+        updateData.stageId = String(value.stage_id);
+    if (value.group_id !== undefined)
+        updateData.groupId = String(value.group_id);
+    if (value.round_id !== undefined)
+        updateData.roundId = String(value.round_id);
+    if (value.child_count !== undefined)
+        updateData.childCount = value.child_count;
+    if (value.number !== undefined)
+        updateData.number = value.number;
+    if (value.status !== undefined)
+        updateData.status = transformers_1.MatchStatusTransformer.to(value.status);
+    if (extra !== undefined)
+        updateData.extra = extra;
+    if (Object.keys(updateData).length > 0) {
+        await db.update(schema_1.match).set(updateData).where((0, drizzle_orm_1.eq)(schema_1.match.id, id));
+    }
+    if (value.opponent1) {
+        await upsertParticipantResult(db, id, value.opponent1, true);
+    }
+    if (value.opponent2) {
+        await upsertParticipantResult(db, id, value.opponent2, false);
+    }
+}
+async function handleMatchUpdate(db, filter, value) {
+    try {
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            await updateById(db, String(filter), value);
+            return true;
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.id, String(filter.id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.number, filter.number));
+        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.status !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.match.status, transformers_1.MatchStatusTransformer.to(filter.status)));
+        const matches = await db
+            .select()
+            .from(schema_1.match)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        await Promise.all(matches.map((m) => updateById(db, m.id, value, m.extra ?? null)));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleParticipantUpdate = handleParticipantUpdate;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleParticipantUpdate(db, filter, value) {
+    try {
+        const updateData = {};
+        if (value.name !== undefined)
+            updateData.name = value.name;
+        if (value.tournament_id !== undefined)
+            updateData.tournamentId = String(value.tournament_id);
+        const extra = (0, transformers_1.participantExtraFromInput)(value);
+        if (extra !== null)
+            updateData.extra = extra;
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            await db
+                .update(schema_1.participant)
+                .set(updateData)
+                .where((0, drizzle_orm_1.eq)(schema_1.participant.id, String(filter)));
+            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
+            .update(schema_1.participant)
+            .set(updateData)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRoundUpdate = handleRoundUpdate;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleRoundUpdate(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 (value.group_id !== undefined)
+            updateData.groupId = String(value.group_id);
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            await db.update(schema_1.round).set(updateData).where((0, drizzle_orm_1.eq)(schema_1.round.id, String(filter)));
+            return true;
+        }
+        const conditions = [];
+        if (filter.id !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.round.id, String(filter.id)));
+        if (filter.number !== undefined)
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.round.number, filter.number));
+        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)));
+        await db
+            .update(schema_1.round)
+            .set(updateData)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStageUpdate = handleStageUpdate;
+const transformers_1 = require("../../transformers");
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleStageUpdate(db, filter, value) {
+    if (typeof filter !== 'number' && typeof filter !== 'string') {
+        return false;
+    }
+    const filterId = String(filter);
+    try {
+        // Update stage
+        const stageData = {};
+        if (value.name !== undefined)
+            stageData.name = value.name;
+        if (value.number !== undefined)
+            stageData.number = value.number;
+        if (value.tournament_id !== undefined)
+            stageData.tournamentId = String(value.tournament_id);
+        if (value.type !== undefined)
+            stageData.type = transformers_1.StageTypeTransformer.to(value.type);
+        if (Object.keys(stageData).length > 0) {
+            await db.update(schema_1.stage).set(stageData).where((0, drizzle_orm_1.eq)(schema_1.stage.id, filterId));
+        }
+        // Update settings if provided
+        if (value.settings) {
+            const settingsData = {};
+            if (value.settings.size !== undefined)
+                settingsData.size = value.settings.size;
+            if (value.settings.seedOrdering !== undefined)
+                settingsData.seedOrdering = value.settings.seedOrdering.map(transformers_1.SeedOrderingTransformer.to);
+            if (value.settings.balanceByes !== undefined)
+                settingsData.balanceByes = value.settings.balanceByes;
+            if (value.settings.matchesChildCount !== undefined)
+                settingsData.matchesChildCount = value.settings.matchesChildCount;
+            if (value.settings.groupCount !== undefined)
+                settingsData.groupCount = value.settings.groupCount;
+            if (value.settings.roundRobinMode !== undefined)
+                settingsData.roundRobinMode = transformers_1.RoundRobinModeTransformer.to(value.settings.roundRobinMode);
+            if (value.settings.manualOrdering !== undefined)
+                settingsData.manualOrdering = value.settings.manualOrdering;
+            if (value.settings.consolationFinal !== undefined)
+                settingsData.consolationFinal = value.settings.consolationFinal;
+            if (value.settings.skipFirstRound !== undefined)
+                settingsData.skipFirstRound = value.settings.skipFirstRound;
+            if (value.settings.grandFinal !== undefined)
+                settingsData.grandFinal = transformers_1.GrandFinalTypeTransformer.to(value.settings.grandFinal);
+            if (Object.keys(settingsData).length > 0) {
+                await db
+                    .update(schema_1.stageSettings)
+                    .set(settingsData)
+                    .where((0, drizzle_orm_1.eq)(schema_1.stageSettings.stageId, filterId));
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleTournamentUpdate = handleTournamentUpdate;
+const schema_1 = require("../../db/schema");
+const drizzle_orm_1 = require("drizzle-orm");
+async function handleTournamentUpdate(db, filter, value) {
+    try {
+        const updateData = {};
+        if (value.name !== undefined)
+            updateData.name = value.name;
+        if (value.description !== undefined)
+            updateData.description = value.description;
+        if (value.start_date !== undefined)
+            updateData.startDate = value.start_date;
+        if (value.end_date !== undefined)
+            updateData.endDate = value.end_date;
+        if (value.extra !== undefined)
+            updateData.extra = value.extra;
+        if (typeof filter === 'number' || typeof filter === 'string') {
+            await db
+                .update(schema_1.tournament)
+                .set(updateData)
+                .where((0, drizzle_orm_1.eq)(schema_1.tournament.id, String(filter)));
+            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
+            .update(schema_1.tournament)
+            .set(updateData)
+            .where(conditions.length > 0 ? (0, drizzle_orm_1.and)(...conditions) : undefined);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

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

package/dist/storage-handlers/update.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdate = handleUpdate;
+const update_handlers_1 = require("./update-handlers");
+async function handleUpdate(db, table, filter, value) {
+    switch (table) {
+        case 'tournament':
+            return (0, update_handlers_1.handleTournamentUpdate)(db, filter, value);
+        case 'participant':
+            return (0, update_handlers_1.handleParticipantUpdate)(db, filter, value);
+        case 'stage':
+            return (0, update_handlers_1.handleStageUpdate)(db, filter, value);
+        case 'group':
+            return (0, update_handlers_1.handleGroupUpdate)(db, filter, value);
+        case 'round':
+            return (0, update_handlers_1.handleRoundUpdate)(db, filter, value);
+        case 'match':
+            return (0, update_handlers_1.handleMatchUpdate)(db, filter, value);
+        case 'match_game':
+            return (0, update_handlers_1.handleMatchGameUpdate)(db, filter, value);
+        default:
+            return false;
+    }
+}

package/dist/storage.d.ts

@@ -0,0 +1,18 @@
+import { CrudInterface, OmitId } from 'brackets-manager';
+import { DataTypes } from 'brackets-manager/dist/types';
+type Id = number | string;
+import type { DrizzleDatabase } from './db';
+export declare class SqlDatabase implements CrudInterface {
+    private db;
+    constructor(db: DrizzleDatabase);
+    insert<T extends keyof DataTypes>(table: T, value: OmitId<DataTypes[T]>): Promise<number>;
+    insert<T extends keyof DataTypes>(table: T, values: OmitId<DataTypes[T]>[]): Promise<boolean>;
+    select<T extends keyof DataTypes>(table: T): Promise<DataTypes[T][] | null>;
+    select<T extends keyof DataTypes>(table: T, id: Id): Promise<DataTypes[T] | null>;
+    select<T extends keyof DataTypes>(table: T, filter: Partial<DataTypes[T]>): Promise<DataTypes[T][] | null>;
+    update<T extends keyof DataTypes>(table: T, id: Id, value: DataTypes[T]): Promise<boolean>;
+    update<T extends keyof DataTypes>(table: T, filter: Partial<DataTypes[T]>, value: Partial<DataTypes[T]>): Promise<boolean>;
+    delete<T extends keyof DataTypes>(table: T): Promise<boolean>;
+    delete<T extends keyof DataTypes>(table: T, filter: Partial<DataTypes[T]>): Promise<boolean>;
+}
+export {};

package/dist/storage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlDatabase = void 0;
+const storage_handlers_1 = require("./storage-handlers");
+// Extended interface that supports text IDs (string or number)
+class SqlDatabase {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    insert(table, values) {
+        // With text IDs, the caller must provide the id - we cast to the expected type
+        return (0, storage_handlers_1.handleInsert)(this.db, table, values);
+    }
+    select(table, filter) {
+        return (0, storage_handlers_1.handleSelect)(this.db, table, filter);
+    }
+    update(table, filter, value) {
+        return (0, storage_handlers_1.handleUpdate)(this.db, table, filter, value);
+    }
+    delete(table, filter) {
+        return (0, storage_handlers_1.handleDelete)(this.db, table, filter);
+    }
+}
+exports.SqlDatabase = SqlDatabase;

package/dist/transformers/enum/grand-final-type.d.ts

@@ -0,0 +1,6 @@
+import { GrandFinalType } from 'brackets-model';
+import type { GrandFinalType as DrizzleGrandFinalType } from '../../db/schema/enums';
+export declare const GrandFinalTypeTransformer: {
+    to(type: GrandFinalType): DrizzleGrandFinalType;
+    from(type: DrizzleGrandFinalType): GrandFinalType;
+};

package/dist/transformers/enum/grand-final-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrandFinalTypeTransformer = void 0;
+exports.GrandFinalTypeTransformer = {
+    to(type) {
+        switch (type) {
+            case 'none':
+                return 'NONE';
+            case 'simple':
+                return 'SIMPLE';
+            case 'double':
+                return 'DOUBLE';
+        }
+    },
+    from(type) {
+        switch (type) {
+            case 'NONE':
+                return 'none';
+            case 'SIMPLE':
+                return 'simple';
+            case 'DOUBLE':
+                return 'double';
+        }
+    },
+};

package/dist/transformers/enum/index.d.ts

@@ -0,0 +1,6 @@
+export * from './grand-final-type';
+export * from './match-result';
+export * from './match-status';
+export * from './round-robin-mode';
+export * from './seed-ordering';
+export * from './stage-type';

package/dist/transformers/enum/index.js

@@ -0,0 +1,22 @@
+"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("./grand-final-type"), exports);
+__exportStar(require("./match-result"), exports);
+__exportStar(require("./match-status"), exports);
+__exportStar(require("./round-robin-mode"), exports);
+__exportStar(require("./seed-ordering"), exports);
+__exportStar(require("./stage-type"), exports);

package/dist/transformers/enum/match-result.d.ts

@@ -0,0 +1,6 @@
+import { Result } from 'brackets-model';
+import type { MatchResult as DrizzleMatchResult } from '../../db/schema/enums';
+export declare const MatchResultTransformer: {
+    to(result: Result): DrizzleMatchResult;
+    from(result: DrizzleMatchResult): Result;
+};

package/dist/transformers/enum/match-result.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchResultTransformer = void 0;
+exports.MatchResultTransformer = {
+    to(result) {
+        switch (result) {
+            case 'win':
+                return 'WIN';
+            case 'draw':
+                return 'DRAW';
+            case 'loss':
+                return 'LOSS';
+        }
+    },
+    from(result) {
+        switch (result) {
+            case 'WIN':
+                return 'win';
+            case 'DRAW':
+                return 'draw';
+            case 'LOSS':
+                return 'loss';
+        }
+    },
+};

package/dist/transformers/enum/match-status.d.ts

@@ -0,0 +1,6 @@
+import { Status } from 'brackets-model';
+import type { MatchStatus as DrizzleMatchStatus } from '../../db/schema/enums';
+export declare const MatchStatusTransformer: {
+    to(status: Status): DrizzleMatchStatus;
+    from(status: DrizzleMatchStatus): Status;
+};

package/dist/transformers/enum/match-status.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MatchStatusTransformer = void 0;
+const brackets_model_1 = require("brackets-model");
+exports.MatchStatusTransformer = {
+    to(status) {
+        switch (status) {
+            case brackets_model_1.Status.Locked:
+                return 'LOCKED';
+            case brackets_model_1.Status.Waiting:
+                return 'WAITING';
+            case brackets_model_1.Status.Ready:
+                return 'READY';
+            case brackets_model_1.Status.Running:
+                return 'RUNNING';
+            case brackets_model_1.Status.Completed:
+                return 'COMPLETED';
+            case brackets_model_1.Status.Archived:
+                return 'ARCHIVED';
+        }
+    },
+    from(status) {
+        switch (status) {
+            case 'LOCKED':
+                return brackets_model_1.Status.Locked;
+            case 'WAITING':
+                return brackets_model_1.Status.Waiting;
+            case 'READY':
+                return brackets_model_1.Status.Ready;
+            case 'RUNNING':
+                return brackets_model_1.Status.Running;
+            case 'COMPLETED':
+                return brackets_model_1.Status.Completed;
+            case 'ARCHIVED':
+                return brackets_model_1.Status.Archived;
+        }
+    },
+};

package/dist/transformers/enum/round-robin-mode.d.ts

@@ -0,0 +1,6 @@
+import { RoundRobinMode } from 'brackets-model';
+import type { RoundRobinMode as DrizzleRoundRobinMode } from '../../db/schema/enums';
+export declare const RoundRobinModeTransformer: {
+    to(mode: RoundRobinMode): DrizzleRoundRobinMode;
+    from(mode: DrizzleRoundRobinMode): RoundRobinMode;
+};